diff --git a/.clinerules/workflows/examine_logs_from_workflow.md b/.clinerules/workflows/examine_logs_from_workflow.md
new file mode 100644
index 000000000..4522e1f97
--- /dev/null
+++ b/.clinerules/workflows/examine_logs_from_workflow.md
@@ -0,0 +1,40 @@
+Help the user figure out what happened in a Github Action test that failed.
+
+## 1. Identify the workflow to analyze
+
+What Tests do you want to analyze?
+
+The user should describe the Tests they want to analyze. Unless otherwise specified, assume they mean the "Integration Tests" workflow.
+
+They could specify a run for a specific branch or commit or PR, or simply whatever the latest results are.
+## 2. Load the workflow run overview
+Use the GitHub CLI tool to find the workflow run specified by the user. Do NOT download the entire logs, they are too large. Instead, use the GitHub CLI tool to get the workflow run overview. This will give you a summary of the workflow run, including the status of each job and step.
+
+## 3. Matrix job
+"Integration Tests" runs a matrix job, so each Test Class is run in it's own job, with it's own result (the job will fail if there are any test failures) and logs.
+
+## 4. Download the logs
+The logs will be Artifacts attached to the workflow run. Download them to a directory that has some idenifying information about the workflow run, such as the commit hash or PR number. Download the FILES locally, make sure they don't end up in the LLM context. Only download the logs for jobs that failed.
+
+## 5. Identify the failing tests
+There will be a file in the logs directory called `failures.log`. This file will contain a list of the tests that failed, along with the reason for the failure. You can use this file to identify which tests to analyze.
+
+## 6. Summarize what has failed, ask for next steps
+Now simply summarize the failures (how many tests, which tests, which classes)
+
+Which tests do you want to analyze?
+
+The user may want to analyze all the tests, or just a specific test.
+
+## 6. Use the testermintlogs tool to analyze the log
+Look at `examine_test_log.md` for details on how to analyze the logs. The test log for a failure will be in the logs directory, and will be named after the test case, with `ClassName-test name might have spaces.log` as the name.
+
+## 7. Summarize all the findings and include CLI commands for further analysis
+Focus on next steps and the likely cause of the failures. If a failure is clearly a known failure, be sure and emphasize that.
+Format a copy-pasteable cmd to run lnav on the log file so the user can grab that and look at the log file themselves.
+Fairly simple, just `lnav `, with the full path and quotes if needed.
+
+## 8. Be prepared for a drill down request
+The user may want you to drill down into a specific test failure. Use the Resources provided by the `testermintlogs` tool to understand how to drill down and look. You can also look at the test file itself to understand the test and what it is supposed to do. If you have questions about the test, ask the user for clarification.
+
+
\ No newline at end of file
diff --git a/.clinerules/workflows/examine_test_log.md b/.clinerules/workflows/examine_test_log.md
new file mode 100644
index 000000000..c911c7570
--- /dev/null
+++ b/.clinerules/workflows/examine_test_log.md
@@ -0,0 +1,41 @@
+# Examine a test log
+Your job is to use the testermintlogs tool to analyze a test log file. The log file is MUCH too large to open directly, and will either be too big for most models
+or will cost a TON of tokens, so you should use the testermintlogs tool to sift through the logs.
+
+## 1. Identify the test to analyze
+Look up the most recent test runs in ./testermint/logs/failures.log.
+Present the user with a list of the most recent failures, and ask them to pick either one or describe which ones to analyze.
+## 2. Load the test log file
+The test log for a failure will be in the logs directory, and will be named after the test case, with `ClassName-test name might have spaces.log` as the name.
+
+Load it into the testermintlogs tool by passing in the full path to the file.
+## 3. Use the testermintlogs tool to analyze the log
+Start by loading the Step by Step instructions resource. This will give you an overview of the approach to use for examining the log. There are other critical resources, but load them as needed, not before hand to reduce token usage. USE THE TOOL AND THE RESOURCES TO UNDERSTAND THE LOGS!
+
+## 4. Expand the context as needed
+The source code for the tests themselves are in the `testermint` folder in this project, and the product code is in `inference-chain` and `decentralized-api`. Use these (especially the test code) to help you understand what the test is doing and what might be going wrong.
+
+## 5. Summarize all the findings as a final step.
+Focus on next steps and the likely cause of the failures. If a failure is clearly a known failure, be sure and emphasize that.
+
+Format a copy-pasteable cmd to run lnav on the log file so the user can grab that and look at the log file themselves.
+Fairly simple, just `lnav `, with the full path and quotes if needed.
+
+## 6. Offer to rerun certain tests
+
+Ask the user if they want to rerun any test or tests based on the findings.
+Would you like to rerun any tests based on these findings?
+
+
+## 7. Backup the original log file for comparson
+
+## 8. Rerun tests if requested
+Use gradle for the testermint project. You can run by test names, class names or tags. For example:
+```bash
+cd testermint && ./gradlew test --tests "TestClassName.*"
+```
+
+## 9. Repeat the analysis if tests were rerun
+Go back to step 1 based on the new test results. Pay special attention to if the failure happened again in the exact same way.
+
+
diff --git a/.clinerules/workflows/run_test_and_examine_logs.md b/.clinerules/workflows/run_test_and_examine_logs.md
new file mode 100644
index 000000000..bc114a3a4
--- /dev/null
+++ b/.clinerules/workflows/run_test_and_examine_logs.md
@@ -0,0 +1,33 @@
+
+# 1. Identify the test to run
+
+What test (or tests) would you like to run?
+
+After the user has selected the test, verify that it is a test,tag or class by looking in the testermint project. Ask follow up questions if unnable to find the test.
+
+# 2. Build and start the chain
+```bash
+cd local-test-net
+./stop-rebuild-launch.sh
+```
+Do NOT include the output of this command in the context! If it fails, immediately stop and ask the user to fix it.
+
+# 4. Run the test(s)
+Use gradle for the testermint project. You can run by test names, class names or tags. For example:
+```bash
+cd testermint && ./gradlew test --tests "TestClassName.*"
+```
+or, for tags:
+```bash
+cd testermint && ./gradlew test --tests "*" -DexcludeTags=unstable,exclude
+```
+
+# 5. Examine the logs
+First, look at the ./testermint/logs/failures.log file to see if there are any failures. If there are, you can use the testermintlogs tool to analyze the logs. The logs will be in the logs directory, and will be named after the test case, with `ClassName-test name might have spaces.log` as the name.
+
+Refer to examine_test_log.md for full details on how to examine the logs. You can use the testermintlogs tool to analyze the logs, and you can also use the test code and product code to help you understand what is going wrong.
+
+# 6. Summarize the findings
+Report back failure/success as well as an analysis of any failures. If a failure is clearly a known failure, be sure and emphasize that.
+
+
\ No newline at end of file
diff --git a/.dockerignore b/.dockerignore
new file mode 100644
index 000000000..9a21c6a58
--- /dev/null
+++ b/.dockerignore
@@ -0,0 +1,50 @@
+# VCS and IDE
+.git
+.gitignore
+.gitattributes
+**/.git
+**/.DS_Store
+**/.idea/
+**/.vscode/
+
+# Logs and transient files
+**/*.log
+direct.log
+test-logs-*/
+
+# Dependency caches
+**/.gradle/
+**/node_modules/
+
+# Build outputs and caches
+**/build/
+**/dist/
+**/output/
+**/.cache
+**/.pytest_cache
+**/__pycache__
+
+# Environment files
+**/.venv
+**/*.env
+
+# Large/unrelated directories to api/node Docker builds
+local-test-net/
+testermint/
+public-html/
+data/
+genesis/
+prod-genesis/
+prod-local/
+prod-sim/
+deploy/
+docs/
+proposals/
+mcp-obsidian/
+logdy/
+jq_test/
+test-net-cloud/
+upgrade-build-files/
+16504109747-artifacts/
+demo/
+mlnode/
diff --git a/.github/actions/gcp-auth-and-gcloud-setup/action.yml b/.github/actions/gcp-auth-and-gcloud-setup/action.yml
new file mode 100644
index 000000000..23b48077d
--- /dev/null
+++ b/.github/actions/gcp-auth-and-gcloud-setup/action.yml
@@ -0,0 +1,14 @@
+name: Authenticate to GCP and setup gcloud
+description: Authenticate to GCP using identity workload federation approach and setup gcloud CLI
+runs:
+ using: "composite"
+ steps:
+ - id: 'gcp-auth'
+ name: 'Authenticate to Google Cloud'
+ uses: 'google-github-actions/auth@v1.1.1'
+ with:
+ workload_identity_provider: 'projects/552613898602/locations/global/workloadIdentityPools/github-pool/providers/github'
+ service_account: 'test-net-deploy@decentralized-ai.iam.gserviceaccount.com'
+ - id: 'gcloud-setup'
+ name: Set up gcloud Cloud SDK environment
+ uses: google-github-actions/setup-gcloud@v1.1.1
diff --git a/.github/scripts/execute_voting_update.py b/.github/scripts/execute_voting_update.py
new file mode 100644
index 000000000..eb5b0fa2d
--- /dev/null
+++ b/.github/scripts/execute_voting_update.py
@@ -0,0 +1,693 @@
+# ./scripts/execute_voting_update.py
+import os
+import subprocess
+import sys
+import time
+import json
+import urllib.request
+import urllib.error
+from pathlib import Path
+from dataclasses import dataclass
+
+@dataclass
+class Node:
+ """
+ Represents a node in the system with its name and associated pods.
+ Equivalent to Kotlin's: data class Node(val name:String, val apiPod:String, nodePod: String)
+ """
+ name: str
+ api_pod: str
+ node_pod: str
+ api_pod_namespace: str = ""
+ node_pod_namespace: str = ""
+ admin_port_local: int = 0 # Local port mapped to admin port (9200)
+ public_port_local: int = 0 # Local port mapped to public port (9000)
+
+ def setup_port_tunnels(self, base_port=10000):
+ """
+ Set up SSH tunnels for the admin port (9200) and public port (9000).
+ Maps these ports to free local ports starting from base_port.
+
+ Args:
+ base_port (int): The starting port number for local port mapping.
+
+ Returns:
+ tuple: The mapped local ports (admin_port_local, public_port_local).
+ """
+ if not self.api_pod:
+ raise ValueError("No api_pod specified for this Node")
+
+ # Assign local ports
+ self.admin_port_local = base_port
+ self.public_port_local = base_port + 1
+
+ # Set up tunnel for admin port (9200)
+ admin_tunnel_command = ["kubectl", "port-forward"]
+
+ # Add namespace if available
+ if self.api_pod_namespace:
+ admin_tunnel_command.extend(["-n", self.api_pod_namespace])
+
+ # Add pod name and port mapping
+ admin_tunnel_command.extend([
+ self.api_pod,
+ f"{self.admin_port_local}:9200"
+ ])
+
+ # Run the command in the background
+ print(f"Setting up admin port tunnel for {self.name}: {self.admin_port_local} -> 9200")
+ subprocess.Popen(admin_tunnel_command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+ # Set up tunnel for public port (9000)
+ public_tunnel_command = ["kubectl", "port-forward"]
+
+ # Add namespace if available
+ if self.api_pod_namespace:
+ public_tunnel_command.extend(["-n", self.api_pod_namespace])
+
+ # Add pod name and port mapping
+ public_tunnel_command.extend([
+ self.api_pod,
+ f"{self.public_port_local}:9000"
+ ])
+
+ # Run the command in the background
+ print(f"Setting up public port tunnel for {self.name}: {self.public_port_local} -> 9000")
+ subprocess.Popen(public_tunnel_command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+ # Wait for tunnels to establish
+ time.sleep(2)
+
+ return (self.admin_port_local, self.public_port_local)
+
+ def _make_request(self, port, url_path, method="GET", payload=None):
+ """
+ Base method to make HTTP requests to a specific port.
+
+ Args:
+ port (int): The local port to send the request to.
+ url_path (str): The URL path beyond localhost:port.
+ method (str): The HTTP method (GET, POST, etc.).
+ payload (dict, optional): The payload to send with the request.
+
+ Returns:
+ dict: The JSON response from the request.
+ """
+ # Construct the full URL
+ url = f"http://localhost:{port}/{url_path.lstrip('/')}"
+
+ # Prepare the request
+ headers = {"Content-Type": "application/json"}
+ data = None
+ if payload:
+ data = json.dumps(payload).encode('utf-8')
+
+ # Create the request object
+ req = urllib.request.Request(
+ url=url,
+ data=data,
+ headers=headers,
+ method=method
+ )
+
+ try:
+ # Send the request and get the response
+ with urllib.request.urlopen(req) as response:
+ response_data = response.read().decode('utf-8')
+ return json.loads(response_data) if response_data else {}
+ except urllib.error.HTTPError as e:
+ print(f"HTTP Error: {e.code} - {e.reason}")
+ print(f"Response: {e.read().decode('utf-8')}")
+ raise
+ except urllib.error.URLError as e:
+ print(f"URL Error: {e.reason}")
+ raise
+ except json.JSONDecodeError:
+ print("Error decoding JSON response")
+ raise
+
+ def admin_request(self, url_path, method="GET", payload=None):
+ """
+ Make an HTTP request to the admin port (9200).
+
+ Args:
+ url_path (str): The URL path beyond localhost:port.
+ method (str): The HTTP method (GET, POST, etc.).
+ payload (dict, optional): The payload to send with the request.
+
+ Returns:
+ dict: The JSON response from the request.
+ """
+ if not self.admin_port_local:
+ raise ValueError("Admin port not set up. Call setup_port_tunnels first.")
+
+ return self._make_request(self.admin_port_local, url_path, method, payload)
+
+ def public_request(self, url_path, method="GET", payload=None):
+ """
+ Make an HTTP request to the public port (9000).
+
+ Args:
+ url_path (str): The URL path beyond localhost:port.
+ method (str): The HTTP method (GET, POST, etc.).
+ payload (dict, optional): The payload to send with the request.
+
+ Returns:
+ dict: The JSON response from the request.
+ """
+ if not self.public_port_local:
+ raise ValueError("Public port not set up. Call setup_port_tunnels first.")
+
+ return self._make_request(self.public_port_local, url_path, method, payload)
+
+ def exec_inferenced(self, args):
+ """
+ Execute the inferenced command on the node_pod using kubectl exec.
+
+ Args:
+ args (list): List of arguments to pass to the inferenced command.
+
+ Returns:
+ str: The stdout output from the command execution.
+ """
+ if not self.node_pod:
+ raise ValueError("No node_pod specified for this Node")
+
+ # Construct the kubectl exec command
+ command = ["kubectl", "exec"]
+
+ # Add namespace if available
+ if self.node_pod_namespace:
+ command.extend(["-n", self.node_pod_namespace])
+
+ # Add pod name and command
+ command.extend([
+ self.node_pod,
+ "--",
+ "inferenced"
+ ])
+
+ # Add the provided arguments
+ command.extend(args)
+
+ # Execute the command
+ result = run_command(command)
+
+ # Return the stdout as a string
+ return result.stdout.strip() if result.stdout else ""
+
+ def exec_inferenced_with_retry(self, args):
+ """
+ Execute the inferenced command on the node_pod using kubectl exec,
+ but don't exit on error - instead, propagate the exception for retry logic to handle.
+
+ Args:
+ args (list): List of arguments to pass to the inferenced command.
+
+ Returns:
+ str: The stdout output from the command execution.
+
+ Raises:
+ subprocess.CalledProcessError: If the command execution fails.
+ FileNotFoundError: If the command is not found.
+ """
+ if not self.node_pod:
+ raise ValueError("No node_pod specified for this Node")
+
+ # Construct the kubectl exec command
+ command = ["kubectl", "exec"]
+
+ # Add namespace if available
+ if self.node_pod_namespace:
+ command.extend(["-n", self.node_pod_namespace])
+
+ # Add pod name and command
+ command.extend([
+ self.node_pod,
+ "--",
+ "inferenced"
+ ])
+
+ # Add the provided arguments
+ command.extend(args)
+
+ # Execute the command directly with subprocess.run
+ print(f"Executing: {' '.join(command)}")
+ process = subprocess.run(command, check=True, capture_output=True, text=True)
+
+ # Return the stdout as a string
+ return process.stdout.strip() if process.stdout else ""
+
+ def get_keys(self):
+ """
+ Get the list of keys from the node.
+
+ Returns:
+ list: A list of key objects.
+ """
+ output = self.exec_inferenced(["keys", "list", "--output", "json"])
+ return json.loads(output)
+
+ def generate_upgrade_proposal(self, upgrade_name, upgrade_height, upgrade_info, title=None, summary="", deposit="100000ngonka", from_address=None, chain_id="prod-sim"):
+ """
+ Generate an upgrade proposal transaction.
+
+ Args:
+ upgrade_name (str): The name of the upgrade.
+ upgrade_height (int): The block height at which the upgrade should occur.
+ upgrade_info (dict): Information about the upgrade, including binaries and versions.
+ title (str, optional): The title of the proposal. Defaults to upgrade_name if not provided.
+ summary (str, optional): A summary of the proposal.
+ deposit (str, optional): The deposit amount for the proposal.
+ from_address (str, optional): The address to use for the proposal. If not provided, uses the first key.
+ chain_id (str, optional): The chain ID to use for the transaction.
+
+ Returns:
+ dict: The generated transaction.
+ """
+ if title is None:
+ title = upgrade_name
+
+ # If from_address is not provided, use the first key
+ if from_address is None:
+ keys = self.get_keys()
+ if not keys:
+ raise ValueError("No keys found on the node")
+ from_address = keys[0]["address"]
+
+ # Convert upgrade_info to a JSON string with minimal output
+ upgrade_info_str = json.dumps(upgrade_info, separators=(',', ':'))
+ print(f"Upgrade info: {upgrade_info_str}")
+ # Build the command
+ cmd = [
+ "tx", "upgrade", "software-upgrade", upgrade_name,
+ "--title", title,
+ "--upgrade-height", str(upgrade_height),
+ "--upgrade-info", upgrade_info_str,
+ "--summary", summary,
+ "--deposit", deposit,
+ "--from", from_address,
+ "--chain-id", chain_id,
+ "--yes",
+ "--broadcast-mode", "sync",
+ "--output", "json",
+ "--gas", "auto"
+ ]
+
+ # Execute the command
+ output = self.exec_inferenced(cmd)
+
+ # Parse the output as JSON
+ try:
+ return json.loads(output)
+ except json.JSONDecodeError:
+ print(f"Error parsing JSON output: {output}")
+ raise
+
+ def submit_transaction(self, transaction):
+ """
+ Submit a transaction to the API.
+
+ Args:
+ transaction (dict): The transaction to submit.
+
+ Returns:
+ dict: The response from the API.
+ """
+ return self.admin_request("admin/v1/tx/send", method="POST", payload=transaction)
+
+ def wait_for_transaction(self, tx_response, max_retries=30, retry_interval=2):
+ """
+ Wait for a transaction to be posted and check its status.
+
+ This method takes the response from sending a transaction (which contains a txhash),
+ then uses the node_pod to query the transaction status until it's ready or max_retries is reached.
+
+ The exec command itself will fail if the transaction is not ready, not just return unparseable output.
+ This method handles both cases - exec failure and unparseable output.
+
+ Args:
+ tx_response (dict): The response from sending a transaction, containing a txhash.
+ max_retries (int, optional): Maximum number of retry attempts. Defaults to 30.
+ retry_interval (int, optional): Time in seconds between retries. Defaults to 2.
+
+ Returns:
+ dict: The transaction details once it's ready, or None if the transaction failed or timed out.
+ """
+ if not tx_response or 'txhash' not in tx_response:
+ print("Error: Invalid transaction response, missing txhash")
+ return None
+
+ txhash = tx_response['txhash']
+ print(f"Waiting for transaction {txhash} to be posted...")
+
+ for attempt in range(max_retries):
+ try:
+ # Query the transaction status using the node_pod with the retry-friendly method
+ cmd = ["query", "tx", "--type=hash", txhash, "--output", "json"]
+ output = self.exec_inferenced_with_retry(cmd)
+
+ # Try to parse the output as JSON
+ try:
+ tx_details = json.loads(output)
+ # If we get here, the transaction has been posted successfully
+ print(f"Transaction {txhash} posted successfully (attempt {attempt+1})")
+ return tx_details
+ except json.JSONDecodeError:
+ # If we can't parse the output as JSON, the transaction might not be posted yet
+ print(f"Transaction {txhash} not yet posted - invalid JSON response (attempt {attempt+1})")
+ print(f"Raw output: {output}")
+
+ except subprocess.CalledProcessError as e:
+ # Handle the case where the exec command itself fails (expected when TX is not ready)
+ print(f"Transaction {txhash} not yet posted - exec failed (attempt {attempt+1})")
+ if hasattr(e, 'stderr') and e.stderr:
+ print(f"Error output: {e.stderr}")
+
+ except Exception as e:
+ # Handle any other unexpected errors
+ print(f"Unexpected error checking transaction status (attempt {attempt+1}): {str(e)}")
+
+ # Wait before retrying
+ if attempt < max_retries - 1:
+ print(f"Waiting {retry_interval} seconds before retrying...")
+ time.sleep(retry_interval)
+
+ print(f"Transaction {txhash} not posted after {max_retries} attempts")
+ return None
+
+ def get_upgrade_json(self, upgrade_name, upgrade_height, node_binaries=None, api_binaries=None, node_version="",
+ title=None, summary="For testing", deposit="500000ngonka", from_address=None):
+ """
+ Submit an upgrade proposal.
+
+ Args:
+ upgrade_name (str): The name of the upgrade.
+ upgrade_height (int): The block height at which the upgrade should occur.
+ node_binaries (dict, optional): Dictionary mapping platform to node binary URLs.
+ api_binaries (dict, optional): Dictionary mapping platform to API binary URLs.
+ node_version (str, optional): The version of the node.
+ title (str, optional): The title of the proposal. Defaults to upgrade_name if not provided.
+ summary (str, optional): A summary of the proposal.
+ deposit (str, optional): The deposit amount for the proposal.
+ from_address (str, optional): The address to use for the proposal. If not provided, uses the first key.
+ chain_id (str, optional): The chain ID to use for the transaction.
+
+ Returns:
+ dict: The response from the API.
+ """
+ # Set default values for binaries if not provided
+ if node_binaries is None:
+ node_binaries = {}
+ if api_binaries is None:
+ api_binaries = {}
+
+ # Create the upgrade info
+ upgrade_info = {
+ "binaries": node_binaries,
+ "api_binaries": api_binaries,
+ "node_version": node_version
+ }
+
+ # Generate and submit the upgrade proposal directly
+ return self.exec_inferenced([
+ "tx", "upgrade", "software-upgrade", upgrade_name,
+ "--title", title or upgrade_name,
+ "--upgrade-height", str(upgrade_height),
+ "--upgrade-info", json.dumps(upgrade_info, separators=(',', ':')),
+ "--summary", summary,
+ "--deposit", deposit,
+ "--from", from_address or self.get_keys()[0]["address"],
+ "--yes",
+ "--broadcast-mode", "sync",
+ "--output", "json",
+ "--gas", "auto",
+ "--generate-only"
+ ])
+
+def run_command(command, **kwargs):
+ """Helper function to run a shell command and print its output."""
+ print(f"Executing: {' '.join(command)}")
+ try:
+ process = subprocess.run(command, check=True, capture_output=True, text=True, **kwargs)
+ if process.stdout:
+ print("STDOUT:\n", process.stdout)
+ if process.stderr:
+ print("STDERR:\n", process.stderr)
+ return process
+ except subprocess.CalledProcessError as e:
+ print(f"Error executing command: {' '.join(command)}")
+ if e.stdout:
+ print("STDOUT:\n", e.stdout)
+ if e.stderr:
+ print("STDERR:\n", e.stderr)
+ sys.exit(1)
+ except FileNotFoundError:
+ print(f"Error: Command '{command[0]}' not found. Make sure it's installed and in PATH.")
+ sys.exit(1)
+
+def get_env_vars():
+ """Read and validate environment variables."""
+ env_vars = {
+ "release_tag": os.environ.get("RELEASE_TAG"),
+ "gce_project_id": os.environ.get("GCE_PROJECT_ID"),
+ "gce_zone": os.environ.get("GCE_ZONE"),
+ "k8s_control_plane_name": os.environ.get("K8S_CONTROL_PLANE_NAME"),
+ "k8s_control_plane_user": os.environ.get("K8S_CONTROL_PLANE_USER")
+ }
+
+ # Print environment variables
+ for key, value in env_vars.items():
+ print(f"{key.replace('_', ' ').title()}: {value}")
+
+ # Validate environment variables
+ if not all(env_vars.values()):
+ print("Error: One or more required environment variables are not set.")
+ sys.exit(1)
+
+ return env_vars
+
+def setup_kubectl(env_vars):
+ """Configure kubectl and return the kubeconfig path."""
+ print("--- Configuring kubectl ---")
+ kube_dir = Path.home() / ".kube"
+ kube_dir.mkdir(parents=True, exist_ok=True)
+ kubeconfig_path = kube_dir / "config"
+
+ # Fetch kubeconfig
+ gcloud_scp_command = [
+ "gcloud", "compute", "scp",
+ f"{env_vars['k8s_control_plane_user']}@{env_vars['k8s_control_plane_name']}:~/.kube/config",
+ str(kubeconfig_path),
+ "--zone", env_vars["gce_zone"],
+ "--project", env_vars["gce_project_id"]
+ ]
+ run_command(gcloud_scp_command)
+
+ # Set KUBECONFIG environment variable
+ os.environ["KUBECONFIG"] = str(kubeconfig_path)
+
+ return kubeconfig_path
+
+def setup_ssh_tunnel(env_vars):
+ """Set up SSH tunnel to the Kubernetes control plane."""
+ print(f"Setting up SSH tunnel to {env_vars['k8s_control_plane_name']}...")
+ gcloud_ssh_command = [
+ "gcloud", "compute", "ssh",
+ f"{env_vars['k8s_control_plane_user']}@{env_vars['k8s_control_plane_name']}",
+ "--zone", env_vars["gce_zone"],
+ "--project", env_vars["gce_project_id"],
+ "--ssh-flag=-L 6443:127.0.0.1:6443 -N -f" # -N: no remote commands, -f: forks to background
+ ]
+ run_command(gcloud_ssh_command) # This will fork to background
+
+ # Wait for SSH tunnel to establish
+ print("Waiting for SSH tunnel to establish...")
+ time.sleep(10)
+
+def verify_kubectl_connection(kubeconfig_path):
+ """Verify kubectl connection and print kubeconfig info."""
+ print(f"KUBECONFIG set to: {os.environ['KUBECONFIG']}")
+ if kubeconfig_path.exists():
+ print("Kubeconfig content (first few lines):")
+ with open(kubeconfig_path, "r") as f:
+ for i, line in enumerate(f):
+ if i >= 5:
+ break
+ print(line.strip())
+ else:
+ print("Kubeconfig file does not exist at expected location.")
+
+ # Verify kubectl connection
+ print("Verifying kubectl connection (this might use the tunnel)...")
+ run_command(["kubectl", "cluster-info"])
+ run_command(["kubectl", "get", "nodes", "--request-timeout=60s"])
+
+def print_versions():
+ """Print kubectl and kustomize versions."""
+ print("--- Versions ---")
+ print("kubectl client version:")
+ run_command(["kubectl", "version", "--client", "-o", "yaml"])
+
+def get_worker_nodes_with_pods():
+ """
+ Find k8s worker nodes and their associated pods.
+ Sets up port tunnels for each node.
+
+ Returns:
+ list[Node]: A list of Node objects, each containing the node name, associated pod names, and port mappings.
+ """
+ print("--- Getting Worker Nodes and Pods ---")
+
+ # Get all nodes
+ nodes_process = run_command(["kubectl", "get", "nodes", "-o", "name"])
+ nodes_output = nodes_process.stdout.strip().split('\n')
+
+ worker_nodes = []
+
+ # Filter for nodes matching k8s-worker-\d pattern
+ import re
+ worker_pattern = re.compile(r'node/k8s-worker-\d+')
+
+ for node_full_name in nodes_output:
+ if worker_pattern.match(node_full_name):
+ # Extract just the node name without the 'node/' prefix
+ node_name = node_full_name.replace('node/', '')
+
+ # Get pods running on this node with their namespaces
+ pods_process = run_command([
+ "kubectl", "get", "pods", "--all-namespaces",
+ "--field-selector", f"spec.nodeName={node_name}",
+ "-o", "custom-columns=NAMESPACE:.metadata.namespace,NAME:.metadata.name",
+ "--no-headers"
+ ])
+
+ pods_with_ns = []
+ if pods_process.stdout.strip():
+ for pod_line in pods_process.stdout.strip().split('\n'):
+ parts = pod_line.split()
+ if len(parts) >= 2:
+ namespace = parts[0]
+ pod_name = parts[1]
+ pods_with_ns.append((namespace, pod_name))
+
+ # Find the first pod starting with "api-" and "node-"
+ api_pod = ""
+ api_pod_namespace = ""
+ node_pod = ""
+ node_pod_namespace = ""
+
+ for namespace, pod_name in pods_with_ns:
+ if pod_name.startswith("api-") and not api_pod:
+ api_pod = pod_name
+ api_pod_namespace = namespace
+ if pod_name.startswith("node-") and not node_pod:
+ node_pod = pod_name
+ node_pod_namespace = namespace
+
+ # Create a Node object and add it to the list
+ worker_nodes.append(Node(
+ name=node_name,
+ api_pod=api_pod,
+ node_pod=node_pod,
+ api_pod_namespace=api_pod_namespace,
+ node_pod_namespace=node_pod_namespace
+ ))
+
+ # Set up port tunnels for each node
+ base_port = 10000
+ for i, node in enumerate(worker_nodes):
+ # Use a different base port for each node to avoid conflicts
+ node_base_port = base_port + (i * 2) # Increment by 2 for each node
+ try:
+ admin_port, public_port = node.setup_port_tunnels(base_port=node_base_port)
+ print(f"Node {node.name} port mappings:")
+ print(f" Admin port: localhost:{admin_port} -> {node.api_pod}:9200")
+ print(f" Public port: localhost:{public_port} -> {node.api_pod}:9000")
+ except Exception as e:
+ print(f"Error setting up port tunnels for node {node.name}: {e}")
+
+ return worker_nodes
+
+def main():
+ print("--- Starting Voting Update Script (Python) ---")
+
+ # Initialize environment and setup
+ env_vars = get_env_vars()
+ kubeconfig_path = setup_kubectl(env_vars)
+ setup_ssh_tunnel(env_vars)
+ verify_kubectl_connection(kubeconfig_path)
+ print_versions()
+
+ # Actual voting update logic
+ print("--- Performing Voting Update Actions ---")
+ print(f"Using Release Tag: {env_vars['release_tag']}")
+ return
+ # Get worker nodes and their pods
+ worker_nodes = get_worker_nodes_with_pods()
+
+
+ # Print the results
+ print(f"Found {len(worker_nodes)} worker nodes:")
+ for node in worker_nodes:
+ print(f"Node: {node.name}")
+ print(f" API Pod: {node.api_pod}")
+ print(f" Node Pod: {node.node_pod}")
+ print(f" Admin port: localhost:{node.admin_port_local} -> {node.api_pod}:9200")
+ print(f" Public port: localhost:{node.public_port_local} -> {node.api_pod}:9000")
+ time.sleep(10)
+
+ first_node = worker_nodes[0]
+ print(first_node.exec_inferenced(["version"]))
+
+ # Example of using the submit_upgrade function
+ if env_vars.get('release_tag') and len(worker_nodes) > 0:
+ print("--- Submitting Upgrade Proposal ---")
+
+ # Example upgrade parameters
+ upgrade_name = f"v{env_vars['release_tag']}"
+ upgrade_height = 60 # Example height, should be determined based on current chain height
+
+ # Example binary URLs
+ node_binaries = {
+ "linux/amd64": f"https://github.com/product-science/race-releases/releases/download/release%2Fv0.1.5/inferenced-amd64.zip?checksum=sha256:cc438e023be7bef75f98a34aaaf184d73196ecbaa4c6c59c8acbbb79d69d1a0b"
+ }
+ api_binaries = {
+ "linux/amd64": f"https://github.com/product-science/race-releases/releases/download/release%2Fv0.1.5/decentralized-api-amd64.zip?checksum=sha256:5611b9bbc6416f30188451f7f49c9d2d93dd497b50c3c1dd29b44e65f40f8841"
+ }
+ print(first_node.admin_request("admin/v1/nodes"))
+
+ # Submit the upgrade proposal
+ try:
+ response = first_node.get_upgrade_json(
+ upgrade_name=upgrade_name,
+ upgrade_height=upgrade_height,
+ node_binaries=node_binaries,
+ api_binaries=api_binaries,
+ node_version="",
+ title=upgrade_name,
+ summary=f"Upgrade to {upgrade_name}",
+ deposit="500000ngonka",
+ from_address="genesis"
+ )
+ except Exception as e:
+ print(f"Error submitting upgrade proposal: {e}")
+
+ response_obj = json.loads(response)
+ print(f"Upgrade proposal prepared, ready to send: {json.dumps(response_obj, indent=2)}")
+
+ # Send the transaction
+ tx_response = first_node.admin_request("admin/v1/tx/send", method="POST", payload=response_obj)
+ print(f"Transaction sent, response: {json.dumps(tx_response, indent=2)}")
+
+ # Wait for the transaction to be posted and get its details
+ tx_details = first_node.wait_for_transaction(tx_response)
+ if tx_details:
+ print(f"Transaction details: {json.dumps(tx_details, indent=2)}")
+ else:
+ print("Failed to get transaction details")
+
+ # print("--- Voting Update Script (Python) Finished ---")
+
+if __name__ == "__main__":
+ main()
diff --git a/.github/workflows/build-upgrades.yml b/.github/workflows/build-upgrades.yml
new file mode 100644
index 000000000..1f2d091ee
--- /dev/null
+++ b/.github/workflows/build-upgrades.yml
@@ -0,0 +1,42 @@
+name: Multi-Platform Build
+
+on:
+ pull_request:
+ branches:
+ - '**'
+ push:
+ branches:
+ - main
+
+jobs:
+ build:
+ runs-on: ubuntu-latest
+ steps:
+ - name: Check initial disk space
+ run: |
+ echo "=== Disk Space Before Cleanup ==="
+ df -h
+
+ - name: Free up disk space on runner
+ run: |
+ echo "Removing large pre-installed tools..."
+ sudo rm -rf /usr/share/dotnet
+ sudo rm -rf /usr/local/lib/android
+ sudo rm -rf /opt/ghc
+ sudo rm -rf /opt/hostedtoolcache/CodeQL
+ echo "Cleaning up apt and docker..."
+ sudo docker system prune -af --volumes
+ sudo apt-get clean
+ echo "=== Disk Space After Cleanup ==="
+ df -h
+
+ - name: Set up Go
+ uses: actions/setup-go@v3.0.0
+ with:
+ go-version: '^1.22.2' # Replace with your Go version
+
+ - name: Checkout code
+ uses: actions/checkout@v3
+
+ - name: Run Makefile build
+ run: make build-for-upgrade
diff --git a/.github/workflows/deploy-test-net-cloud.yml b/.github/workflows/deploy-test-net-cloud.yml
new file mode 100644
index 000000000..6ebb08ea6
--- /dev/null
+++ b/.github/workflows/deploy-test-net-cloud.yml
@@ -0,0 +1,241 @@
+name: Deploy Test Net Cloud
+
+on:
+ workflow_dispatch:
+
+jobs:
+ deploy-test-net-cloud:
+ runs-on: ubuntu-latest
+
+ permissions:
+ contents: 'read'
+ id-token: 'write'
+ packages: 'write' # Added for pushing to GHCR
+
+ steps:
+ - uses: actions/checkout@v3
+ with:
+ fetch-depth: 0 # Required for git describe --always to work accurately
+
+ - name: Get commit short version
+ id: git_version
+ run: echo "COMMIT_TAG=$(git describe --always)" >> $GITHUB_ENV
+
+ - name: Log in to GitHub Container Registry
+ uses: docker/login-action@v3
+ with:
+ registry: ghcr.io
+ username: ${{ secrets.CROSS_ORG_PACKAGE_USERNAME }}
+ password: ${{ secrets.CROSS_ORG_PACKAGE_TOKEN }}
+
+ - name: Build and Push Images if not exist
+ env:
+ COMMIT_TAG: ${{ env.COMMIT_TAG }}
+ # GITHUB_TOKEN is automatically available to docker login action, make targets might need it if they implement their own login
+ shell: bash
+ run: |
+ set -e # exit on error
+ echo "Commit tag is: $COMMIT_TAG"
+
+ # Format: "kustomize_name image_url make_target"
+ # kustomize_name is the 'name' field in kustomization.yaml images list
+ # image_url is the full URL of the image repository
+ # make_target is the make target to build and push this specific image
+ images_to_manage=(
+ "api ghcr.io/product-science/api decentralized-api-release"
+ "node ghcr.io/product-science/inferenced inference-chain-release"
+ "tmkms ghcr.io/product-science/tmkms-softsign-with-keygen tmkms-release"
+ # Add more images here in the same format to extend
+ )
+
+ for img_info in "${images_to_manage[@]}"; do
+ read -r kustomize_name image_url make_target <<< "$img_info"
+ echo "--------------------------------------------------"
+ echo "Processing image: $kustomize_name (${image_url})"
+ echo "Target tag: $COMMIT_TAG"
+ echo "Make target: $make_target"
+ echo "--------------------------------------------------"
+
+ echo "Checking for image: ${image_url}:${COMMIT_TAG}"
+ if docker manifest inspect "${image_url}:${COMMIT_TAG}" > /dev/null 2>&1; then
+ echo "Image ${image_url}:${COMMIT_TAG} already exists in ghcr.io."
+ else
+ echo "Image ${image_url}:${COMMIT_TAG} not found in ghcr.io."
+ echo "Building and pushing using target: ${make_target} with VERSION=${COMMIT_TAG}..."
+ # The VERSION env var should be picked up by the Makefiles
+ # (assuming sub-Makefiles inherit it or use VERSION ?= default)
+ VERSION=$COMMIT_TAG make $make_target
+ echo "Finished building and pushing ${image_url}:${COMMIT_TAG}."
+ fi
+ done
+
+ - name: Install yq
+ run: |
+ echo "Installing yq..."
+ sudo wget https://github.com/mikefarah/yq/releases/latest/download/yq_linux_amd64 -O /usr/local/bin/yq
+ sudo chmod +x /usr/local/bin/yq
+ yq --version
+
+ - name: Update Kustomization Image Tags
+ env:
+ COMMIT_TAG: ${{ env.COMMIT_TAG }}
+ shell: bash
+ run: |
+ KUSTOMIZATION_FILE="test-net-cloud/k8s/image-versions/kustomization.yaml"
+ echo "Updating $KUSTOMIZATION_FILE with tag $COMMIT_TAG using yq"
+
+ # Same list as in the build step for consistency
+ images_to_manage=(
+ "api ghcr.io/product-science/api decentralized-api-release"
+ "node ghcr.io/product-science/inferenced inference-chain-release"
+ "tmkms ghcr.io/product-science/tmkms-softsign-with-keygen tmkms-release"
+ # Add more images here if their tags in kustomization.yaml need updating
+ )
+
+ for img_info in "${images_to_manage[@]}"; do
+ read -r kustomize_name _ _ <<< "$img_info" # We only need kustomize_name here
+ echo "Updating newTag for image '$kustomize_name' in $KUSTOMIZATION_FILE"
+ # This command finds an image by its 'name' (kustomize_name) and updates its 'newTag'.
+ # It handles cases where the image might not be present without erroring,
+ # though in this workflow, we expect them to be defined.
+ yq e "(.images[] | select(.name == \"$kustomize_name\").newTag) = strenv(COMMIT_TAG)" -i $KUSTOMIZATION_FILE
+ done
+ echo "Successfully updated $KUSTOMIZATION_FILE."
+
+ - name: Cat Kustomization File
+ run: |
+ echo "Contents of test-net-cloud/k8s/image-versions/kustomization.yaml after update:"
+ cat test-net-cloud/k8s/image-versions/kustomization.yaml
+
+ - uses: ./.github/actions/gcp-auth-and-gcloud-setup
+
+ - name: Define GCE/K8s parameters
+ id: params
+ run: |
+ echo "GCE_PROJECT_ID=$(gcloud config get-value project)" >> $GITHUB_OUTPUT
+ echo "GCE_ZONE=us-central1-a" >> $GITHUB_OUTPUT
+ echo "K8S_CONTROL_PLANE_NAME=k8s-control-plane" >> $GITHUB_OUTPUT
+ echo "K8S_CONTROL_PLANE_USER=dev" >> $GITHUB_OUTPUT
+ echo "K8S_WORKER_1_NAME=k8s-worker-1" >> $GITHUB_OUTPUT
+ echo "K8S_WORKER_2_NAME=k8s-worker-2" >> $GITHUB_OUTPUT
+ echo "K8S_WORKER_3_NAME=k8s-worker-3" >> $GITHUB_OUTPUT
+
+ - name: Install kubectl
+ uses: azure/setup-kubectl@v4
+
+ - name: Print kubectl and kustomize versions
+ run: |
+ echo "kubectl client version:"
+ kubectl version --client -o yaml # -o yaml gives more structured output
+
+ - name: Configure kubectl
+ env:
+ GCE_PROJECT_ID: ${{ steps.params.outputs.GCE_PROJECT_ID }}
+ GCE_ZONE: ${{ steps.params.outputs.GCE_ZONE }}
+ K8S_CONTROL_PLANE_NAME: ${{ steps.params.outputs.K8S_CONTROL_PLANE_NAME }}
+ K8S_CONTROL_PLANE_USER: ${{ steps.params.outputs.K8S_CONTROL_PLANE_USER }}
+ run: |
+ echo "Fetching kubeconfig from ${K8S_CONTROL_PLANE_NAME} in zone ${GCE_ZONE}..."
+ mkdir -p $HOME/.kube
+ gcloud compute scp ${K8S_CONTROL_PLANE_USER}@${K8S_CONTROL_PLANE_NAME}:~/.kube/config $HOME/.kube/config --zone ${GCE_ZONE} --project ${GCE_PROJECT_ID}
+ export KUBECONFIG=$HOME/.kube/config
+ echo "KUBECONFIG=$KUBECONFIG" >> $GITHUB_ENV
+
+ # ---- IMPORTANT: SSH Tunnel (if K8s API server is not directly accessible) ----
+ # If your K8s API server isn't publicly accessible, you'll need an SSH tunnel.
+ # 1. Uncomment and adapt the following lines.
+ # 2. Ensure your kubeconfig (once copied) targets 'https://127.0.0.1:6443' or similar.
+ #
+ echo "Setting up SSH tunnel to ${K8S_CONTROL_PLANE_NAME}..."
+ gcloud compute ssh ${K8S_CONTROL_PLANE_USER}@${K8S_CONTROL_PLANE_NAME} --zone ${GCE_ZONE} --project ${GCE_PROJECT_ID} \
+ --ssh-flag="-L 6443:127.0.0.1:6443 -N -f"
+ sleep 5 # Give tunnel time to establish
+ echo "Kubeconfig modified to use tunnel."
+ # ---- End SSH Tunnel Section ----
+
+ echo "Verifying kubectl connection..."
+ kubectl cluster-info
+ kubectl get nodes --request-timeout=30s
+
+ - name: Create HF Token Secret
+ env:
+ HF_TOKEN: ${{ secrets.HF_TOKEN }}
+ run: |
+ echo "Creating HF token secret in all namespaces..."
+ # Create the secret in each namespace
+ kubectl create secret generic hf-token \
+ --from-literal=HF_TOKEN="$HF_TOKEN" \
+ --namespace=genesis \
+ --dry-run=client -o yaml | kubectl apply -f -
+
+ kubectl create secret generic hf-token \
+ --from-literal=HF_TOKEN="$HF_TOKEN" \
+ --namespace=join-k8s-worker-2 \
+ --dry-run=client -o yaml | kubectl apply -f -
+
+ kubectl create secret generic hf-token \
+ --from-literal=HF_TOKEN="$HF_TOKEN" \
+ --namespace=join-k8s-worker-3 \
+ --dry-run=client -o yaml | kubectl apply -f -
+
+ echo "HF token secret created/updated in all namespaces."
+
+ - name: Stop existing Kubernetes resources
+ run: |
+ echo "Deleting resources in genesis namespace..."
+ kubectl delete all --all -n genesis --ignore-not-found=true --request-timeout=2m
+ echo "Deleting resources in join-k8s-worker-2 namespace..."
+ kubectl delete all --all -n join-k8s-worker-2 --ignore-not-found=true --request-timeout=2m
+ kubectl delete pvc tmkms-data-pvc -n join-k8s-worker-2 --ignore-not-found=true --request-timeout=1m
+ echo "Deleting resources in join-k8s-worker-3 namespace..."
+ kubectl delete all --all -n join-k8s-worker-3 --ignore-not-found=true --request-timeout=2m
+ kubectl delete pvc tmkms-data-pvc -n join-k8s-worker-3 --ignore-not-found=true --request-timeout=1m
+ continue-on-error: true
+
+ - name: Clean data on GCE instances
+ env:
+ GCE_PROJECT_ID: ${{ steps.params.outputs.GCE_PROJECT_ID }}
+ GCE_ZONE: ${{ steps.params.outputs.GCE_ZONE }}
+ K8S_WORKER_1_NAME: ${{ steps.params.outputs.K8S_WORKER_1_NAME }}
+ K8S_WORKER_2_NAME: ${{ steps.params.outputs.K8S_WORKER_2_NAME }}
+ K8S_WORKER_3_NAME: ${{ steps.params.outputs.K8S_WORKER_3_NAME }}
+ run: |
+ echo "Cleaning data on ${K8S_WORKER_1_NAME}..."
+ gcloud compute ssh ${K8S_WORKER_1_NAME} --zone ${GCE_ZONE} --project ${GCE_PROJECT_ID} --command "sudo rm -rf /srv/dai"
+ echo "Cleaning data on ${K8S_WORKER_2_NAME}..."
+ gcloud compute ssh ${K8S_WORKER_2_NAME} --zone ${GCE_ZONE} --project ${GCE_PROJECT_ID} --command "sudo rm -rf /srv/dai"
+ echo "Cleaning data on ${K8S_WORKER_3_NAME}..."
+ gcloud compute ssh ${K8S_WORKER_3_NAME} --zone ${GCE_ZONE} --project ${GCE_PROJECT_ID} --command "sudo rm -rf /srv/dai"
+
+ - name: Deploy Kubernetes resources
+ env:
+ KUBECONFIG: ${{ env.KUBECONFIG }} # Ensure KUBECONFIG is available
+ run: |
+ echo "About to deploy kubernetes resouces"
+ pwd
+ ls
+ # Applying kustomizations from the test-net-cloud/k8s directory (relative to repo root)
+ echo "Applying genesis manifests..."
+ kubectl apply -k test-net-cloud/k8s/genesis -n genesis
+ echo "Waiting for 15 seconds for genesis node to initialize..."
+ sleep 15
+ echo "Applying join-k8s-worker-2 manifests..."
+ kubectl apply -k test-net-cloud/k8s/overlays/join-k8s-worker-2 -n join-k8s-worker-2
+ echo "Applying join-k8s-worker-3 manifests..."
+ kubectl apply -k test-net-cloud/k8s/overlays/join-k8s-worker-3 -n join-k8s-worker-3
+
+ - name: Verify deployments
+ env:
+ KUBECONFIG: ${{ env.KUBECONFIG }} # Ensure KUBECONFIG is available
+ run: |
+ echo "Waiting for 60 seconds for pods to stabilize..."
+ sleep 60
+ echo "Pods in genesis namespace:"
+ kubectl get pods -n genesis -o wide
+ echo "Pods in join-k8s-worker-2 namespace:"
+ kubectl get pods -n join-k8s-worker-2 -o wide
+ echo "Pods in join-k8s-worker-3 namespace:"
+ kubectl get pods -n join-k8s-worker-3 -o wide
+ echo "PersistentVolumeClaims in relevant namespaces:"
+ kubectl get pvc -n join-k8s-worker-2
+ kubectl get pvc -n join-k8s-worker-3
diff --git a/.github/workflows/integration.yml b/.github/workflows/integration.yml
new file mode 100644
index 000000000..6cf83d2ef
--- /dev/null
+++ b/.github/workflows/integration.yml
@@ -0,0 +1,35 @@
+name: Integration Tests
+
+on:
+ workflow_dispatch:
+ inputs:
+ use_matrix:
+ description: 'Use matrix strategy for parallel test execution'
+ required: false
+ type: boolean
+ default: true
+ push:
+ branches:
+ - main
+ paths:
+ - 'inference-chain/**'
+ - 'decentralized-api/**'
+ - 'local-test-net/**'
+ - 'testermint/**'
+ issue_comment:
+ types: [created]
+
+jobs:
+ integration-tests:
+ if: github.event_name == 'workflow_dispatch' || github.event_name == 'push' || (github.event_name == 'issue_comment' && github.event.issue.pull_request && contains(github.event.comment.body, '/run-integration'))
+ uses: ./.github/workflows/test-workflow.yml
+ permissions:
+ contents: read
+ checks: write
+ with:
+ test_name: "Integration Tests"
+ test_command: "run-tests"
+ is_pr_comment: ${{ github.event_name == 'issue_comment' }}
+ pr_number: ${{ github.event.issue.number || '' }}
+ enable_upgrades: true
+ use_matrix: ${{ github.event_name == 'workflow_dispatch' && inputs.use_matrix || true }}
diff --git a/.github/workflows/publish_upgrade_binaries.yml b/.github/workflows/publish_upgrade_binaries.yml
new file mode 100644
index 000000000..750cc8c01
--- /dev/null
+++ b/.github/workflows/publish_upgrade_binaries.yml
@@ -0,0 +1,65 @@
+# .github/workflows/build-and-release-to-repo-b.yml (in RepoA)
+name: Build and Release to race-releases
+
+on:
+ push:
+ tags:
+ - 'release/v[0-9]*.[0-9]*.[0-9]*'
+ - 'release/v[0-9]*.[0-9]*.[0-9]*-*'
+jobs:
+ build_and_release:
+ runs-on: ubuntu-latest
+ steps:
+ - name: Set up Go
+ uses: actions/setup-go@v3.0.0
+ with:
+ go-version: '^1.22.2' # Replace with your Go version
+
+ - name: Checkout code
+ uses: actions/checkout@v3
+
+ - name: Run Makefile build
+ run: make build-for-upgrade
+ # This should produce files in:
+ # ./public/html/v2/inferenced/*
+ # ./public/html/v2/dapi/*
+
+ - name: Generate GitHub App Installation Token for release
+ id: get_release_token
+ uses: actions/create-github-app-token@v2
+ with:
+ app-id: ${{ secrets.APP_ID }}
+ private-key: ${{ secrets.APP_PRIVATE_KEY }}
+ owner: product-science
+ repositories: race-releases
+
+ - name: Create Release in race-releases with softprops/action-gh-release
+ uses: softprops/action-gh-release@v2 # Or specific commit hash for stability
+ with:
+ # The token generated by create-github-app-token has permissions for RepoB
+ token: ${{ steps.get_release_token.outputs.token }}
+ # --- Target Repository ---
+ repository: product-science/race-releases
+
+ # --- Release Details ---
+ tag_name: ${{ github.ref_name }} # Use the tag from the push event
+ name: Release ${{ github.ref_name }} # Use the tag for the release name
+ body: |
+ Automated release created from main source tag ${{ github.ref_name }}.
+ Build artifacts from the `build-for-upgrade` target.
+ draft: false
+ prerelease: false # Set to true if these are pre-releases
+
+ # --- Files to Upload ---
+ files: |
+ ./public-html/v2/inferenced/*.zip
+ ./public-html/v2/dapi/*.zip
+
+ - name: Create tag artifact
+ run: echo "${{ github.ref_name }}" > release_tag.txt
+
+ - name: Upload tag artifact
+ 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
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 0d472b428..dec5b3542 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -17,12 +17,15 @@ on: push
jobs:
might_release:
runs-on: ubuntu-latest
+ defaults:
+ run:
+ working-directory: ./inference-chain
steps:
- name: Checkout
- uses: actions/checkout@v2
+ uses: actions/checkout@v3
with:
fetch-depth: 0
-
+# https://github.com/ignite/cli/blob/281fff026281c3f00c05e2582701df6a7c402fe1/actions/release/vars/action.yml#L2
- name: Prepare Release Variables
id: vars
uses: ignite/cli/actions/release/vars@main
diff --git a/.github/workflows/sanity.yml b/.github/workflows/sanity.yml
new file mode 100644
index 000000000..2168ecef0
--- /dev/null
+++ b/.github/workflows/sanity.yml
@@ -0,0 +1,16 @@
+name: Sanity Tests
+
+on:
+ workflow_dispatch:
+ issue_comment:
+ types: [created]
+
+jobs:
+ sanity-tests:
+ if: github.event_name == 'workflow_dispatch' || (github.event_name == 'issue_comment' && github.event.issue.pull_request && contains(github.event.comment.body, '/run-sanity'))
+ uses: ./.github/workflows/test-workflow.yml
+ with:
+ test_name: "Sanity Tests"
+ test_command: "run-sanity"
+ is_pr_comment: ${{ github.event_name == 'issue_comment' }}
+ pr_number: ${{ github.event.issue.number || '' }}
\ No newline at end of file
diff --git a/.github/workflows/test-workflow.yml b/.github/workflows/test-workflow.yml
new file mode 100644
index 000000000..3278947b6
--- /dev/null
+++ b/.github/workflows/test-workflow.yml
@@ -0,0 +1,516 @@
+name: Reusable Test Workflow
+
+on:
+ workflow_call:
+ inputs:
+ test_name:
+ required: true
+ type: string
+ description: 'Name of the test suite (e.g., "Integration Tests" or "Sanity Tests")'
+ test_command:
+ required: true
+ type: string
+ description: 'Make command to run the tests (e.g., "run-tests" or "run-sanity")'
+ pr_number:
+ required: false
+ type: string
+ description: 'PR number when triggered by comment'
+ is_pr_comment:
+ required: false
+ type: boolean
+ default: false
+ description: 'Whether this workflow was triggered by a PR comment'
+ enable_upgrades:
+ required: false
+ type: boolean
+ default: false
+ description: 'Whether to run upgrade builds'
+ use_matrix:
+ required: false
+ type: boolean
+ default: true
+ description: 'Whether to use matrix strategy for parallel execution'
+
+jobs:
+ # This job dynamically scans for test classes and sets up the matrix for parallel test execution
+ # It replaces the previous hardcoded matrix with a dynamically generated one based on the actual test classes
+ setup-test-matrix:
+ runs-on: ubuntu-latest
+ outputs:
+ matrix: ${{ steps.set-matrix.outputs.matrix }}
+ steps:
+ - name: Check initial disk space
+ run: |
+ echo "=== Disk Space Before Cleanup ==="
+ df -h
+
+ - name: Free up disk space on runner
+ run: |
+ echo "Removing large pre-installed tools..."
+ sudo rm -rf /usr/share/dotnet
+ sudo rm -rf /usr/local/lib/android
+ sudo rm -rf /opt/ghc
+ sudo rm -rf /opt/hostedtoolcache/CodeQL
+ echo "Cleaning up apt and docker..."
+ sudo docker system prune -af --volumes
+ sudo apt-get clean
+ echo "=== Disk Space After Cleanup ==="
+ df -h
+ - name: Checkout code
+ uses: actions/checkout@v3
+ with:
+ ref: ${{ inputs.is_pr_comment && format('refs/pull/{0}/head', inputs.pr_number) || github.ref }}
+
+ - name: Set up Java
+ uses: actions/setup-java@v3
+ with:
+ distribution: 'temurin'
+ java-version: '21'
+
+ # This step uses Gradle tasks to scan for test classes that will actually run tests after filtering
+ # The tasks properly handle both class-level and method-level tags:
+ # 1. Classes with @Tag("exclude") or @Tag("unstable") at the class level are completely excluded
+ # 2. For remaining classes:
+ # - For run-tests: Lists only classes that have at least one test that doesn't have unstable,exclude tags
+ # - For run-sanity: Lists only classes that have at least one test with the sanity tag that doesn't have unstable,exclude tags
+ # This ensures we don't create matrix entries for test classes that would have zero tests after filtering,
+ # and properly handles files with multiple classes (like SpecTests.kt)
+ - name: Generate test matrix
+ id: set-matrix
+ run: |
+ cd testermint
+ if [[ "${{ inputs.test_command }}" == "run-tests" ]]; then
+ echo "Running listAllTestClasses task for integration tests"
+ # This uses the custom Gradle task that scans for all test classes
+ # The actual tag filtering (excluding unstable,exclude) happens at test runtime
+ TEST_CLASSES=$(./gradlew -q listAllTestClasses)
+ elif [[ "${{ inputs.test_command }}" == "run-sanity" ]]; then
+ echo "Running findSanityTestClasses task for sanity tests"
+ # This uses the custom Gradle task that scans for classes containing sanity-tagged tests
+ TEST_CLASSES=$(./gradlew -q findSanityTestClasses)
+ else
+ echo "Unknown test command: ${{ inputs.test_command }}"
+ exit 1
+ fi
+
+ # Format the output as a JSON array for the matrix
+ echo "matrix={\"test_group\":[${TEST_CLASSES}]}" >> $GITHUB_OUTPUT
+ echo "Generated matrix: {\"test_group\":[${TEST_CLASSES}]}"
+
+ build-images:
+ runs-on: ubuntu-latest
+ steps:
+ - name: Check initial disk space
+ run: |
+ echo "=== Disk Space Before Cleanup ==="
+ df -h
+
+ - name: Free up disk space on runner
+ run: |
+ echo "Removing large pre-installed tools..."
+ sudo rm -rf /usr/share/dotnet
+ sudo rm -rf /usr/local/lib/android
+ sudo rm -rf /opt/ghc
+ sudo rm -rf /opt/hostedtoolcache/CodeQL
+ echo "Cleaning up apt and docker..."
+ sudo docker system prune -af --volumes
+ sudo apt-get clean
+ echo "=== Disk Space After Cleanup ==="
+ df -h
+
+ - name: Checkout code
+ uses: actions/checkout@v3
+ with:
+ ref: ${{ inputs.is_pr_comment && format('refs/pull/{0}/head', inputs.pr_number) || github.ref }}
+
+ - name: Set up Docker (Latest Version)
+ uses: docker/setup-docker-action@v4
+ with:
+ version: 'latest'
+
+ - name: Verify Docker Installation
+ run: |
+ docker --version
+ docker compose version
+
+ - name: Install Make
+ run: |
+ sudo apt-get update
+ sudo apt-get install -y make
+
+ - name: Set up Java
+ uses: actions/setup-java@v3
+ with:
+ distribution: 'temurin'
+ java-version: '19'
+
+ - name: Make Docker Images
+ env:
+ GENESIS_OVERRIDES_FILE: "inference-chain/test_genesis_overrides.json"
+ run: |
+ sudo make build-docker
+ echo "=== Images immediately after build ==="
+ sudo docker images | head -20
+
+ - name: Save Docker Images
+ run: |
+ mkdir -p docker-images
+ sudo docker save -o docker-images/inference-chain.tar ghcr.io/product-science/inferenced:latest
+ sudo docker save -o docker-images/decentralized-api.tar ghcr.io/product-science/api:latest
+ sudo docker save -o docker-images/inference-mock-server.tar inference-mock-server:latest
+ sudo docker save -o docker-images/proxy.tar ghcr.io/product-science/proxy:latest
+ # Compress images to save storage space
+ sudo gzip docker-images/*.tar
+ # Fix ownership so upload-artifact can access files
+ sudo chown -R $USER:$USER docker-images/
+ echo "=== Created files ==="
+ ls -la docker-images/
+
+ - name: Upload Docker Images
+ uses: actions/upload-artifact@v4
+ with:
+ name: docker-images
+ path: docker-images/
+ retention-days: 1
+
+ - name: Make Upgrade Build
+ if: ${{ inputs.enable_upgrades }}
+ run: |
+ sudo make build-for-upgrade-tests
+ # Fix ownership of upgrade build files
+ sudo chown -R $USER:$USER public-html/ || true
+
+ - name: Upload Upgrade Build Files
+ if: ${{ inputs.enable_upgrades }}
+ uses: actions/upload-artifact@v4
+ with:
+ name: upgrade-build-files
+ path: public-html/
+ retention-days: 1
+
+ # This job runs the tests in parallel using the dynamically generated matrix
+ # It depends on both setup-test-matrix (for the matrix) and build-images (for the Docker images)
+ run-tests:
+ needs: [setup-test-matrix, build-images]
+ runs-on: ubuntu-latest
+ strategy:
+ fail-fast: false
+ # Use the dynamically generated matrix from the setup-test-matrix job
+ # This replaces the previous hardcoded list of test classes
+ matrix: ${{ fromJson(needs.setup-test-matrix.outputs.matrix) }}
+
+ steps:
+ - name: Checkout code
+ uses: actions/checkout@v3
+ with:
+ ref: ${{ inputs.is_pr_comment && format('refs/pull/{0}/head', inputs.pr_number) || github.ref }}
+
+ - name: Set up Docker (Latest Version)
+ uses: docker/setup-docker-action@v4
+ with:
+ version: '28.5.2'
+
+ - name: Download Docker Images
+ uses: actions/download-artifact@v4
+ with:
+ name: docker-images
+ path: docker-images/
+
+ - name: Load Docker Images
+ run: |
+ # Decompress first
+ sudo gunzip docker-images/*.tar.gz || true
+ # Load images with :latest tags
+ sudo docker load -i docker-images/inference-chain.tar || true
+ sudo docker load -i docker-images/decentralized-api.tar || true
+ sudo docker load -i docker-images/inference-mock-server.tar || true
+ sudo docker load -i docker-images/proxy.tar || true
+
+ - name: Install Make
+ run: |
+ sudo apt-get update
+ sudo apt-get install -y make
+
+ - name: Set up Java
+ uses: actions/setup-java@v3
+ with:
+ distribution: 'temurin'
+ java-version: '19'
+
+ - name: Download Upgrade Build Files
+ if: ${{ inputs.enable_upgrades }}
+ uses: actions/download-artifact@v4
+ continue-on-error: true
+ with:
+ name: upgrade-build-files
+ path: public-html/
+
+ - name: Start test chain
+ working-directory: local-test-net
+ run: sudo ./launch.sh
+
+ - name: Run Tests (Matrix - Integration)
+ if: ${{ inputs.use_matrix && inputs.test_command == 'run-tests' }}
+ run: |
+ echo "Running test group: ${{ matrix.test_group }}"
+ sudo make run-tests TESTS="${{ matrix.test_group }}"
+
+ - name: Run Tests (Matrix - Sanity)
+ if: ${{ inputs.use_matrix && inputs.test_command == 'run-sanity' }}
+ run: |
+ echo "Running sanity test group: ${{ matrix.test_group }}"
+ sudo make run-sanity TESTS="${{ matrix.test_group }}"
+
+ - name: Run Tests (Non-Matrix)
+ if: ${{ !inputs.use_matrix }}
+ run: sudo make ${{ inputs.test_command }}
+
+ - name: Archive Test Logs
+ if: always()
+ uses: actions/upload-artifact@v4
+ id: archive-logs
+ with:
+ name: test-logs-${{ matrix.test_group }}
+ path: ./testermint/logs
+ retention-days: 7 # Keep test logs for 1 week only
+
+ - name: Detect Unordered Nonce in Logs
+ if: always()
+ id: detect-unordered-nonce
+ run: |
+ set -e
+ # Search all files under logs for the exact text (ignore binary)
+ MATCHES=$(grep -RIl -F "failed to add unordered nonce" ./testermint/logs || true)
+ if [ -n "$MATCHES" ]; then
+ echo "Detected 'failed to add unordered nonce' in the following files:"
+ echo "$MATCHES"
+ # Expose to later steps
+ echo "HAS_UNORDERED_NONCE=true" >> "$GITHUB_ENV"
+ # Also keep list of files (for debugging if needed)
+ {
+ echo "UNORDERED_NONCE_FILES<> "$GITHUB_ENV"
+ # Fail this step so the job is marked as failed
+ exit 1
+ else
+ echo "HAS_UNORDERED_NONCE=false" >> "$GITHUB_ENV"
+ fi
+
+ - name: Install XML utilities
+ if: always()
+ run: sudo apt-get update && sudo apt-get install -y libxml2-utils
+
+ - name: Publish Test Results
+ uses: dorny/test-reporter@v1
+ if: always()
+ continue-on-error: true
+ id: test-reporter
+ with:
+ name: ${{ inputs.test_name }} (${{ matrix.test_group }})
+ path: ./testermint/build/test-results/**/*.xml
+ reporter: java-junit
+ fail-on-error: false
+
+ - name: Save Test Counts
+ if: always()
+ run: |
+ # Count tests from XML files
+ PASSED=0
+ FAILED=0
+ SKIPPED=0
+ FAILED_TESTS=""
+
+ if [ -d "./testermint/build/test-results/test" ]; then
+ for xml in ./testermint/build/test-results/test/*.xml; do
+ if [ -f "$xml" ]; then
+ TESTS=$(grep -o 'tests="[0-9]*"' "$xml" | grep -o '[0-9]*' || echo "0")
+ FAILURES=$(grep -o 'failures="[0-9]*"' "$xml" | grep -o '[0-9]*' || echo "0")
+ SKIPS=$(grep -o 'skipped="[0-9]*"' "$xml" | grep -o '[0-9]*' || echo "0")
+
+ PASSED=$((PASSED + TESTS - FAILURES - SKIPS))
+ FAILED=$((FAILED + FAILURES))
+ SKIPPED=$((SKIPPED + SKIPS))
+
+ # Extract detailed failed test names
+ if [ "$FAILURES" -gt 0 ]; then
+ # This is more robust against spaces in test names.
+ # It extracts the attribute values by replacing quotes with newlines and filtering.
+ FAILED_CLASSNAMES=$(xmllint --xpath "//testcase[failure]/@classname" "$xml" 2>/dev/null | tr '"' '\n' | grep -v 'classname=' | grep . || echo "")
+ FAILED_NAMES=$(xmllint --xpath "//testcase[failure]/@name" "$xml" 2>/dev/null | tr '"' '\n' | grep -v 'name=' | grep . || echo "")
+
+ # Combine them line-by-line, e.g., "com.example.Test > testMethod"
+ # and then convert to a single comma-separated string.
+ if [ -n "$FAILED_NAMES" ]; then
+ FAILED_DETAILS_LINES=$(paste -d ' > ' <(echo "$FAILED_CLASSNAMES") <(echo "$FAILED_NAMES"))
+ FAILED_FROM_XML=$(echo "$FAILED_DETAILS_LINES" | tr '\n' ',')
+
+ if [ ! -z "$FAILED_FROM_XML" ]; then
+ if [ -z "$FAILED_TESTS" ];
+ then FAILED_TESTS="$FAILED_FROM_XML"
+ else FAILED_TESTS="$FAILED_TESTS$FAILED_FROM_XML"
+ fi
+ fi
+ fi
+ fi
+ fi
+ done
+ fi
+
+ # If unordered nonce error detected in logs, treat it as a failed test
+ if [ "${HAS_UNORDERED_NONCE:-false}" = "true" ]; then
+ FAILED=$((FAILED + 1))
+ if [ -z "$FAILED_TESTS" ]; then
+ FAILED_TESTS="Unordered Nonce Check (see Logs),"
+ else
+ FAILED_TESTS="${FAILED_TESTS}Unordered Nonce Check (see Logs),"
+ fi
+ fi
+
+ # Clean up failed tests list (remove trailing comma)
+ FAILED_TESTS=$(echo "$FAILED_TESTS" | sed 's/,$//')
+
+ # Get URLs for test report and logs
+ TEST_REPORT_URL="${{ steps.test-reporter.outputs.url_html || 'N/A' }}"
+ LOGS_ARTIFACT_URL="https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}/artifacts/${{ steps.archive-logs.outputs.artifact-id || 'N/A' }}"
+
+ # Save to file with unique name
+ {
+ echo "${{ matrix.test_group }}: $PASSED passed, $FAILED failed, $SKIPPED skipped"
+ echo "TEST_REPORT_URL: $TEST_REPORT_URL"
+ echo "LOGS_URL: $LOGS_ARTIFACT_URL"
+ if [ ! -z "$FAILED_TESTS" ]; then
+ echo "FAILED_TESTS: $FAILED_TESTS"
+ fi
+ } > test-counts-${{ matrix.test_group }}.txt
+
+ echo "##[debug]${{ matrix.test_group }}: P=$PASSED, F=$FAILED, S=$SKIPPED"
+ if [ ! -z "$FAILED_TESTS" ]; then
+ echo "##[debug]Failed tests: $FAILED_TESTS"
+ fi
+
+ # Show contents of the generated file for debugging
+ echo "##[debug]Generated file contents:"
+ cat test-counts-${{ matrix.test_group }}.txt
+
+ - name: Upload Test Counts
+ if: always()
+ uses: actions/upload-artifact@v4
+ with:
+ name: test-counts-${{ matrix.test_group }}
+ path: test-counts-${{ matrix.test_group }}.txt
+ retention-days: 1
+
+ # Simple summary job
+ test-summary:
+ needs: run-tests
+ runs-on: ubuntu-latest
+ if: always()
+ steps:
+ - name: Download All Test Counts
+ uses: actions/download-artifact@v4
+ with:
+ pattern: test-counts-*
+ merge-multiple: true
+
+ - name: Aggregate Results
+ run: |
+ echo "# 📊 Test Results Summary" >> $GITHUB_STEP_SUMMARY
+ echo "" >> $GITHUB_STEP_SUMMARY
+ echo "| Test Group | Passed | Failed | Skipped | Reports |" >> $GITHUB_STEP_SUMMARY
+ echo "|------------|--------|--------|---------|---------|" >> $GITHUB_STEP_SUMMARY
+
+ TOTAL_PASSED=0
+ TOTAL_FAILED=0
+ TOTAL_SKIPPED=0
+ ALL_FAILED_TESTS=""
+
+ echo "##[debug]Looking for test count files..."
+ ls -la test-counts-*.txt || echo "No test count files found"
+
+ for file in test-counts-*.txt; do
+ if [ -f "$file" ]; then
+ content=$(cat "$file")
+ echo "Processing: $content"
+
+ # Extract test group name and numbers from first line
+ first_line=$(echo "$content" | head -n1)
+ TEST_GROUP=$(echo "$first_line" | cut -d':' -f1)
+ PASSED=$(echo "$first_line" | grep -o '[0-9]* passed' | grep -o '[0-9]*')
+ FAILED=$(echo "$first_line" | grep -o '[0-9]* failed' | grep -o '[0-9]*')
+ SKIPPED=$(echo "$first_line" | grep -o '[0-9]* skipped' | grep -o '[0-9]*')
+
+ # Extract URLs
+ TEST_REPORT_URL=""
+ LOGS_URL=""
+ if grep -q "TEST_REPORT_URL:" "$file"; then
+ TEST_REPORT_URL=$(grep "TEST_REPORT_URL:" "$file" | cut -d':' -f2- | sed 's/^ *//')
+ fi
+ if grep -q "LOGS_URL:" "$file"; then
+ LOGS_URL=$(grep "LOGS_URL:" "$file" | cut -d':' -f2- | sed 's/^ *//')
+ fi
+
+ # Create links
+ LINKS=""
+ if [ ! -z "$TEST_REPORT_URL" ] && [ "$TEST_REPORT_URL" != "N/A" ]; then
+ LINKS="[Report]($TEST_REPORT_URL)"
+ fi
+ if [ ! -z "$LOGS_URL" ] && [ "$LOGS_URL" != "N/A" ]; then
+ if [ ! -z "$LINKS" ]; then
+ LINKS="$LINKS / [Logs]($LOGS_URL)"
+ else
+ LINKS="[Logs]($LOGS_URL)"
+ fi
+ fi
+
+ # Add to table
+ echo "| $TEST_GROUP | $PASSED | $FAILED | $SKIPPED | $LINKS |" >> $GITHUB_STEP_SUMMARY
+
+ TOTAL_PASSED=$((TOTAL_PASSED + PASSED))
+ TOTAL_FAILED=$((TOTAL_FAILED + FAILED))
+ TOTAL_SKIPPED=$((TOTAL_SKIPPED + SKIPPED))
+
+ # Extract failed test names if present
+ if grep -q "FAILED_TESTS:" "$file"; then
+ FAILED_TESTS=$(grep "FAILED_TESTS:" "$file" | cut -d':' -f2- | sed 's/^ *//')
+ if [ ! -z "$FAILED_TESTS" ]; then
+ if [ -z "$ALL_FAILED_TESTS" ]; then
+ ALL_FAILED_TESTS="**$TEST_GROUP:** $FAILED_TESTS"
+ else
+ ALL_FAILED_TESTS="$ALL_FAILED_TESTS\n**$TEST_GROUP:** $FAILED_TESTS"
+ fi
+ fi
+ fi
+
+ echo "##[debug]$TEST_GROUP: P=$PASSED, F=$FAILED, S=$SKIPPED"
+ fi
+ done
+
+ # Add totals row
+ echo "|------------|--------|--------|---------|---------|" >> $GITHUB_STEP_SUMMARY
+ echo "| **TOTAL** | **$TOTAL_PASSED** | **$TOTAL_FAILED** | **$TOTAL_SKIPPED** | |" >> $GITHUB_STEP_SUMMARY
+ echo "" >> $GITHUB_STEP_SUMMARY
+
+ # Add status indicator
+ if [ $TOTAL_FAILED -eq 0 ]; then
+ echo "## ✅ All tests passed!" >> $GITHUB_STEP_SUMMARY
+ echo "**Total tests executed: $((TOTAL_PASSED + TOTAL_SKIPPED))**" >> $GITHUB_STEP_SUMMARY
+ else
+ echo "## ❌ Some tests failed" >> $GITHUB_STEP_SUMMARY
+ echo "**$TOTAL_FAILED test(s) failed out of $((TOTAL_PASSED + TOTAL_FAILED + TOTAL_SKIPPED)) total**" >> $GITHUB_STEP_SUMMARY
+
+ # Add failed test details
+ if [ ! -z "$ALL_FAILED_TESTS" ]; then
+ echo "" >> $GITHUB_STEP_SUMMARY
+ echo "### 🔍 Failed Tests Details:" >> $GITHUB_STEP_SUMMARY
+ echo "" >> $GITHUB_STEP_SUMMARY
+ echo -e "$ALL_FAILED_TESTS" >> $GITHUB_STEP_SUMMARY
+ fi
+ fi
+
+ echo "" >> $GITHUB_STEP_SUMMARY
+ echo "---" >> $GITHUB_STEP_SUMMARY
+ echo "*Individual test reports are available in the Checks tab above*" >> $GITHUB_STEP_SUMMARY
+
+ echo "##[debug]FINAL TOTALS: Passed=$TOTAL_PASSED, Failed=$TOTAL_FAILED, Skipped=$TOTAL_SKIPPED"
diff --git a/.github/workflows/update_voting.yml b/.github/workflows/update_voting.yml
new file mode 100644
index 000000000..c1e834c68
--- /dev/null
+++ b/.github/workflows/update_voting.yml
@@ -0,0 +1,162 @@
+name: Update Voting Configuration
+on:
+ workflow_run:
+ workflows: [ "Build and Release to race-releases" ]
+ types:
+ - completed
+ workflow_dispatch: # Allows manual triggering
+ inputs:
+ release_tag:
+ description: 'Release tag to use for testing'
+ required: false
+ type: string
+ default: 'release/v0.0.0-manual-test'
+
+jobs:
+ vote_for_update:
+ runs-on: ubuntu-latest
+ # Run if manually dispatched OR if triggered by a successful workflow_run
+ # if: github.event_name == 'workflow_dispatch' || (github.event_name == 'workflow_run' && github.event.workflow_run.conclusion == 'success')
+
+ permissions:
+ contents: 'read'
+ id-token: 'write'
+ packages: 'write'
+ actions: 'read' # Still needed if workflow_run triggers and we download artifact
+ checks: 'write' # Needed for test results reporting
+
+ steps:
+ - uses: actions/checkout@v3
+ with:
+ fetch-depth: 0
+
+ - name: Download release tag artifact (if triggered by workflow_run)
+ if: github.event_name == 'workflow_run' # Only run this step if triggered by another workflow
+ uses: actions/download-artifact@v4
+ with:
+ name: release-tag-artifact
+ run-id: ${{ github.event.workflow_run.id }}
+ github-token: ${{secrets.GITHUB_TOKEN}}
+ # Use the GITHUB_TOKEN to authenticate and download the artifact
+ # Artifact is downloaded as a .zip that needs to be extracted
+ # Continue even if artifact download fails for some reason, next step handles missing file.
+ continue-on-error: true
+
+ - name: Extract artifact (if needed)
+ if: github.event_name == 'workflow_run'
+ run: |
+ # Find and unzip any .zip files in the workspace
+ find . -name "*.zip" -exec unzip -o {} \;
+ # List files for debugging purposes
+ echo "Files after extraction:"
+ ls -la
+ continue-on-error: true
+
+ - name: Determine Release Tag
+ id: release_info
+ run: |
+ DEFAULT_TAG="v0.0.0-manual-test" # Default tag for manual runs or if artifact is missing
+ TAG_VALUE="$DEFAULT_TAG"
+
+ if [[ "${{ github.event_name }}" == "workflow_run" ]]; then
+ echo "Workflow triggered by 'workflow_run'."
+ if [[ -f release_tag.txt ]]; then
+ TAG_VALUE=$(cat release_tag.txt)
+ echo "Using tag from downloaded artifact: $TAG_VALUE"
+ else
+ echo "WARNING: 'workflow_run' trigger but release_tag.txt not found (or download failed). Using default tag: $TAG_VALUE"
+ fi
+ elif [[ "${{ github.event_name }}" == "workflow_dispatch" ]]; then
+ if [[ -n "${{ inputs.release_tag }}" ]]; then
+ TAG_VALUE="${{ inputs.release_tag }}"
+ echo "Using provided release tag: $TAG_VALUE"
+ else
+ echo "No release tag provided. Using default tag: $TAG_VALUE"
+ fi
+ else
+ echo "Workflow triggered by '${{ github.event_name }}'. Using default tag: $TAG_VALUE"
+ fi
+ echo "Final Release Tag: $TAG_VALUE"
+ echo "release_tag=$TAG_VALUE" >> $GITHUB_OUTPUT
+
+ - uses: ./.github/actions/gcp-auth-and-gcloud-setup # Assumes this sets up gcloud CLI
+
+ - name: Install kubectl
+ uses: azure/setup-kubectl@v4
+
+ - name: Define GCE/K8s parameters
+ id: params
+ run: |
+ echo "GCE_PROJECT_ID=$(gcloud config get-value project)" >> $GITHUB_OUTPUT
+ echo "GCE_ZONE=us-central1-a" >> $GITHUB_OUTPUT
+ echo "K8S_CONTROL_PLANE_NAME=k8s-control-plane" >> $GITHUB_OUTPUT
+ echo "K8S_CONTROL_PLANE_USER=dev" >> $GITHUB_OUTPUT
+
+ - name: Configure kubectl
+ env:
+ GCE_PROJECT_ID: ${{ steps.params.outputs.GCE_PROJECT_ID }}
+ GCE_ZONE: ${{ steps.params.outputs.GCE_ZONE }}
+ K8S_CONTROL_PLANE_NAME: ${{ steps.params.outputs.K8S_CONTROL_PLANE_NAME }}
+ K8S_CONTROL_PLANE_USER: ${{ steps.params.outputs.K8S_CONTROL_PLANE_USER }}
+ run: |
+ echo "Fetching kubeconfig from ${K8S_CONTROL_PLANE_NAME} in zone ${GCE_ZONE}..."
+ mkdir -p $HOME/.kube
+ gcloud compute scp ${K8S_CONTROL_PLANE_USER}@${K8S_CONTROL_PLANE_NAME}:~/.kube/config $HOME/.kube/config --zone ${GCE_ZONE} --project ${GCE_PROJECT_ID}
+ export KUBECONFIG=$HOME/.kube/config
+ echo "KUBECONFIG=$KUBECONFIG" >> $GITHUB_ENV
+
+ # ---- IMPORTANT: SSH Tunnel (if K8s API server is not directly accessible) ----
+ # If your K8s API server isn't publicly accessible, you'll need an SSH tunnel.
+ # 1. Uncomment and adapt the following lines.
+ # 2. Ensure your kubeconfig (once copied) targets 'https://127.0.0.1:6443' or similar.
+ #
+ echo "Setting up SSH tunnel to ${K8S_CONTROL_PLANE_NAME}..."
+ gcloud compute ssh ${K8S_CONTROL_PLANE_USER}@${K8S_CONTROL_PLANE_NAME} --zone ${GCE_ZONE} --project ${GCE_PROJECT_ID} \
+ --ssh-flag="-L 6443:127.0.0.1:6443 -N -f"
+ sleep 5 # Give tunnel time to establish
+ echo "Kubeconfig modified to use tunnel."
+ # ---- End SSH Tunnel Section ----
+
+ echo "Verifying kubectl connection..."
+ kubectl cluster-info
+ kubectl get nodes --request-timeout=30s
+ kubectl get pods --all-namespaces --field-selector spec.nodeName=k8s-worker-1 -o wide
+
+ - name: Set up Java
+ uses: actions/setup-java@v3
+ with:
+ distribution: 'temurin'
+ java-version: '19'
+
+ - name: Install Make
+ run: |
+ sudo apt-get update
+ sudo apt-get install -y make
+
+ - name: Check file permissions
+ run: ls -l $HOME/.kube/config
+
+ - name: Run k8sUpgrade Test
+ env:
+ RELEASE_TAG: ${{ steps.release_info.outputs.release_tag }}
+ KUBECONFIG: ${{ env.KUBECONFIG }}
+ run: |
+ cd testermint
+ sudo -E ./gradlew test --tests "KubernetesTests.k8sUpgrade" \
+ -DRELEASE_TAG=${RELEASE_TAG} \
+ -DKUBECONFIG=${KUBECONFIG}
+
+ - name: Archive Test Logs
+ if: always()
+ uses: actions/upload-artifact@v4
+ with:
+ name: k8s-upgrade-test-logs
+ path: ./testermint/logs
+
+ - name: Publish Test Results
+ uses: dorny/test-reporter@v1
+ if: always()
+ with:
+ name: K8s Upgrade Test
+ path: ./testermint/build/test-results/**/*.xml
+ reporter: java-junit
diff --git a/.github/workflows/verify.yml b/.github/workflows/verify.yml
index d1e143809..19bde58e4 100644
--- a/.github/workflows/verify.yml
+++ b/.github/workflows/verify.yml
@@ -10,12 +10,76 @@ on:
jobs:
build-and-test:
runs-on: ubuntu-latest
+ name: Build and Test chain
+ permissions:
+ contents: read
+ checks: write
defaults:
run:
- working-directory: ./inference # Set your desired directory here
+ working-directory: ./inference-chain
+ steps:
+ - name: Set up Go
+ uses: actions/setup-go@v3.0.0
+ with:
+ go-version: '^1.22.2' # Replace with your Go version
+
+ - name: Checkout code
+ uses: actions/checkout@v3
+
+ - name: Clone cosmos-sdk repo with specific branch
+ run: |
+ git clone --branch release/v0.50.x https://github.com/product-science/cosmos-sdk.git ../../ps-fork/cosmos-sdk
+
+ - name: Cache Go modules
+ uses: actions/cache@v4
+ with:
+ path: ~/go/pkg/mod
+ key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
+ restore-keys: |
+ ${{ runner.os }}-go-
+
+ - name: Install dependencies
+ run: go mod download
+
+ - name: Build
+ run: go build -o ./build/inferenced ./cmd/inferenced/main.go
+
+ - name: Install go-junit-report
+ run: go install github.com/jstemmer/go-junit-report/v2@latest
+
+ - name: Run Tests and Generate JUnit Report
+ run: go test ./... -v 2>&1 | go-junit-report -set-exit-code > junit-report.xml
+
+ - name: Publish Test Results
+ uses: actions/upload-artifact@v4
+ if: always()
+ with:
+ name: node-junit-report
+ path: inference-chain/junit-report.xml
+
+ - name: Report Test Results in GitHub
+ uses: dorny/test-reporter@v1
+ if: always()
+ with:
+ name: Inferenced Tests
+ path: inference-chain/junit-report.xml
+ reporter: java-junit
+ build-and-test-api:
+ runs-on: ubuntu-latest
+ name: Build and Test API Wrapper
+ permissions:
+ contents: read
+ checks: write
+ defaults:
+ run:
+ working-directory: ./decentralized-api
steps:
- name: Checkout code
- uses: actions/checkout@v2
+ uses: actions/checkout@v3
+
+ - name: Clone cosmos-sdk repo with specific branch
+ run: |
+ git clone --branch release/v0.50.x https://github.com/product-science/cosmos-sdk.git ../../ps-fork/cosmos-sdk
- name: Set up Go
uses: actions/setup-go@v2
@@ -23,7 +87,7 @@ jobs:
go-version: '^1.22.2' # Replace with your Go version
- name: Cache Go modules
- uses: actions/cache@v2
+ uses: actions/cache@v4
with:
path: ~/go/pkg/mod
key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
@@ -36,5 +100,23 @@ jobs:
- name: Build
run: go build ./...
- - name: Test
- run: go test ./... -v
\ No newline at end of file
+ - name: Install go-junit-report
+ run: go install github.com/jstemmer/go-junit-report@latest
+
+ - name: Run Tests and Generate JUnit Report
+ run: go test ./... -v 2>&1 | go-junit-report -set-exit-code > junit-report.xml
+
+ - name: Publish Test Results
+ uses: actions/upload-artifact@v4
+ if: always()
+ with:
+ name: api-junit-report
+ path: decentralized-api/junit-report.xml
+
+ - name: Report Test Results in GitHub
+ uses: dorny/test-reporter@v1
+ if: always()
+ with:
+ name: Decentralized-API Tests
+ path: decentralized-api/junit-report.xml
+ reporter: java-junit
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 000000000..4d17ed547
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,35 @@
+vue/node_modules
+vue/dist
+release/
+.idea/
+.vscode/
+.DS_Store
+*.dot
+*.log
+*.ign
+prod-sim/
+gcp-prod-sim/
+decentralized-api/build/
+decentralized-api/dist/
+decentralized-api/responses/
+inference-chain/build/
+inference-chain/dist/
+/decentralized-api/decentralized-api
+chain-venv/
+.inference/
+prod-genesis/
+prod-local/
+/payload.json
+/prod-local/genesis
+/inference-chain/output/
+/decentralized-api/output/
+/jq_test/
+/public-html/
+/logdy
+/inference-chain/junit-report.xml
+/deploy/**/config.env
+/testermint/reboot.txt
+/local-test-net/node_payload_2.json
+/testermint/downloads/
+/testermint/logs/
+balances-*.json
diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 000000000..5f792ffa1
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "mlnode/packages/train/third_party/gorilla"]
+ path = mlnode/packages/train/third_party/gorilla
+ url = https://github.com/product-science/gorilla.git
diff --git a/.idea/inference-ignite.iml b/.idea/inference-ignite.iml
index 5e764c4f0..fc1061e31 100644
--- a/.idea/inference-ignite.iml
+++ b/.idea/inference-ignite.iml
@@ -1,9 +1,23 @@
+
+
+
+
+
-
-
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/vcs.xml b/.idea/vcs.xml
index 35eb1ddfb..9d331cd52 100644
--- a/.idea/vcs.xml
+++ b/.idea/vcs.xml
@@ -1,6 +1,7 @@
-
+
+
\ No newline at end of file
diff --git a/.junie/guidelines.md b/.junie/guidelines.md
new file mode 100644
index 000000000..ec1f01ebe
--- /dev/null
+++ b/.junie/guidelines.md
@@ -0,0 +1,144 @@
+# Development Guidelines for Gonka Project
+
+This document outlines the development guidelines for the Gonka project, with a special focus on considerations for AI Agents working with the codebase.
+
+## Project Overview
+
+Gonka is a decentralized AI infrastructure designed to optimize computational power for AI model training and inference. The project uses a novel consensus mechanism called "Proof of Work 2.0" that ensures computational resources are allocated to AI workloads rather than being wasted on securing the blockchain.
+
+The system consists of three main components:
+1. **Chain Node** - Connects to the blockchain, maintains the blockchain layer, and handles consensus
+2. **API Node** - Serves as the coordination layer between the blockchain and the AI execution environment
+3. **ML Node** - Handles AI workload execution: training, inference, and Proof of Work 2.0(This is currently not in this repo)
+
+## Repository Structure
+
+```
+/client-libs # Client script to interact with the chain
+/cosmovisor # Cosmovisor binaries
+/decentralized-api # Api node
+/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
+/testermint # Integration tests suite
+/local-test-net # Scripts and other files for runnina a local test net with multiple nodes
+```
+
+## Guidelines for Generated Files
+
+### Protobuf Files
+
+**IMPORTANT**: Do not edit `.pb.go` files directly. These are generated files based on `.proto` files.
+
+When working with protobuf definitions:
+
+1. Edit the `.proto` files
+2. Run `ignite generate proto-go` in the `inference-chain` directory to regenerate the Go code
+3. For ML node protobuf definitions, refer to the [chain-protos repository](https://github.com/product-science/chain-protos/blob/main/proto/network_node/v1/network_node.proto)
+4. After editing `.proto` files, copy them to the ML node and Inference Ignite repositories, and regenerate the bindings (currently not possible within this repo)
+
+### Ignite Commands
+
+For working with Cosmos Ignite:
+
+**ALL** ignite commands should be run in the `inference-chain` directory, NOT the root.
+
+- Add new store object:
+ ```
+ ignite scaffold map participant reputation:int weight:int join_time:uint join_height:int last_inference_time:uint --index address --module inference --no-message
+ ```
+ - Include `--no-message` to prevent the store object from being modifiable by messages sent to the chain
+ - Prefer snake_case naming
+
+- Add new message:
+ ```
+ ignite scaffold message createGame black red --module checkers --response gameIndex
+ ```
+
+- Add new query:
+ ```
+ ignite scaffold query getGameResult gameIndex --module checkers --response result
+ ```
+
+- Modify existing store object:
+ 1. Change the types in the `.proto` file for the store object
+ 2. Run `ignite generate proto-go`
+
+- Modify existing message:
+ 1. Change the types in `tx.proto`
+ 2. Run `ignite generate proto-go`
+
+## Blockchain-Specific Considerations
+
+### Avoiding Consensus Failures
+
+Consensus failures can occur when nodes calculate the state differently. To prevent this:
+
+1. **Don't use maps in state calculations**
+ - Go's map iteration order is indeterminate
+ - Use slices or arrays instead
+ - If maps are necessary, implement a deterministic map
+
+2. **Avoid randomness in state calculations**
+ - All GUIDs, random numbers, and anything using randomness must be calculated outside chain state calculation
+ - Any randomness in state calculations means consensus cannot be reached
+
+3. **Don't use map iteration to generate lists or maps**
+ - If needed, implement a deterministic map or iterate on a sorted list of keys
+
+### Debugging Consensus Failures
+
+If a consensus failure occurs:
+
+1. Note the block height of the failure
+2. Exec into a container running the node
+3. Run `inferenced export --height `
+4. Compare the JSON state output from different nodes to identify where states differed
+
+## Testing Requirements
+
+Before submitting a pull request:
+
+1. Run unit tests and integration tests:
+ ```
+ make local-build
+ make run-tests
+ ```
+2. `make run-tests` will take a very long time to run (90 minutes+), so do it only when most of the work is done.
+2. Ensure all unit tests pass
+3. Ensure all integration tests pass, minus known issues listed in `testermint/KNOW_ISSUES.md`
+
+## Documentation
+
+- Update documentation alongside code changes that affect behavior, APIs, or assumptions
+- Missing documentation may delay PR approval
+
+## Guidelines for AI Agents
+
+When working with this codebase, AI Agents should:
+
+1. **Understand the architecture** - Familiarize yourself with the three main components (Chain Node, API Node, ML Node) and how they interact
+
+2. **Respect generated files** - Never modify `.pb.go` files directly; always edit the `.proto` files and regenerate
+
+3. **Be aware of blockchain constraints** - Pay special attention to determinism in state calculations, avoiding maps and randomness
+
+4. **Follow testing protocols** - Run unit tests before finishing. Do not run integration tests unless specifically told to
+
+5. **Document changes thoroughly** - Provide clear explanations for any proposed modifications
+
+6. **Consider consensus implications** - Any changes to state calculation must maintain deterministic behavior across all nodes. NEVER use maps in proto files or iterate over maps to generate parts of the state, as these are non-deterministic and will BREAK THE CHAIN.
+
+7. **Use appropriate Ignite commands** - Follow the patterns established in the ignite_cheat_sheet.md for scaffolding new and modifying existing components. Components only need to be added using ignite if they are to be stored in the actual state of the blockchain, however.
+
+8. **Add new files to Git** - Use `git add` on the CLI to add newly created files to Github.
+9. **NEVER COMMIT FILES** - AI Agents should never commit files directly. Instead, they should provide the necessary changes and explanations, which can then be reviewed and committed by a human developer.
+
+By following these guidelines, AI Agents can contribute effectively to the Gonka project while maintaining the integrity and stability of the system.
+
+## Running Unit Tests During Dev
+To run tests in the `inference-chain` project:
+1. change to the `inference-chain` directory
+2. To execute ALL tests: `go test ./...`
+3. To execute tests for a specific file `go test (relative path from inference-chain)`
\ No newline at end of file
diff --git a/.run/build-w-config.run.xml b/.run/build-w-config.run.xml
new file mode 100644
index 000000000..2b3ebe42b
--- /dev/null
+++ b/.run/build-w-config.run.xml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 000000000..5f99c3f79
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,132 @@
+# Contributing guidelines
+This project is maintained by a distributed team of contributors, and contributions are more than welcome. This guide outlines everything you need to know to participate — from coding standards to PR approvals and architectural proposals.
+## Pull request lifecycle
+
+1. Fork and branch
+ 1. Always work on a feature branch off the main branch.
+ 2. Use clear and descriptive naming: `feature/xyz`, `bugfix/abc`, `refactor/component-name`.
+2. Create a pull request
+ 1. Push your changes and open a pull request against the main branch.
+ 2. Link related issues (if any), and include a summary of changes.
+ 3. Tag relevant reviewers using @username.
+3. [Work in progress] Review and voting process
+ 1. PRs (involving protocol logic or architecture) must go through a voting process (described below). Voting follows a simple majority unless otherwise stated.
+4. Merge. Once approved, a maintainer will merge the PR.
+## [Work in progress] Governance
+
+Currently, GitHub will remain our primary development platform, however, governance will be handled on-chain, requiring approval by the majority for all code changes. Here’s how this hybrid approach works.
+
+**Software Update**
+- Every update must be approved by an on-chain vote.
+- Update proposals include the commit hash or binary hash.
+- Only after on-chain approval is code recognized as the official network version.
+- A REST API is available for participants to verify which version is approved.
+
+**Code Integrity**
+- This repository serves as the primary codebase for blockchain development and contains the current production code.
+- Code ownership and governance are separated. All proposed changes to this repository are subject to voting and approval.
+- Participant nodes monitor the repository for unauthorized changes in the main branch of the repo.
+- If an unapproved commit is detected, all network participants are notified immediately.
+
+## Testing requirements
+
+Before opening a PR, run unit tests and integration tests:
+```
+make local-build build-docker
+make run-tests
+```
+
+- Some tests must pass before a PR can be approved:
+ - All unit test
+ - All integration tests, minus known issues listed in `testermint/KNOW_ISSUES.md`
+- To run tests with a real `ml` node (locally):
+ - [Work in progress]
+## Code standards
+- [Work in progress]
+## [Work in progress] Proposing architectural changes
+
+Before starting significant architectural work:
+1. Open a GitHub issue, describing the proposed change.
+2. Share a design document (in Markdown or as a diagram).
+3. Get feedback from other contributors.
+4. Reach a consensus before implementation begins.
+## Documentation guidelines
+
+- All relevant docs are stored in [here](https://github.com/product-science/pivot-docs)
+- Update docs alongside code changes that affect behavior, APIs, or assumptions
+- Missing docs may delay PR approval
+
+## Protobufs
+
+- All `ml` node protobuf definitions are stored in [here](https://github.com/product-science/chain-protos/blob/main/proto/network_node/v1/network_node.proto)
+- After editing the `.proto` files, copy them to the `ml` node and Inference Ignite repositories, and regenerate the bindings.
+## Deployment and updates
+
+We use Cosmovisor for managing binary upgrades, in coordination with the Cosmos SDK’s on-chain upgrade and governance modules. This approach ensures safe, automated, and verifiable upgrades for both `chain` and `api` nodes.
+
+**How it works**
+- **Cosmovisor** monitors the blockchain for upgrade instructions and automatically switches binaries at the specified block height.
+- **On-chain governance proposals** (via `x/governance` and `x/upgrade`) define precisely when and how upgrades are applied.
+- **`Chain` and `api` node binaries** are upgraded simultaneously to avoid compatibility issues.
+- **`Api` node** continuously tracks the block height and listens for upgrade events, coordinating restarts to avoid interrupting long-running processes.
+- **`Ml` node** maintains versioned APIs and employs a dual-version rollout strategy. When an `api` node update introduces a new API version, both the old and new `ml` node versions must be deployed concurrently. `Api`node then automatically switches to the new container.
+
+
+## Stress Testing
+
+We use fork of [compressa-perf](https://github.com/product-science/compressa-perf) for stress testing.
+It can be installed with `pip`:
+```
+pip install git+https://github.com/product-science/compressa-perf.git
+```
+
+
+**Run Performance Test (Preffered):**
+```bash
+# len of prompt in symbols: 3000
+# tasks to be executed: 200
+# total parallel workers: 100
+compressa-perf \
+ measure \
+ --node_url http://36.189.234.237:19252/ \
+ --model_name Qwen/Qwen2.5-7B-Instruct \
+ --create-account-testnet \
+ --inferenced-path ./inferenced \
+ --experiment_name test \
+ --generate_prompts \
+ --num_prompts 3000 \
+ --prompt_length 3000 \
+ --num_tasks 200 \
+ --num_runners 100 \
+ --max_tokens 100
+```
+
+`--node_url` right now all requests going through that Transfer Agent.
+
+**To view performance measurements:**
+```
+compressa-perf list --show-metrics --show-parameters
+```
+
+**To check balances for all nodes:**
+```
+compressa-perf check-balances --node_url http://36.189.234.237:19252
+```
+
+**Run long term performance test:**
+```
+compressa-perf \
+ stress \
+ --node_url http://36.189.234.237:19252 \
+ --model_name Qwen/Qwen2.5-7B-Instruct \
+ --create-account-testnet \
+ --inferenced-path ./inferenced \
+ --experiment_name "stress_test" \
+ --generate_prompts \
+ --num_prompts 200 \
+ --prompt_length 1000 \
+ --num_runners 20 \
+ --max_tokens 300 \
+ --report_freq_min 1 \
+ --account-pool-size 4
+```
diff --git a/LICENSE.md b/LICENSE.md
new file mode 100644
index 000000000..c65ef7554
--- /dev/null
+++ b/LICENSE.md
@@ -0,0 +1,109 @@
+## GONKA LICENSE:
+
+This License applies to all portions of the Work expressly designated as subject to the Gonka License, including, without limitation, the Genesis Code as identified in Section 1. Except as expressly modified herein, the terms of the Apache License, Version 2.0 (“Apache 2.0”) will govern. In the event of a conflict between this License and Apache 2.0, this License will control for all Licensed Material. Capitalized terms otherwise not defined in the Gonka license shall have the meaning ascribed to them in Apache 2.0.
+
+1. Definitions
+
+ (a) “Community” refers to the active participants on the original network.
+
+ (b) “Forking” means the act of copying and using the Genesis Code to create a separate, independent, or disconnected network.
+
+ (c) “Genesis Code” means the portions of the source code listed in Appendix A (Genesis Code Reference). The Genesis Code Reference, including commit hashes or specific files, will be published at https://github.com/gonka-ai/gonka. The initial reference point for the Genesis Code is commit `f9850bb4d5cfe018302d8d5c69de3d19967aa815` (“Genesis Commit”).
+
+ (d) “Requisite Threshold” means the affirmative vote of active participants, with voting weight determined proportionally to their verified computational power contributed to the network during the most recent Sprint, optionally augmented by staked gonka collateral, as defined by the Proof-of-Compute consensus procedure and the on-chain Governance rules encoded in the Genesis Code.
+
+ (e) “One-Year Anniversary” refers to the date that is exactly one year from the official launch of the original network.
+
+
+2. License Grant
+ Subject to the restrictions and conditions set forth in this License, the code published under this License is made available on an open-source basis, with the right to use, modify, distribute, and contribute, consistent with the terms of the Apache License 2.0, except where overridden by the custom provisions in this document.
+
+3. Terms of the Apache License 2.0
+ Copyright held by Product Science, Inc. (the “Licensor”)
+ Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
+ http://www.apache.org/licenses/LICENSE-2.0
+
+4. No Warranties
+ Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+
+5. Restriction on Forking
+ Notwithstanding any other provision of this License or Apache 2.0, You may not use the Genesis Code, in whole or in part, to create, operate, or contribute to any Separate Network. “Separate Network” means any distributed ledger or blockchain that is not fully compatible with, and does not participate in, the consensus or economic mechanisms of the original network as operated by the Community, except as expressly approved by a Community vote pursuant to Section 6 (Lifting of Forking Restriction).
+
+6. Lifting of Forking Restriction
+ The restriction on Forking described in Section 5 may be lifted upon a Community vote conducted no earlier than the One-Year Anniversary of the creation of the original network. If the Community vote meets a Requisite Threshold, the restriction on Forking shall be considered null and void.
+
+7. Public Domain Transition
+ Upon a successful Community vote under Section 6, the Licensor will, to the fullest extent permitted by applicable law and without limitation, make an irrevocable dedication of the codebase to the public domain, using the Creative Commons CC0 1.0 Universal Public Domain Dedication (“CC0”) or any successor tool recognized for this purpose. In jurisdictions where the public domain dedication is not legally recognized, the Licensor grants a perpetual, irrevocable, royalty-free, no-charge, worldwide license to exercise all rights in the codebase for any purpose.
+
+8. Compliance and Enforcement
+ Any use of the Genesis Code in violation of this License shall be considered a material breach, and violators may be subject to legal action or other enforcement measures as deemed appropriate by the project maintainers or community governance.
+ Enforcement of this License with respect to the Genesis Code and related restrictions may be pursued by the Licensor, any enforcement agent designated by the Licensor. All disputes relating to this License will be governed by the laws of the State of Delaware, United States, and venue will be in the courts of the State of Delaware, United States.
+
+9. Miscellaneous
+
+ (a) This License is intended to be interpreted in alignment with the principles of the Apache License 2.0, except where explicitly overridden by the provisions set forth herein.
+
+ (b) In the event of any conflict between this License and the Apache License 2.0, the terms of this License shall govern with respect to the Genesis Code and the specified governance processes.
+
+ (c) Any amendment or modification to this License must (i) be proposed in writing and posted to the official project repository and community forum at least 14 days prior to any vote, and (ii) receive approval from a Community vote meeting the Requisite Threshold. No amendment will affect rights granted prior to its effective date thereof.
+
+
+## APACHE LICENSE 2.0:
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+ "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."
+ "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.
+
+
+2. Grant of Copyright License.
+ Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License.
+ Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.
+
+4. Redistribution.
+ You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:
+
+ (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.
+
+5. Submission of Contributions.
+ Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.
+
+6. Trademarks.
+ This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty.
+ Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability.
+ In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability.
+ While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.
+
diff --git a/Makefile b/Makefile
new file mode 100644
index 000000000..47013a9b4
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,158 @@
+.PHONY: release decentralized-api-release inference-chain-release tmkms-release proxy-release proxy-ssl-release bridge-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
+
+VERSION ?= $(shell git describe --always)
+TAG_NAME := "release/v$(VERSION)"
+
+all: build-docker
+
+build-docker: api-build-docker node-build-docker mock-server-build-docker proxy-build-docker proxy-ssl-build-docker bridge-build-docker
+
+api-build-docker:
+ @make -C decentralized-api build-docker SET_LATEST=1
+
+node-build-docker:
+ @make -C inference-chain build-docker SET_LATEST=1 $(if $(GENESIS_OVERRIDES_FILE),GENESIS_OVERRIDES_FILE=$(GENESIS_OVERRIDES_FILE),)
+
+mock-server-build-docker:
+ @echo "Building mock-server JAR file..."
+ @cd testermint/mock_server && ./gradlew clean && ./gradlew shadowJar
+ @echo "Building mock-server docker image..."
+ @DOCKER_BUILDKIT=1 docker build --load -t inference-mock-server -f testermint/Dockerfile testermint
+
+proxy-build-docker:
+ @make -C proxy build-docker SET_LATEST=1
+
+proxy-ssl-build-docker:
+ @make -C proxy-ssl build-docker SET_LATEST=1
+
+bridge-build-docker:
+ @make -C bridge build-docker SET_LATEST=1
+
+release: decentralized-api-release inference-chain-release tmkms-release proxy-release proxy-ssl-release bridge-release
+ @git tag $(TAG_NAME)
+ @git push origin $(TAG_NAME)
+
+decentralized-api-release:
+ @echo "Releasing decentralized-api..."
+ @make -C decentralized-api release
+ @make -C decentralized-api docker-push
+
+inference-chain-release:
+ @echo "Releasing inference-chain..."
+ @make -C inference-chain release
+ @make -C inference-chain docker-push
+
+tmkms-release:
+ @echo "Releasing tmkms..."
+ @make -C tmkms release
+ @make -C tmkms docker-push
+
+proxy-release:
+ @echo "Releasing proxy..."
+ @make -C proxy release
+
+proxy-ssl-release:
+ @echo "Releasing proxy-ssl..."
+ @make -C proxy-ssl release
+
+bridge-release:
+ @echo "Releasing bridge..."
+ @make -C bridge release
+ @make -C bridge docker-push
+
+check-docker:
+ @docker info > /dev/null 2>&1 || (echo "Docker Desktop is not running. Please start Docker Desktop." && exit 1)
+
+# Default to running all tests if TESTS is not specified
+TESTS ?= ALL
+
+run-tests:
+ @cd testermint && if [ "$(TESTS)" = "ALL" ]; then \
+ ./gradlew :test -DexcludeTags=unstable,exclude; \
+ else \
+ ./gradlew :test --tests "$(TESTS)" -DexcludeTags=unstable,exclude; \
+ fi
+
+run-sanity: build-docker
+ @cd testermint && ./gradlew :test --tests "$(TESTS)" -DincludeTags=sanity
+
+run-bls-tests: check-docker
+ @echo "Running BLS DKG integration tests (requires Docker)..."
+ @cd testermint && ./gradlew test --tests "BLSDKGSuccessTest"
+
+test-blockchain: check-docker run-blockchain-tests
+
+# Local build targets
+api-local-build:
+ @echo "Building decentralized-api locally..."
+ @cd decentralized-api && go build -mod=mod -o ./build/dapi
+
+node-local-build:
+ @echo "Building inference-chain locally..."
+ @make -C inference-chain build
+
+api-test:
+ @echo "Running decentralized-api tests..."
+ @cd decentralized-api && go test ./... -v > ../api-test-output.log
+ @echo "----------------------------------------"
+ @echo "DECENTRALIZED-API TEST SUMMARY:"
+ @PASS_COUNT=$$(grep -c "PASS:" api-test-output.log); \
+ FAIL_COUNT=$$(grep -c "FAIL:" api-test-output.log); \
+ NO_TEST_COUNT=$$(grep -c "no test files" api-test-output.log); \
+ echo "Passed: $$PASS_COUNT tests"; \
+ echo "Failed: $$FAIL_COUNT tests"; \
+ echo "No test files: $$NO_TEST_COUNT packages";
+ @echo "----------------------------------------"
+ @if [ $$(grep -c "FAIL:" api-test-output.log) -gt 0 ]; then \
+ echo "Failed tests:"; \
+ grep -A 1 "FAIL:" api-test-output.log | grep -v "^\--"; \
+ fi
+ @if [ $$(grep -c "FAIL:" api-test-output.log) -gt 0 ]; then \
+ exit 1; \
+ fi
+
+node-test:
+ @echo "Running inference-chain tests..."
+ @cd inference-chain && go test ./... -v > ../node-test-output.log
+ @echo "----------------------------------------"
+ @echo "INFERENCE-CHAIN TEST SUMMARY:"
+ @PASS_COUNT=$$(grep -c "PASS:" node-test-output.log); \
+ FAIL_COUNT=$$(grep -c "FAIL:" node-test-output.log); \
+ NO_TEST_COUNT=$$(grep -c "no test files" node-test-output.log); \
+ echo "Passed: $$PASS_COUNT tests"; \
+ echo "Failed: $$FAIL_COUNT tests"; \
+ echo "No test files: $$NO_TEST_COUNT packages";
+ @echo "----------------------------------------"
+ @if [ $$(grep -c "FAIL:" node-test-output.log) -gt 0 ]; then \
+ echo "Failed tests:"; \
+ grep -A 1 "FAIL:" node-test-output.log | grep -v "^\--"; \
+ fi
+ @if [ $$(grep -c "FAIL:" node-test-output.log) -gt 0 ]; then \
+ exit 1; \
+ fi
+
+local-build: api-local-build node-local-build api-test node-test
+ @echo "=========================================="
+ @echo "LOCAL BUILD AND TEST SUMMARY:"
+ @API_PASS=$$(grep -c "PASS:" api-test-output.log); \
+ API_FAIL=$$(grep -c "FAIL:" api-test-output.log); \
+ NODE_PASS=$$(grep -c "PASS:" node-test-output.log); \
+ NODE_FAIL=$$(grep -c "FAIL:" node-test-output.log); \
+ TOTAL_PASS=$$((API_PASS + NODE_PASS)); \
+ TOTAL_FAIL=$$((API_FAIL + NODE_FAIL)); \
+ echo "API Tests - Passed: $$API_PASS, Failed: $$API_FAIL"; \
+ echo "Node Tests - Passed: $$NODE_PASS, Failed: $$NODE_FAIL"; \
+ echo "Total - Passed: $$TOTAL_PASS, Failed: $$TOTAL_FAIL";
+ @echo "=========================================="
+ @echo "Local build and tests completed successfully!"
+ @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
+
+build-for-upgrade-tests:
+ @make -C inference-chain build-for-upgrade TESTS=1
+ @make -C decentralized-api build-for-upgrade TESTS=1
diff --git a/README.md b/README.md
index affdd62d9..fc982a0a5 100644
--- a/README.md
+++ b/README.md
@@ -1 +1,123 @@
-# inference-ignite
+# Gonka
+
+Gonka is a decentralized AI infrastructure designed to optimize computational power for AI model training and inference, offering an alternative to monopolistic, high-cost, centralized cloud providers. As AI models become increasingly complex, their computational demands surge, presenting significant challenges for developers and businesses that rely on costly, centralized resources.
+
+To exchange ideas, follow project updates, and connect with the community, join [Discord](https://discord.com/invite/RADwCT2U6R).
+
+## Introduction
+
+We introduce a novel consensus mechanism, **Proof of Work 2.0**, that ensures nearly 100% of computational resources are allocated to AI workloads, rather than being wasted on securing the blockchain.
+## Key Roles
+
+- **Developers** — Use the decentralized network to run inference and LLM training.
+- **Hosts (Hardware Providers or Nodes)** — Contribute computational resources and earn rewards based on their input.
+## Key Features
+
+1. A novel **“Sprint”** mechanism, where participants compete in time-bound computational Races to solve AI-relevant tasks. Instead of traditional Proof of Work (e.g., compute hashes), these Races use **transformer-based models**, aligning the computation with AI model workloads. The number of successful computations a node generates during the Race determines its **voting weight**, directly linking computational contribution to governance and task validation rights. This voting weight not only determines consensus power but also controls task allocation: nodes with higher weight are assigned a larger share of AI inferences and training workloads, and are proportionally responsible for validating others’ results. This ensures that system resources are used efficiently, with real-world tasks assigned in proportion to each node’s proven compute capacity, enabling a “one-computational-power-one-vote” principle rather than capital-based influence (see diagram 1).
+2. The platform uses **Randomized Task Verification**. Instead of verifying every inference task redundantly, the system selects a subset of tasks for verification based on cryptographically secure randomization. Nodes with higher voting weight have greater responsibility for validation. This approach drastically reduces overhead to just 1–10% of tasks, while maintaining trust through probabilistic guarantees and the threat of losing rewards if caught cheating.
+3. **Validation during model training** follows a similar protocol as inference. Nodes are required to complete training workloads and are subject to majority-weighted peer verification. The system handles the non-deterministic nature of AI training by applying statistical validation, allowing for slight output variances while penalizing repeated or malicious inconsistencies. Rewards are withheld until a node’s training contributions are verified as honest and complete.
+4. The infrastructure leverages **DiLoCo**'s periodic synchronization approach to enable **Geo-Distributed Training** by efficiently distributing AI training tasks across a network of independent hardware providers, creating a **decentralized training environment** with minimal communication overhead. Nodes contribute compute power and receive tasks in proportion to their capabilities. Developers can initiate and fund training projects, and the system ensures workload distribution and result validation through its Proof of Work 2.0 protocol and validation layers. The platform is designed to maintain **fault tolerance and decentralized coordination**, enabling scalable training without centralized oversight.
+5. A reputation score is assigned to each node and increases with consistent, honest behavior. New nodes start with zero and are subject to more frequent checks. As reputation grows, verification frequency decreases, allowing for lower overhead and higher reward efficiency. Nodes caught submitting false results lose all earned rewards for that cycle and reset their reputation, entering a phase of strict scrutiny. This encourages long-term honesty and punishes strategic cheating.
+
+
+
+*[Work in progress] Diagram 1. The Task flow [Source](docs/papers/InferenceFlow.png)**
+
+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/).
+
+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 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.
+### 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
+3. Docker Desktop (4.37+)
+4. Make
+5. Java 19+
+6. (Optional) A Go IDE
+7. (Optional) A Kotlin IDE (for testing)
+#### 2. Build the project
+Clone the repository:
+```
+git clone https://github.com/gonka-ai/gonka.git
+cd gonka (or repo name)**
+```
+
+Build chain and API nodes, and run unit tests:
+```
+make local-build
+```
+#### 3. Run local tests
+There is an integration testing framework dubbed “Testermint”. This framework runs on live `api` and `chain` nodes, and emulates `ml` nodes using WireMock. It runs a local cluster of nodes using Docker and tests things very close to how they will work in a live environment. See the README.md in the [`/testermint`](https://github.com/gonka-ai/gonka/tree/main/testermint) directory for more details.
+
+This command will build locally, deploy a small network of Docker containers, and run a set of these integration-level tests. It will take quite some time to run completely.
+```
+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.
+
+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
+
+Our project is built as a modular, containerized infrastructure with multiple interoperable components.
+### Core components
+
+- Network Node — This service handles all communication, including:
+ - [`chain`](https://github.com/gonka-ai/gonka/tree/main/inference-chain) node that connects to the blockchain, maintains the blockchain layer, and handles consensus.
+ - [`api`](https://github.com/gonka-ai/gonka/tree/main/decentralized-api) node serves as the primary coordination layer between the blockchain (`chain node`) and the AI execution environment (`ml` node). It exposes REST/gRPC endpoints for interacting with users, developers, and internal components, while managing work orchestration, validation scheduling, and result verification processes that require off-chain execution. In addition to handling user requests, it is responsible for:
+ - Routing inference and training jobs to the `ml` node
+ - Recording inference results and ensuring task completion
+ - Scheduling and managing validation tasks
+ - Reporting receipts and signatures to the chain node for consensus
+ - Orchestrating Proof of Work 2.0 execution
+ - Technologies: GO, Cosmos-SDK.
+- `ml` node — Handles AI workload execution: training, inference, and Proof of Work 2.0. Participants run `ml`nodes to contribute compute.
+ - Technologies: Python, Docker, NVIDIA CUDA, gRPC, PyTorch, vLLM.
+ - Location: [MLNode GitHub Repository](https://github.com/product-science/mlnode/tree/main)
+
+
+
+*Diagram 2. The diagram outlines how components interact across the system. [Source](https://github.com/product-science/mlnode/blob/main/network-architecture.png)*
+## Repository Layout
+
+The repository is organized as follows:
+```
+/client-libs # Client script to interact with the chain
+/cosmovisor # Cosmovisor binaries
+/decentralized-api # Api node
+/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
+/testermint # Integration tests suite
+```
+## Testing
+
+We support several types of tests to ensure the system’s stability and reliability:
+- Unit tests – For core logic in `ml`node, `chain` node, and `api` node
+- End-to-End tests – Test full task lifecycle across the network using Testermint module
+
+Detailed instructions on running and contributing to tests are available in [`CONTRIBUTING.md`](https://github.com/gonka-ai/gonka/blob/main/CONTRIBUTING.md).
+## Deployment strategy
+
+The system is designed around **containerized microservices**. Each component runs in its own Docker container, allowing:
+- Independent deployment – Components don’t need to be co-located
+- Scalable compute – Easily add more `ml`nodes or `api`nodes
+- Simplified redeployments – Faster updates and rollback support
+
+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/)
+## Support
+
+- Reach us at hello@productscience.ai.
+- [Discord](https://discord.com/invite/RADwCT2U6R) – Join for real-time discussions, updates, and support.
diff --git a/add_founders_to_genesis.sh b/add_founders_to_genesis.sh
new file mode 100755
index 000000000..6efb4676c
--- /dev/null
+++ b/add_founders_to_genesis.sh
@@ -0,0 +1,107 @@
+#!/bin/bash
+
+# Script to add founders' vesting accounts to genesis using inferenced CLI
+# Usage: ./add_founders_to_genesis.sh
+
+set -e # Exit on any error
+
+# Configuration
+FOUNDERS_LEDGER="genesis/founders_ledger.json"
+INFERENCED_PATH="./inference-chain/build/inferenced"
+GENESIS_HOME="./genesis/"
+GENESIS_DRAFT_PATH="./genesis/genesis-draft.json"
+
+# Check if draft exists
+if [ ! -f "$GENESIS_DRAFT_PATH" ]; then
+ echo "Error: genesis-draft.json not found at $GENESIS_DRAFT_PATH"
+ exit 1
+fi
+
+echo $"Copy draft to genesis"
+cp $GENESIS_DRAFT_PATH $GENESIS_HOME/config/genesis.json
+
+# Check if inferenced binary exists
+if [ ! -f "$INFERENCED_PATH" ]; then
+ echo "Error: inferenced binary not found at $INFERENCED_PATH"
+ echo "Please build the binary first or adjust the INFERENCED_PATH variable"
+ exit 1
+fi
+
+# Check if founders ledger exists
+if [ ! -f "$FOUNDERS_LEDGER" ]; then
+ echo "Error: founders ledger not found at $FOUNDERS_LEDGER"
+ exit 1
+fi
+
+# Check if genesis config exists
+if [ ! -f "$GENESIS_HOME/config/genesis.json" ]; then
+ echo "Error: genesis.json not found at $GENESIS_HOME/config/genesis.json"
+ echo "Please make sure you've copied genesis-draft.json to genesis/genesis-draft.json"
+ exit 1
+fi
+
+# Calculate vesting times
+# Start time: 20:20 PST 08/20/2025 = 04:20 UTC 08/21/2025
+START_TIME=$(date -u -j -f "%Y-%m-%d %H:%M:%S" "2025-08-21 04:20:00" +%s)
+# End time: 4 years later
+END_TIME=$((START_TIME + 4 * 365 * 24 * 60 * 60))
+
+echo "Adding founders' vesting accounts to genesis..."
+echo "Vesting start time: $(date -u -r $START_TIME '+%Y-%m-%d %H:%M:%S UTC') (20:20 PST 08/20/2025)"
+echo "Vesting end time: $(date -u -r $END_TIME '+%Y-%m-%d %H:%M:%S UTC')"
+echo "Genesis home: $GENESIS_HOME"
+echo ""
+
+# Parse founders ledger and add accounts
+account_count=0
+total_amount=0
+
+while IFS=$'\t' read -r address amount_str || [ -n "$address" ]; do
+ # Skip empty lines
+ if [ -z "$address" ] || [ -z "$amount_str" ]; then
+ continue
+ fi
+
+ # Clean up the amount (remove commas)
+ amount=$(echo "$amount_str" | tr -d ',' | tr -d ' ')
+
+ # Validate address format
+ if [[ ! "$address" =~ ^gonka1[a-zA-Z0-9]{38,}$ ]]; then
+ echo "Warning: Skipping invalid address: $address"
+ continue
+ fi
+
+ # Validate amount is numeric
+ if ! [[ "$amount" =~ ^[0-9]+$ ]]; then
+ echo "Warning: Skipping invalid amount for $address: $amount_str"
+ continue
+ fi
+
+ echo "Adding account: $address with ${amount}ngonka"
+
+ # Add the vesting account using inferenced CLI
+ if $INFERENCED_PATH genesis add-genesis-account "$address" "${amount}ngonka" \
+ --vesting-amount "${amount}ngonka" \
+ --vesting-start-time "$START_TIME" \
+ --vesting-end-time "$END_TIME" \
+ --home "$GENESIS_HOME"; then
+
+ account_count=$((account_count + 1))
+ total_amount=$((total_amount + amount))
+ echo "✓ Successfully added $address"
+ else
+ echo "✗ Failed to add $address"
+ fi
+
+done < "$FOUNDERS_LEDGER"
+
+echo ""
+echo "=== SUMMARY ==="
+echo "Successfully added: $account_count accounts"
+echo "Total vesting amount: $(printf "%'d" $total_amount) ngonka"
+echo "Genesis file updated at: $GENESIS_HOME/config/genesis.json"
+echo ""
+echo "Vesting schedule:"
+echo " Start: $(date -u -r $START_TIME '+%Y-%m-%d %H:%M:%S UTC') (20:20 PST 08/20/2025)"
+echo " End: $(date -u -r $END_TIME '+%Y-%m-%d %H:%M:%S UTC')"
+echo " Duration: 4 years"
diff --git a/bridge/Dockerfile b/bridge/Dockerfile
new file mode 100644
index 000000000..1e4e354e7
--- /dev/null
+++ b/bridge/Dockerfile
@@ -0,0 +1,31 @@
+# Extract Geth binary from prebuilt container
+FROM ghcr.io/product-science/bridge-geth:0.2.5 AS geth-source
+
+# Extract Prysm binaries from prebuilt container
+FROM ghcr.io/product-science/bridge-prysm:0.2.5 AS prysm-source
+
+# Final image
+FROM alpine:latest
+# coreutils provides stdbuf for line-buffering Prysm logs
+RUN apk add --no-cache ca-certificates openssl bash curl coreutils
+
+# Copy Geth binary from prebuilt container
+COPY --from=geth-source /usr/local/bin/geth /usr/local/bin/
+
+# Copy Prysm binaries from prebuilt container
+COPY --from=prysm-source /usr/local/bin/beacon-chain /usr/local/bin/
+COPY --from=prysm-source /usr/local/bin/validator /usr/local/bin/
+
+# Create necessary directories
+RUN mkdir -p /data/geth /data/prysm /data/jwt
+
+# Set environment variables
+ENV GETH_DATA_DIR=/data/geth
+ENV PRYSM_DATA_DIR=/data/prysm
+ENV JWT_SECRET_PATH=/data/jwt/jwt.hex
+
+# Copy startup script
+COPY script.sh /usr/local/bin/
+RUN chmod +x /usr/local/bin/script.sh
+
+ENTRYPOINT ["/usr/local/bin/script.sh"]
\ No newline at end of file
diff --git a/bridge/Makefile b/bridge/Makefile
new file mode 100644
index 000000000..ffd6b4825
--- /dev/null
+++ b/bridge/Makefile
@@ -0,0 +1,41 @@
+.PHONY: all build-docker docker-push release
+
+VERSION ?= $(shell git describe --always)
+SET_LATEST ?= 0
+SET_LATEST := $(shell if [ "$(SET_LATEST)" = "1" ]; then echo 1; else echo 0; fi)
+
+define DOCKER_BUILD
+ @echo "--> building bridge docker image"
+ @echo " platform: $(PLATFORM)"
+ @docker build \
+ --platform $(PLATFORM) \
+ -f $(DOCKER_FILE) \
+ . \
+ -t $(DOCKER_TAG)
+endef
+
+all: build-docker
+
+build-docker:
+ $(eval PLATFORM=linux/amd64)
+ $(eval DOCKER_FILE=Dockerfile)
+ $(eval DOCKER_TAG=ghcr.io/product-science/bridge:$(VERSION))
+ $(DOCKER_BUILD)
+ @if [ "$(SET_LATEST)" = "1" ]; then \
+ echo "Setting latest tag..."; \
+ docker tag $(DOCKER_TAG) ghcr.io/product-science/bridge:latest; \
+ fi
+
+docker-push:
+ @echo "--> pushing bridge docker image"
+ @echo "pushing to GitHub Container Registry"
+ @docker push ghcr.io/product-science/bridge:$(VERSION)
+ @if [ "$(SET_LATEST)" = "1" ]; then \
+ echo "Setting latest tag..."; \
+ docker tag ghcr.io/product-science/bridge:$(VERSION) ghcr.io/product-science/bridge:latest; \
+ docker push ghcr.io/product-science/bridge:latest; \
+ fi
+
+release: build-docker
+
+
diff --git a/bridge/script.sh b/bridge/script.sh
new file mode 100644
index 000000000..c18fa68d1
--- /dev/null
+++ b/bridge/script.sh
@@ -0,0 +1,379 @@
+#!/bin/sh
+set -e
+# Ensure we can detect failures within pipelines when supported
+set -o pipefail 2>/dev/null || true
+
+# Allow configuring internal ports per-container (no host exposure)
+# Defaults match client defaults to preserve existing behavior
+GETH_HTTP_PORT=${GETH_HTTP_PORT:-8545}
+GETH_AUTHRPC_PORT=${GETH_AUTHRPC_PORT:-8551}
+GETH_P2P_PORT=${GETH_P2P_PORT:-30303}
+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}
+
+require_env_vars() {
+ missing=false
+ for var_name in "$@"; do
+ eval "value=\${$var_name:-}"
+ if [ -z "$value" ]; then
+ echo "Error: required environment variable $var_name is not set" >&2
+ missing=true
+ fi
+ done
+ if [ "$missing" = "true" ]; then
+ echo "Exiting because required environment variables are missing." >&2
+ exit 1
+ fi
+}
+
+require_env_vars \
+ JWT_SECRET_PATH \
+ GETH_DATA_DIR \
+ PRYSM_DATA_DIR \
+ BRIDGE_POSTBLOCK \
+ BRIDGE_GETADDRESSES \
+ BEACON_STATE_URL
+
+# Create log directories
+mkdir -p /var/log/geth /var/log/prysm
+# Define Prysm log file paths (raw and formatted)
+PRYSM_RAW_LOG=/var/log/prysm/beacon.raw.log
+PRYSM_FORMATTED_LOG=/var/log/prysm/beacon.log
+
+echo "Initializing Ethereum Bridge Service Version 0.1.0"
+
+# Generate JWT secret if it doesn't exist
+if [ ! -f "$JWT_SECRET_PATH" ]; then
+ openssl rand -hex 32 > "$JWT_SECRET_PATH"
+ echo "Generated new JWT secret"
+fi
+
+# Handle persistent Geth data
+if [ -n "$PERSISTENT_DB_DIR" ] && [ -d "$PERSISTENT_DB_DIR" ] && [ -n "$(ls -A "$PERSISTENT_DB_DIR")" ]; then
+ echo "Copying Geth data from persistent storage..."
+ # Copy contents directly to the mounted directory
+ cp -r "$PERSISTENT_DB_DIR/geth/." "$GETH_DATA_DIR/"
+ echo "Copied Geth data to $GETH_DATA_DIR/"
+fi
+
+# Create log processing scripts
+mkdir -p /tmp/log_formatters
+
+# Create Geth log formatter
+cat > /tmp/log_formatters/geth_formatter.sh << 'EOL'
+#!/bin/sh
+while IFS= read -r line; do
+ echo "GETH: $line"
+done
+EOL
+chmod +x /tmp/log_formatters/geth_formatter.sh
+
+# Create Prysm log formatter
+cat > /tmp/log_formatters/prysm_formatter.sh << 'EOL'
+#!/bin/sh
+while IFS= read -r line; do
+ # Extract level and reformat to uppercase at the beginning
+ if echo "$line" | grep -q 'level='; then
+ level=$(echo "$line" | sed -E 's/.*level=([^ ]+).*/\1/')
+ level_upper=$(echo "$level" | tr '[:lower:]' '[:upper:]')
+
+ # Extract time and format it in brackets
+ timestamp=$(echo "$line" | sed -E 's/.*time="([^"]+)".*/\1/')
+ # Extract date components manually to avoid dependencies on specific date command options
+ month=$(echo "$timestamp" | cut -d'-' -f2)
+ day=$(echo "$timestamp" | cut -d'-' -f3 | cut -d' ' -f1)
+ time=$(echo "$timestamp" | cut -d' ' -f2 | cut -d'.' -f1)
+
+ # Extract message and the rest of the parameters
+ msg=$(echo "$line" | sed -E 's/.*msg="([^"]+)".*/\1/')
+ params=$(echo "$line" | sed -E 's/.*msg="[^"]+"(.*)/\1/')
+
+ # Reconstructed line in Geth format
+ echo "PRSM: $level_upper [$month-$day|$time.000] $msg$params"
+ else
+ echo "PRSM: $line"
+ fi
+done
+EOL
+chmod +x /tmp/log_formatters/prysm_formatter.sh
+
+
+
+# Function to start Geth
+is_pid_alive() {
+ if [ -n "$1" ] && kill -0 "$1" 2>/dev/null; then
+ return 0
+ fi
+ return 1
+}
+stop_process() {
+ local name=$1
+ local pid=$2
+ if [ -z "$pid" ]; then
+ return 0
+ fi
+ if ! is_pid_alive "$pid"; then
+ return 0
+ fi
+ echo "Stopping $name (PID: $pid)"
+ kill "$pid" 2>/dev/null || true
+ for i in 1 2 3 4 5 6 7 8 9 10; do
+ if ! is_pid_alive "$pid"; then
+ break
+ fi
+ sleep 1
+ done
+ if is_pid_alive "$pid"; then
+ echo "$name did not exit in time, sending SIGKILL"
+ kill -9 "$pid" 2>/dev/null || true
+ sleep 1
+ fi
+}
+
+describe_exit() {
+ # Print a human-readable reason for a process exit code
+ local exit_code=$1
+ if [ "$exit_code" -eq 0 ]; then
+ echo "exited cleanly (code 0)"
+ return 0
+ fi
+ if [ "$exit_code" -ge 128 ] 2>/dev/null; then
+ local signal=$((exit_code - 128))
+ case "$signal" in
+ 9) echo "terminated by SIGKILL (9) — likely OOMKilled" ;;
+ 11) echo "terminated by SIGSEGV (11) — segmentation fault" ;;
+ 6) echo "terminated by SIGABRT (6) — abort" ;;
+ 15) echo "terminated by SIGTERM (15)" ;;
+ *) echo "terminated by signal $signal (exit $exit_code)" ;;
+ esac
+ else
+ echo "exited with status $exit_code"
+ fi
+}
+
+
+# Wait up to N seconds for a PID to stay alive (handles immediate crash-on-start)
+wait_until_alive() {
+ local pid=$1
+ local timeout=${2:-5}
+ local elapsed=0
+ while [ $elapsed -lt $timeout ]; do
+ if ! is_pid_alive "$pid"; then
+ return 1
+ fi
+ sleep 1
+ elapsed=$((elapsed+1))
+ done
+ return 0
+}
+
+start_geth() {
+ echo "Starting Geth..."
+ geth --datadir $GETH_DATA_DIR \
+ --http \
+ --http.addr 0.0.0.0 \
+ --http.port $GETH_HTTP_PORT \
+ --http.api "eth,net,engine" \
+ --ipcdisable \
+ --bridge.postblock $BRIDGE_POSTBLOCK \
+ --bridge.getaddresses $BRIDGE_GETADDRESSES \
+ --authrpc.addr 127.0.0.1 \
+ --authrpc.port $GETH_AUTHRPC_PORT \
+ --authrpc.jwtsecret $JWT_SECRET_PATH \
+ --port $GETH_P2P_PORT \
+ --discovery.port $GETH_DISCOVERY_PORT 2>&1 | /tmp/log_formatters/geth_formatter.sh > /var/log/geth/geth.log &
+
+ GETH_PID=$!
+ # Ensure it didn't crash immediately
+ if wait_until_alive "$GETH_PID" 3; then
+ echo "Geth started with PID: $GETH_PID"
+ else
+ echo "Geth failed to stay alive after start (PID: $GETH_PID)"
+ # Attempt stale lock recovery if present
+ LOCK_FILE="$GETH_DATA_DIR/chaindata/LOCK"
+ if [ -f "$LOCK_FILE" ]; then
+ echo "Detected stale DB lock at $LOCK_FILE; removing and retrying once"
+ rm -f "$LOCK_FILE" || true
+ sleep 1
+ # Retry once
+ geth --datadir $GETH_DATA_DIR \
+ --http \
+ --http.addr 0.0.0.0 \
+ --http.port $GETH_HTTP_PORT \
+ --http.api "eth,net,engine" \
+ --ipcdisable \
+ --bridge.postblock $BRIDGE_POSTBLOCK \
+ --bridge.getaddresses $BRIDGE_GETADDRESSES \
+ --authrpc.addr 127.0.0.1 \
+ --authrpc.port $GETH_AUTHRPC_PORT \
+ --authrpc.jwtsecret $JWT_SECRET_PATH \
+ --port $GETH_P2P_PORT \
+ --discovery.port $GETH_DISCOVERY_PORT 2>&1 | /tmp/log_formatters/geth_formatter.sh > /var/log/geth/geth.log &
+ GETH_PID=$!
+ if wait_until_alive "$GETH_PID" 3; then
+ echo "Geth started after stale lock recovery (PID: $GETH_PID)"
+ return 0
+ fi
+ fi
+ return 1
+ fi
+}
+
+# Function to start Prysm
+start_prysm() {
+ echo "Starting Prysm beacon chain..."
+ FORCE_CLEAR=""
+ if [ "$DEBUG" != "true" ]; then
+ FORCE_CLEAR="--force-clear-db"
+ echo "Force clear DB enabled (set DEBUG=true to disable)"
+ fi
+
+ # Truncate raw log on each (re)start to make crash context clear
+ : > "$PRYSM_RAW_LOG"
+
+ # Start Prysm and redirect its stdout/stderr directly to the raw log
+ if command -v stdbuf >/dev/null 2>&1; then
+ stdbuf -oL -eL \
+ beacon-chain \
+ --accept-terms-of-use \
+ $FORCE_CLEAR \
+ --checkpoint-sync-url=$BEACON_STATE_URL \
+ --execution-endpoint=http://127.0.0.1:$GETH_AUTHRPC_PORT \
+ --datadir $PRYSM_DATA_DIR \
+ --p2p-tcp-port=$PRYSM_P2P_TCP_PORT \
+ --p2p-udp-port=$PRYSM_P2P_UDP_PORT \
+ --jwt-secret $JWT_SECRET_PATH >> "$PRYSM_RAW_LOG" 2>&1 &
+ else
+ beacon-chain \
+ --accept-terms-of-use \
+ $FORCE_CLEAR \
+ --checkpoint-sync-url=$BEACON_STATE_URL \
+ --execution-endpoint=http://127.0.0.1:$GETH_AUTHRPC_PORT \
+ --datadir $PRYSM_DATA_DIR \
+ --p2p-tcp-port=$PRYSM_P2P_TCP_PORT \
+ --p2p-udp-port=$PRYSM_P2P_UDP_PORT \
+ --jwt-secret $JWT_SECRET_PATH >> "$PRYSM_RAW_LOG" 2>&1 &
+ fi
+
+ PRYSM_PID=$!
+ PRYSM_EXIT_STATUS="" # reset any previous exit code
+
+ # (Re)start log formatter to transform raw Prysm logs into the formatted file
+ if [ -n "$PRYSM_FORMATTER_PID" ]; then
+ stop_process "Prysm log formatter" "$PRYSM_FORMATTER_PID"
+ fi
+ tail -n +1 -F "$PRYSM_RAW_LOG" | /tmp/log_formatters/prysm_formatter.sh > "$PRYSM_FORMATTED_LOG" &
+ PRYSM_FORMATTER_PID=$!
+
+ if wait_until_alive "$PRYSM_PID" 3; then
+ echo "Prysm beacon chain started with PID: $PRYSM_PID"
+ else
+ echo "Prysm failed to stay alive after start (PID: $PRYSM_PID)"
+ # Capture immediate failure reason if available
+ if wait "$PRYSM_PID" 2>/dev/null; then
+ PRYSM_EXIT_STATUS=$?
+ fi
+ return 1
+ fi
+}
+
+# Function to restart both processes
+restart_processes() {
+ echo "Restarting both processes..."
+
+ # Kill existing processes if they exist
+ stop_process "Geth" "$GETH_PID"
+ stop_process "Prysm" "$PRYSM_PID"
+ stop_process "Prysm log formatter" "$PRYSM_FORMATTER_PID"
+
+ # Start processes in correct order (Geth first, then Prysm)
+ if start_geth; then
+ sleep 3 # Give Geth time to start
+ if start_prysm; then
+ echo "Both processes restarted successfully"
+ else
+ echo "Prysm restart failed; will retry in monitor loop"
+ fi
+ else
+ echo "Geth restart failed; will retry in monitor loop"
+ fi
+}
+
+# Function to check if processes are still running and restart if needed
+check_and_restart_processes() {
+ local restart_needed=false
+ local geth_died=false
+ local prysm_died=false
+
+ # Check Geth
+ if [ -n "$GETH_PID" ] && ! kill -0 $GETH_PID 2>/dev/null; then
+ echo "Geth process (PID: $GETH_PID) died"
+ geth_died=true
+ restart_needed=true
+ fi
+
+ # Check Prysm
+ if [ -n "$PRYSM_PID" ] && ! kill -0 $PRYSM_PID 2>/dev/null; then
+ # Retrieve and report the exit status, once
+ if [ -z "$PRYSM_EXIT_STATUS" ]; then
+ if wait $PRYSM_PID 2>/dev/null; then
+ PRYSM_EXIT_STATUS=$?
+ else
+ PRYSM_EXIT_STATUS=$?
+ fi
+ fi
+ echo "Prysm process (PID: $PRYSM_PID) $(describe_exit ${PRYSM_EXIT_STATUS:-"unknown"})"
+ # Show recent raw logs to aid debugging
+ if [ -f "$PRYSM_RAW_LOG" ]; then
+ echo "--- Last 100 lines of Prysm raw log ---"
+ tail -n 100 "$PRYSM_RAW_LOG" | sed 's/^/PRSM: /'
+ echo "--- End Prysm raw log excerpt ---"
+ fi
+ prysm_died=true
+ restart_needed=true
+ # Stop formatter if still running; it will be restarted with Prysm
+ stop_process "Prysm log formatter" "$PRYSM_FORMATTER_PID"
+ fi
+
+ # Restart if either process died
+ if [ "$restart_needed" = "true" ]; then
+ echo "Restarting processes due to crash..."
+ restart_processes
+ fi
+}
+
+# Function to display logs
+tail_logs() {
+ # Combine logs without filename headers
+ (
+ echo "=== Starting combined log output ==="
+ tail -f /var/log/geth/geth.log /var/log/prysm/beacon.log | while IFS= read -r line; do
+ # Skip lines that look like file headers from tail
+ if ! echo "$line" | grep -q "^==> .* <==$"; then
+ echo "$line"
+ fi
+ done
+ ) &
+ TAIL_PID=$!
+}
+
+# Start both processes initially (Geth first, then Prysm)
+start_geth
+sleep 3 # Give Geth time to start
+start_prysm
+
+
+# Start showing logs
+tail_logs
+
+# Trap to handle termination
+trap "echo 'Received termination signal, shutting down...'; kill $GETH_PID $PRYSM_PID $TAIL_PID 2>/dev/null; exit 0" SIGTERM SIGINT
+trap "echo 'Received termination signal, shutting down...'; kill $GETH_PID $PRYSM_PID $PRYSM_FORMATTER_PID $TAIL_PID 2>/dev/null; exit 0" SIGTERM SIGINT
+
+# Main loop to keep container running and check process health
+echo "Bridge service started. Monitoring processes..."
+while true; do
+ check_and_restart_processes
+ sleep 5
+done
\ No newline at end of file
diff --git a/client-libs/py-weai/verification_script.py b/client-libs/py-weai/verification_script.py
new file mode 100644
index 000000000..39a215f7e
--- /dev/null
+++ b/client-libs/py-weai/verification_script.py
@@ -0,0 +1,123 @@
+import requests
+from dataclasses import dataclass, asdict
+
+
+HISTORY_NODE_HOST = "localhost"
+HISTORY_NODE_API_PORT = "8080"
+HISTORY_NODE_CHAIN_PORT = "26657"
+
+TRUSTED_VERIFIER_NODE_HOST = "localhost"
+TRUSTED_VERIFIER_NODE_API_PORT = "8080"
+
+
+@dataclass
+class Validator:
+ #address: str
+ pub_key: str
+ voting_power: int
+
+
+def get_url(host: str, port: str, path: str) -> str:
+ return f"http://{host}:{port}/{path}"
+
+
+def get_genesis_validators() -> list[Validator]:
+ genesis = get_genesis()
+ return extract_validators_from_genesis(genesis)
+
+
+def extract_validators_from_genesis(genesis):
+ validators = []
+ for tx in genesis["app_state"]["genutil"]["gen_txs"]:
+ for msg in tx["body"]["messages"]:
+ if msg["@type"] != "/cosmos.staking.v1beta1.MsgCreateValidator":
+ continue
+
+ v = Validator(
+ pub_key=msg["pubkey"]["key"],
+ voting_power=int(msg["value"]["amount"]),
+ )
+ validators.append(v)
+
+ return validators
+
+
+def extract_validators_from_active_participants(active_participants) -> list[Validator]:
+ validators = []
+ for val in active_participants["active_participants"]["participants"]:
+ v = Validator(
+ pub_key=val["validatorKey"],
+ voting_power=int(val["weight"]),
+ )
+ validators.append(v)
+
+ return validators
+
+
+def get_genesis():
+ # TODO: implement genesis endpoint for the API node (proxy to chain node)
+ url = get_url(HISTORY_NODE_HOST, HISTORY_NODE_CHAIN_PORT, "genesis")
+ response = requests.get(url)
+ response.raise_for_status()
+
+ return response.json()["result"]["genesis"]
+
+
+def get_active_participants(epoch: str) -> dict[str, any]:
+ url = get_url(HISTORY_NODE_HOST, HISTORY_NODE_API_PORT, f"v1/epochs/{epoch}/participants")
+ response = requests.get(url)
+ response.raise_for_status()
+
+ return response.json()
+
+
+def verify_proof(active_participants):
+ url = get_url(TRUSTED_VERIFIER_NODE_HOST, TRUSTED_VERIFIER_NODE_API_PORT, "v1/verify-proof")
+ payload = {
+ "value": active_participants["active_participants_bytes"],
+ "app_hash": active_participants["block"][2]["header"]["app_hash"],
+ "proof_ops": active_participants["proof_ops"],
+ "epoch": active_participants["active_participants"]["epochGroupId"],
+ }
+ response = requests.post(url, json=payload)
+ response.raise_for_status()
+
+
+def verify_block(prev_validators: list[Validator], block):
+ url = get_url(TRUSTED_VERIFIER_NODE_HOST, TRUSTED_VERIFIER_NODE_API_PORT, "v1/verify-block")
+ payload = {
+ "block": block,
+ "validators": [asdict(v) for v in prev_validators],
+ }
+ response = requests.post(url, json=payload)
+ response.raise_for_status()
+
+
+def main():
+ current_active_participants = get_active_participants(epoch="current")
+ # TODO: Rename epochGroupId > epoch_group_id/epoch
+ current_epoch = current_active_participants["active_participants"]["epochGroupId"]
+
+ print(f"Current epoch: {current_epoch}")
+
+ prev_validators = None
+ for i in range(1, current_epoch + 1):
+ if i == 1:
+ prev_validators = get_genesis_validators()
+
+ active_participants = get_active_participants(epoch=str(i))
+
+ verify_proof(active_participants)
+ verify_block(prev_validators, active_participants["block"][2])
+
+ prev_validators = extract_validators_from_active_participants(active_participants)
+ print(f"Verified epoch {i}. prev_validators: {prev_validators}")
+
+
+def debug_main():
+ prev_validators = get_genesis_validators()
+ print(prev_validators)
+
+
+if __name__ == '__main__':
+ main()
diff --git a/copy_proto.sh b/copy_proto.sh
new file mode 100755
index 000000000..456d1cb2f
--- /dev/null
+++ b/copy_proto.sh
@@ -0,0 +1 @@
+cp ../chain-protos/proto/network_node/v1/network_node.proto inference-chain/proto/inference/inference/network_node.proto
diff --git a/cosmovisor/v1.7.0/linux-amd64/cosmovisor b/cosmovisor/v1.7.0/linux-amd64/cosmovisor
new file mode 100755
index 000000000..28825d2cf
Binary files /dev/null and b/cosmovisor/v1.7.0/linux-amd64/cosmovisor differ
diff --git a/cosmovisor/v1.7.0/linux-arm64/cosmovisor b/cosmovisor/v1.7.0/linux-arm64/cosmovisor
new file mode 100755
index 000000000..41ccca7b7
Binary files /dev/null and b/cosmovisor/v1.7.0/linux-arm64/cosmovisor differ
diff --git a/cosmovisor/v1.7.2/linux-amd64/cosmovisor b/cosmovisor/v1.7.2/linux-amd64/cosmovisor
new file mode 100755
index 000000000..567579ca5
Binary files /dev/null and b/cosmovisor/v1.7.2/linux-amd64/cosmovisor differ
diff --git a/cosmovisor/v1.7.2/linux-arm64/cosmovisor b/cosmovisor/v1.7.2/linux-arm64/cosmovisor
new file mode 100755
index 000000000..fcd1b4e98
Binary files /dev/null and b/cosmovisor/v1.7.2/linux-arm64/cosmovisor differ
diff --git a/decentralized-api/.gitignore b/decentralized-api/.gitignore
new file mode 100644
index 000000000..ffb18bc27
--- /dev/null
+++ b/decentralized-api/.gitignore
@@ -0,0 +1 @@
+decentralized-api/validation.test
diff --git a/decentralized-api/Dockerfile b/decentralized-api/Dockerfile
new file mode 100644
index 000000000..4f5270b20
--- /dev/null
+++ b/decentralized-api/Dockerfile
@@ -0,0 +1,113 @@
+# syntax=docker/dockerfile:1.4
+
+################################################################################
+# Build the application
+################################################################################
+FROM golang:1.23.2-alpine3.20 AS builder
+
+ARG BUILD_FLAGS
+ARG GOOS
+ARG GOARCH
+
+ENV GOOS=${GOOS} \
+ GOARCH=${GOARCH} \
+ CGO_ENABLED=1 \
+ GO111MODULE=on \
+ GOCACHE=/root/.cache/go-build \
+ GOMODCACHE=/go/pkg/mod \
+ CGO_CFLAGS="-I/lib" \
+ CGO_LDFLAGS="-L/lib" \
+ # Override the wasmvm library path to use our musl version
+ LD_LIBRARY_PATH=/lib
+
+RUN apk add --no-cache make gcc musl-dev git patchelf
+
+# Use the musl libc version of wasmvm and create a symlink for the linker
+RUN if [ "$GOARCH" = "arm64" ]; then \
+ wget -O /lib/libwasmvm_muslc.aarch64.a https://github.com/CosmWasm/wasmvm/releases/download/v2.2.4/libwasmvm_muslc.aarch64.a \
+ && echo "27fb13821dbc519119f4f98c30a42cb32429b111b0fdc883686c34a41777488f /lib/libwasmvm_muslc.aarch64.a" | sha256sum -c \
+ && ln -s /lib/libwasmvm_muslc.aarch64.a /lib/libwasmvm_muslc.a \
+ && rm -f /go/pkg/mod/github.com/\!cosm\!wasm/wasmvm@v2.2.4/internal/api/libwasmvm.aarch64.so; \
+ else \
+ wget -O /lib/libwasmvm_muslc.x86_64.a https://github.com/CosmWasm/wasmvm/releases/download/v2.2.4/libwasmvm_muslc.x86_64.a \
+ && echo "70c989684d2b48ca17bbd55bb694bbb136d75c393c067ef3bdbca31d2b23b578 /lib/libwasmvm_muslc.x86_64.a" | sha256sum -c \
+ && ln -s /lib/libwasmvm_muslc.x86_64.a /lib/libwasmvm_muslc.a \
+ && rm -f /go/pkg/mod/github.com/\!cosm\!wasm/wasmvm@v2.2.4/internal/api/libwasmvm.x86_64.so; \
+ fi
+
+COPY inference-chain/ /app/inference-chain
+
+WORKDIR /app/decentralized-api
+COPY decentralized-api/go.mod decentralized-api/go.sum ./
+
+RUN --mount=type=cache,id=go-build-cache3,target=/root/.cache/go-build \
+ --mount=type=cache,id=go-mod-cache3,target=/go/pkg/mod \
+ CGO_ENABLED=1 CC=gcc \
+ go mod download
+
+COPY decentralized-api/. .
+
+# ARG LDFLAGS
+RUN --mount=type=cache,id=go-build-cache3,target=/root/.cache/go-build \
+ --mount=type=cache,id=go-mod-cache3,target=/go/pkg/mod \
+ CGO_ENABLED=1 CC=gcc \
+ go build -mod=readonly -tags muslc -ldflags "$LDFLAGS" \
+ -o ./build/dapi \
+ && patchelf --set-rpath '$ORIGIN:$ORIGIN/current:/root/.dapi/cosmovisor/current' ./build/dapi
+
+# TO FIX: temporary to have both binaries in api image
+RUN --mount=type=cache,id=go-build-cache3,target=/root/.cache/go-build \
+ --mount=type=cache,id=go-mod-cache3,target=/go/pkg/mod \
+ cd /app/inference-chain && \
+ CGO_ENABLED=1 CC=gcc \
+ go build -mod=readonly -tags muslc -ldflags "-X github.com/cosmos/cosmos-sdk/version.Name=inference-chain -X github.com/cosmos/cosmos-sdk/version.AppName=inference-chaind" \
+ -o ./build/inferenced ./cmd/inferenced/main.go \
+ && patchelf --set-rpath '$ORIGIN:$ORIGIN/current:/root/.inference/cosmovisor/current' ./build/inferenced
+
+RUN mkdir /build_output
+################################################################################
+# Binary Exporter stage (for --output optimization)
+################################################################################
+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 /usr/lib/libgcc_s.so.1 /build_output/libgcc_s.so.1
+
+################################################################################
+# Final image
+################################################################################
+ARG TARGETPLATFORM
+FROM --platform=$TARGETPLATFORM alpine:3.18 AS final
+
+ARG GOOS
+ARG GOARCH
+
+RUN apk update && \
+ apk add --no-cache sed ca-certificates jq libgcc musl-dev curl && \
+ rm -rf /var/cache/apk/*
+
+WORKDIR /root
+
+ENV DAEMON_HOME=/root/.dapi
+ENV DAEMON_NAME=decentralized-api
+ENV DAEMON_ALLOW_DOWNLOAD_BINARIES=true
+ENV DAEMON_RESTART_AFTER_UPGRADE=true
+ENV DAEMON_DOWNLOAD_RETRIES=-1
+
+# Copy over binaries from the build-env
+COPY --from=builder /app/decentralized-api/build/dapi /usr/bin/decentralized-api
+COPY --from=builder /app/inference-chain/build/inferenced /usr/bin/inferenced
+COPY ./decentralized-api/scripts/init-docker.sh /root/init-docker.sh
+COPY ./decentralized-api/config-prod.yaml /root/api-config.yaml
+COPY ./cosmovisor/v1.7.2/${GOOS}-${GOARCH}/cosmovisor /usr/bin/cosmovisor
+COPY --from=builder /lib/libwasmvm_muslc.*.a /lib/
+
+ENV API_CONFIG_PATH=/root/.dapi/api-config.yaml
+
+RUN chmod +x /root/init-docker.sh
+
+EXPOSE 9000
+
+CMD ["sh", "./init-docker.sh"]
diff --git a/decentralized-api/Makefile b/decentralized-api/Makefile
new file mode 100644
index 000000000..533866aa3
--- /dev/null
+++ b/decentralized-api/Makefile
@@ -0,0 +1,155 @@
+.PHONY: all install build build-docker init clean-state mock-expected-keepers docker-push release build-all package deploy
+
+BRANCH := $(shell git rev-parse --abbrev-ref HEAD)
+COMMIT := $(shell git log -1 --format='%H')
+
+VERSION ?= $(shell git describe --always)
+SET_LATEST ?= 0
+SET_LATEST := $(shell if [ "$(SET_LATEST)" = "1" ]; then echo 1; else echo 0; fi)
+
+ldflags = -X github.com/cosmos/cosmos-sdk/version.Name=decentralized-api \
+ -X github.com/cosmos/cosmos-sdk/version.AppName=decentralized-api \
+ -X github.com/cosmos/cosmos-sdk/version.Version=$(VERSION) \
+ -X github.com/cosmos/cosmos-sdk/version.Commit=$(COMMIT)
+
+BUILD_FLAGS ?= -ldflags '$(ldflags)'
+
+define DOCKER_BUILD
+ @echo "--> building decentralized-api docker image"
+ @echo " platform: $(PLATFORM)"
+ @echo " BUILD_FLAGS: $(BUILD_FLAGS)"
+ @echo " GOOS: $(GOOS)"
+ @echo " GOARCH: $(GOARCH)"
+ @DOCKER_BUILDKIT=1 \
+ docker build \
+ --load \
+ --platform $(PLATFORM) \
+ --build-arg BUILD_FLAGS="$(BUILD_FLAGS)" \
+ --build-arg GOOS=$(GOOS) \
+ --build-arg GOARCH=$(GOARCH) \
+ -f $(DOCKER_FILE) \
+ .. \
+ -t $(DOCKER_TAG)
+endef
+
+define DOCKER_BUILD_UPGRADE
+ @echo "--> building decentralized-api docker image"
+ @echo " platform: $(PLATFORM)"
+ @echo " BUILD_FLAGS: $(BUILD_FLAGS)"
+ @echo " GOOS: $(GOOS)"
+ @echo " GOARCH: $(GOARCH)"
+ @docker build \
+ --platform $(PLATFORM) \
+ --build-arg BUILD_FLAGS="$(BUILD_FLAGS)" \
+ --build-arg GOOS=$(GOOS) \
+ --build-arg GOARCH=$(GOARCH) \
+ --target binary-exporter \
+ -f $(DOCKER_FILE) \
+ --output type=local,dest=./output \
+ ..
+endef
+
+
+all:
+ install
+
+install:
+ @echo "--> ensure dependencies have not been modified"
+ @go mod verify
+ @echo "--> installing decentralized-api"
+ @echo "BUILD_FLAGS = $(BUILD_FLAGS)"
+ @go install $(BUILD_FLAGS) -mod=readonly
+
+build:
+ @echo "--> ensure dependencies have not been modified"
+ @go mod verify
+ @echo "--> building decentralized-api"
+ @echo "BUILD_FLAGS = $(BUILD_FLAGS)"
+ @CGO_ENABLED=1 CC=gcc \
+ go build $(BUILD_FLAGS) -o ./build/dapi
+
+build-docker:
+ rm -rf build/
+ $(eval PLATFORM=linux/amd64)
+ $(eval GOOS=linux)
+ $(eval GOARCH=amd64)
+ $(eval DOCKER_FILE=Dockerfile)
+ $(eval DOCKER_TAG=ghcr.io/product-science/api:$(VERSION))
+ $(DOCKER_BUILD)
+ @if [ "$(SET_LATEST)" = "1" ]; then \
+ echo "Setting latest tag..."; \
+ docker tag $(DOCKER_TAG) ghcr.io/product-science/api:latest; \
+ fi
+
+docker-push:
+ @echo "--> pushing decentralized-api docker image"
+ @echo "pushing to GitHub Container Registry"
+ @docker push ghcr.io/product-science/api:$(VERSION)
+
+ @if [ "$(SET_LATEST)" = "1" ]; then \
+ @echo "Setting latest tag..."; \
+ @docker tag ghcr.io/product-science/api:$(VERSION) ghcr.io/product-science/api:latest; \
+ @docker push ghcr.io/product-science/api:latest; \
+ 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/*
+ @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"
+ # 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
+ @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"
+
+#################################################
+# CROSS-COMPILATION SECTION
+#################################################
+
+PLATFORMS := linux darwin windows
+ARCHS := amd64 arm64
+
+release: build-docker
+
+build-all:
+ @echo "Building all platforms/architectures..."
+ @$(foreach os,$(PLATFORMS),\
+ $(foreach arch,$(ARCHS),\
+ $(MAKE) --no-print-directory build-$(os)-$(arch);))
+ @echo "All builds complete."
+
+build-%:
+ $(eval OS := $(word 1,$(subst -, ,$*)))
+ $(eval ARCH := $(word 2,$(subst -, ,$*)))
+
+ @echo "Building for OS: $(OS), ARCH: $(ARCH)"
+ @mkdir -p build/$(OS)/$(ARCH)
+ @GOOS=$(OS) GOARCH=$(ARCH) go build -o build/$(OS)/$(ARCH)/decentralized-api
+
+package:
+ @echo "Packaging binaries..."
+ @mkdir -p release
+ @for os in $(PLATFORMS); do \
+ for arch in $(ARCHS); do \
+ if [ -f build/$$os/$$arch/decentralized-api ]; then \
+ zip -j release/decentralized-api-$$os-$$arch.zip \
+ build/$$os/$$arch/decentralized-api; \
+ fi; \
+ done; \
+ done
\ No newline at end of file
diff --git a/decentralized-api/apiconfig/accounts.go b/decentralized-api/apiconfig/accounts.go
new file mode 100644
index 000000000..4748d1ad5
--- /dev/null
+++ b/decentralized-api/apiconfig/accounts.go
@@ -0,0 +1,78 @@
+package apiconfig
+
+import (
+ "bytes"
+ "encoding/base64"
+ "fmt"
+
+ "github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
+ cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
+ "github.com/cosmos/cosmos-sdk/types"
+ "github.com/ignite/cli/v28/ignite/pkg/cosmosaccount"
+ "github.com/ignite/cli/v28/ignite/pkg/cosmosclient"
+)
+
+type ApiAccount struct {
+ AccountKey cryptotypes.PubKey
+ SignerAccount *cosmosaccount.Account
+ AddressPrefix string
+}
+
+func NewApiAccount(addressPrefix string, nodeConfig ChainNodeConfig, client *cosmosclient.Client) (*ApiAccount, error) {
+ signer, err := client.AccountRegistry.GetByName(nodeConfig.SignerKeyName)
+ if err != nil {
+ return nil, fmt.Errorf("failed to get signer account '%s' from keyring: %w", nodeConfig.SignerKeyName, err)
+ }
+
+ pubKeyBytes, err := base64.StdEncoding.DecodeString(nodeConfig.AccountPublicKey)
+ if err != nil {
+ return nil, fmt.Errorf("failed to decode account public key: %w", err)
+ }
+ accountKey := secp256k1.PubKey{Key: pubKeyBytes}
+ return &ApiAccount{
+ AccountKey: &accountKey,
+ SignerAccount: &signer,
+ AddressPrefix: addressPrefix,
+ }, nil
+}
+
+func (a *ApiAccount) AccountAddressBech32() (string, error) {
+ addr, err := types.Bech32ifyAddressBytes(a.AddressPrefix, a.AccountKey.Address())
+ if err != nil {
+ return "", fmt.Errorf("failed to Bech32-encode address: %w", err)
+ }
+ return addr, nil
+}
+
+func (a *ApiAccount) AccountAddress() (types.AccAddress, error) {
+ return types.AccAddress(a.AccountKey.Address()), nil
+}
+
+func (a *ApiAccount) SignerAddressBech32() (string, error) {
+ pubKey, err := a.SignerAccount.Record.GetPubKey()
+ if err != nil {
+ return "", fmt.Errorf("failed to get signer public key: %w", err)
+ }
+ addr, err := types.Bech32ifyAddressBytes(a.AddressPrefix, pubKey.Address())
+ if err != nil {
+ return "", fmt.Errorf("failed to Bech32-encode address: %w", err)
+ }
+ return addr, nil
+}
+
+func (a *ApiAccount) SignerAddress() (types.AccAddress, error) {
+ pubKey, err := a.SignerAccount.Record.GetPubKey()
+ if err != nil {
+ return types.AccAddress{}, fmt.Errorf("failed to get signer public key: %w", err)
+ }
+ return types.AccAddress(pubKey.Address()), nil
+}
+
+func (a *ApiAccount) IsSignerTheMainAccount() bool {
+ signerPubKey, err := a.SignerAccount.Record.GetPubKey()
+ if err != nil {
+ return false
+ }
+
+ return bytes.Equal(signerPubKey.Bytes(), a.AccountKey.Bytes())
+}
diff --git a/decentralized-api/apiconfig/accounts_test.go b/decentralized-api/apiconfig/accounts_test.go
new file mode 100644
index 000000000..4cff06d8e
--- /dev/null
+++ b/decentralized-api/apiconfig/accounts_test.go
@@ -0,0 +1,94 @@
+package apiconfig
+
+import (
+ "encoding/base64"
+ "testing"
+
+ "github.com/cosmos/cosmos-sdk/codec/types"
+ "github.com/cosmos/cosmos-sdk/crypto/keyring"
+ "github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
+ "github.com/ignite/cli/v28/ignite/pkg/cosmosaccount"
+ "github.com/stretchr/testify/require"
+)
+
+const (
+ // Test data from your previous debugging sessions
+ testPubKeyStr = "Au5ZQav3E36PZpGta2xUa8r9xEEo9Biph3fG5i3qaeSG"
+ testAddressPrefix = "gonka"
+ testExpectedAddr = "gonka1jwrv4q8hpxc354pr87pt0pkulaep67e9s4z0ym"
+)
+
+// TestApiAccount_AccountAddress verifies that the AccountAddress method correctly
+// converts the public key into the expected bech32 address string.
+func TestApiAccount_AccountAddress(t *testing.T) {
+ pubKeyBytes, err := base64.StdEncoding.DecodeString(testPubKeyStr)
+ require.NoError(t, err, "Failed to decode test public key string")
+
+ pubKey := &secp256k1.PubKey{Key: pubKeyBytes}
+ apiAccount := &ApiAccount{
+ AccountKey: pubKey,
+ AddressPrefix: testAddressPrefix,
+ }
+
+ // Act
+ actualAddress, err := apiAccount.AccountAddressBech32()
+ require.NoError(t, err)
+
+ // Assert
+ require.Equal(t, testExpectedAddr, actualAddress)
+}
+
+// TestApiAccount_IsSignerTheMainAccount verifies the logic for comparing
+// the signer's public key with the main account's public key.
+func TestApiAccount_IsSignerTheMainAccount(t *testing.T) {
+ mainPubKeyBytes, err := base64.StdEncoding.DecodeString(testPubKeyStr)
+ require.NoError(t, err)
+ mainPubKey := &secp256k1.PubKey{Key: mainPubKeyBytes}
+
+ // Create a different public key for the mismatch case
+ otherPubKeyBytes := make([]byte, 33)
+ otherPubKeyBytes[0] = 0x02 // A different valid compressed key
+ otherPubKey := &secp256k1.PubKey{Key: otherPubKeyBytes}
+
+ // --- Test Case 1: The signer key IS the main account key ---
+ t.Run("should return true when keys are the same", func(t *testing.T) {
+ // Arrange
+ // In Ignite v28, the account record is a `keyring.Record`, and its PubKey is a `*types.Any`.
+ // We must convert our `cryptotypes.PubKey` to a `*types.Any` to create the mock.
+ mainPubKeyAny, err := types.NewAnyWithValue(mainPubKey)
+ require.NoError(t, err)
+
+ signerAccountWithSameKey := &cosmosaccount.Account{
+ Record: &keyring.Record{
+ PubKey: mainPubKeyAny, // Use the same key, wrapped in Any
+ },
+ }
+ apiAccount := &ApiAccount{
+ AccountKey: mainPubKey,
+ SignerAccount: signerAccountWithSameKey,
+ }
+
+ require.True(t, apiAccount.IsSignerTheMainAccount(), "Expected keys to be equal")
+ })
+
+ // --- Test Case 2: The signer key is NOT the main account key ---
+ t.Run("should return false when keys are different", func(t *testing.T) {
+ // Arrange
+ otherPubKeyAny, err := types.NewAnyWithValue(otherPubKey)
+ require.NoError(t, err)
+
+ signerAccountWithDifferentKey := &cosmosaccount.Account{
+ Record: &keyring.Record{
+ PubKey: otherPubKeyAny, // Use the different key, wrapped in Any
+ },
+ }
+ apiAccount := &ApiAccount{
+ AccountKey: mainPubKey,
+ SignerAccount: signerAccountWithDifferentKey,
+ }
+
+ // Act & Assert
+ // NOTE: See comment in the test case above.
+ require.False(t, apiAccount.IsSignerTheMainAccount(), "Expected keys to be different")
+ })
+}
diff --git a/decentralized-api/apiconfig/config.go b/decentralized-api/apiconfig/config.go
new file mode 100644
index 000000000..dee5eb1a7
--- /dev/null
+++ b/decentralized-api/apiconfig/config.go
@@ -0,0 +1,168 @@
+package apiconfig
+
+import (
+ "fmt"
+ "strings"
+)
+
+type Config struct {
+ Api ApiConfig `koanf:"api" json:"api"`
+ Nodes []InferenceNodeConfig `koanf:"nodes" json:"nodes"`
+ NodeConfigIsMerged bool `koanf:"merged_node_config" json:"merged_node_config"`
+ ChainNode ChainNodeConfig `koanf:"chain_node" json:"chain_node"`
+ UpcomingSeed SeedInfo `koanf:"upcoming_seed" json:"upcoming_seed"`
+ CurrentSeed SeedInfo `koanf:"current_seed" json:"current_seed"`
+ PreviousSeed SeedInfo `koanf:"previous_seed" json:"previous_seed"`
+ CurrentHeight int64 `koanf:"current_height" json:"current_height"`
+ LastProcessedHeight int64 `koanf:"last_processed_height" json:"last_processed_height"`
+ UpgradePlan UpgradePlan `koanf:"upgrade_plan" json:"upgrade_plan"`
+ MLNodeKeyConfig MLNodeKeyConfig `koanf:"ml_node_key_config" json:"ml_node_key_config"`
+ Nats NatsServerConfig `koanf:"nats" json:"nats"`
+ CurrentNodeVersion string `koanf:"current_node_version" json:"current_node_version"`
+ LastUsedVersion string `koanf:"last_used_version" json:"last_used_version"`
+ ValidationParams ValidationParamsCache `koanf:"validation_params" json:"validation_params"`
+ BandwidthParams BandwidthParamsCache `koanf:"bandwidth_params" json:"bandwidth_params"`
+ Validator ValidatorConfig `koanf:"validator" json:"validator"`
+}
+
+type NatsServerConfig struct {
+ Host string `koanf:"host" json:"host"`
+ Port int `koanf:"port" json:"port"`
+}
+
+type UpgradePlan struct {
+ Name string `koanf:"name" json:"name"`
+ Height int64 `koanf:"height" json:"height"`
+ Binaries map[string]string `koanf:"binaries" json:"binaries"`
+ NodeVersion string `koanf:"node_version" json:"node_version"`
+}
+
+type SeedInfo struct {
+ Seed int64 `koanf:"seed" json:"seed"`
+ EpochIndex uint64 `koanf:"epoch_index" json:"epoch_index"`
+ Signature string `koanf:"signature" json:"signature"`
+ Claimed bool `koanf:"claimed" json:"claimed"`
+}
+
+type ApiConfig struct {
+ Port int `koanf:"port" json:"port"`
+ PoCCallbackUrl string `koanf:"poc_callback_url" json:"poc_callback_url"`
+ MlGrpcCallbackAddress string `koanf:"ml_grpc_callback_address" json:"ml_grpc_callback_address"`
+ PublicUrl string `koanf:"public_url" json:"public_url"`
+ PublicServerPort int `koanf:"public_server_port" json:"public_server_port"`
+ MLServerPort int `koanf:"ml_server_port" json:"ml_server_port"`
+ AdminServerPort int `koanf:"admin_server_port" json:"admin_server_port"`
+ MlGrpcServerPort int `koanf:"ml_grpc_server_port" json:"ml_grpc_server_port"`
+ TestMode bool `koanf:"test_mode" json:"test_mode"`
+}
+
+type ChainNodeConfig struct {
+ Url string `koanf:"url" json:"url"`
+ IsGenesis bool `koanf:"is_genesis" json:"is_genesis"`
+ SeedApiUrl string `koanf:"seed_api_url" json:"seed_api_url"`
+ AccountPublicKey string `koanf:"account_public_key" json:"account_public_key"`
+ SignerKeyName string `koanf:"signer_key_name" json:"signer_key_name"`
+ KeyringBackend string `koanf:"keyring_backend" json:"keyring_backend"`
+ KeyringDir string `koanf:"keyring_dir" json:"keyring_dir"`
+ KeyringPassword string `json:"-"`
+}
+
+type MLNodeKeyConfig struct {
+ WorkerPublicKey string `koanf:"worker_public" json:"worker_public"`
+ WorkerPrivateKey string `koanf:"worker_private" json:"worker_private"`
+}
+
+// IF YOU CHANGE ANY OF THESE STRUCTURES BE SURE TO CHANGE HardwareNode proto in inference-chain!!!
+type InferenceNodeConfig struct {
+ Host string `koanf:"host" json:"host"`
+ InferenceSegment string `koanf:"inference_segment" json:"inference_segment"`
+ InferencePort int `koanf:"inference_port" json:"inference_port"`
+ PoCSegment string `koanf:"poc_segment" json:"poc_segment"`
+ PoCPort int `koanf:"poc_port" json:"poc_port"`
+ Models map[string]ModelConfig `koanf:"models" json:"models"`
+ Id string `koanf:"id" json:"id"`
+ MaxConcurrent int `koanf:"max_concurrent" json:"max_concurrent"`
+ Hardware []Hardware `koanf:"hardware" json:"hardware"`
+}
+
+// ValidateInferenceNodeBasic validates basic fields of an InferenceNodeConfig without checking for duplicates.
+// This is useful when loading from JSON before the broker exists.
+// Returns an error describing what is wrong, or nil if valid.
+func ValidateInferenceNodeBasic(node InferenceNodeConfig) []string {
+ var errors []string
+
+ // Validate required fields
+ if strings.TrimSpace(node.Id) == "" {
+ errors = append(errors, "node id is required and cannot be empty")
+ }
+
+ if strings.TrimSpace(node.Host) == "" {
+ errors = append(errors, "host is required and cannot be empty")
+ }
+
+ if node.InferencePort <= 0 || node.InferencePort > 65535 {
+ errors = append(errors, fmt.Sprintf("inference_port must be between 1 and 65535, got %d", node.InferencePort))
+ }
+
+ if node.PoCPort <= 0 || node.PoCPort > 65535 {
+ errors = append(errors, fmt.Sprintf("poc_port must be between 1 and 65535, got %d", node.PoCPort))
+ }
+
+ if node.MaxConcurrent <= 0 {
+ errors = append(errors, fmt.Sprintf("max_concurrent must be greater than 0, got %d", node.MaxConcurrent))
+ }
+
+ if len(node.Models) == 0 {
+ errors = append(errors, "at least one model must be specified")
+ }
+
+ return errors
+}
+
+func (n InferenceNodeConfig) DeepCopy() InferenceNodeConfig {
+ result := n
+
+ if n.Models != nil {
+ result.Models = make(map[string]ModelConfig, len(n.Models))
+ for k, v := range n.Models {
+ modelCopy := v
+ if v.Args != nil {
+ modelCopy.Args = make([]string, len(v.Args))
+ copy(modelCopy.Args, v.Args)
+ }
+ result.Models[k] = modelCopy
+ }
+ }
+
+ if n.Hardware != nil {
+ result.Hardware = make([]Hardware, len(n.Hardware))
+ copy(result.Hardware, n.Hardware)
+ }
+
+ return result
+}
+
+type ModelConfig struct {
+ Args []string `json:"args"`
+}
+
+type Hardware struct {
+ Type string `koanf:"type" json:"type"`
+ Count uint32 `koanf:"count" json:"count"`
+}
+
+type ValidationParamsCache struct {
+ TimestampExpiration int64 `koanf:"timestamp_expiration" json:"timestamp_expiration"`
+ TimestampAdvance int64 `koanf:"timestamp_advance" json:"timestamp_advance"`
+ ExpirationBlocks int64 `koanf:"expiration_blocks" json:"expiration_blocks"`
+}
+
+type BandwidthParamsCache struct {
+ EstimatedLimitsPerBlockKb uint64 `koanf:"estimated_limits_per_block_kb" json:"estimated_limits_per_block_kb"`
+ KbPerInputToken float64 `koanf:"kb_per_input_token" json:"kb_per_input_token"`
+ KbPerOutputToken float64 `koanf:"kb_per_output_token" json:"kb_per_output_token"`
+}
+
+type ValidatorConfig struct {
+ VllmUrl string `koanf:"vllm_url" json:"vllm_url"`
+}
diff --git a/decentralized-api/apiconfig/config_manager.go b/decentralized-api/apiconfig/config_manager.go
new file mode 100644
index 000000000..14ef93a12
--- /dev/null
+++ b/decentralized-api/apiconfig/config_manager.go
@@ -0,0 +1,919 @@
+package apiconfig
+
+import (
+ "context"
+ "database/sql"
+ "decentralized-api/logging"
+ "encoding/base64"
+ "encoding/json"
+ "io"
+ "log"
+ "os"
+ "path/filepath"
+ "strconv"
+ "strings"
+ "sync"
+ "time"
+
+ "github.com/cometbft/cometbft/crypto/ed25519"
+ "github.com/knadh/koanf/parsers/yaml"
+ "github.com/knadh/koanf/providers/env"
+ "github.com/knadh/koanf/providers/file"
+ "github.com/knadh/koanf/providers/structs"
+ "github.com/knadh/koanf/v2"
+ "github.com/productscience/inference/x/inference/types"
+ "google.golang.org/grpc"
+)
+
+type ConfigManager struct {
+ currentConfig Config
+ KoanProvider koanf.Provider
+ WriterProvider WriteCloserProvider
+ sqlDb SqlDatabase
+ mutex sync.Mutex
+ configDumpPath string
+ sqlitePath string
+}
+
+type WriteCloserProvider interface {
+ GetWriter() WriteCloser
+}
+
+func LoadDefaultConfigManager() (*ConfigManager, error) {
+ return LoadConfigManagerWithPaths(getConfigPath(), getSqlitePath(), os.Getenv("NODE_CONFIG_PATH"))
+}
+
+// LoadConfigManagerWithPaths allows tests to supply explicit paths.
+func LoadConfigManagerWithPaths(configPath, sqlitePath, nodeConfigPath string) (*ConfigManager, error) {
+ defaultDbCfg := SqliteConfig{
+ Path: sqlitePath,
+ }
+
+ db := NewSQLiteDb(defaultDbCfg)
+ ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+ defer cancel()
+ if err := db.BootstrapLocal(ctx); err != nil {
+ log.Printf("Error bootstrapping local SQLite DB: %+v", err)
+ return nil, err
+ }
+
+ manager := ConfigManager{
+ KoanProvider: file.Provider(configPath),
+ WriterProvider: NewFileWriteCloserProvider(configPath),
+ sqlDb: db,
+ mutex: sync.Mutex{},
+ configDumpPath: filepath.Join(filepath.Dir(sqlitePath), "config-dump.json"),
+ sqlitePath: sqlitePath,
+ }
+ err := manager.Load()
+ if err != nil {
+ return nil, err
+ }
+
+ err = manager.migrateDynamicDataToDb(ctx)
+ if err != nil {
+ log.Printf("Error migrating dynamic data to DB: %+v", err)
+ return nil, err
+ }
+
+ if err = manager.Write(); err != nil {
+ log.Printf("Error writing config: %+v", err)
+ return nil, err
+ }
+ log.Printf("Saved static config after load")
+
+ // Hydrate in-memory dynamic state from DB once
+ if err := manager.HydrateFromDB(context.Background()); err != nil {
+ log.Printf("Error hydrating dynamic data from DB: %+v", err)
+ return nil, err
+ }
+ // Load node config JSON into in-memory struct if it's the very first run
+ if err := manager.LoadNodeConfig(ctx, nodeConfigPath); err != nil {
+ log.Fatalf("error loading node config: %v", err)
+ }
+
+ // Log the resulting config in pretty JSON format for easier debugging
+ // Make a copy and sanitize sensitive fields before logging
+ sanitized := manager.currentConfig
+ sanitized.CurrentSeed.Seed = 0
+ sanitized.PreviousSeed.Seed = 0
+ sanitized.UpcomingSeed.Seed = 0
+ sanitized.MLNodeKeyConfig.WorkerPrivateKey = ""
+ if cfgBytes, err := json.MarshalIndent(sanitized, "", " "); err != nil {
+ log.Printf("Error marshaling final config to JSON: %+v", err)
+ } else {
+ log.Printf("Final loaded config (JSON):\n%s", string(cfgBytes))
+ }
+ return &manager, nil
+}
+
+func (cm *ConfigManager) Write() error {
+ cm.mutex.Lock()
+ defer cm.mutex.Unlock()
+ // Write only static fields to config file
+ staticCopy := cm.getStaticConfigCopyUnsafe()
+ return writeConfig(staticCopy, cm.WriterProvider)
+}
+
+func (cm *ConfigManager) Load() error {
+ cm.mutex.Lock()
+ defer cm.mutex.Unlock()
+ config, err := readConfig(cm.KoanProvider)
+ if err != nil {
+ return err
+ }
+ cm.currentConfig = config
+ return nil
+}
+
+// Need to make sure we pass back a COPY of the ChainNodeConfig to make sure
+// we don't modify the original
+func (cm *ConfigManager) GetChainNodeConfig() ChainNodeConfig {
+ return cm.currentConfig.ChainNode
+}
+
+func (cm *ConfigManager) GetApiConfig() ApiConfig {
+ return cm.currentConfig.Api
+}
+
+func (cm *ConfigManager) GetNatsConfig() NatsServerConfig {
+ return cm.currentConfig.Nats
+}
+
+func (cm *ConfigManager) GetNodes() []InferenceNodeConfig {
+ nodes := make([]InferenceNodeConfig, len(cm.currentConfig.Nodes))
+ copy(nodes, cm.currentConfig.Nodes)
+ return nodes
+}
+
+// SqlDb returns the configured SQL database handle if available
+func (cm *ConfigManager) SqlDb() SqlDatabase {
+ return cm.sqlDb
+}
+
+func (cm *ConfigManager) getConfig() *Config {
+ return &cm.currentConfig
+}
+
+// GetConfig returns a snapshot copy of the current configuration.
+// The returned value should be treated as read-only by callers.
+func (cm *ConfigManager) GetConfig() Config {
+ cm.mutex.Lock()
+ defer cm.mutex.Unlock()
+ return cm.currentConfig
+}
+
+func (cm *ConfigManager) GetUpgradePlan() UpgradePlan { return cm.currentConfig.UpgradePlan }
+
+func (cm *ConfigManager) SetUpgradePlan(plan UpgradePlan) error {
+ cm.mutex.Lock()
+ defer cm.mutex.Unlock()
+ cm.currentConfig.UpgradePlan = plan
+ logging.Info("Setting upgrade plan", types.Config, "plan", plan)
+ return nil
+}
+
+func (cm *ConfigManager) ClearUpgradePlan() error {
+ cm.mutex.Lock()
+ defer cm.mutex.Unlock()
+ cm.currentConfig.UpgradePlan = UpgradePlan{}
+ logging.Info("Clearing upgrade plan", types.Config)
+ return nil
+}
+
+func (cm *ConfigManager) SetHeight(height int64) error {
+ cm.mutex.Lock()
+ defer cm.mutex.Unlock()
+ cm.currentConfig.CurrentHeight = height
+ logging.Info("Setting height", types.Config, "height", height)
+ return nil
+}
+
+func (cm *ConfigManager) GetLastProcessedHeight() int64 {
+ return cm.currentConfig.LastProcessedHeight
+}
+
+func (cm *ConfigManager) SetLastProcessedHeight(height int64) error {
+ cm.mutex.Lock()
+ defer cm.mutex.Unlock()
+ cm.currentConfig.LastProcessedHeight = height
+ logging.Info("Setting last processed height", types.Config, "height", height)
+ return nil
+}
+
+func (cm *ConfigManager) GetCurrentNodeVersion() string {
+ return cm.currentConfig.CurrentNodeVersion
+}
+
+func (cm *ConfigManager) SetCurrentNodeVersion(version string) error {
+ cm.mutex.Lock()
+ defer cm.mutex.Unlock()
+ oldVersion := cm.currentConfig.CurrentNodeVersion
+ cm.currentConfig.CurrentNodeVersion = version
+ logging.Info("Setting current node version", types.Config, "oldVersion", oldVersion, "newVersion", version)
+ return nil
+}
+
+// SyncVersionFromChain queries the current version from chain and updates config if needed
+// This should be called when the blockchain is ready and connections are stable
+func (cm *ConfigManager) SyncVersionFromChain(cosmosClient CosmosQueryClient) error {
+ ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+ defer cancel()
+
+ resp, err := cosmosClient.MLNodeVersion(ctx, &types.QueryGetMLNodeVersionRequest{})
+ if err != nil {
+ logging.Warn("Failed to sync MLNode version from chain, keeping current version",
+ types.Config, "error", err)
+ return err
+ }
+
+ chainVersion := resp.MlnodeVersion.CurrentVersion
+ if chainVersion == "" {
+ logging.Warn("Chain version is empty", types.Config)
+ }
+
+ currentVersion := cm.GetCurrentNodeVersion()
+ if chainVersion != currentVersion {
+ logging.Info("Version mismatch detected - updating from chain", types.Config,
+ "currentVersion", currentVersion, "chainVersion", chainVersion)
+ return cm.SetCurrentNodeVersion(chainVersion)
+ }
+
+ logging.Info("Version sync complete - no changes needed", types.Config, "version", currentVersion)
+ return nil
+}
+
+// CosmosQueryClient defines interface for querying version from cosmos
+type CosmosQueryClient interface {
+ MLNodeVersion(ctx context.Context, req *types.QueryGetMLNodeVersionRequest, opts ...grpc.CallOption) (*types.QueryGetMLNodeVersionResponse, error)
+}
+
+func (cm *ConfigManager) SetValidationParams(params ValidationParamsCache) error {
+ cm.mutex.Lock()
+ defer cm.mutex.Unlock()
+ cm.currentConfig.ValidationParams = params
+ logging.Info("Setting validation params", types.Config, "params", params)
+ return nil
+}
+
+func (cm *ConfigManager) GetValidationParams() ValidationParamsCache {
+ return cm.currentConfig.ValidationParams
+}
+
+func (cm *ConfigManager) SetBandwidthParams(params BandwidthParamsCache) error {
+ cm.mutex.Lock()
+ defer cm.mutex.Unlock()
+ cm.currentConfig.BandwidthParams = params
+ logging.Info("Setting bandwidth params", types.Config, "params", params)
+ return nil
+}
+
+func (cm *ConfigManager) GetBandwidthParams() BandwidthParamsCache {
+ return cm.currentConfig.BandwidthParams
+}
+
+func (cm *ConfigManager) GetHeight() int64 {
+ return cm.currentConfig.CurrentHeight
+}
+
+func (cm *ConfigManager) GetLastUsedVersion() string {
+ return cm.currentConfig.LastUsedVersion
+}
+
+func (cm *ConfigManager) SetLastUsedVersion(version string) error {
+ cm.mutex.Lock()
+ defer cm.mutex.Unlock()
+ cm.currentConfig.LastUsedVersion = version
+ logging.Info("Setting last used version", types.Config, "version", version)
+ return nil
+}
+
+func (cm *ConfigManager) ShouldRefreshClients() bool {
+ currentVersion := cm.GetCurrentNodeVersion()
+ lastUsedVersion := cm.GetLastUsedVersion()
+ return currentVersion != lastUsedVersion
+}
+
+func (cm *ConfigManager) SetPreviousSeed(seed SeedInfo) error {
+ cm.mutex.Lock()
+ defer cm.mutex.Unlock()
+ cm.currentConfig.PreviousSeed = seed
+ logging.Info("Setting previous seed", types.Config, "seed", seed)
+ return nil
+}
+
+func (cm *ConfigManager) AdvanceCurrentSeed() {
+ cm.mutex.Lock()
+ defer cm.mutex.Unlock()
+
+ cm.currentConfig.PreviousSeed = cm.currentConfig.CurrentSeed
+ cm.currentConfig.CurrentSeed = cm.currentConfig.UpcomingSeed
+ cm.currentConfig.UpcomingSeed = SeedInfo{}
+}
+
+func (cm *ConfigManager) MarkPreviousSeedClaimed() error {
+ cm.mutex.Lock()
+ defer cm.mutex.Unlock()
+ prev := cm.currentConfig.PreviousSeed
+ prev.Claimed = true
+ cm.currentConfig.PreviousSeed = prev
+ logging.Info("Marking previous seed as claimed", types.Config, "epochIndex", cm.currentConfig.PreviousSeed.EpochIndex)
+ return nil
+}
+
+func (cm *ConfigManager) IsPreviousSeedClaimed() bool {
+ seed := cm.GetPreviousSeed()
+ return seed.Claimed
+}
+
+func (cm *ConfigManager) GetPreviousSeed() SeedInfo {
+ return cm.currentConfig.PreviousSeed
+}
+
+func (cm *ConfigManager) SetCurrentSeed(seed SeedInfo) error {
+ cm.mutex.Lock()
+ defer cm.mutex.Unlock()
+ cm.currentConfig.CurrentSeed = seed
+ logging.Info("Setting current seed", types.Config, "seed", seed)
+ return nil
+}
+
+func (cm *ConfigManager) GetCurrentSeed() SeedInfo {
+ return cm.currentConfig.CurrentSeed
+}
+
+func (cm *ConfigManager) SetUpcomingSeed(seed SeedInfo) error {
+ cm.mutex.Lock()
+ defer cm.mutex.Unlock()
+ cm.currentConfig.UpcomingSeed = seed
+ logging.Info("Setting upcoming seed", types.Config, "seed", seed)
+ return nil
+}
+
+func (cm *ConfigManager) GetUpcomingSeed() SeedInfo {
+ return cm.currentConfig.UpcomingSeed
+}
+
+// Called from:
+// 1. syncNodesWithConfig periodic routine
+// 2. admin API when nodes are added/removed
+func (cm *ConfigManager) SetNodes(nodes []InferenceNodeConfig) error {
+ cm.mutex.Lock()
+ defer cm.mutex.Unlock()
+ cm.currentConfig.Nodes = nodes
+ logging.Info("Setting nodes", types.Config, "nodes", nodes)
+ return nil
+}
+
+func (cm *ConfigManager) CreateWorkerKey() (string, error) {
+ workerKey := ed25519.GenPrivKey()
+ workerPublicKey := workerKey.PubKey()
+ workerPublicKeyString := base64.StdEncoding.EncodeToString(workerPublicKey.Bytes())
+ workerPrivateKey := workerKey.Bytes()
+ workerPrivateKeyString := base64.StdEncoding.EncodeToString(workerPrivateKey)
+ cfg := MLNodeKeyConfig{WorkerPublicKey: workerPublicKeyString, WorkerPrivateKey: workerPrivateKeyString}
+ cm.currentConfig.MLNodeKeyConfig = cfg
+ return workerPublicKeyString, nil
+}
+
+func getFileProvider() koanf.Provider {
+ configPath := getConfigPath()
+ return file.Provider(configPath)
+}
+
+func getConfigPath() string {
+ configPath := os.Getenv("API_CONFIG_PATH")
+ if configPath == "" {
+ configPath = "config.yaml" // Default value if the environment variable is not set
+ }
+ return configPath
+}
+
+func getSqlitePath() string {
+ path := os.Getenv("API_SQLITE_PATH")
+ if path == "" {
+ return "/root/.dapi/gonka.db"
+ }
+ return path
+}
+
+type FileWriteCloserProvider struct {
+ path string
+}
+
+func NewFileWriteCloserProvider(path string) *FileWriteCloserProvider {
+ return &FileWriteCloserProvider{path: path}
+}
+
+func (f *FileWriteCloserProvider) GetWriter() WriteCloser {
+ file, err := os.OpenFile(f.path, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0755)
+ if err != nil {
+ log.Fatalf("error opening file at %s: %v", f.path, err)
+ }
+ return file
+}
+
+func readConfig(provider koanf.Provider) (Config, error) {
+ k := koanf.New(".")
+ parser := yaml.Parser()
+
+ if err := k.Load(provider, parser); err != nil {
+ log.Fatalf("error loading config: %v", err)
+ }
+ err := k.Load(env.Provider("DAPI_", ".", func(s string) string {
+ return strings.Replace(strings.ToLower(
+ strings.TrimPrefix(s, "DAPI_")), "__", ".", -1)
+ }), nil)
+
+ if err != nil {
+ log.Fatalf("error loading env: %v", err)
+ }
+ var config Config
+ err = k.Unmarshal("", &config)
+ if err != nil {
+ log.Fatalf("error unmarshalling config: %v", err)
+ }
+ if keyName, found := os.LookupEnv("KEY_NAME"); found {
+ config.ChainNode.SignerKeyName = keyName
+ log.Printf("Loaded KEY_NAME: %+v", keyName)
+ }
+
+ if accountPubKey, found := os.LookupEnv("ACCOUNT_PUBKEY"); found {
+ config.ChainNode.AccountPublicKey = accountPubKey
+ log.Printf("Loaded ACCOUNT_PUBKEY: %+v", accountPubKey)
+ }
+
+ if keyRingBackend, found := os.LookupEnv("KEYRING_BACKEND"); found {
+ config.ChainNode.KeyringBackend = keyRingBackend
+ log.Printf("Loaded KEYRING_BACKEND: %+v", keyRingBackend)
+ }
+
+ if keyringPassword, found := os.LookupEnv("KEYRING_PASSWORD"); found {
+ config.ChainNode.KeyringPassword = keyringPassword
+ log.Printf("Loaded KEYRING_PASSWORD: %+v", keyringPassword)
+ } else {
+ log.Printf("Warning: KEYRING_PASSWORD environment variable not set - keyring operations may fail")
+ }
+
+ return config, nil
+}
+
+func writeConfig(config Config, writerProvider WriteCloserProvider) error {
+ // Skip writing in tests where WriterProvider is nil
+ if writerProvider == nil {
+ return nil
+ }
+
+ writer := writerProvider.GetWriter()
+ k := koanf.New(".")
+ parser := yaml.Parser()
+ err := k.Load(structs.Provider(config, "koanf"), nil)
+ if err != nil {
+ logging.Error("error loading config", types.Config, "error", err)
+ return err
+ }
+ output, err := k.Marshal(parser)
+ if err != nil {
+ logging.Error("error marshalling config", types.Config, "error", err)
+ return err
+ }
+ _, err = writer.Write(output)
+ if err != nil {
+ logging.Error("error writing config", types.Config, "error", err)
+ return err
+ }
+ return nil
+}
+
+type WriteCloser interface {
+ Write([]byte) (int, error)
+ Close() error
+}
+
+// LoadNodeConfig loads additional nodes from a JSON file and writes them into the DB once.
+// Idempotent via KV flag kvKeyNodeConfigMerged.
+func (cm *ConfigManager) LoadNodeConfig(ctx context.Context, nodeConfigPathOverride string) error {
+ if err := cm.ensureDbReady(ctx); err != nil {
+ return err
+ }
+
+ // If already merged, skip
+ var merged bool
+ if ok, err := KVGetJSON(ctx, cm.sqlDb.GetDb(), kvKeyNodeConfigMerged, &merged); err == nil && ok && merged {
+ logging.Info("Node config already merged. Skipping", types.Config)
+ return nil
+ }
+
+ nodeConfigPath := nodeConfigPathOverride
+ if strings.TrimSpace(nodeConfigPath) == "" {
+ var found bool
+ nodeConfigPath, found = os.LookupEnv("NODE_CONFIG_PATH")
+ if !found {
+ nodeConfigPath = ""
+ }
+ }
+ if strings.TrimSpace(nodeConfigPath) == "" {
+ logging.Info("NODE_CONFIG_PATH not set. No additional nodes will be added to config", types.Config)
+ return nil
+ }
+
+ logging.Info("Loading and merging node configuration", types.Config, "path", nodeConfigPath)
+
+ newNodes, err := parseInferenceNodesFromNodeConfigJson(nodeConfigPath)
+ if err != nil {
+ return err
+ }
+
+ // Validate nodes and filter out invalid ones
+ validNodes := getValidNodes(newNodes)
+
+ if len(validNodes) < len(newNodes) {
+ logging.Warn("Some nodes were skipped due to validation errors", types.Config,
+ "total_nodes", len(newNodes), "valid_nodes", len(validNodes), "skipped", len(newNodes)-len(validNodes))
+ }
+
+ // Populate in-memory nodes and mark dirty. Auto-flush will persist and then set merged flag.
+ cm.mutex.Lock()
+ cm.currentConfig.Nodes = validNodes
+ cm.mutex.Unlock()
+
+ logging.Info("Loaded node configuration into memory; will persist on next flush", types.Config,
+ "valid_nodes", len(validNodes))
+ return nil
+}
+
+func getValidNodes(newNodes []InferenceNodeConfig) []InferenceNodeConfig {
+ validNodes := make([]InferenceNodeConfig, 0, len(newNodes))
+ idSet := make(map[string]bool)
+ hostPortSet := make(map[string]bool)
+ for i, node := range newNodes {
+ id := node.Id
+ if _, exists := idSet[id]; exists {
+ logging.Error("Skipping duplicate node from node_config.json", types.Config, "node_id", id, "index_in_file", i)
+ continue
+ }
+
+ hostInfPort := strings.ToLower(strings.TrimSpace(node.Host)) + ":" + strconv.Itoa(node.InferencePort)
+ if _, exists := hostPortSet[hostInfPort]; exists {
+ logging.Error("Skipping node with duplicate host:port from node_config.json", types.Config, "host_port", hostInfPort, "index_in_file", i)
+ continue
+ }
+
+ hostPocPort := strings.ToLower(strings.TrimSpace(node.Host)) + ":" + strconv.Itoa(node.PoCPort)
+ if _, exists := hostPortSet[hostPocPort]; exists {
+ logging.Error("Skipping node with duplicate host:port from node_config.json", types.Config, "host_port", hostPocPort, "index_in_file", i)
+ continue
+ }
+
+ validationErrors := ValidateInferenceNodeBasic(node)
+
+ if len(validationErrors) > 0 {
+ logging.Error("Skipping invalid node from node_config.json", types.Config,
+ "index", i, "node_id", node.Id, "errors", validationErrors)
+ } else {
+ validNodes = append(validNodes, node)
+ idSet[id] = true
+ hostPortSet[hostInfPort] = true
+ hostPortSet[hostPocPort] = true
+ }
+ }
+ return validNodes
+}
+
+func parseInferenceNodesFromNodeConfigJson(nodeConfigPath string) ([]InferenceNodeConfig, error) {
+ file, err := os.Open(nodeConfigPath)
+ if err != nil {
+ logging.Error("Failed to open node config file", types.Config, "error", err)
+ return nil, err
+ }
+ defer file.Close()
+
+ bytes, err := io.ReadAll(file)
+ if err != nil {
+ logging.Error("Failed to read node config file", types.Config, "error", err)
+ return nil, err
+ }
+
+ var newNodes []InferenceNodeConfig
+ if err := json.Unmarshal(bytes, &newNodes); err != nil {
+ logging.Error("Failed to parse node config JSON", types.Config, "error", err)
+ return nil, err
+ }
+
+ return newNodes, nil
+}
+
+func (cm *ConfigManager) migrateDynamicDataToDb(ctx context.Context) error {
+ if err := cm.ensureDbReady(ctx); err != nil {
+ return err
+ }
+ // Only migrate once, gated by a KV flag
+ var migrated bool
+ if ok, err := KVGetJSON(ctx, cm.sqlDb.GetDb(), kvKeyConfigMigrated, &migrated); err == nil && ok && migrated {
+ logging.Info("Config migration already completed. Skipping", types.Config)
+ return nil
+ }
+ config := cm.currentConfig
+ // If YAML indicates nodes were already merged historically, persist the flag so LoadNodeConfig skips
+ if config.NodeConfigIsMerged {
+ _ = KVSetJSON(ctx, cm.sqlDb.GetDb(), kvKeyNodeConfigMerged, true)
+ }
+ // Nodes: upsert unconditionally (idempotent)
+ if err := WriteNodes(ctx, cm.sqlDb.GetDb(), config.Nodes); err != nil {
+ logging.Error("Error writing nodes to DB", types.Config, "error", err)
+ return err
+ }
+
+ // Per-key idempotent migrations: only populate if missing
+ // Heights
+ if _, ok, _ := KVGetInt64(ctx, cm.sqlDb.GetDb(), kvKeyCurrentHeight); !ok && config.CurrentHeight != 0 {
+ _ = KVSetInt64(ctx, cm.sqlDb.GetDb(), kvKeyCurrentHeight, config.CurrentHeight)
+ }
+ if _, ok, _ := KVGetInt64(ctx, cm.sqlDb.GetDb(), kvKeyLastProcessedHeight); !ok && config.LastProcessedHeight != 0 {
+ _ = KVSetInt64(ctx, cm.sqlDb.GetDb(), kvKeyLastProcessedHeight, config.LastProcessedHeight)
+ }
+
+ // Seeds (migrate once into typed table if not already present)
+ if s := config.CurrentSeed; s.Seed != 0 || s.Signature != "" {
+ _ = SetActiveSeed(ctx, cm.sqlDb.GetDb(), "current", s)
+ }
+ if s := config.PreviousSeed; s.Seed != 0 || s.Signature != "" {
+ _ = SetActiveSeed(ctx, cm.sqlDb.GetDb(), "previous", s)
+ }
+ if s := config.UpcomingSeed; s.Seed != 0 || s.Signature != "" {
+ _ = SetActiveSeed(ctx, cm.sqlDb.GetDb(), "upcoming", s)
+ }
+
+ // Upgrade plan
+ var up UpgradePlan
+ if ok, _ := func() (bool, error) { return KVGetJSON(ctx, cm.sqlDb.GetDb(), kvKeyUpgradePlan, &up) }(); !ok && (config.UpgradePlan.Height != 0 || config.UpgradePlan.Name != "") {
+ _ = KVSetJSON(ctx, cm.sqlDb.GetDb(), kvKeyUpgradePlan, config.UpgradePlan)
+ }
+
+ // Versions
+ if _, ok, _ := KVGetString(ctx, cm.sqlDb.GetDb(), kvKeyCurrentNodeVersion); !ok && config.CurrentNodeVersion != "" {
+ _ = KVSetString(ctx, cm.sqlDb.GetDb(), kvKeyCurrentNodeVersion, config.CurrentNodeVersion)
+ }
+ if _, ok, _ := KVGetString(ctx, cm.sqlDb.GetDb(), kvKeyLastUsedVersion); !ok && config.LastUsedVersion != "" {
+ _ = KVSetString(ctx, cm.sqlDb.GetDb(), kvKeyLastUsedVersion, config.LastUsedVersion)
+ }
+
+ // Params
+ var vp ValidationParamsCache
+ if ok, _ := func() (bool, error) { return KVGetJSON(ctx, cm.sqlDb.GetDb(), kvKeyValidationParams, &vp) }(); !ok && (config.ValidationParams.TimestampExpiration != 0 || config.ValidationParams.ExpirationBlocks != 0) {
+ _ = KVSetJSON(ctx, cm.sqlDb.GetDb(), kvKeyValidationParams, config.ValidationParams)
+ }
+ var bp BandwidthParamsCache
+ if ok, _ := func() (bool, error) { return KVGetJSON(ctx, cm.sqlDb.GetDb(), kvKeyBandwidthParams, &bp) }(); !ok && (config.BandwidthParams.EstimatedLimitsPerBlockKb != 0) {
+ _ = KVSetJSON(ctx, cm.sqlDb.GetDb(), kvKeyBandwidthParams, config.BandwidthParams)
+ }
+
+ // ML node key config
+ var mk MLNodeKeyConfig
+ if ok, _ := func() (bool, error) { return KVGetJSON(ctx, cm.sqlDb.GetDb(), kvKeyMLNodeKeyConfig, &mk) }(); !ok && (config.MLNodeKeyConfig.WorkerPublicKey != "" || config.MLNodeKeyConfig.WorkerPrivateKey != "") {
+ _ = KVSetJSON(ctx, cm.sqlDb.GetDb(), kvKeyMLNodeKeyConfig, config.MLNodeKeyConfig)
+ }
+
+ // Mark migration as done
+ _ = KVSetJSON(ctx, cm.sqlDb.GetDb(), kvKeyConfigMigrated, true)
+ return nil
+}
+
+// HydrateFromDB loads dynamic fields from DB into memory ONCE during startup.
+func (cm *ConfigManager) HydrateFromDB(_ context.Context) error {
+ ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+ defer cancel()
+ _ = cm.ensureDbReady(ctx)
+ cm.mutex.Lock()
+ defer cm.mutex.Unlock()
+ if db := cm.sqlDb.GetDb(); db != nil {
+ if nodes, err := ReadNodes(ctx, db); err == nil && len(nodes) >= 0 {
+ logging.Info("Reading nodes from DB", types.Config, "nodes", nodes)
+ cm.currentConfig.Nodes = nodes
+ }
+ if s, ok, err := GetActiveSeed(ctx, db, "current"); err == nil && ok {
+ cm.currentConfig.CurrentSeed = s
+ sanitizedS := s
+ sanitizedS.Seed = 0
+ logging.Info("Reading active seed from DB", types.Config, "sanitizedSeed", s)
+ }
+ if s, ok, err := GetActiveSeed(ctx, db, "previous"); err == nil && ok {
+ cm.currentConfig.PreviousSeed = s
+ sanitizedS := s
+ sanitizedS.Seed = 0
+ logging.Info("Reading previous seed from DB", types.Config, "sanitizedSeed", s)
+ }
+ if s, ok, err := GetActiveSeed(ctx, db, "upcoming"); err == nil && ok {
+ cm.currentConfig.UpcomingSeed = s
+ sanitizedS := s
+ sanitizedS.Seed = 0
+ logging.Info("Reading upcoming seed from DB", types.Config, "sanitizedSeed", s)
+ }
+ if v, ok, err := KVGetInt64(ctx, db, kvKeyCurrentHeight); err == nil && ok {
+ logging.Info("Reading current height from DB", types.Config, "height", v)
+ cm.currentConfig.CurrentHeight = v
+ }
+ if v, ok, err := KVGetInt64(ctx, db, kvKeyLastProcessedHeight); err == nil && ok {
+ logging.Info("Reading last processed height from DB", types.Config, "height", v)
+ cm.currentConfig.LastProcessedHeight = v
+ }
+ var up UpgradePlan
+ if ok, err := KVGetJSON(ctx, db, kvKeyUpgradePlan, &up); err == nil && ok {
+ logging.Info("Reading upgrade plan from DB", types.Config, "plan", up)
+ cm.currentConfig.UpgradePlan = up
+ }
+ if v, ok, err := KVGetString(ctx, db, kvKeyCurrentNodeVersion); err == nil && ok {
+ logging.Info("Reading current node version from DB", types.Config, "version", v)
+ cm.currentConfig.CurrentNodeVersion = v
+ }
+ if v, ok, err := KVGetString(ctx, db, kvKeyLastUsedVersion); err == nil && ok {
+ logging.Info("Reading last used version from DB", types.Config, "version", v)
+ cm.currentConfig.LastUsedVersion = v
+ }
+ var vp ValidationParamsCache
+ if ok, err := KVGetJSON(ctx, db, kvKeyValidationParams, &vp); err == nil && ok {
+ logging.Info("Reading validation params from DB", types.Config, "params", vp)
+ cm.currentConfig.ValidationParams = vp
+ }
+ var bp BandwidthParamsCache
+ if ok, err := KVGetJSON(ctx, db, kvKeyBandwidthParams, &bp); err == nil && ok {
+ logging.Info("Reading bandwidth params from DB", types.Config, "params", bp)
+ cm.currentConfig.BandwidthParams = bp
+ }
+ var mk MLNodeKeyConfig
+ if ok, err := KVGetJSON(ctx, db, kvKeyMLNodeKeyConfig, &mk); err == nil && ok {
+ cm.currentConfig.MLNodeKeyConfig = mk
+ sanitizedMk := mk
+ mk.WorkerPrivateKey = ""
+ logging.Info("Reading MLNodeKeyConfig from DB", types.Config, "sanitizedConfig", sanitizedMk)
+ }
+ }
+ return nil
+}
+
+// StartAutoFlush launches a background goroutine that periodically flushes dynamic fields to DB.
+func (cm *ConfigManager) StartAutoFlush(ctx context.Context, interval time.Duration) {
+ t := time.NewTicker(interval)
+ go func() {
+ defer t.Stop()
+ for {
+ select {
+ case <-ctx.Done():
+ return
+ case <-t.C:
+ _ = cm.flushToDB(ctx)
+ }
+ }
+ }()
+}
+
+// FlushNow flushes dynamic fields immediately.
+func (cm *ConfigManager) FlushNow(ctx context.Context) error {
+ logging.Info("Executing FlushNow", types.Config)
+ return cm.flushToDB(ctx)
+}
+
+// flushToDB writes all dynamic fields if there were any changes since last flush.
+func (cm *ConfigManager) flushToDB(ctx context.Context) error {
+ logging.Info("Executing flushToDB", types.Config)
+
+ ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
+ defer cancel()
+ if err := cm.ensureDbReady(ctx); err != nil {
+ return err
+ }
+ cm.mutex.Lock()
+ cfg := cm.currentConfig
+ cm.mutex.Unlock()
+ db := cm.sqlDb.GetDb()
+ if db == nil {
+ return nil
+ }
+
+ // Always flush everything; each logical group uses its own transaction inside helpers
+ if err := ReplaceInferenceNodes(ctx, db, cfg.Nodes); err != nil {
+ return err
+ }
+ _ = KVSetJSON(ctx, db, kvKeyNodeConfigMerged, true)
+
+ // Seeds: must be atomic as a group; perform in one tx
+ if err := setSeedsAtomic(ctx, db, cfg); err != nil {
+ return err
+ }
+
+ _ = KVSetInt64(ctx, db, kvKeyCurrentHeight, cfg.CurrentHeight)
+ _ = KVSetInt64(ctx, db, kvKeyLastProcessedHeight, cfg.LastProcessedHeight)
+ _ = KVSetJSON(ctx, db, kvKeyUpgradePlan, cfg.UpgradePlan)
+ _ = KVSetString(ctx, db, kvKeyCurrentNodeVersion, cfg.CurrentNodeVersion)
+ _ = KVSetString(ctx, db, kvKeyLastUsedVersion, cfg.LastUsedVersion)
+ _ = KVSetJSON(ctx, db, kvKeyMLNodeKeyConfig, cfg.MLNodeKeyConfig)
+ _ = KVSetJSON(ctx, db, kvKeyValidationParams, cfg.ValidationParams)
+ _ = KVSetJSON(ctx, db, kvKeyBandwidthParams, cfg.BandwidthParams)
+
+ logging.Info("Flushed dynamic config to DB", types.Config)
+
+ // Also write a pretty-printed config dump JSON next to the DB
+ if cm.configDumpPath != "" {
+ if dumpBytes, err := json.MarshalIndent(cfg, "", " "); err != nil {
+ logging.Warn("Failed to marshal config dump", types.Config, "error", err)
+ } else {
+ // Ensure directory exists
+ _ = os.MkdirAll(filepath.Dir(cm.configDumpPath), 0o755)
+ if err := os.WriteFile(cm.configDumpPath, dumpBytes, 0o644); err != nil {
+ logging.Warn("Failed to write config dump", types.Config, "path", cm.configDumpPath, "error", err)
+ }
+ logging.Info("Saved config dump", types.Config, "configDumpPath", cm.configDumpPath)
+ }
+ }
+ return nil
+}
+
+// setSeedsAtomic writes all three seeds in a single transaction to keep them consistent.
+func setSeedsAtomic(ctx context.Context, db *sql.DB, cfg Config) error {
+ tx, err := db.BeginTx(ctx, &sql.TxOptions{})
+ if err != nil {
+ return err
+ }
+ defer func() { _ = tx.Rollback() }()
+ if _, err := tx.ExecContext(ctx, `UPDATE seed_info SET is_active = 0 WHERE is_active = 1 AND type IN ('current','previous','upcoming')`); err != nil {
+ return err
+ }
+ if err := insertSeedTx(ctx, tx, "current", cfg.CurrentSeed); err != nil {
+ return err
+ }
+ if err := insertSeedTx(ctx, tx, "previous", cfg.PreviousSeed); err != nil {
+ return err
+ }
+ if err := insertSeedTx(ctx, tx, "upcoming", cfg.UpcomingSeed); err != nil {
+ return err
+ }
+ return tx.Commit()
+}
+
+func insertSeedTx(ctx context.Context, tx *sql.Tx, seedType string, s SeedInfo) error {
+ _, err := tx.ExecContext(ctx, `INSERT INTO seed_info(type, seed, epoch_index, signature, claimed, is_active) VALUES(?, ?, ?, ?, ?, 1)`,
+ seedType, s.Seed, s.EpochIndex, s.Signature, s.Claimed)
+ return err
+}
+
+// ensureDbReady pings the DB and attempts to reopen if needed
+func (cm *ConfigManager) ensureDbReady(ctx context.Context) error {
+ db := cm.sqlDb.GetDb()
+ if db != nil {
+ if err := db.PingContext(ctx); err == nil {
+ return nil
+ }
+ }
+ // Reopen
+ reopenPath := cm.sqlitePath
+ if strings.TrimSpace(reopenPath) == "" {
+ reopenPath = getSqlitePath()
+ }
+ newDb := NewSQLiteDb(SqliteConfig{Path: reopenPath})
+ if err := newDb.BootstrapLocal(ctx); err != nil {
+ return err
+ }
+ // Close old handle to avoid leaks
+ if cm.sqlDb != nil && cm.sqlDb.GetDb() != nil {
+ _ = cm.sqlDb.GetDb().Close()
+ }
+ cm.sqlDb = newDb
+ return nil
+}
+
+// getStaticConfigCopyUnsafe returns a copy of config with dynamic fields zeroed for file persistence.
+func (cm *ConfigManager) getStaticConfigCopyUnsafe() Config {
+ c := cm.currentConfig
+ // Zero dynamic fields
+ c.Nodes = nil
+ c.NodeConfigIsMerged = false
+ c.UpcomingSeed = SeedInfo{}
+ c.CurrentSeed = SeedInfo{}
+ c.PreviousSeed = SeedInfo{}
+ c.CurrentHeight = 0
+ c.LastProcessedHeight = 0
+ c.UpgradePlan = UpgradePlan{}
+ c.MLNodeKeyConfig = MLNodeKeyConfig{}
+ c.CurrentNodeVersion = ""
+ c.LastUsedVersion = ""
+ c.ValidationParams = ValidationParamsCache{}
+ c.BandwidthParams = BandwidthParamsCache{}
+ return c
+}
+
+// KV keys for dynamic data
+const (
+ kvKeyCurrentHeight = "current_height"
+ kvKeyLastProcessedHeight = "last_processed_height"
+ kvKeyUpgradePlan = "upgrade_plan"
+ kvKeyCurrentSeed = "seed_current"
+ kvKeyPreviousSeed = "seed_previous"
+ kvKeyUpcomingSeed = "seed_upcoming"
+ kvKeyCurrentNodeVersion = "current_node_version"
+ kvKeyLastUsedVersion = "last_used_version"
+ kvKeyValidationParams = "validation_params"
+ kvKeyBandwidthParams = "bandwidth_params"
+ kvKeyMLNodeKeyConfig = "ml_node_key_config"
+ kvKeyNodeConfigMerged = "node_config_merged"
+ kvKeyConfigMigrated = "config_migrated"
+)
diff --git a/decentralized-api/apiconfig/config_manager_migration_test.go b/decentralized-api/apiconfig/config_manager_migration_test.go
new file mode 100644
index 000000000..d96690cc2
--- /dev/null
+++ b/decentralized-api/apiconfig/config_manager_migration_test.go
@@ -0,0 +1,249 @@
+package apiconfig_test
+
+import (
+ "context"
+ "decentralized-api/apiconfig"
+ "encoding/json"
+ "os"
+ "path/filepath"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+)
+
+func writeTempFile(t *testing.T, dir, name, contents string) string {
+ t.Helper()
+ p := filepath.Join(dir, name)
+ require.NoError(t, os.WriteFile(p, []byte(contents), 0644))
+ return p
+}
+
+// Scenario 1: YAML has dynamic state, DB empty, node-config.json present but should be ignored because merged_node_config=true
+func TestLoadDefaultConfigManager_Migration_Idempotent_And_NodeConfigSkipped(t *testing.T) {
+ tmp := t.TempDir()
+
+ yaml := `api:
+ port: 8080
+chain_node:
+ url: http://join1-node:26657
+ signer_key_name: join1
+ account_public_key: ""
+ keyring_backend: test
+ keyring_dir: /root/.inference
+current_height: 393
+current_seed:
+ seed: 3898730504561900192
+ epoch_index: 380
+ signature: abc
+previous_seed:
+ seed: 1370553182438852893
+ epoch_index: 370
+ signature: def
+upcoming_seed:
+ seed: 254929314898674592
+ epoch_index: 390
+ signature: ghi
+nodes:
+ - host: http://yaml-node:8080/
+ models:
+ modelA: {args: []}
+ id: yaml-node-1
+ max_concurrent: 5
+merged_node_config: true
+current_node_version: "v3.0.8"
+`
+ cfgPath := writeTempFile(t, tmp, "config.yaml", yaml)
+
+ // Present but must be ignored due to merged_node_config=true
+ nodeJson := `[{"host":"http://json-node:8080/","inference_port":8080,"poc_port":5000,"models":{"modelB":{"args":[]}},"id":"json-node-1","max_concurrent":10,"hardware":[]}]`
+ nodePath := writeTempFile(t, tmp, "node-config.json", nodeJson)
+ dbPath := filepath.Join(tmp, "test.db")
+ _ = os.Remove(dbPath)
+
+ // First load -> migration and hydrate
+ mgr, err := apiconfig.LoadConfigManagerWithPaths(cfgPath, dbPath, nodePath)
+ require.NoError(t, err)
+ ctx := context.Background()
+ require.NoError(t, mgr.FlushNow(ctx))
+
+ // Migration flag present
+ var dummy bool
+ ok, err := apiconfig.KVGetJSON(ctx, mgr.SqlDb().GetDb(), "config_migrated", &dummy)
+ require.NoError(t, err)
+ require.True(t, ok)
+
+ // Nodes come from YAML, not JSON
+ nodes, err := apiconfig.ReadNodes(ctx, mgr.SqlDb().GetDb())
+ require.NoError(t, err)
+ ids := make([]string, 0, len(nodes))
+ for _, n := range nodes {
+ ids = append(ids, n.Id)
+ }
+ b, _ := json.Marshal(ids)
+ require.NotContains(t, ids, "json-node-1", string(b))
+ require.Contains(t, ids, "yaml-node-1", string(b))
+
+ // Second load -> idempotent
+ mgr2, err := apiconfig.LoadConfigManagerWithPaths(cfgPath, dbPath, nodePath)
+ require.NoError(t, err)
+ require.NoError(t, mgr2.FlushNow(ctx))
+ nodes2, err := apiconfig.ReadNodes(ctx, mgr2.SqlDb().GetDb())
+ require.NoError(t, err)
+ ids2 := make([]string, 0, len(nodes2))
+ for _, n := range nodes2 {
+ ids2 = append(ids2, n.Id)
+ }
+ require.Equal(t, ids, ids2)
+
+ // Cleanup
+ _ = os.Remove(dbPath)
+}
+
+// Scenario 2: Migration + node-config merge on first run (merged_node_config=false)
+func TestMigrationAndNodeConfigMerge_FirstRun(t *testing.T) {
+ tmp := t.TempDir()
+
+ yaml := `api:
+ port: 8080
+current_height: 5
+nodes:
+ - host: http://yaml-node:8080/
+ models:
+ modelY: {args: []}
+ id: yaml-node
+ max_concurrent: 3
+merged_node_config: false
+`
+ cfgPath := writeTempFile(t, tmp, "config.yaml", yaml)
+
+ nodeJson := `[{"host":"http://json-node:8080/","inference_port":8080,"poc_port":5000,"models":{"modelZ":{"args":[]}},"id":"json-node","max_concurrent":2,"hardware":[]}]`
+ nodePath := writeTempFile(t, tmp, "node-config.json", nodeJson)
+ dbPath := filepath.Join(tmp, "test.db")
+ _ = os.Remove(dbPath)
+
+ mgr, err := apiconfig.LoadConfigManagerWithPaths(cfgPath, dbPath, nodePath)
+ require.NoError(t, err)
+ ctx := context.Background()
+ require.NoError(t, mgr.FlushNow(ctx))
+
+ // KV flags set
+ var dummy bool
+ ok, err := apiconfig.KVGetJSON(ctx, mgr.SqlDb().GetDb(), "config_migrated", &dummy)
+ require.NoError(t, err)
+ require.True(t, ok)
+ ok, err = apiconfig.KVGetJSON(ctx, mgr.SqlDb().GetDb(), "node_config_merged", &dummy)
+ require.NoError(t, err)
+ require.True(t, ok)
+
+ nodes, err := apiconfig.ReadNodes(ctx, mgr.SqlDb().GetDb())
+ require.NoError(t, err)
+ ids := make([]string, 0, len(nodes))
+ for _, n := range nodes {
+ ids = append(ids, n.Id)
+ }
+ b, _ := json.Marshal(ids)
+ // Because merged_node_config was false, JSON must win on first run
+ require.Contains(t, ids, "json-node", string(b))
+}
+
+// Scenario 3: First run without node-config.json (merged_node_config=false)
+func TestFirstRun_NoNodeConfig_UsesYamlNodesAndStripsDynamicFromYaml(t *testing.T) {
+ tmp := t.TempDir()
+ yaml := `api:
+ port: 8080
+current_height: 7
+nodes:
+ - host: http://yaml-node:8080/
+ models:
+ modelY: {args: []}
+ id: yaml-node
+ max_concurrent: 3
+merged_node_config: false
+`
+ cfgPath := writeTempFile(t, tmp, "config.yaml", yaml)
+ // No node-config.json
+ dbPath := filepath.Join(tmp, "test.db")
+ _ = os.Remove(dbPath)
+
+ mgr, err := apiconfig.LoadConfigManagerWithPaths(cfgPath, dbPath, "")
+ require.NoError(t, err)
+ ctx := context.Background()
+ require.NoError(t, mgr.FlushNow(ctx))
+
+ // DB has yaml nodes
+ nodes, err := apiconfig.ReadNodes(ctx, mgr.SqlDb().GetDb())
+ require.NoError(t, err)
+ ids := make([]string, 0, len(nodes))
+ for _, n := range nodes {
+ ids = append(ids, n.Id)
+ }
+ require.Contains(t, ids, "yaml-node")
+
+ // After Write(), static-only YAML should be persisted; dynamic fields zeroed (e.g., current_height: 0)
+ // Call Write() explicitly and re-read file
+ require.NoError(t, mgr.Write())
+ data, err := os.ReadFile(cfgPath)
+ require.NoError(t, err)
+ s := string(data)
+ require.Contains(t, s, "current_height: 0")
+
+ // Now reload manager and ensure zero in YAML is ignored and DB value is used (should be 7)
+ mgr2, err := apiconfig.LoadConfigManagerWithPaths(cfgPath, dbPath, "")
+ require.NoError(t, err)
+ require.Equal(t, int64(7), mgr2.GetHeight())
+}
+
+// Scenario 4: Relaunch after migration; ignore dynamic YAML and skip migration
+func TestRelaunchAfterMigration_Idempotent(t *testing.T) {
+ tmp := t.TempDir()
+ dbPath := filepath.Join(tmp, "test.db")
+ yaml1 := `api:
+ port: 8080
+current_height: 10
+nodes:
+ - host: http://yaml-node:8080/
+ models:
+ modelY: {args: []}
+ id: yaml-node
+ max_concurrent: 3
+merged_node_config: false
+`
+ cfgPath := writeTempFile(t, tmp, "config.yaml", yaml1)
+
+ // First run with JSON nodes imported
+ nodeJson := `[{"host":"http://json-node:8080/","inference_port":8080,"poc_port":5000,"models":{"modelZ":{"args":[]}},"id":"json-node","max_concurrent":2,"hardware":[]}]`
+ nodePath := writeTempFile(t, tmp, "node-config.json", nodeJson)
+ _ = os.Remove(dbPath)
+ mgr, err := apiconfig.LoadConfigManagerWithPaths(cfgPath, dbPath, nodePath)
+ require.NoError(t, err)
+ ctx := context.Background()
+ require.NoError(t, mgr.FlushNow(ctx))
+
+ // Second run with conflicting YAML dynamic (try to re-introduce nonsense)
+ yaml2 := `api:
+ port: 8080
+current_height: 999
+merged_node_config: true
+nodes:
+ - host: http://yaml-node2:8080/
+ models:
+ modelY: {args: []}
+ id: yaml-node2
+ max_concurrent: 3
+`
+ require.NoError(t, os.WriteFile(cfgPath, []byte(yaml2), 0644))
+ mgr2, err := apiconfig.LoadConfigManagerWithPaths(cfgPath, dbPath, nodePath)
+ require.NoError(t, err)
+ require.NoError(t, mgr2.FlushNow(ctx))
+
+ nodes, err := apiconfig.ReadNodes(ctx, mgr2.SqlDb().GetDb())
+ require.NoError(t, err)
+ ids := make([]string, 0, len(nodes))
+ for _, n := range nodes {
+ ids = append(ids, n.Id)
+ }
+ b, _ := json.Marshal(ids)
+ // Must still be json-node from DB, not yaml-node2
+ require.Contains(t, ids, "json-node", string(b))
+ require.NotContains(t, ids, "yaml-node2", string(b))
+}
diff --git a/decentralized-api/apiconfig/config_test.go b/decentralized-api/apiconfig/config_test.go
new file mode 100644
index 000000000..e862f9852
--- /dev/null
+++ b/decentralized-api/apiconfig/config_test.go
@@ -0,0 +1,212 @@
+package apiconfig_test
+
+import (
+ "bytes"
+ "decentralized-api/apiconfig"
+ "decentralized-api/logging"
+ "os"
+ "path/filepath"
+ "testing"
+
+ "github.com/knadh/koanf/providers/rawbytes"
+ "github.com/stretchr/testify/require"
+)
+
+func TestConfigLoad(t *testing.T) {
+ testManager := &apiconfig.ConfigManager{
+ KoanProvider: rawbytes.Provider([]byte(testYaml)),
+ }
+ err := testManager.Load()
+ require.NoError(t, err)
+ require.Equal(t, 8080, testManager.GetApiConfig().Port)
+ require.Equal(t, "http://join1-node:26657", testManager.GetChainNodeConfig().Url)
+ require.Equal(t, "join1", testManager.GetChainNodeConfig().SignerKeyName)
+ require.Equal(t, "test", testManager.GetChainNodeConfig().KeyringBackend)
+ require.Equal(t, "/root/.inference", testManager.GetChainNodeConfig().KeyringDir)
+}
+
+func TestNodeVersion(t *testing.T) {
+ testManager := &apiconfig.ConfigManager{
+ KoanProvider: rawbytes.Provider([]byte(testYaml)),
+ WriterProvider: &CaptureWriterProvider{},
+ }
+ err := testManager.Load()
+ require.NoError(t, err)
+
+ // Test that default version is returned correctly
+ require.Equal(t, testManager.GetCurrentNodeVersion(), "v3.0.8")
+}
+
+func TestConfigLoadEnvOverride(t *testing.T) {
+ testManager := &apiconfig.ConfigManager{
+ KoanProvider: rawbytes.Provider([]byte(testYaml)),
+ }
+
+ os.Setenv("DAPI_API__PORT", "9000")
+ os.Setenv("KEY_NAME", "join2")
+ os.Setenv("DAPI_CHAIN_NODE__URL", "http://join1-node:26658")
+ os.Setenv("DAPI_API__POC_CALLBACK_URL", "http://callback")
+ os.Setenv("DAPI_API__PUBLIC_URL", "http://public")
+ err := testManager.Load()
+ require.NoError(t, err)
+ require.Equal(t, 9000, testManager.GetApiConfig().Port)
+ require.Equal(t, "http://join1-node:26658", testManager.GetChainNodeConfig().Url)
+ require.Equal(t, "join2", testManager.GetChainNodeConfig().SignerKeyName)
+ require.Equal(t, "http://callback", testManager.GetApiConfig().PoCCallbackUrl)
+ require.Equal(t, "http://public", testManager.GetApiConfig().PublicUrl)
+ require.Equal(t, "test", testManager.GetChainNodeConfig().KeyringBackend)
+ require.Equal(t, "/root/.inference", testManager.GetChainNodeConfig().KeyringDir)
+
+}
+
+type CaptureWriterProvider struct {
+ CapturedData string
+}
+
+func (c *CaptureWriterProvider) Write(data []byte) (int, error) {
+ c.CapturedData += string(data)
+ return len(data), nil
+}
+
+func (c *CaptureWriterProvider) Close() error {
+ return nil
+}
+
+func (c *CaptureWriterProvider) GetWriter() apiconfig.WriteCloser {
+ return c
+}
+
+func TestConfigRoundTrip(t *testing.T) {
+ os.Unsetenv("DAPI_API__PORT")
+ os.Unsetenv("KEY_NAME")
+ os.Unsetenv("DAPI_CHAIN_NODE__URL")
+ os.Unsetenv("DAPI_API__POC_CALLBACK_URL")
+ os.Unsetenv("DAPI_API__PUBLIC_URL")
+ writeCapture := &CaptureWriterProvider{}
+ testManager := &apiconfig.ConfigManager{
+ KoanProvider: rawbytes.Provider([]byte(testYaml)),
+ WriterProvider: writeCapture,
+ }
+ err := testManager.Load()
+ require.NoError(t, err)
+
+ // Test can write config successfully
+ err = testManager.Write()
+ require.NoError(t, err)
+
+ t.Log("\n")
+ t.Log(writeCapture.CapturedData)
+ testManager2 := &apiconfig.ConfigManager{
+ KoanProvider: rawbytes.Provider([]byte(writeCapture.CapturedData)),
+ WriterProvider: writeCapture,
+ }
+ err = testManager2.Load()
+
+ testManager2.SetHeight(50)
+ require.NoError(t, err)
+ require.Equal(t, 8080, testManager2.GetApiConfig().Port)
+ require.Equal(t, "http://join1-node:26657", testManager2.GetChainNodeConfig().Url)
+ require.Equal(t, "join1", testManager2.GetChainNodeConfig().SignerKeyName)
+ require.Equal(t, "test", testManager2.GetChainNodeConfig().KeyringBackend)
+ require.Equal(t, "/root/.inference", testManager2.GetChainNodeConfig().KeyringDir)
+ // After Write() we persist only static fields; dynamic fields like version are not in YAML
+ require.Equal(t, "", testManager2.GetCurrentNodeVersion())
+}
+
+func writeTemp(t *testing.T, dir, name, content string) string {
+ t.Helper()
+ path := filepath.Join(dir, name)
+ require.NoError(t, os.WriteFile(path, []byte(content), 0644))
+ return path
+}
+
+func loadManager(t *testing.T) error {
+ testManager := &apiconfig.ConfigManager{
+ KoanProvider: rawbytes.Provider([]byte(testYaml)),
+ }
+ os.Setenv("DAPI_API__PORT", "9000")
+ os.Setenv("DAPI_CHAIN_NODE__URL", "http://join1-node:26658")
+ os.Setenv("KEY_NAME", "join2")
+ defer func() {
+ // Clean up environment variables
+ os.Unsetenv("DAPI_API__PORT")
+ os.Unsetenv("DAPI_CHAIN_NODE__URL")
+ os.Unsetenv("KEY_NAME")
+ }()
+
+ if err := testManager.Load(); err != nil {
+ return err
+ }
+ return nil
+}
+
+// We cannot write anything to stdout when loading config or we break cosmovisor!
+func TestNoLoggingToStdout(t *testing.T) {
+ // Save the original stdout
+ originalStdout := os.Stdout
+ defer func() { os.Stdout = originalStdout }() // Restore it after the test
+
+ // Create a pipe to capture stdout
+ r, w, err := os.Pipe()
+ if err != nil {
+ t.Fatalf("Failed to create pipe: %v", err)
+ }
+ os.Stdout = w
+
+ // Buffer to capture log output
+ var buf bytes.Buffer
+
+ // Load config with overrides
+ _, noLoggerErr := logging.WithNoopLogger(func() (interface{}, error) {
+ err := loadManager(t)
+ return nil, err
+ })
+ require.NoError(t, noLoggerErr)
+
+ // Close the pipe and reset stdout
+ _ = w.Close()
+ os.Stdout = originalStdout
+
+ // Read captured output
+ _, _ = buf.ReadFrom(r)
+
+ // Fail if anything is written to stdout
+ if buf.Len() > 0 {
+ t.Errorf("Unexpected logging to stdout: %q", buf.String())
+ }
+}
+
+var testYaml = `
+api:
+ port: 8080
+chain_node:
+ url: http://join1-node:26657
+ signer_key_name: join1
+ account_public_key: ""
+ keyring_backend: test
+ keyring_dir: /root/.inference
+current_height: 393
+current_seed:
+ seed: 3898730504561900192
+ height: 380
+ signature: 815794b7bbb414900a84c8a543ffc96a3ebb5fbbd0175648eaf5f60897b786df5a0be5bc6047ee2ac3c8c2444510fcb9a1f565a6359927226f619dd534035bb7
+nodes:
+ - url: http://34.171.235.205:8080/
+ models:
+ - Qwen/Qwen2.5-7B-Instruct: {}
+ id: node1
+ max_concurrent: 500
+previous_seed:
+ seed: 1370553182438852893
+ height: 370
+ signature: 1d1f9fc6f44840af03368ce24e0335834181e42a9a45c81d7a17e14866729fa81a08c14d3397e00d4b16da3ab708e284650f8b14b33b318820ae0524b6ead6db
+upcoming_seed:
+ seed: 254929314898674592
+ height: 390
+ signature: 75296c164d43e5570c44c88176c7988e7d52d3e44be6c43e8e6c8f07327279510092f429addc401665d6ed128725f2181a95c7aba66c89ea77209c55ef2ce342
+upgrade_plan:
+ name: ""
+ height: 0
+ binaries: {}
+current_node_version: "v3.0.8"
+`
diff --git a/decentralized-api/apiconfig/seeds_atomic_test.go b/decentralized-api/apiconfig/seeds_atomic_test.go
new file mode 100644
index 000000000..2d6bedb02
--- /dev/null
+++ b/decentralized-api/apiconfig/seeds_atomic_test.go
@@ -0,0 +1,44 @@
+package apiconfig_test
+
+import (
+ "context"
+ "decentralized-api/apiconfig"
+ "os"
+ "path/filepath"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+)
+
+func TestSeedsAtomicAdvance(t *testing.T) {
+ tmp := t.TempDir()
+ cfgPath := filepath.Join(tmp, "config.yaml")
+ dbPath := filepath.Join(tmp, "test.db")
+
+ // minimal static yaml
+ require.NoError(t, os.WriteFile(cfgPath, []byte("api:\n port: 8080\n"), 0644))
+
+ mgr, err := apiconfig.LoadConfigManagerWithPaths(cfgPath, dbPath, "")
+ require.NoError(t, err)
+
+ // Seed initial values
+ require.NoError(t, mgr.SetCurrentSeed(apiconfig.SeedInfo{Seed: 1, EpochIndex: 1, Signature: "a"}))
+ require.NoError(t, mgr.SetUpcomingSeed(apiconfig.SeedInfo{Seed: 2, EpochIndex: 2, Signature: "b"}))
+ require.NoError(t, mgr.FlushNow(context.Background()))
+
+ // Advance: current -> previous, upcoming -> current
+ mgr.AdvanceCurrentSeed()
+ require.NoError(t, mgr.FlushNow(context.Background()))
+
+ // Read back from DB using getters (hydrated state kept in memory, but we trust flush for DB write)
+ ctx := context.Background()
+ sPrev, ok, err := apiconfig.GetActiveSeed(ctx, mgr.SqlDb().GetDb(), "previous")
+ require.NoError(t, err)
+ require.True(t, ok)
+ require.Equal(t, int64(1), sPrev.Seed)
+
+ sCur, ok, err := apiconfig.GetActiveSeed(ctx, mgr.SqlDb().GetDb(), "current")
+ require.NoError(t, err)
+ require.True(t, ok)
+ require.Equal(t, int64(2), sCur.Seed)
+}
diff --git a/decentralized-api/apiconfig/sqlite_store.go b/decentralized-api/apiconfig/sqlite_store.go
new file mode 100644
index 000000000..3d0d2a60e
--- /dev/null
+++ b/decentralized-api/apiconfig/sqlite_store.go
@@ -0,0 +1,604 @@
+package apiconfig
+
+import (
+ "context"
+ "database/sql"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "strings"
+
+ _ "modernc.org/sqlite"
+)
+
+// SqliteConfig holds configuration for an embedded SQLite DB
+type SqliteConfig struct {
+ Path string // e.g., gonka.db
+}
+
+type SqlDatabase interface {
+ BootstrapLocal(ctx context.Context) error
+ GetDb() *sql.DB
+}
+
+type SqliteDb struct {
+ config SqliteConfig
+ db *sql.DB
+}
+
+func NewSQLiteDb(cfg SqliteConfig) *SqliteDb {
+ return &SqliteDb{config: cfg}
+}
+
+func (d *SqliteDb) BootstrapLocal(ctx context.Context) error {
+ db, err := OpenSQLite(d.config)
+ if err != nil {
+ return err
+ }
+ if err := EnsureSchema(ctx, db); err != nil {
+ _ = db.Close()
+ return err
+ }
+ d.db = db
+ return nil
+}
+
+func (d *SqliteDb) GetDb() *sql.DB { return d.db }
+
+// OpenSQLite opens an embedded SQLite database (in process)
+func OpenSQLite(cfg SqliteConfig) (*sql.DB, error) {
+ if cfg.Path == "" {
+ return nil, errors.New("sqlite path is empty")
+ }
+ db, err := sql.Open("sqlite", cfg.Path)
+ if err != nil {
+ return nil, err
+ }
+ // Reasonable pool defaults for sqlite
+ db.SetMaxOpenConns(1) // SQLite is single-writer
+ db.SetConnMaxLifetime(0)
+ db.SetMaxIdleConns(1)
+
+ // Improve durability and reduce lock errors in long-running process
+ // Enable WAL; if it fails, return error (not optional for our usage)
+ if _, err := db.ExecContext(context.Background(), "PRAGMA journal_mode=WAL;"); err != nil {
+ return nil, err
+ }
+ // Reasonable defaults; ignore failure as they are optional
+ _, _ = db.ExecContext(context.Background(), "PRAGMA synchronous=NORMAL;")
+ _, _ = db.ExecContext(context.Background(), "PRAGMA busy_timeout=5000;")
+ return db, nil
+}
+
+// EnsureSchema creates the minimal tables for storing dynamic config: inference nodes.
+func EnsureSchema(ctx context.Context, db *sql.DB) error {
+ stmt := `
+CREATE TABLE IF NOT EXISTS inference_nodes (
+ id TEXT PRIMARY KEY,
+ host TEXT NOT NULL,
+ inference_segment TEXT NOT NULL,
+ inference_port INTEGER NOT NULL,
+ poc_segment TEXT NOT NULL,
+ poc_port INTEGER NOT NULL,
+ max_concurrent INTEGER NOT NULL,
+ models_json TEXT NOT NULL,
+ hardware_json TEXT NOT NULL,
+ updated_at DATETIME NOT NULL DEFAULT (STRFTIME('%Y-%m-%d %H:%M:%f','now')),
+ created_at DATETIME NOT NULL DEFAULT (STRFTIME('%Y-%m-%d %H:%M:%f','now'))
+);
+
+CREATE TABLE IF NOT EXISTS kv_config (
+ key TEXT PRIMARY KEY,
+ value_json TEXT NOT NULL,
+ updated_at DATETIME NOT NULL DEFAULT (STRFTIME('%Y-%m-%d %H:%M:%f','now')),
+ created_at DATETIME NOT NULL DEFAULT (STRFTIME('%Y-%m-%d %H:%M:%f','now'))
+);
+
+CREATE TABLE IF NOT EXISTS seed_info (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ type TEXT NOT NULL, -- 'current', 'previous', 'upcoming'
+ seed INTEGER NOT NULL,
+ epoch_index INTEGER NOT NULL,
+ signature TEXT NOT NULL,
+ claimed BOOLEAN NOT NULL DEFAULT 0,
+ is_active BOOLEAN NOT NULL DEFAULT 1,
+ created_at DATETIME NOT NULL DEFAULT (STRFTIME('%Y-%m-%d %H:%M:%f','now'))
+);`
+ _, err := db.ExecContext(ctx, stmt)
+ return err
+}
+
+// UpsertInferenceNodes replaces or inserts the given nodes by id.
+func UpsertInferenceNodes(ctx context.Context, db *sql.DB, nodes []InferenceNodeConfig) error {
+ if len(nodes) == 0 {
+ return nil
+ }
+ tx, err := db.BeginTx(ctx, &sql.TxOptions{})
+ if err != nil {
+ return err
+ }
+ defer func() { _ = tx.Rollback() }()
+
+ q := `
+INSERT INTO inference_nodes (
+ id, host, inference_segment, inference_port, poc_segment, poc_port, max_concurrent, models_json, hardware_json
+) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+ON CONFLICT(id) DO UPDATE SET
+ host = excluded.host,
+ inference_segment = excluded.inference_segment,
+ inference_port = excluded.inference_port,
+ poc_segment = excluded.poc_segment,
+ poc_port = excluded.poc_port,
+ max_concurrent = excluded.max_concurrent,
+ models_json = excluded.models_json,
+ hardware_json = excluded.hardware_json,
+ updated_at = (STRFTIME('%Y-%m-%d %H:%M:%f','now'))`
+
+ stmt, err := tx.PrepareContext(ctx, q)
+ if err != nil {
+ return err
+ }
+ defer stmt.Close()
+
+ for _, n := range nodes {
+ modelsJSON, err := json.Marshal(n.Models)
+ if err != nil {
+ return err
+ }
+ hardwareJSON, err := json.Marshal(n.Hardware)
+ if err != nil {
+ return err
+ }
+ if _, err := stmt.ExecContext(
+ ctx,
+ n.Id,
+ n.Host,
+ n.InferenceSegment,
+ n.InferencePort,
+ n.PoCSegment,
+ n.PoCPort,
+ n.MaxConcurrent,
+ string(modelsJSON),
+ string(hardwareJSON),
+ ); err != nil {
+ return err
+ }
+ }
+ return tx.Commit()
+}
+
+// WriteNodes is a convenience wrapper for UpsertInferenceNodes.
+func WriteNodes(ctx context.Context, db *sql.DB, nodes []InferenceNodeConfig) error {
+ return UpsertInferenceNodes(ctx, db, nodes)
+}
+
+// ReadNodes reads all nodes from the database and reconstructs InferenceNodeConfig entries.
+func ReadNodes(ctx context.Context, db *sql.DB) ([]InferenceNodeConfig, error) {
+ rows, err := db.QueryContext(ctx, `
+SELECT id, host, inference_segment, inference_port, poc_segment, poc_port, max_concurrent, models_json, hardware_json
+FROM inference_nodes ORDER BY id`)
+ if err != nil {
+ return nil, err
+ }
+ defer rows.Close()
+
+ var out []InferenceNodeConfig
+ for rows.Next() {
+ var (
+ id string
+ host string
+ infSeg string
+ infPort int
+ pocSeg string
+ pocPort int
+ maxConc int
+ modelsRaw []byte
+ hardwareRaw []byte
+ )
+ if err := rows.Scan(&id, &host, &infSeg, &infPort, &pocSeg, &pocPort, &maxConc, &modelsRaw, &hardwareRaw); err != nil {
+ return nil, err
+ }
+ var models map[string]ModelConfig
+ if len(modelsRaw) > 0 {
+ if err := json.Unmarshal(modelsRaw, &models); err != nil {
+ return nil, err
+ }
+ }
+ var hardware []Hardware
+ if len(hardwareRaw) > 0 {
+ if err := json.Unmarshal(hardwareRaw, &hardware); err != nil {
+ return nil, err
+ }
+ }
+ out = append(out, InferenceNodeConfig{
+ Host: host,
+ InferenceSegment: infSeg,
+ InferencePort: infPort,
+ PoCSegment: pocSeg,
+ PoCPort: pocPort,
+ Models: models,
+ Id: id,
+ MaxConcurrent: maxConc,
+ Hardware: hardware,
+ })
+ }
+ if err := rows.Err(); err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+// ReplaceInferenceNodes deletes all nodes and inserts the given list atomically.
+func ReplaceInferenceNodes(ctx context.Context, db *sql.DB, nodes []InferenceNodeConfig) error {
+ tx, err := db.BeginTx(ctx, &sql.TxOptions{})
+ if err != nil {
+ return err
+ }
+ defer func() { _ = tx.Rollback() }()
+
+ if _, err := tx.ExecContext(ctx, `DELETE FROM inference_nodes`); err != nil {
+ return err
+ }
+
+ if len(nodes) == 0 {
+ return tx.Commit()
+ }
+
+ q := `
+INSERT INTO inference_nodes (
+ id, host, inference_segment, inference_port, poc_segment, poc_port, max_concurrent, models_json, hardware_json
+) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+
+ stmt, err := tx.PrepareContext(ctx, q)
+ if err != nil {
+ return err
+ }
+ defer stmt.Close()
+
+ for _, n := range nodes {
+ modelsJSON, err := json.Marshal(n.Models)
+ if err != nil {
+ return err
+ }
+ hardwareJSON, err := json.Marshal(n.Hardware)
+ if err != nil {
+ return err
+ }
+ if _, err := stmt.ExecContext(
+ ctx,
+ n.Id,
+ n.Host,
+ n.InferenceSegment,
+ n.InferencePort,
+ n.PoCSegment,
+ n.PoCPort,
+ n.MaxConcurrent,
+ string(modelsJSON),
+ string(hardwareJSON),
+ ); err != nil {
+ return err
+ }
+ }
+ return tx.Commit()
+}
+
+// SeedInfo typed accessors
+
+// SetActiveSeed deactivates previous active seed of given type and inserts a new active row.
+func SetActiveSeed(ctx context.Context, db *sql.DB, seedType string, info SeedInfo) error {
+ if db == nil {
+ return errors.New("db is nil")
+ }
+ tx, err := db.BeginTx(ctx, &sql.TxOptions{})
+ if err != nil {
+ return err
+ }
+ defer func() { _ = tx.Rollback() }()
+
+ if _, err := tx.ExecContext(ctx, `UPDATE seed_info SET is_active = 0 WHERE type = ? AND is_active = 1`, seedType); err != nil {
+ return err
+ }
+ q := `INSERT INTO seed_info(type, seed, epoch_index, signature, claimed, is_active) VALUES(?, ?, ?, ?, ?, 1)`
+ if _, err := tx.ExecContext(ctx, q, seedType, info.Seed, info.EpochIndex, info.Signature, info.Claimed); err != nil {
+ return err
+ }
+ return tx.Commit()
+}
+
+// GetActiveSeed returns the active seed for type; ok=false if none.
+func GetActiveSeed(ctx context.Context, db *sql.DB, seedType string) (SeedInfo, bool, error) {
+ if db == nil {
+ return SeedInfo{}, false, errors.New("db is nil")
+ }
+ row := db.QueryRowContext(ctx, `SELECT seed, epoch_index, signature, claimed FROM seed_info WHERE type = ? AND is_active = 1 ORDER BY id DESC LIMIT 1`, seedType)
+ var s SeedInfo
+ if err := row.Scan(&s.Seed, &s.EpochIndex, &s.Signature, &s.Claimed); err != nil {
+ if err == sql.ErrNoRows {
+ return SeedInfo{}, false, nil
+ }
+ return SeedInfo{}, false, err
+ }
+ return s, true, nil
+}
+
+// MarkSeedClaimed sets claimed=true for current active seed of given type. ok=false if none.
+func MarkSeedClaimed(ctx context.Context, db *sql.DB, seedType string) (ok bool, err error) {
+ if db == nil {
+ return false, errors.New("db is nil")
+ }
+ res, err := db.ExecContext(ctx, `UPDATE seed_info SET claimed = 1 WHERE type = ? AND is_active = 1`, seedType)
+ if err != nil {
+ return false, err
+ }
+ affected, _ := res.RowsAffected()
+ return affected > 0, nil
+}
+
+// IsSeedClaimed reads claimed for active seed of given type. ok=false if none.
+func IsSeedClaimed(ctx context.Context, db *sql.DB, seedType string) (claimed bool, ok bool, err error) {
+ if db == nil {
+ return false, false, errors.New("db is nil")
+ }
+ row := db.QueryRowContext(ctx, `SELECT claimed FROM seed_info WHERE type = ? AND is_active = 1 ORDER BY id DESC LIMIT 1`, seedType)
+ var c bool
+ if err := row.Scan(&c); err != nil {
+ if err == sql.ErrNoRows {
+ return false, false, nil
+ }
+ return false, false, err
+ }
+ return c, true, nil
+}
+
+// ExportAllDb returns a JSON-friendly dump of all user tables in the database.
+// It introspects table schemas and converts values into Go primitives suitable for JSON encoding.
+func ExportAllDb(ctx context.Context, db *sql.DB) (map[string]any, error) {
+ tables, err := listUserTables(ctx, db)
+ if err != nil {
+ return nil, err
+ }
+ out := make(map[string]any, len(tables))
+ for _, t := range tables {
+ rows, err := dumpTable(ctx, db, t)
+ if err != nil {
+ return nil, fmt.Errorf("dump table %s: %w", t, err)
+ }
+ out[t] = rows
+ }
+ return out, nil
+}
+
+func listUserTables(ctx context.Context, db *sql.DB) ([]string, error) {
+ q := `SELECT name FROM sqlite_schema WHERE type = 'table' AND name NOT LIKE 'sqlite_%' ORDER BY name`
+ var out []string
+ rows, err := db.QueryContext(ctx, q)
+ if err != nil {
+ return nil, err
+ }
+ defer rows.Close()
+ for rows.Next() {
+ var name string
+ if err := rows.Scan(&name); err != nil {
+ return nil, err
+ }
+ out = append(out, name)
+ }
+ if err := rows.Err(); err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+type columnInfo struct {
+ name string
+ declType string
+}
+
+func getTableColumns(ctx context.Context, db *sql.DB, table string) ([]columnInfo, error) {
+ rows, err := db.QueryContext(ctx, "PRAGMA table_info("+table+")")
+ if err != nil {
+ return nil, err
+ }
+ defer rows.Close()
+ var cols []columnInfo
+ // pragma table_info returns: cid, name, type, notnull, dflt_value, pk
+ for rows.Next() {
+ var (
+ cid int
+ name string
+ declType string
+ notnull int
+ dflt sql.NullString
+ pk int
+ )
+ if err := rows.Scan(&cid, &name, &declType, ¬null, &dflt, &pk); err != nil {
+ return nil, err
+ }
+ cols = append(cols, columnInfo{name: name, declType: declType})
+ }
+ if err := rows.Err(); err != nil {
+ return nil, err
+ }
+ return cols, nil
+}
+
+func dumpTable(ctx context.Context, db *sql.DB, table string) ([]map[string]any, error) {
+ cols, err := getTableColumns(ctx, db, table)
+ if err != nil {
+ return nil, err
+ }
+ if len(cols) == 0 {
+ return []map[string]any{}, nil
+ }
+ // Build SELECT with explicit column list for stable order
+ colNames := make([]string, len(cols))
+ for i, c := range cols {
+ colNames[i] = c.name
+ }
+ q := "SELECT " + strings.Join(colNames, ",") + " FROM " + table
+ rows, err := db.QueryContext(ctx, q)
+ if err != nil {
+ return nil, err
+ }
+ defer rows.Close()
+
+ // Prepare scanners based on decl types
+ results := make([]map[string]any, 0, 64)
+ for rows.Next() {
+ // Allocate stable per-column holders to avoid slice reallocation pointer invalidation
+ scanHolders := make([]any, len(cols))
+ holderKinds := make([]string, len(cols))
+ for i, c := range cols {
+ t := strings.ToUpper(c.declType)
+ switch {
+ case strings.Contains(t, "INT") || strings.Contains(t, "BOOL"):
+ h := new(sql.NullInt64)
+ scanHolders[i] = h
+ holderKinds[i] = "int"
+ case strings.Contains(t, "REAL") || strings.Contains(t, "FLOA") || strings.Contains(t, "DOUB"):
+ h := new(sql.NullFloat64)
+ scanHolders[i] = h
+ holderKinds[i] = "float"
+ case strings.Contains(t, "BLOB"):
+ var b []byte
+ scanHolders[i] = &b
+ holderKinds[i] = "blob"
+ default:
+ h := new(sql.NullString)
+ scanHolders[i] = h
+ holderKinds[i] = "text"
+ }
+ }
+ if err := rows.Scan(scanHolders...); err != nil {
+ return nil, err
+ }
+ // reconstruct per row map
+ rowMap := make(map[string]any, len(cols))
+ for i, c := range cols {
+ kind := holderKinds[i]
+ switch kind {
+ case "int":
+ v := scanHolders[i].(*sql.NullInt64)
+ if !v.Valid {
+ rowMap[c.name] = nil
+ break
+ }
+ // if declared as BOOL* return true/false
+ if strings.Contains(strings.ToUpper(c.declType), "BOOL") {
+ rowMap[c.name] = v.Int64 != 0
+ } else {
+ rowMap[c.name] = v.Int64
+ }
+ case "float":
+ v := scanHolders[i].(*sql.NullFloat64)
+ if !v.Valid {
+ rowMap[c.name] = nil
+ break
+ }
+ rowMap[c.name] = v.Float64
+ case "blob":
+ b := *(scanHolders[i].(*[]byte))
+ if b == nil {
+ rowMap[c.name] = nil
+ break
+ }
+ rowMap[c.name] = b // will JSON-encode as base64
+ default: // text
+ v := scanHolders[i].(*sql.NullString)
+ if !v.Valid {
+ rowMap[c.name] = nil
+ break
+ }
+ // Special-case kv_config.value_json to decode JSON payload
+ if table == "kv_config" && c.name == "value_json" {
+ var parsed any
+ if err := json.Unmarshal([]byte(v.String), &parsed); err == nil {
+ rowMap[c.name] = parsed
+ continue
+ }
+ }
+ rowMap[c.name] = v.String
+ }
+ }
+ results = append(results, rowMap)
+ }
+ if err := rows.Err(); err != nil {
+ return nil, err
+ }
+ return results, nil
+}
+
+// KV helpers for dynamic config
+
+// KVSetJSON upserts an arbitrary Go value encoded as JSON at the given key.
+func KVSetJSON(ctx context.Context, db *sql.DB, key string, value any) error {
+ if db == nil {
+ return errors.New("db is nil")
+ }
+ bytes, err := json.Marshal(value)
+ if err != nil {
+ return err
+ }
+ tx, err := db.BeginTx(ctx, &sql.TxOptions{})
+ if err != nil {
+ return err
+ }
+ defer func() { _ = tx.Rollback() }()
+
+ q := `INSERT INTO kv_config(key, value_json) VALUES(?, ?)
+ON CONFLICT(key) DO UPDATE SET value_json = excluded.value_json, updated_at = (STRFTIME('%Y-%m-%d %H:%M:%f','now'))`
+ if _, err := tx.ExecContext(ctx, q, key, string(bytes)); err != nil {
+ return err
+ }
+ return tx.Commit()
+}
+
+// KVGetJSON loads a key and unmarshals JSON into destPtr.
+// If key not found, ok=false and no error is returned.
+func KVGetJSON(ctx context.Context, db *sql.DB, key string, destPtr any) (ok bool, err error) {
+ if db == nil {
+ return false, errors.New("db is nil")
+ }
+ var raw string
+ err = db.QueryRowContext(ctx, `SELECT value_json FROM kv_config WHERE key = ?`, key).Scan(&raw)
+ if err == sql.ErrNoRows {
+ return false, nil
+ }
+ if err != nil {
+ return false, err
+ }
+ if err := json.Unmarshal([]byte(raw), destPtr); err != nil {
+ return false, fmt.Errorf("unmarshal json for key %s: %w", key, err)
+ }
+ return true, nil
+}
+
+// KVSetInt64 stores an int64 under key.
+func KVSetInt64(ctx context.Context, db *sql.DB, key string, v int64) error {
+ return KVSetJSON(ctx, db, key, v)
+}
+
+// KVGetInt64 retrieves an int64. If missing, returns ok=false.
+func KVGetInt64(ctx context.Context, db *sql.DB, key string) (val int64, ok bool, err error) {
+ var tmp int64
+ ok, err = KVGetJSON(ctx, db, key, &tmp)
+ if !ok || err != nil {
+ return 0, ok, err
+ }
+ return tmp, true, nil
+}
+
+// KVSetString stores a string under key.
+func KVSetString(ctx context.Context, db *sql.DB, key string, v string) error {
+ return KVSetJSON(ctx, db, key, v)
+}
+
+// KVGetString retrieves a string. If missing, returns ok=false.
+func KVGetString(ctx context.Context, db *sql.DB, key string) (val string, ok bool, err error) {
+ var tmp string
+ ok, err = KVGetJSON(ctx, db, key, &tmp)
+ if !ok || err != nil {
+ return "", ok, err
+ }
+ return tmp, true, nil
+}
diff --git a/decentralized-api/broker/README.md b/decentralized-api/broker/README.md
new file mode 100644
index 000000000..1e09ad99c
--- /dev/null
+++ b/decentralized-api/broker/README.md
@@ -0,0 +1,66 @@
+# Broker Architectural Overview
+
+The `broker` package implements a non-blocking, concurrent controller pattern to manage the state and lifecycle of distributed machine learning nodes. Its core responsibility is to ensure that the actual state of each node converges to the state intended by the network's current phase (e.g., `Inference`, `PoC Generate`, `PoC Validate`).
+
+The architecture is designed around the following key principles:
+
+1. **Hybrid Command and State-Driven Model**: The system uses a two-level approach.
+ * **Imperative Commands**: External actors, like the `OnNewBlockDispatcher`, issue explicit commands (e.g., `StartPocCommand`, `InitValidateCommand`) to the broker in response to specific blockchain events.
+ * **Declarative State Machine**: These commands are handled by the broker's command processor, which translates them into a declarative state by setting an **`IntendedStatus`** and **`PocIntendedStatus`** on the relevant nodes. The broker's sole long-term goal is to make the node's **`CurrentStatus`** and **`PocCurrentStatus`** match this intended state.
+
+2. **Asynchronous Reconciliation Loop**: A central, continuously running goroutine, the `reconcilerLoop`, is the heart of the system. It periodically checks the state of all nodes, but can also be manually triggered for immediate action via the `TriggerReconciliation()` method. This loop is the only component that initiates state-changing actions on nodes. This design avoids complex, event-driven race conditions and makes the system's behavior predictable. A manual trigger is typically issued after a command has been processed to ensure the system reacts quickly to changes in the nodes' intended state.
+
+3. **Thread-Safe State Management**: All access to the shared `nodes` map and their state is protected by a `sync.RWMutex`, ensuring that reads and writes from different goroutines are safe.
+
+4. **Idempotent, Cancellable Worker Tasks**: All long-running operations (like calling a node's API) are executed by dedicated `NodeWorker` goroutines.
+ * **Cancellable**: Every task is associated with a `context.Context` that can be cancelled. The `reconcilerLoop` intelligently cancels outdated tasks (e.g., if a node's `IntendedStatus` changes while a previous reconciliation is in flight).
+ * **Atomic State Updates**: Workers **never** modify the shared `NodeState` directly. Upon completion, failure, or cancellation, a worker queues a `NodeResult` back to the broker's main command processor. This handler is the single source of truth for finalizing state transitions, which prevents race conditions and ensures that results from stale/cancelled tasks are safely ignored.
+
+5. **Non-Blocking API**: All commands sent to the broker are fast, non-blocking operations. They either update the `IntendedStatus` and trigger the reconciler or queue a result for processing, ensuring the command processor remains responsive.
+
+---
+
+### TODOs:
+
+- [ ] ...
+
+### UML Sequence Diagram
+
+```mermaid
+sequenceDiagram
+ participant D as OnNewBlockDispatcher
+ participant B as Broker (processCommands)
+ participant R as Broker (reconcilerLoop)
+ participant W as NodeWorker
+ participant M as ML Node (External)
+
+ D->>+B: Queues Command (e.g., StartPocCommand)
+ B->>B: Updates IntendedStatus for all nodes
+ B->>R: TriggerReconciliation()
+ B-->>-D: Returns immediately
+
+ loop Periodic Ticker / Manual Trigger
+ R->>R: reconcile()
+ end
+
+ R->>R: 1. Cancel Outdated Tasks
+ Note right of R: Finds nodes where ReconcileInfo != IntendedStatus
and calls cancel() on the context.
+
+ R->>R: 2. Dispatch New Tasks
+ Note right of R: Finds nodes where CurrentStatus != IntendedStatus
and ReconcileInfo is nil.
+
+ R->>+W: worker.Submit(ctx, cmd)
+ Note over R,W: ReconcileInfo and cancel() func are set on NodeState
+
+ W->>+M: Calls ML Node API (e.g., Stop, InitGenerate)
+ M-->>-W: Returns result
+
+ W->>+B: Queues UpdateNodeResultCommand
+ W-->>-R: Worker's job is done
+
+ B->>B: updateNodeResult()
+ Note right of B: Acquires lock, performs safety check
to ignore stale results, and updates
CurrentStatus and clears ReconcileInfo.
+ B-->>-W: Returns immediately
+
+ R->>R: (Next reconciliation cycle begins)
+```
diff --git a/decentralized-api/broker/broker.go b/decentralized-api/broker/broker.go
new file mode 100644
index 000000000..37a5876f2
--- /dev/null
+++ b/decentralized-api/broker/broker.go
@@ -0,0 +1,1444 @@
+package broker
+
+import (
+ "context"
+ "decentralized-api/apiconfig"
+ "decentralized-api/chainphase"
+ "decentralized-api/cosmosclient"
+ "decentralized-api/logging"
+ "decentralized-api/mlnodeclient"
+ "decentralized-api/participant"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "reflect"
+ "sort"
+ "strconv"
+ "strings"
+ "sync"
+ "sync/atomic"
+ "time"
+
+ "github.com/productscience/inference/x/inference/types"
+)
+
+/*
+enum HardwareNodeStatus {
+UNKNOWN = 0;
+INFERENCE = 1;
+POC = 2;
+TRAINING = 3;
+}
+*/
+
+// BrokerChainBridge defines the interface for the broker to interact with the blockchain.
+// This abstraction allows for easier testing and isolates the broker from the specifics
+// of the cosmos client implementation.
+type BrokerChainBridge interface {
+ GetHardwareNodes() (*types.QueryHardwareNodesResponse, error)
+ SubmitHardwareDiff(diff *types.MsgSubmitHardwareDiff) error
+ GetBlockHash(height int64) (string, error)
+ GetGovernanceModels() (*types.QueryModelsAllResponse, error)
+ GetCurrentEpochGroupData() (*types.QueryCurrentEpochGroupDataResponse, error)
+ GetEpochGroupDataByModelId(pocHeight uint64, modelId string) (*types.QueryGetEpochGroupDataResponse, error)
+}
+
+type BrokerChainBridgeImpl struct {
+ client cosmosclient.CosmosMessageClient
+ chainNodeUrl string
+}
+
+func NewBrokerChainBridgeImpl(client cosmosclient.CosmosMessageClient, chainNodeUrl string) BrokerChainBridge {
+ return &BrokerChainBridgeImpl{client: client, chainNodeUrl: chainNodeUrl}
+}
+
+func (b *BrokerChainBridgeImpl) GetHardwareNodes() (*types.QueryHardwareNodesResponse, error) {
+ queryClient := b.client.NewInferenceQueryClient()
+ req := &types.QueryHardwareNodesRequest{
+ Participant: b.client.GetAccountAddress(),
+ }
+ return queryClient.HardwareNodes(b.client.GetContext(), req)
+}
+
+func (b *BrokerChainBridgeImpl) SubmitHardwareDiff(diff *types.MsgSubmitHardwareDiff) error {
+ _, err := b.client.SendTransactionAsyncNoRetry(diff)
+ return err
+}
+
+func (b *BrokerChainBridgeImpl) GetBlockHash(height int64) (string, error) {
+ client, err := cosmosclient.NewRpcClient(b.chainNodeUrl)
+ if err != nil {
+ return "", err
+ }
+
+ block, err := client.Block(context.Background(), &height)
+ if err != nil {
+ return "", err
+ }
+
+ return block.Block.Hash().String(), err
+}
+
+func (b *BrokerChainBridgeImpl) GetGovernanceModels() (*types.QueryModelsAllResponse, error) {
+ queryClient := b.client.NewInferenceQueryClient()
+ req := &types.QueryModelsAllRequest{}
+ return queryClient.ModelsAll(b.client.GetContext(), req)
+}
+
+func (b *BrokerChainBridgeImpl) GetCurrentEpochGroupData() (*types.QueryCurrentEpochGroupDataResponse, error) {
+ queryClient := b.client.NewInferenceQueryClient()
+ req := &types.QueryCurrentEpochGroupDataRequest{}
+ return queryClient.CurrentEpochGroupData(b.client.GetContext(), req)
+}
+
+func (b *BrokerChainBridgeImpl) GetEpochGroupDataByModelId(epochIndex uint64, modelId string) (*types.QueryGetEpochGroupDataResponse, error) {
+ queryClient := b.client.NewInferenceQueryClient()
+ req := &types.QueryGetEpochGroupDataRequest{
+ EpochIndex: epochIndex,
+ ModelId: modelId,
+ }
+ return queryClient.EpochGroupData(b.client.GetContext(), req)
+}
+
+type Broker struct {
+ highPriorityCommands chan Command
+ lowPriorityCommands chan Command
+ nodes map[string]*NodeWithState
+ mu sync.RWMutex
+ curMaxNodesNum atomic.Uint64
+ chainBridge BrokerChainBridge
+ nodeWorkGroup *NodeWorkGroup
+ phaseTracker *chainphase.ChainPhaseTracker
+ participantInfo participant.CurrenParticipantInfo
+ callbackUrl string
+ mlNodeClientFactory mlnodeclient.ClientFactory
+ reconcileTrigger chan struct{}
+ lastEpochIndex uint64
+ lastEpochPhase types.EpochPhase
+ statusQueryTrigger chan statusQuerySignal
+ configManager *apiconfig.ConfigManager
+}
+
+const (
+ PoCBatchesPath = "/v1/poc-batches"
+)
+
+func GetPocBatchesCallbackUrl(callbackUrl string) string {
+ return fmt.Sprintf("%s"+PoCBatchesPath, callbackUrl)
+}
+
+func GetPocValidateCallbackUrl(callbackUrl string) string {
+ // For now the URl is the same, the node inference server appends "/validated" to the URL
+ // or "/generated" (in case of init-generate)
+ return fmt.Sprintf("%s"+PoCBatchesPath, callbackUrl)
+}
+
+type ModelArgs struct {
+ Args []string `json:"args"`
+}
+
+type Node struct {
+ Host string `json:"host"`
+ InferenceSegment string `json:"inference_segment"`
+ InferencePort int `json:"inference_port"`
+ PoCSegment string `json:"poc_segment"`
+ PoCPort int `json:"poc_port"`
+ Models map[string]ModelArgs `json:"models"`
+ Id string `json:"id"`
+ MaxConcurrent int `json:"max_concurrent"`
+ NodeNum uint64 `json:"node_num"`
+ Hardware []apiconfig.Hardware `json:"hardware"`
+}
+
+func (n *Node) InferenceUrl() string {
+ return fmt.Sprintf("http://%s:%d%s", n.Host, n.InferencePort, n.InferenceSegment)
+}
+
+func (n *Node) InferenceUrlWithVersion(version string) string {
+ if version == "" {
+ return n.InferenceUrl()
+ }
+ return fmt.Sprintf("http://%s:%d/%s%s", n.Host, n.InferencePort, version, n.InferenceSegment)
+}
+
+func (n *Node) PoCUrl() string {
+ return fmt.Sprintf("http://%s:%d%s", n.Host, n.PoCPort, n.PoCSegment)
+}
+
+func (n *Node) PoCUrlWithVersion(version string) string {
+ if version == "" {
+ return n.PoCUrl()
+ }
+ return fmt.Sprintf("http://%s:%d/%s%s", n.Host, n.PoCPort, version, n.PoCSegment)
+}
+
+type NodeWithState struct {
+ Node Node
+ State NodeState
+}
+
+// AdminState tracks administrative enable/disable status
+type AdminState struct {
+ Enabled bool `json:"enabled"`
+ Epoch uint64 `json:"epoch"`
+}
+
+type NodeState struct {
+ IntendedStatus types.HardwareNodeStatus `json:"intended_status"`
+ CurrentStatus types.HardwareNodeStatus `json:"current_status"`
+ ReconcileInfo *ReconcileInfo `json:"reconcile_info,omitempty"`
+ cancelInFlightTask func()
+
+ PocIntendedStatus PocStatus `json:"poc_intended_status"`
+ PocCurrentStatus PocStatus `json:"poc_current_status"`
+
+ TrainingTask *TrainingTaskPayload `json:"training_task,omitempty"`
+
+ LockCount int `json:"lock_count"`
+ FailureReason string `json:"failure_reason"`
+ StatusTimestamp time.Time `json:"status_timestamp"`
+ AdminState AdminState `json:"admin_state"`
+
+ // Epoch-specific data, populated from the chain
+ EpochModels map[string]types.Model `json:"epoch_models"`
+ EpochMLNodes map[string]types.MLNodeInfo `json:"epoch_ml_nodes"`
+}
+
+func (s NodeState) MarshalJSON() ([]byte, error) {
+ type Alias NodeState
+ return json.Marshal(&struct {
+ IntendedStatus string `json:"intended_status"`
+ CurrentStatus string `json:"current_status"`
+ Alias
+ }{
+ IntendedStatus: s.IntendedStatus.String(),
+ CurrentStatus: s.CurrentStatus.String(),
+ Alias: (Alias)(s),
+ })
+}
+
+type TrainingTaskPayload struct {
+ Id uint64 `json:"id"`
+ MasterNodeAddr string `json:"master_node_addr"`
+ NodeRanks map[string]int `json:"node_ranks"`
+ WorldSize int `json:"world_size"`
+}
+
+type ReconcileInfo struct {
+ Status types.HardwareNodeStatus `json:"status"`
+ PocStatus PocStatus `json:"poc_status"`
+ TrainingTaskId uint64 `json:"training_task_id"`
+}
+
+func (s *NodeState) UpdateStatusAt(time time.Time, status types.HardwareNodeStatus) {
+ s.CurrentStatus = status
+ s.StatusTimestamp = time
+}
+
+func (s *NodeState) UpdateStatusWithPocStatusNow(status types.HardwareNodeStatus, pocStatus PocStatus) {
+ s.UpdateStatusWithPocStatusAt(time.Now(), status, pocStatus)
+}
+
+func (s *NodeState) UpdateStatusWithPocStatusAt(time time.Time, status types.HardwareNodeStatus, pocStatus PocStatus) {
+ s.CurrentStatus = status
+ s.PocCurrentStatus = pocStatus
+ s.StatusTimestamp = time
+}
+
+func (s *NodeState) UpdateStatusNow(status types.HardwareNodeStatus) {
+ s.CurrentStatus = status
+ s.StatusTimestamp = time.Now()
+}
+
+func (s *NodeState) Failure(reason string) {
+ s.FailureReason = reason
+ s.UpdateStatusNow(types.HardwareNodeStatus_FAILED)
+}
+
+func (s *NodeState) IsOperational() bool {
+ return s.CurrentStatus != types.HardwareNodeStatus_FAILED
+}
+
+// ShouldBeOperational checks if node should be operational based on admin state and current epoch
+func (s *NodeState) ShouldBeOperational(latestEpoch uint64, currentPhase types.EpochPhase) bool {
+ return ShouldBeOperational(s.AdminState, latestEpoch, currentPhase)
+}
+
+// ShouldContinueInference checks if node should continue inference service
+// based on its POC_SLOT timeslot allocation. Returns true if POC_SLOT is set to true
+// for any model supported by this node.
+func (s *NodeState) ShouldContinueInference() bool {
+ // Check if any MLNode for this node has POC_SLOT set to true
+ for modelId, mlNodeInfo := range s.EpochMLNodes {
+ if len(mlNodeInfo.TimeslotAllocation) > 1 && mlNodeInfo.TimeslotAllocation[1] { // index 1 = POC_SLOT
+ logging.Debug("Node should continue inference service based on POC_SLOT allocation", types.PoC,
+ "model_id", modelId,
+ "poc_slot", mlNodeInfo.TimeslotAllocation[1])
+ return true
+ }
+ }
+ return false
+}
+
+func ShouldBeOperational(adminState AdminState, latestEpoch uint64, currentPhase types.EpochPhase) bool {
+ if adminState.Enabled {
+ if latestEpoch > adminState.Epoch {
+ return true
+ } else { // latestEpoch == adminState.Epoch
+ return currentPhase == types.InferencePhase
+ }
+ } else {
+ return adminState.Epoch >= latestEpoch
+ }
+}
+
+type NodeResponse struct {
+ Node Node `json:"node"`
+ State NodeState `json:"state"`
+}
+
+func NewBroker(chainBridge BrokerChainBridge, phaseTracker *chainphase.ChainPhaseTracker, participantInfo participant.CurrenParticipantInfo, callbackUrl string, clientFactory mlnodeclient.ClientFactory, configManager *apiconfig.ConfigManager) *Broker {
+ broker := &Broker{
+ highPriorityCommands: make(chan Command, 100),
+ lowPriorityCommands: make(chan Command, 10000),
+ nodes: make(map[string]*NodeWithState),
+ chainBridge: chainBridge,
+ phaseTracker: phaseTracker,
+ participantInfo: participantInfo,
+ callbackUrl: callbackUrl,
+ mlNodeClientFactory: clientFactory,
+ reconcileTrigger: make(chan struct{}, 1),
+ statusQueryTrigger: make(chan statusQuerySignal, 1),
+ configManager: configManager,
+ }
+
+ // Initialize NodeWorkGroup
+ broker.nodeWorkGroup = NewNodeWorkGroup()
+
+ go broker.processCommands()
+ go nodeSyncWorker(broker)
+ // Reconciliation is now triggered by OnNewBlockDispatcher
+ // go nodeReconciliationWorker(broker)
+ go nodeStatusQueryWorker(broker)
+ go broker.reconcilerLoop()
+ return broker
+}
+
+type statusQuerySignal struct {
+ BypassDebounce bool
+}
+
+func (b *Broker) TriggerStatusQuery(bypassDebounce bool) {
+ select {
+ case b.statusQueryTrigger <- statusQuerySignal{BypassDebounce: bypassDebounce}:
+ default: // Non-blocking send
+ }
+}
+
+func (b *Broker) GetChainBridge() BrokerChainBridge {
+ return b.chainBridge
+}
+
+func (b *Broker) LoadNodeToBroker(node *apiconfig.InferenceNodeConfig) chan NodeCommandResponse {
+ if node == nil {
+ return nil
+ }
+
+ cmd := NewRegisterNodeCommand(*node)
+ err := b.QueueMessage(cmd)
+ if err != nil {
+ logging.Error("Error loading node to broker", types.Nodes, "error", err)
+ panic(err)
+ // return nil
+ }
+ return cmd.Response
+}
+
+func nodeSyncWorker(broker *Broker) {
+ ticker := time.NewTicker(60 * time.Second)
+ defer ticker.Stop()
+ for range ticker.C {
+ logging.Debug("Syncing nodes", types.Nodes)
+ if err := broker.QueueMessage(NewSyncNodesCommand()); err != nil {
+ logging.Error("Error syncing nodes", types.Nodes, "error", err)
+ }
+ }
+}
+
+func (b *Broker) processCommands() {
+ for {
+ select {
+ case command := <-b.highPriorityCommands:
+ b.executeCommand(command)
+ default:
+ select {
+ case command := <-b.highPriorityCommands:
+ b.executeCommand(command)
+ case command := <-b.lowPriorityCommands:
+ b.executeCommand(command)
+ }
+ }
+ }
+}
+
+func (b *Broker) executeCommand(command Command) {
+ logging.Debug("Processing command", types.Nodes, "type", reflect.TypeOf(command).String())
+ switch command := command.(type) {
+ case LockAvailableNode:
+ b.lockAvailableNode(command)
+ case ReleaseNode:
+ b.releaseNode(command)
+ case RegisterNode:
+ command.Execute(b)
+ case RemoveNode:
+ command.Execute(b)
+ case UpdateNode:
+ command.Execute(b)
+ case GetNodesCommand:
+ command.Execute(b)
+ case SyncNodesCommand:
+ b.syncNodes()
+ case LockNodesForTrainingCommand:
+ b.lockNodesForTraining(command)
+ case StartTrainingCommand:
+ command.Execute(b)
+ case SetNodesActualStatusCommand:
+ command.Execute(b)
+ case SetNodeAdminStateCommand:
+ command.Execute(b)
+ case UpdateNodeHardwareCommand:
+ command.Execute(b)
+ case InferenceUpAllCommand:
+ command.Execute(b)
+ case StartPocCommand:
+ command.Execute(b)
+ case InitValidateCommand:
+ command.Execute(b)
+ case UpdateNodeResultCommand:
+ command.Execute(b)
+ default:
+ logging.Error("Unregistered command type", types.Nodes, "type", reflect.TypeOf(command).String())
+ }
+}
+
+type InvalidCommandError struct {
+ Message string
+}
+
+func (b *Broker) QueueMessage(command Command) error {
+ // Check validity of command. Primarily check all `Response` channels to make sure they
+ // support buffering, or else we could end up blocking the broker.
+ if command.GetResponseChannelCapacity() == 0 {
+ logging.Error("Message queued with unbuffered channel", types.Nodes, "command", reflect.TypeOf(command).String())
+ return errors.New("response channel must support buffering")
+ }
+
+ switch command.(type) {
+ case StartPocCommand, InitValidateCommand, InferenceUpAllCommand, UpdateNodeResultCommand, SetNodesActualStatusCommand, SetNodeAdminStateCommand, RegisterNode, RemoveNode, StartTrainingCommand, LockNodesForTrainingCommand, SyncNodesCommand:
+ b.highPriorityCommands <- command
+ default:
+ b.lowPriorityCommands <- command
+ }
+ return nil
+}
+
+func (b *Broker) NewNodeClient(node *Node) mlnodeclient.MLNodeClient {
+ version := b.configManager.GetCurrentNodeVersion()
+ return b.mlNodeClientFactory.CreateClient(node.PoCUrlWithVersion(version), node.InferenceUrlWithVersion(version))
+}
+
+func (b *Broker) lockAvailableNode(command LockAvailableNode) {
+ leastBusyNode := b.getLeastBusyNode(command)
+
+ if leastBusyNode != nil {
+ b.mu.RLock()
+ leastBusyNode.State.LockCount++
+ b.mu.RUnlock()
+ }
+ logging.Debug("Locked node", types.Nodes, "node", leastBusyNode)
+ if leastBusyNode == nil {
+ command.Response <- nil
+ } else {
+ command.Response <- &leastBusyNode.Node
+ }
+}
+
+func (b *Broker) getLeastBusyNode(command LockAvailableNode) *NodeWithState {
+ epochState := b.phaseTracker.GetCurrentEpochState()
+ if epochState.IsNilOrNotSynced() {
+ logging.Error("getLeastBusyNode. Cannot get least busy node, epoch state is empty", types.Nodes)
+ return nil
+ }
+ b.mu.RLock()
+ defer b.mu.RUnlock()
+
+ // Build skip set
+ skip := make(map[string]struct{}, len(command.SkipNodeIDs))
+ for _, id := range command.SkipNodeIDs {
+ if id != "" {
+ skip[id] = struct{}{}
+ }
+ }
+
+ var leastBusyNode *NodeWithState = nil
+ for _, node := range b.nodes {
+ if _, shouldSkip := skip[node.Node.Id]; shouldSkip {
+ logging.Info("Node skipped by LockAvailableNode skip list", types.Nodes, "node_id", node.Node.Id)
+ continue
+ }
+ // TODO: log some kind of a reason as to why the node is not available
+ if available, reason := b.nodeAvailable(node, command.Model, epochState.LatestEpoch.EpochIndex, epochState.CurrentPhase); available {
+ if leastBusyNode == nil || node.State.LockCount < leastBusyNode.State.LockCount {
+ leastBusyNode = node
+ }
+ } else {
+ logging.Info("Node not available", types.Nodes, "node_id", node.Node.Id, "reason", reason)
+ }
+ }
+
+ return leastBusyNode
+}
+
+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 {
+ 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 {
+ 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)
+
+ if node.State.ReconcileInfo != nil {
+ return false, fmt.Sprintf("Node is currently reconciling: %s", node.State.ReconcileInfo.Status)
+ }
+ logging.Info("nodeAvailable. Node is not being reconciled, ReconcileInfo == nil", types.Nodes, "nodeId", node.Node.Id)
+
+ if node.State.LockCount >= node.Node.MaxConcurrent {
+ return false, fmt.Sprintf("Node is locked too many times: lockCount=%d, maxConcurrent=%d", node.State.LockCount, node.Node.MaxConcurrent)
+ }
+ logging.Info("nodeAvailable. Node is not locked too many times", types.Nodes, "nodeId", node.Node.Id, "lockCount", node.State.LockCount, "maxConcurrent", node.Node.MaxConcurrent)
+
+ // Check admin state using provided epoch and phase
+ if !node.State.ShouldBeOperational(currentEpoch, currentPhase) {
+ return false, fmt.Sprintf("Node is administratively disabled: currentEpoch=%v, currentPhase=%s, adminState = %v", currentEpoch, currentPhase, node.State.AdminState)
+ }
+ logging.Info("nodeAvailable. Node is not administratively enabled", types.Nodes, "nodeId", node.Node.Id, "adminState", node.State.AdminState)
+
+ _, found := node.State.EpochModels[neededModel]
+ if !found {
+ logging.Info("Node does not have neededModel", types.Nodes, "node_id", node.Node.Id, "neededModel", neededModel)
+ return false, fmt.Sprintf("Node does not have model %s", neededModel)
+ } else {
+ logging.Info("Node has neededModel", types.Nodes, "node_id", node.Node.Id, "neededModel", neededModel)
+ return true, ""
+ }
+}
+
+func (b *Broker) releaseNode(command ReleaseNode) {
+ b.mu.RLock()
+ node, ok := b.nodes[command.NodeId]
+ b.mu.RUnlock()
+
+ if !ok {
+ command.Response <- false
+ return
+ } else {
+ b.mu.RLock()
+ node.State.LockCount--
+ b.mu.RUnlock()
+ if !command.Outcome.IsSuccess() {
+ logging.Error("Node failed", types.Nodes, "node_id", command.NodeId, "reason", command.Outcome.GetMessage())
+ // FIXME: need a write lock here?
+ // not sure if we should update the state, we have health checks for that
+ // node.State.Failure("Inference failed")
+ }
+ }
+ logging.Debug("Released node", types.Nodes, "node_id", command.NodeId)
+ command.Response <- true
+}
+
+var ErrNoNodesAvailable = errors.New("no nodes available for inference")
+
+func LockNode[T any](
+ b *Broker,
+ model string,
+ action func(node *Node) (T, error),
+) (T, error) {
+ var zero T
+
+ nodeChan := make(chan *Node, 2)
+ err := b.QueueMessage(LockAvailableNode{
+ Model: model,
+ Response: nodeChan,
+ })
+ if err != nil {
+ return zero, err
+ }
+ node := <-nodeChan
+ if node == nil {
+ return zero, ErrNoNodesAvailable
+ }
+
+ defer func() {
+ queueError := b.QueueMessage(ReleaseNode{
+ NodeId: node.Id,
+ Outcome: InferenceSuccess{},
+ Response: make(chan bool, 2),
+ })
+
+ if queueError != nil {
+ logging.Error("Error releasing node", types.Nodes, "error", queueError)
+ }
+ }()
+
+ return action(node)
+}
+
+// FIXME: Should return a copy! To avoid modifying state outside of the broker
+func (b *Broker) GetNodes() ([]NodeResponse, error) {
+ command := NewGetNodesCommand()
+ err := b.QueueMessage(command)
+ if err != nil {
+ return nil, err
+ }
+ nodes := <-command.Response
+
+ if nodes == nil {
+ return nil, errors.New("Error getting nodes")
+ }
+ logging.Debug("Got nodes", types.Nodes, "size", len(nodes))
+ return nodes, nil
+}
+
+func (b *Broker) GetNodeByNodeNum(nodeNum uint64) (*Node, bool) {
+ b.mu.RLock()
+ defer b.mu.RUnlock()
+
+ for _, nodeWithState := range b.nodes {
+ if nodeWithState.Node.NodeNum == nodeNum {
+ return &nodeWithState.Node, true
+ }
+ }
+
+ return nil, false
+}
+
+func (b *Broker) syncNodes() {
+ resp, err := b.chainBridge.GetHardwareNodes()
+ if err != nil {
+ logging.Error("[sync nodes]. Error getting nodes", types.Nodes, "error", err)
+ return
+ }
+ logging.Info("[sync nodes] Fetched chain nodes", types.Nodes, "size", len(resp.Nodes.HardwareNodes))
+
+ chainNodesMap := make(map[string]*types.HardwareNode)
+ for _, node := range resp.Nodes.HardwareNodes {
+ chainNodesMap[node.LocalId] = node
+ }
+
+ b.mu.RLock()
+ nodesCopy := make(map[string]*NodeWithState, len(b.nodes))
+ for id, node := range b.nodes {
+ nodesCopy[id] = node
+ }
+ b.mu.RUnlock()
+
+ logging.Info("[sync nodes] Local nodes", types.Nodes, "size", len(nodesCopy))
+
+ diff := b.calculateNodesDiff(chainNodesMap, nodesCopy)
+
+ logging.Info("[sync nodes] Hardware diff computed", types.Nodes, "diff", diff)
+
+ if len(diff.Removed) == 0 && len(diff.NewOrModified) == 0 {
+ logging.Info("[sync nodes] No diff to submit", types.Nodes)
+ } else {
+ logging.Info("[sync nodes] Submitting diff", types.Nodes)
+ if err = b.chainBridge.SubmitHardwareDiff(&diff); err != nil {
+ logging.Error("[sync nodes] Error submitting diff", types.Nodes, "error", err)
+ }
+ }
+}
+
+func (b *Broker) calculateNodesDiff(chainNodesMap map[string]*types.HardwareNode, localNodes map[string]*NodeWithState) types.MsgSubmitHardwareDiff {
+ var diff types.MsgSubmitHardwareDiff
+ diff.Creator = b.participantInfo.GetAddress()
+
+ for id, localNode := range localNodes {
+ localHWNode := convertInferenceNodeToHardwareNode(localNode)
+
+ chainNode, exists := chainNodesMap[id]
+ if !exists {
+ diff.NewOrModified = append(diff.NewOrModified, localHWNode)
+ } else if !areHardwareNodesEqual(localHWNode, chainNode) {
+ diff.NewOrModified = append(diff.NewOrModified, localHWNode)
+ }
+ }
+
+ for id, chainNode := range chainNodesMap {
+ if _, exists := localNodes[id]; !exists {
+ diff.Removed = append(diff.Removed, chainNode)
+ }
+ }
+ return diff
+}
+
+func (b *Broker) lockNodesForTraining(command LockNodesForTrainingCommand) {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+ // PRTODO: implement
+ command.Response <- true
+}
+
+// convertInferenceNodeToHardwareNode converts a local InferenceNode into a HardwareNode.
+func convertInferenceNodeToHardwareNode(in *NodeWithState) *types.HardwareNode {
+ node := in.Node
+ hardware := make([]*types.Hardware, 0, len(node.Hardware))
+ for _, hw := range node.Hardware {
+ hardware = append(hardware, &types.Hardware{
+ Type: hw.Type,
+ Count: hw.Count,
+ })
+ }
+
+ modelNames := make([]string, 0)
+ for model := range node.Models {
+ modelNames = append(modelNames, model)
+ }
+
+ // sort models names to make sure they will be in same order every time
+ sort.Strings(modelNames)
+
+ return &types.HardwareNode{
+ LocalId: node.Id,
+ Status: in.State.CurrentStatus,
+ Hardware: hardware,
+ Models: modelNames,
+ Host: node.Host,
+ Port: strconv.Itoa(node.PoCPort),
+ }
+}
+
+// areHardwareNodesEqual performs a field-by-field comparison between two HardwareNodes.
+func areHardwareNodesEqual(a, b *types.HardwareNode) bool {
+ // Compare each field that determines whether the node has changed.
+ if a.LocalId != b.LocalId {
+ return false
+ }
+ if a.Status != b.Status {
+ return false
+ }
+ if len(a.Hardware) != len(b.Hardware) {
+ return false
+ }
+
+ if !hardwareEquals(a, b) {
+ return false
+ }
+
+ return true
+}
+
+func hardwareEquals(a *types.HardwareNode, b *types.HardwareNode) bool {
+ if len(a.Models) != len(b.Models) {
+ return false
+ }
+
+ aModels := make([]string, len(a.Models))
+ bModels := make([]string, len(b.Models))
+ copy(aModels, a.Models)
+ copy(bModels, b.Models)
+ sort.Strings(aModels)
+ sort.Strings(bModels)
+
+ for i := range aModels {
+ if aModels[i] != bModels[i] {
+ return false
+ }
+ }
+
+ aHardware := make([]*types.Hardware, len(a.Hardware))
+ bHardware := make([]*types.Hardware, len(b.Hardware))
+ copy(aHardware, a.Hardware)
+ copy(bHardware, b.Hardware)
+
+ sort.Slice(aHardware, func(i, j int) bool {
+ if aHardware[i].Type == aHardware[j].Type {
+ return aHardware[i].Count < aHardware[j].Count
+ }
+ return aHardware[i].Type < aHardware[j].Type
+ })
+ sort.Slice(bHardware, func(i, j int) bool {
+ if bHardware[i].Type == bHardware[j].Type {
+ return bHardware[i].Count < bHardware[j].Count
+ }
+ return bHardware[i].Type < bHardware[j].Type
+ })
+
+ for i := range aHardware {
+ if aHardware[i].Type != bHardware[i].Type || aHardware[i].Count != bHardware[i].Count {
+ return false
+ }
+ }
+
+ return true
+}
+
+type pocParams struct {
+ startPoCBlockHeight int64
+ startPoCBlockHash string
+}
+
+const reconciliationInterval = 30 * time.Second
+
+// Timeouts for node health checks used in queryNodeStatus
+const (
+ nodeStatusRequestTimeout = 5 * time.Second
+ inferenceHealthRequestTimeout = 5 * time.Second
+ // statusScanMinInterval enforces a minimal delay between consecutive full scans
+ // in nodeStatusQueryWorker, covering both manual and timer triggers.
+ statusScanMinInterval = 2 * time.Second
+)
+
+func (b *Broker) TriggerReconciliation() {
+ select {
+ case b.reconcileTrigger <- struct{}{}:
+ default:
+ }
+}
+
+func (b *Broker) reconcilerLoop() {
+ ticker := time.NewTicker(reconciliationInterval)
+ defer ticker.Stop()
+
+ for {
+ select {
+ case <-b.reconcileTrigger:
+ b.reconcileIfSynced("Reconciliation triggered manually")
+ case <-ticker.C:
+ b.reconcileIfSynced("Reconciliation triggered by timer")
+ // Check for version changes and refresh clients if needed
+ b.checkAndRefreshClientsIfNeeded()
+ }
+ }
+}
+
+type VersionHealthReport struct {
+ IsAlive bool `json:"is_alive"`
+ Error string `json:"error,omitempty"`
+}
+
+func (b *Broker) CheckVersionHealth(version string) map[string]VersionHealthReport {
+ b.mu.RLock()
+ nodeIds := make([]string, 0, len(b.nodes))
+ for nodeId := range b.nodes {
+ nodeIds = append(nodeIds, nodeId)
+ }
+ b.mu.RUnlock()
+
+ reports := make(map[string]VersionHealthReport)
+ var wg sync.WaitGroup
+ var reportsMu sync.Mutex
+
+ for _, nodeId := range nodeIds {
+ wg.Add(1)
+ go func(nodeId string) {
+ defer wg.Done()
+ worker, exists := b.nodeWorkGroup.GetWorker(nodeId)
+ report := VersionHealthReport{}
+
+ if !exists {
+ report.Error = "worker not found"
+ } else {
+ alive, err := worker.CheckClientVersionAlive(version, b.mlNodeClientFactory)
+ report.IsAlive = alive
+ if err != nil {
+ report.Error = err.Error()
+ }
+ }
+
+ reportsMu.Lock()
+ reports[nodeId] = report
+ reportsMu.Unlock()
+ }(nodeId)
+ }
+
+ wg.Wait()
+ return reports
+}
+
+// checkAndRefreshClientsIfNeeded checks if the MLNode version has changed and refreshes all clients if needed
+func (b *Broker) checkAndRefreshClientsIfNeeded() {
+ if b.configManager.ShouldRefreshClients() {
+ currentVersion := b.configManager.GetCurrentNodeVersion()
+ lastUsedVersion := b.configManager.GetLastUsedVersion()
+
+ logging.Info("MLNode version change detected - immediately refreshing all clients", types.Nodes,
+ "oldVersion", lastUsedVersion, "newVersion", currentVersion)
+
+ // Immediately refresh all worker clients (no queuing delay)
+ b.mu.RLock()
+ workerIds := make([]string, 0, len(b.nodes))
+ for nodeId := range b.nodes {
+ workerIds = append(workerIds, nodeId)
+ }
+ b.mu.RUnlock()
+
+ // Immediately refresh all workers
+ refreshedCount := 0
+ for _, nodeId := range workerIds {
+ worker, exists := b.nodeWorkGroup.GetWorker(nodeId)
+ if exists {
+ worker.RefreshClientImmediate(lastUsedVersion, currentVersion)
+ refreshedCount++
+ }
+ }
+
+ logging.Info("Immediately refreshed all MLNode clients", types.Nodes,
+ "oldVersion", lastUsedVersion, "newVersion", currentVersion, "count", refreshedCount)
+
+ // Update last used version (fire and forget - if this fails, we'll retry next cycle)
+ if err := b.configManager.SetLastUsedVersion(currentVersion); err != nil {
+ logging.Warn("Failed to update last used version", types.Config, "error", err)
+ }
+ } else {
+ // Ensure lastUsedVersion is set if it's empty (first time initialization)
+ if b.configManager.GetLastUsedVersion() == "" {
+ currentVersion := b.configManager.GetCurrentNodeVersion()
+ if currentVersion != "" {
+ if err := b.configManager.SetLastUsedVersion(currentVersion); err != nil {
+ logging.Warn("Failed to initialize last used version", types.Config, "error", err)
+ }
+ }
+ }
+ }
+ upgradeVersion := b.configManager.GetUpgradePlan().NodeVersion
+ if upgradeVersion != "" {
+ reports := b.CheckVersionHealth(upgradeVersion)
+ for nodeId, report := range reports {
+ if report.Error != "" {
+ logging.Warn("Failed to check MLNode version in upgrade plan", types.Nodes, "node_id", nodeId, "error", report.Error)
+ } else if !report.IsAlive {
+ logging.Warn("MLNode version in upgrade plan is not alive", types.Nodes, "node_id", nodeId)
+ } else {
+ logging.Debug("MLNode version in upgrade plan is alive", types.Nodes, "node_id", nodeId)
+ }
+ }
+ }
+}
+
+func (b *Broker) reconcileIfSynced(triggerMsg string) {
+ epochPhaseInfo := b.phaseTracker.GetCurrentEpochState()
+ if epochPhaseInfo.IsNilOrNotSynced() {
+ logging.Warn("Reconciliation triggered while epoch phase info is not synced. Skipping", types.Nodes)
+ return
+ }
+
+ logging.Info(triggerMsg, types.Nodes, "blockHeight", epochPhaseInfo.CurrentBlock.Height)
+ b.reconcile(*epochPhaseInfo)
+}
+
+func (b *Broker) reconcile(epochState chainphase.EpochState) {
+ blockHeight := epochState.CurrentBlock.Height
+
+ // Phase 1: Cancel outdated tasks
+ nodesToCancel := make(map[string]func())
+ b.mu.RLock()
+ for id, node := range b.nodes {
+ if node.State.ReconcileInfo != nil &&
+ (node.State.ReconcileInfo.Status != node.State.IntendedStatus ||
+ node.State.ReconcileInfo.PocStatus != node.State.PocIntendedStatus) {
+ if node.State.cancelInFlightTask != nil {
+ nodesToCancel[id] = node.State.cancelInFlightTask
+ }
+ }
+ }
+ b.mu.RUnlock()
+
+ for id, cancel := range nodesToCancel {
+ logging.Info("Cancelling outdated task for node", types.Nodes, "node_id", id, "blockHeight", blockHeight)
+ cancel()
+ b.mu.Lock()
+ if node, ok := b.nodes[id]; ok {
+ node.State.ReconcileInfo = nil
+ node.State.cancelInFlightTask = nil
+ }
+ b.mu.Unlock()
+ }
+
+ nodesToDispatch := make(map[string]*NodeWithState)
+ b.mu.RLock()
+ for id, node := range b.nodes {
+ isStable := node.State.ReconcileInfo == nil
+ if !isStable {
+ continue
+ }
+
+ // Condition: The primary or PoC intended state does not match the current state.
+ if node.State.IntendedStatus != node.State.CurrentStatus || node.State.PocIntendedStatus != node.State.PocCurrentStatus {
+ nodeCopy := *node
+ nodesToDispatch[id] = &nodeCopy
+ }
+ }
+ b.mu.RUnlock()
+
+ currentPoCParams, pocParamsErr := b.prefetchPocParams(epochState, nodesToDispatch, blockHeight)
+
+ for id, node := range nodesToDispatch {
+ // Re-check conditions under write lock to prevent races
+ b.mu.Lock()
+ currentNode, ok := b.nodes[id]
+ if !ok ||
+ (currentNode.State.IntendedStatus == currentNode.State.CurrentStatus && (currentNode.State.CurrentStatus != types.HardwareNodeStatus_POC || currentNode.State.PocIntendedStatus == currentNode.State.PocCurrentStatus)) ||
+ currentNode.State.ReconcileInfo != nil {
+ b.mu.Unlock()
+ continue
+ }
+
+ ctx, cancel := context.WithCancel(context.Background())
+ intendedStatusCopy := currentNode.State.IntendedStatus
+ pocIntendedStatusCopy := currentNode.State.PocIntendedStatus
+ currentNode.State.ReconcileInfo = &ReconcileInfo{
+ Status: intendedStatusCopy,
+ PocStatus: pocIntendedStatusCopy,
+ }
+ currentNode.State.cancelInFlightTask = cancel
+
+ worker, exists := b.nodeWorkGroup.GetWorker(id)
+ b.mu.Unlock()
+
+ if !exists {
+ logging.Error("Worker not found for reconciliation", types.Nodes, "node_id", id, "blockHeight", blockHeight)
+ cancel() // Cancel context if worker doesn't exist
+ b.mu.Lock()
+ if nodeToClean, ok := b.nodes[id]; ok {
+ nodeToClean.State.ReconcileInfo = nil
+ nodeToClean.State.cancelInFlightTask = nil
+ }
+ b.mu.Unlock()
+ continue
+ }
+
+ // TODO: we should make reindexing as some indexes might be skipped
+ totalNumNodes := b.curMaxNodesNum.Load() + 1
+ // Create and dispatch the command
+ cmd := b.getCommandForState(&node.State, currentPoCParams, pocParamsErr, int(totalNumNodes))
+ if cmd != nil {
+ logging.Info("Dispatching reconciliation command", types.Nodes,
+ "node_id", id, "target_status", node.State.IntendedStatus, "target_poc_status", node.State.PocIntendedStatus, "blockHeight", blockHeight)
+ if !worker.Submit(ctx, cmd) {
+ logging.Error("Failed to submit reconciliation command", types.Nodes, "node_id", id, "blockHeight", blockHeight)
+ cancel()
+ b.mu.Lock()
+ if nodeToClean, ok := b.nodes[id]; ok {
+ nodeToClean.State.ReconcileInfo = nil
+ nodeToClean.State.cancelInFlightTask = nil
+ }
+ b.mu.Unlock()
+ }
+ } else {
+ logging.Info("No valid command for reconciliation, cleaning up", types.Nodes, "node_id", id)
+ cancel()
+ b.mu.Lock()
+ if nodeToClean, ok := b.nodes[id]; ok {
+ nodeToClean.State.ReconcileInfo = nil
+ nodeToClean.State.cancelInFlightTask = nil
+ }
+ b.mu.Unlock()
+ }
+ }
+}
+
+func (b *Broker) prefetchPocParams(epochState chainphase.EpochState, nodesToDispatch map[string]*NodeWithState, blockHeight int64) (*pocParams, error) {
+ needsPocParams := false
+ for _, node := range nodesToDispatch {
+ if node.State.IntendedStatus == types.HardwareNodeStatus_POC {
+ if node.State.PocIntendedStatus == PocStatusGenerating || node.State.PocIntendedStatus == PocStatusValidating {
+ needsPocParams = true
+ }
+ }
+ }
+
+ if needsPocParams {
+ // CONFIRMATION PoC - use hash from event (populated by chain at generation_start_height)
+ if epochState.CurrentPhase == types.InferencePhase && epochState.ActiveConfirmationPoCEvent != nil {
+ event := epochState.ActiveConfirmationPoCEvent
+ return &pocParams{
+ startPoCBlockHeight: event.TriggerHeight,
+ startPoCBlockHash: event.PocSeedBlockHash,
+ }, nil
+ }
+
+ // REGULAR PoC - query hash as usual
+ currentPoCParams, pocParamsErr := b.queryCurrentPoCParams(epochState.LatestEpoch.PocStartBlockHeight)
+ if pocParamsErr != nil {
+ logging.Error("Failed to query PoC Generation parameters, skipping PoC reconciliation", types.Nodes, "error", pocParamsErr, "blockHeight", blockHeight)
+ }
+ return currentPoCParams, pocParamsErr
+ } else {
+ return nil, nil
+ }
+}
+
+func (b *Broker) getCommandForState(nodeState *NodeState, pocGenParams *pocParams, pocGenErr error, totalNodes int) NodeWorkerCommand {
+ switch nodeState.IntendedStatus {
+ case types.HardwareNodeStatus_INFERENCE:
+ return InferenceUpNodeCommand{}
+ case types.HardwareNodeStatus_POC:
+ switch nodeState.PocIntendedStatus {
+ case PocStatusGenerating:
+ if pocGenParams != nil && pocGenParams.startPoCBlockHeight > 0 {
+ return StartPoCNodeCommand{
+ BlockHeight: pocGenParams.startPoCBlockHeight,
+ BlockHash: pocGenParams.startPoCBlockHash,
+ PubKey: b.participantInfo.GetPubKey(),
+ CallbackUrl: GetPocBatchesCallbackUrl(b.callbackUrl),
+ TotalNodes: totalNodes,
+ }
+ }
+ logging.Error("Cannot create StartPoCNodeCommand: missing PoC parameters", types.Nodes, "error", pocGenErr)
+ return nil
+ case PocStatusValidating:
+ if pocGenParams != nil && pocGenParams.startPoCBlockHeight > 0 {
+ return InitValidateNodeCommand{
+ BlockHeight: pocGenParams.startPoCBlockHeight,
+ BlockHash: pocGenParams.startPoCBlockHash,
+ PubKey: b.participantInfo.GetPubKey(),
+ CallbackUrl: GetPocValidateCallbackUrl(b.callbackUrl),
+ TotalNodes: totalNodes,
+ }
+ }
+ logging.Error("Cannot create InitValidateNodeCommand: missing PoC parameters", types.Nodes, "error", pocGenErr)
+ return nil
+ default:
+ return nil // No action for other phases if status is POC
+ }
+ case types.HardwareNodeStatus_STOPPED:
+ return StopNodeCommand{}
+ case types.HardwareNodeStatus_TRAINING:
+ if nodeState.TrainingTask == nil {
+ logging.Error("Training task ID is nil, cannot create StartTrainingCommand", types.Nodes)
+ return nil
+ }
+ return StartTrainingNodeCommand{
+ TaskId: nodeState.TrainingTask.Id,
+ Participant: b.participantInfo.GetAddress(),
+ MasterNodeAddr: nodeState.TrainingTask.MasterNodeAddr,
+ NodeRanks: nodeState.TrainingTask.NodeRanks,
+ WorldSize: nodeState.TrainingTask.WorldSize,
+ }
+ default:
+ logging.Info("Reconciliation for state not yet implemented", types.Nodes,
+ "intended_state", nodeState.IntendedStatus.String())
+ return nil
+ }
+}
+
+func (b *Broker) queryCurrentPoCParams(epochPoCStartHeight int64) (*pocParams, error) {
+ hash, err := b.chainBridge.GetBlockHash(epochPoCStartHeight)
+ if err != nil {
+ logging.Error("Failed to query PoC start block hash", types.Nodes, "height", epochPoCStartHeight, "error", err)
+ return nil, err
+ }
+ return &pocParams{
+ startPoCBlockHeight: epochPoCStartHeight,
+ startPoCBlockHash: hash,
+ }, nil
+}
+
+func nodeStatusQueryWorker(broker *Broker) {
+ checkInterval := 60 * time.Second
+ // Track when an actual scan starts to enforce a minimal interval between scans
+ var lastScanStart time.Time
+ ticker := time.NewTicker(checkInterval)
+ defer ticker.Stop()
+
+ for {
+ bypassDebounce := false
+ select {
+ case <-ticker.C:
+ logging.Debug("nodeStatusQueryWorker triggered by ticker", types.Nodes)
+ case sig := <-broker.statusQueryTrigger:
+ logging.Debug("nodeStatusQueryWorker triggered manually", types.Nodes)
+ bypassDebounce = sig.BypassDebounce
+ }
+
+ // Enforce minimal interval between scans unless bypass requested
+ if !bypassDebounce && !lastScanStart.IsZero() {
+ elapsed := time.Since(lastScanStart)
+ if elapsed < statusScanMinInterval {
+ logging.Debug("nodeStatusQueryWorker skipping scan due to min interval", types.Nodes, "elapsed", elapsed)
+ continue
+ }
+ }
+ // Mark the start of an actual scan
+ lastScanStart = time.Now()
+
+ nodes, err := broker.GetNodes()
+ if err != nil {
+ logging.Error("nodeStatusQueryWorker. Failed to get nodes for status query", types.Nodes, "error", err)
+ continue
+ }
+
+ statusUpdates := make([]StatusUpdate, 0)
+
+ for _, nodeResp := range nodes {
+ // Only check nodes that are UNKNOWN or haven't been checked in a while.
+ sinceLastStatusCheck := time.Since(nodeResp.State.StatusTimestamp)
+ if nodeResp.State.CurrentStatus != types.HardwareNodeStatus_UNKNOWN && sinceLastStatusCheck < checkInterval {
+ logging.Info("nodeStatusQueryWorker skipping status query for node", types.Nodes,
+ "nodeId", nodeResp.Node.Id,
+ "currentStatus", nodeResp.State.CurrentStatus.String(),
+ "sinceLastStatusCheck", sinceLastStatusCheck)
+ continue
+ }
+
+ queryStatusResult, err := broker.queryNodeStatus(nodeResp.Node, nodeResp.State)
+ timestamp := time.Now()
+ if err != nil {
+ logging.Error("nodeStatusQueryWorker. Failed to queue status query command", types.Nodes,
+ "nodeId", nodeResp.Node.Id, "error", err)
+ continue
+ }
+
+ if queryStatusResult.PrevStatus != queryStatusResult.CurrentStatus {
+ logging.Info("nodeStatusQueryWorker. Node status changed", types.Nodes,
+ "nodeId", nodeResp.Node.Id,
+ "prevStatus", queryStatusResult.PrevStatus.String(),
+ "currentStatus", queryStatusResult.CurrentStatus.String())
+
+ statusUpdates = append(statusUpdates, StatusUpdate{
+ NodeId: nodeResp.Node.Id,
+ PrevStatus: queryStatusResult.PrevStatus,
+ NewStatus: queryStatusResult.CurrentStatus,
+ Timestamp: timestamp,
+ })
+ }
+ }
+
+ if len(statusUpdates) > 0 {
+ err = broker.QueueMessage(NewSetNodesActualStatusCommand(statusUpdates))
+ logging.Info("nodeStatusQueryWorker. Queued status updates submitted", types.Nodes,
+ "len(statusUpdates)", len(statusUpdates))
+ if err != nil {
+ logging.Error("nodeStatusQueryWorker. Failed to queue status update command", types.Nodes, "error", err)
+ continue
+ }
+ }
+ }
+}
+
+type statusQueryResult struct {
+ PrevStatus types.HardwareNodeStatus
+ CurrentStatus types.HardwareNodeStatus
+}
+
+// Pass by value, because this is supposed to be a readonly function
+func (b *Broker) queryNodeStatus(node Node, state NodeState) (*statusQueryResult, error) {
+ client := b.NewNodeClient(&node)
+
+ ctx, cancel := context.WithTimeout(context.Background(), nodeStatusRequestTimeout)
+ defer cancel()
+ status, err := client.NodeState(ctx)
+
+ nodeId := node.Id
+ prevStatus := state.CurrentStatus
+ var currentStatus types.HardwareNodeStatus
+ if err != nil {
+ logging.Error("queryNodeStatus. Failed to query node status. Assuming currentStatus = FAILED", types.Nodes,
+ "nodeId", nodeId, "error", err)
+ currentStatus = types.HardwareNodeStatus_FAILED
+ } else {
+ currentStatus = toStatus(*status)
+ }
+
+ logging.Info("queryNodeStatus. Queried node status", types.Nodes, "nodeId", nodeId, "currentStatus", currentStatus.String(), "prevStatus", prevStatus.String())
+
+ if currentStatus == types.HardwareNodeStatus_INFERENCE {
+ hctx, hcancel := context.WithTimeout(context.Background(), inferenceHealthRequestTimeout)
+ defer hcancel()
+ ok, err := client.InferenceHealth(hctx)
+ if !ok || err != nil {
+ currentStatus = types.HardwareNodeStatus_FAILED
+ logging.Info("queryNodeStatus. Node inference health check failed", types.Nodes, "nodeId", nodeId, "currentStatus", currentStatus.String(), "prevStatus", prevStatus.String(), "err", err)
+ }
+ }
+
+ // TODO: probably should also check PoC sub status here
+ // but before implementing it, need to check we treat them correctly during reconciliation
+ // for example I think we expect IDLE instead of STOPPED for PoC nodes
+ // which is actually wrong
+
+ return &statusQueryResult{
+ PrevStatus: prevStatus,
+ CurrentStatus: currentStatus,
+ }, nil
+}
+
+func toStatus(response mlnodeclient.StateResponse) types.HardwareNodeStatus {
+ switch response.State {
+ case mlnodeclient.MlNodeState_POW:
+ return types.HardwareNodeStatus_POC
+ case mlnodeclient.MlNodeState_INFERENCE:
+ return types.HardwareNodeStatus_INFERENCE
+ case mlnodeclient.MlNodeState_TRAIN:
+ return types.HardwareNodeStatus_TRAINING
+ case mlnodeclient.MlNodeState_STOPPED:
+ return types.HardwareNodeStatus_STOPPED
+ default:
+ return types.HardwareNodeStatus_UNKNOWN
+ }
+}
+
+// UpdateNodeWithEpochData queries the current epoch group data from the chain
+// and populates the NodeState with the epoch-specific model and MLNode info.
+// It only performs the update if the epoch index or phase has changed.
+func (b *Broker) UpdateNodeWithEpochData(epochState *chainphase.EpochState) error {
+ if epochState.LatestEpoch.EpochIndex <= b.lastEpochIndex && epochState.CurrentPhase == b.lastEpochPhase {
+ return nil // No change, no need to update
+ }
+
+ // Update the broker's last known state
+ b.lastEpochIndex = epochState.LatestEpoch.EpochIndex
+ b.lastEpochPhase = epochState.CurrentPhase
+
+ logging.Info("Epoch or phase change detected, updating node data with epoch info.", types.Nodes,
+ "old_epoch", b.lastEpochIndex, "new_epoch", epochState.LatestEpoch.EpochIndex,
+ "old_phase", b.lastEpochPhase, "new_phase", epochState.CurrentPhase)
+
+ // 1. Get the parent epoch group to find all subgroup models
+ parentGroupResp, err := b.chainBridge.GetEpochGroupDataByModelId(epochState.LatestEpoch.EpochIndex, "")
+ if err != nil {
+ logging.Error("Failed to get parent epoch group", types.Nodes, "error", err)
+ return err
+ }
+ if parentGroupResp == nil {
+ logging.Error("Parent epoch group data is nil", types.Nodes, "epoch_index", epochState.LatestEpoch.EpochIndex, "epoch_poc_start_block_height", epochState.LatestEpoch.PocStartBlockHeight, "epoch_group_data_poc_start_block_height")
+ return nil
+ }
+ if len(parentGroupResp.EpochGroupData.SubGroupModels) == 0 {
+ logging.Warn("Parent epoch group SubGroupModels are empty", types.Nodes, "epoch_index", epochState.LatestEpoch.EpochIndex, "epoch_poc_start_block_height", epochState.LatestEpoch.PocStartBlockHeight, "epoch_group_data_poc_start_block_height", parentGroupResp.EpochGroupData.PocStartBlockHeight)
+ return nil
+ }
+
+ parentEpochData := parentGroupResp.GetEpochGroupData()
+
+ b.clearNodeEpochData()
+
+ // 2. Iterate through each model subgroup
+ for _, modelId := range parentEpochData.SubGroupModels {
+ subgroupResp, err := b.chainBridge.GetEpochGroupDataByModelId(parentEpochData.EpochIndex, modelId)
+ if err != nil {
+ logging.Error("Failed to get subgroup epoch data", types.Nodes, "model_id", modelId, "error", err)
+ continue
+ }
+ if subgroupResp == nil {
+ logging.Warn("Subgroup epoch data response is nil", types.Nodes, "model_id", modelId)
+ continue
+ }
+
+ subgroup := subgroupResp.EpochGroupData
+ if subgroup.ModelSnapshot == nil {
+ logging.Error("ModelSnapshot is nil in subgroup", types.Nodes, "model_id", modelId)
+ continue
+ }
+
+ // 3. Iterate through participants in the subgroup
+ for _, weightInfo := range subgroup.ValidationWeights {
+ // Check if the participant is the one this broker is managing
+ if weightInfo.MemberAddress == b.participantInfo.GetAddress() {
+ // 4. Iterate through the ML nodes for this participant in the epoch data
+ b.UpdateNodeEpochData(weightInfo.MlNodes, modelId, *subgroup.ModelSnapshot)
+ }
+ }
+ }
+
+ return nil
+}
+
+func (b *Broker) clearNodeEpochData() {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+
+ logging.Info("Clearing node epoch data", types.Nodes)
+ for _, node := range b.nodes {
+ node.State.EpochModels = make(map[string]types.Model)
+ node.State.EpochMLNodes = make(map[string]types.MLNodeInfo)
+ }
+}
+
+func (b *Broker) UpdateNodeEpochData(mlNodes []*types.MLNodeInfo, modelId string, modelSnapshot types.Model) {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+
+ for _, mlNodeInfo := range mlNodes {
+ if node, ok := b.nodes[mlNodeInfo.NodeId]; ok {
+ node.State.EpochModels[modelId] = modelSnapshot
+ node.State.EpochMLNodes[modelId] = *mlNodeInfo
+ logging.Info("Updated epoch data for node", types.Nodes, "node_id", node.Node.Id, "model_id", modelId)
+ }
+ }
+}
+
+// MergeModelArgs combines model arguments from the epoch snapshot with locally
+// configured arguments, with epoch arguments taking precedence.
+// It understands arguments as --key or --key value pairs.
+func (b *Broker) MergeModelArgs(epochArgs []string, localArgs []string) []string {
+ // The final merged arguments, preserving the order from epochArgs, then localArgs.
+ mergedArgs := make([]string, 0, len(epochArgs)+len(localArgs))
+ // A set to store the keys from epochArgs to check for precedence.
+ epochKeys := make(map[string]struct{})
+
+ // 1. Process epochArgs first. They all go into the result and populate epochKeys.
+ for i := 0; i < len(epochArgs); i++ {
+ arg := epochArgs[i]
+ if strings.HasPrefix(arg, "--") {
+ key := arg
+ epochKeys[key] = struct{}{}
+ mergedArgs = append(mergedArgs, key)
+
+ // Check if the next element is a value for this key.
+ if i+1 < len(epochArgs) && !strings.HasPrefix(epochArgs[i+1], "--") {
+ // It's a value, add it to mergedArgs and skip it in the next iteration.
+ mergedArgs = append(mergedArgs, epochArgs[i+1])
+ i++
+ }
+ } else {
+ // This case handles a value without a preceding key in epochArgs,
+ // which is unlikely but we add it to be safe.
+ mergedArgs = append(mergedArgs, arg)
+ }
+ }
+
+ // 2. Process localArgs and add only the ones with keys not present in epochArgs.
+ for i := 0; i < len(localArgs); i++ {
+ arg := localArgs[i]
+ if strings.HasPrefix(arg, "--") {
+ key := arg
+ if _, exists := epochKeys[key]; !exists {
+ // This key is not in epochArgs, so we can add it.
+ mergedArgs = append(mergedArgs, key)
+
+ // Check if it has a value.
+ if i+1 < len(localArgs) && !strings.HasPrefix(localArgs[i+1], "--") {
+ // It has a value, add it and skip.
+ mergedArgs = append(mergedArgs, localArgs[i+1])
+ i++
+ }
+ } else {
+ // Key already exists in epoch args, so we skip it.
+ // If it has a value, we need to skip that too.
+ if i+1 < len(localArgs) && !strings.HasPrefix(localArgs[i+1], "--") {
+ i++ // Skip the value of the overridden key.
+ }
+ }
+ }
+ // Non-key arguments are ignored here as they are considered values
+ // of keys, which are handled within the loop.
+ }
+
+ return mergedArgs
+}
diff --git a/decentralized-api/broker/broker_test.go b/decentralized-api/broker/broker_test.go
new file mode 100644
index 000000000..4f4d1b693
--- /dev/null
+++ b/decentralized-api/broker/broker_test.go
@@ -0,0 +1,1504 @@
+package broker
+
+import (
+ "decentralized-api/apiconfig"
+ "decentralized-api/chainphase"
+ "decentralized-api/mlnodeclient"
+ "decentralized-api/participant"
+ "fmt"
+ "testing"
+ "time"
+
+ "github.com/productscience/inference/x/inference/types"
+ "github.com/stretchr/testify/mock"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+ "golang.org/x/exp/slog"
+)
+
+type MockBrokerChainBridge struct {
+ mock.Mock
+}
+
+func (m *MockBrokerChainBridge) GetHardwareNodes() (*types.QueryHardwareNodesResponse, error) {
+ args := m.Called()
+ return args.Get(0).(*types.QueryHardwareNodesResponse), args.Error(1)
+}
+
+func (m *MockBrokerChainBridge) SubmitHardwareDiff(diff *types.MsgSubmitHardwareDiff) error {
+ args := m.Called(diff)
+ return args.Error(0)
+}
+
+func (m *MockBrokerChainBridge) GetBlockHash(height int64) (string, error) {
+ args := m.Called(height)
+ return args.String(0), args.Error(1)
+}
+
+func (m *MockBrokerChainBridge) GetGovernanceModels() (*types.QueryModelsAllResponse, error) {
+ args := m.Called()
+ if args.Get(0) == nil {
+ return nil, args.Error(1)
+ }
+ return args.Get(0).(*types.QueryModelsAllResponse), args.Error(1)
+}
+
+func (m *MockBrokerChainBridge) GetCurrentEpochGroupData() (*types.QueryCurrentEpochGroupDataResponse, error) {
+ args := m.Called()
+ if args.Get(0) == nil {
+ return nil, args.Error(1)
+ }
+ return args.Get(0).(*types.QueryCurrentEpochGroupDataResponse), args.Error(1)
+}
+
+func (m *MockBrokerChainBridge) GetEpochGroupDataByModelId(pocHeight uint64, modelId string) (*types.QueryGetEpochGroupDataResponse, error) {
+ args := m.Called(pocHeight, modelId)
+ if args.Get(0) == nil {
+ return nil, args.Error(1)
+ }
+ return args.Get(0).(*types.QueryGetEpochGroupDataResponse), args.Error(1)
+}
+
+func NewTestBroker() *Broker {
+ participantInfo := participant.CosmosInfo{
+ Address: "cosmos1dummyaddress",
+ PubKey: "dummyPubKey",
+ }
+ phaseTracker := chainphase.NewChainPhaseTracker()
+ phaseTracker.Update(
+ chainphase.BlockInfo{Height: 1, Hash: "hash-1"},
+ &types.Epoch{Index: 0, PocStartBlockHeight: 0},
+ &types.EpochParams{},
+ true,
+ nil,
+ )
+
+ mockChainBridge := &MockBrokerChainBridge{}
+ mockChainBridge.On("GetGovernanceModels").Return(&types.QueryModelsAllResponse{
+ Model: []types.Model{
+ {Id: "model1"},
+ },
+ }, nil)
+
+ // Setup meaningful mock responses for epoch data
+ parentEpochData := &types.QueryCurrentEpochGroupDataResponse{
+ EpochGroupData: types.EpochGroupData{
+ PocStartBlockHeight: 100,
+ SubGroupModels: []string{"model1"},
+ },
+ }
+ model1EpochData := &types.QueryGetEpochGroupDataResponse{
+ EpochGroupData: types.EpochGroupData{
+ PocStartBlockHeight: 100,
+ ModelSnapshot: &types.Model{Id: "model1"},
+ ValidationWeights: []*types.ValidationWeight{
+ {
+ MemberAddress: "cosmos1dummyaddress",
+ MlNodes: []*types.MLNodeInfo{
+ {NodeId: "test-node-1"},
+ },
+ },
+ },
+ },
+ }
+
+ mockChainBridge.On("GetCurrentEpochGroupData").Return(parentEpochData, nil)
+ mockChainBridge.On("GetEpochGroupDataByModelId", uint64(100), "model1").Return(model1EpochData, nil)
+
+ mockConfigManager := &apiconfig.ConfigManager{}
+ return NewBroker(mockChainBridge, phaseTracker, participantInfo, "", mlnodeclient.NewMockClientFactory(), mockConfigManager)
+}
+
+func TestSingleNode(t *testing.T) {
+ broker := NewTestBroker()
+ node := apiconfig.InferenceNodeConfig{
+ Host: "localhost",
+ InferencePort: 8080,
+ PoCPort: 5000,
+ Models: map[string]apiconfig.ModelConfig{"model1": {Args: make([]string, 0)}},
+ Id: "node1",
+ MaxConcurrent: 1,
+ }
+
+ registerNodeAndSetInferenceStatus(t, broker, node)
+
+ availableNode := make(chan *Node, 2)
+ queueMessage(t, broker, LockAvailableNode{Model: "model1", Response: availableNode})
+ runningNode := <-availableNode
+ if runningNode == nil {
+ t.Fatalf("expected node1, got nil")
+ }
+ if runningNode.Id != node.Id {
+ t.Fatalf("expected node1, got: " + runningNode.Id)
+ }
+ queueMessage(t, broker, LockAvailableNode{Model: "model1", Response: availableNode})
+ if <-availableNode != nil {
+ t.Fatalf("expected nil, got " + runningNode.Id)
+ }
+}
+
+func registerNodeAndSetInferenceStatus(t *testing.T, broker *Broker, node apiconfig.InferenceNodeConfig) {
+ cmd := NewRegisterNodeCommand(node)
+ nodeIsRegistered := cmd.Response
+ queueMessage(t, broker, cmd)
+
+ // Wait for the 1st command to be propagated,
+ // so our set status timestamp comes after the initial registration timestamp
+ _ = <-nodeIsRegistered
+
+ mlNode := types.MLNodeInfo{
+ NodeId: node.Id,
+ Throughput: 0,
+ PocWeight: 10,
+ TimeslotAllocation: []bool{true, false},
+ }
+
+ var modelId string
+ for m, _ := range node.Models {
+ modelId = m
+ break
+ }
+ if modelId == "" {
+ t.Fatalf("expected modelId, got empty string")
+ }
+ model := types.Model{
+ Id: modelId,
+ }
+ broker.UpdateNodeEpochData([]*types.MLNodeInfo{&mlNode}, modelId, model)
+
+ inferenceUpCommand := NewInferenceUpAllCommand()
+ queueMessage(t, broker, inferenceUpCommand)
+
+ // Wait for InferenceUpAllCommand to complete
+ <-inferenceUpCommand.Response
+
+ setStatusCommand := NewSetNodesActualStatusCommand(
+ []StatusUpdate{
+ {
+ NodeId: node.Id,
+ PrevStatus: types.HardwareNodeStatus_UNKNOWN,
+ NewStatus: types.HardwareNodeStatus_INFERENCE,
+ Timestamp: time.Now(),
+ },
+ },
+ )
+ queueMessage(t, broker, setStatusCommand)
+
+ <-setStatusCommand.Response
+
+ time.Sleep(50 * time.Millisecond)
+}
+
+func TestNodeRemoval(t *testing.T) {
+ broker := NewTestBroker()
+ node := apiconfig.InferenceNodeConfig{
+ Host: "localhost",
+ InferencePort: 8080,
+ PoCPort: 5000,
+ Models: map[string]apiconfig.ModelConfig{"model1": {Args: make([]string, 0)}},
+ Id: "node1",
+ MaxConcurrent: 1,
+ }
+
+ registerNodeAndSetInferenceStatus(t, broker, node)
+
+ availableNode := make(chan *Node, 2)
+ queueMessage(t, broker, LockAvailableNode{Model: "model1", Response: availableNode})
+ runningNode := <-availableNode
+ if runningNode == nil {
+ t.Fatalf("expected node1, got nil")
+ }
+ if runningNode.Id != node.Id {
+ t.Fatalf("expected node1, got: " + runningNode.Id)
+ }
+ release := make(chan bool, 2)
+ queueMessage(t, broker, RemoveNode{node.Id, release})
+ if !<-release {
+ t.Fatalf("expected true, got false")
+ }
+ queueMessage(t, broker, LockAvailableNode{Model: "model1", Response: availableNode})
+ if <-availableNode != nil {
+ t.Fatalf("expected nil, got node")
+ }
+}
+
+func TestModelMismatch(t *testing.T) {
+ broker := NewTestBroker()
+ node := apiconfig.InferenceNodeConfig{
+ Host: "localhost",
+ InferencePort: 8080,
+ PoCPort: 5000,
+ Models: map[string]apiconfig.ModelConfig{"model1": {Args: make([]string, 0)}},
+ Id: "node1",
+ MaxConcurrent: 1,
+ }
+
+ registerNodeAndSetInferenceStatus(t, broker, node)
+
+ availableNode := make(chan *Node, 2)
+ queueMessage(t, broker, LockAvailableNode{Model: "model2", Response: availableNode})
+ if <-availableNode != nil {
+ t.Fatalf("expected nil, got node1")
+ }
+}
+
+func TestHighConcurrency(t *testing.T) {
+ broker := NewTestBroker()
+ node := apiconfig.InferenceNodeConfig{
+ Host: "localhost",
+ InferencePort: 8080,
+ PoCPort: 5000,
+ Models: map[string]apiconfig.ModelConfig{"model1": {Args: make([]string, 0)}},
+ Id: "node1",
+ MaxConcurrent: 100,
+ }
+
+ registerNodeAndSetInferenceStatus(t, broker, node)
+
+ availableNode := make(chan *Node, 2)
+ for i := 0; i < 100; i++ {
+ queueMessage(t, broker, LockAvailableNode{Model: "model1", Response: availableNode})
+ if <-availableNode == nil {
+ t.Fatalf("expected node1, got nil")
+ }
+ }
+}
+
+func TestMultipleNodes(t *testing.T) {
+ broker := NewTestBroker()
+ node1 := apiconfig.InferenceNodeConfig{
+ Host: "localhost",
+ InferencePort: 8080,
+ PoCPort: 5000,
+ Models: map[string]apiconfig.ModelConfig{"model1": {Args: make([]string, 0)}},
+ Id: "node1",
+ MaxConcurrent: 1,
+ }
+ node2 := apiconfig.InferenceNodeConfig{
+ Host: "localhost",
+ InferencePort: 8081,
+ PoCPort: 5001,
+ Models: map[string]apiconfig.ModelConfig{"model1": {Args: make([]string, 0)}},
+ Id: "node2",
+ MaxConcurrent: 1,
+ }
+ registerNodeAndSetInferenceStatus(t, broker, node1)
+ registerNodeAndSetInferenceStatus(t, broker, node2)
+
+ availableNode := make(chan *Node, 2)
+ queueMessage(t, broker, LockAvailableNode{Model: "model1", Response: availableNode})
+ firstNode := <-availableNode
+ if firstNode == nil {
+ t.Fatalf("expected node1 or node2, got nil")
+ }
+ println("First Node: " + firstNode.Id)
+ if firstNode.Id != node1.Id && firstNode.Id != node2.Id {
+ t.Fatalf("expected node1 or node2, got: " + firstNode.Id)
+ }
+ queueMessage(t, broker, LockAvailableNode{Model: "model1", Response: availableNode})
+ secondNode := <-availableNode
+ if secondNode == nil {
+ t.Fatalf("expected another node, got nil")
+ }
+ println("Second Node: " + secondNode.Id)
+ if secondNode.Id == firstNode.Id {
+ t.Fatalf("expected different node from 1, got: " + secondNode.Id)
+ }
+}
+
+func queueMessage(t *testing.T, broker *Broker, command Command) {
+ err := broker.QueueMessage(command)
+ if err != nil {
+ t.Fatalf("error sending message" + err.Error())
+ }
+}
+
+func TestReleaseNode(t *testing.T) {
+ broker := NewTestBroker()
+ node := apiconfig.InferenceNodeConfig{
+ Host: "localhost",
+ InferencePort: 8080,
+ PoCPort: 5000,
+ Models: map[string]apiconfig.ModelConfig{"model1": {Args: make([]string, 0)}},
+ Id: "node1",
+ MaxConcurrent: 1,
+ }
+ registerNodeAndSetInferenceStatus(t, broker, node)
+
+ availableNode := make(chan *Node, 2)
+ queueMessage(t, broker, LockAvailableNode{Model: "model1", Response: availableNode})
+ runningNode := <-availableNode
+ require.NotNil(t, runningNode)
+ require.Equal(t, node.Id, runningNode.Id)
+ release := make(chan bool, 2)
+ queueMessage(t, broker, ReleaseNode{node.Id, InferenceSuccess{}, release})
+
+ b := <-release
+ require.True(t, b, "expected release response to be true")
+ queueMessage(t, broker, LockAvailableNode{Model: "model1", Response: availableNode})
+ require.NotNil(t, <-availableNode, "expected node1, got nil")
+}
+
+func TestRoundTripSegment(t *testing.T) {
+ broker := NewTestBroker()
+ node := apiconfig.InferenceNodeConfig{
+ Host: "localhost",
+ InferenceSegment: "/is",
+ InferencePort: 8080,
+ PoCSegment: "/is",
+ PoCPort: 5000,
+ Models: map[string]apiconfig.ModelConfig{"model1": {Args: make([]string, 0)}},
+ Id: "node1",
+ MaxConcurrent: 1,
+ }
+ registerNodeAndSetInferenceStatus(t, broker, node)
+
+ availableNode := make(chan *Node, 2)
+ queueMessage(t, broker, LockAvailableNode{Model: "model1", Response: availableNode})
+ runningNode := <-availableNode
+ if runningNode == nil {
+ t.Fatalf("expected node1, got nil")
+ }
+ if runningNode.Id != node.Id {
+ t.Fatalf("expected node1, got: " + runningNode.Id)
+ }
+ if runningNode.InferenceSegment != node.InferenceSegment {
+ slog.Warn("Inference segment not matching", "expected", node, "got", runningNode)
+ t.Fatalf("expected inference segment /is, got: " + runningNode.InferenceSegment)
+ }
+}
+
+func TestCapacityCheck(t *testing.T) {
+ broker := NewTestBroker()
+ node := apiconfig.InferenceNodeConfig{
+ Host: "localhost",
+ InferencePort: 8080,
+ PoCPort: 5000,
+ Models: map[string]apiconfig.ModelConfig{"model1": {Args: make([]string, 0)}},
+ Id: "node1",
+ MaxConcurrent: 1,
+ }
+ if err := broker.QueueMessage(RegisterNode{node, make(chan NodeCommandResponse, 0)}); err == nil {
+ t.Fatalf("expected error, got nil")
+ }
+}
+
+func TestNodeShouldBeOperationalTest(t *testing.T) {
+ adminState := AdminState{
+ Enabled: true,
+ Epoch: 10,
+ }
+ require.False(t, ShouldBeOperational(adminState, 10, types.PoCGeneratePhase))
+ require.False(t, ShouldBeOperational(adminState, 10, types.PoCGenerateWindDownPhase))
+ require.False(t, ShouldBeOperational(adminState, 10, types.PoCValidatePhase))
+ require.False(t, ShouldBeOperational(adminState, 10, types.PoCValidateWindDownPhase))
+ require.True(t, ShouldBeOperational(adminState, 10, types.InferencePhase))
+
+ adminState = AdminState{
+ Enabled: false,
+ Epoch: 11,
+ }
+ require.True(t, ShouldBeOperational(adminState, 11, types.PoCGeneratePhase))
+ require.True(t, ShouldBeOperational(adminState, 11, types.PoCGenerateWindDownPhase))
+ require.True(t, ShouldBeOperational(adminState, 11, types.PoCValidatePhase))
+ require.True(t, ShouldBeOperational(adminState, 11, types.PoCValidateWindDownPhase))
+ require.True(t, ShouldBeOperational(adminState, 11, types.InferencePhase))
+
+ require.False(t, ShouldBeOperational(adminState, 12, types.PoCGeneratePhase))
+ require.False(t, ShouldBeOperational(adminState, 12, types.PoCGenerateWindDownPhase))
+ require.False(t, ShouldBeOperational(adminState, 12, types.PoCValidatePhase))
+ require.False(t, ShouldBeOperational(adminState, 12, types.PoCValidateWindDownPhase))
+ require.False(t, ShouldBeOperational(adminState, 12, types.InferencePhase))
+}
+
+func TestVersionedUrls(t *testing.T) {
+ node := Node{
+ Host: "example.com",
+ InferencePort: 8080,
+ InferenceSegment: "/api/v1",
+ PoCPort: 9090,
+ PoCSegment: "/api/v1",
+ }
+
+ // Test InferenceUrl without version (backward compatibility)
+ expectedInferenceUrl := "http://example.com:8080/api/v1"
+ actualInferenceUrl := node.InferenceUrl()
+ assert.Equal(t, expectedInferenceUrl, actualInferenceUrl)
+
+ // Test InferenceUrlWithVersion with empty version (should fall back to non-versioned)
+ actualInferenceUrlEmpty := node.InferenceUrlWithVersion("")
+ assert.Equal(t, expectedInferenceUrl, actualInferenceUrlEmpty)
+
+ // Test InferenceUrlWithVersion with version
+ expectedVersionedInferenceUrl := "http://example.com:8080/v3.0.8/api/v1"
+ actualVersionedInferenceUrl := node.InferenceUrlWithVersion("v3.0.8")
+ assert.Equal(t, expectedVersionedInferenceUrl, actualVersionedInferenceUrl)
+
+ // Test PoCUrl without version (backward compatibility)
+ expectedPocUrl := "http://example.com:9090/api/v1"
+ actualPocUrl := node.PoCUrl()
+ assert.Equal(t, expectedPocUrl, actualPocUrl)
+
+ // Test PoCUrlWithVersion with empty version (should fall back to non-versioned)
+ actualPocUrlEmpty := node.PoCUrlWithVersion("")
+ assert.Equal(t, expectedPocUrl, actualPocUrlEmpty)
+
+ // Test PoCUrlWithVersion with version
+ expectedVersionedPocUrl := "http://example.com:9090/v3.0.8/api/v1"
+ actualVersionedPocUrl := node.PoCUrlWithVersion("v3.0.8")
+ assert.Equal(t, expectedVersionedPocUrl, actualVersionedPocUrl)
+}
+
+func TestImmediateClientRefreshLogic(t *testing.T) {
+ // Test the immediate client refresh logic
+ broker := NewTestBroker()
+
+ // Test case 1: Should not refresh when lastUsedVersion is empty (first time)
+ assert.False(t, broker.configManager.ShouldRefreshClients(), "Should not refresh on first time")
+
+ // Test the RefreshAllClients functionality by registering a node
+ node := apiconfig.InferenceNodeConfig{
+ Host: "localhost",
+ InferencePort: 8080,
+ PoCPort: 5000,
+ Models: map[string]apiconfig.ModelConfig{"model1": {Args: make([]string, 0)}},
+ Id: "node1",
+ MaxConcurrent: 1,
+ }
+
+ registerNodeAndSetInferenceStatus(t, broker, node)
+
+ // Get the worker and mock client factory
+ worker, exists := broker.nodeWorkGroup.GetWorker("node1")
+ require.True(t, exists, "Worker should exist")
+
+ mockFactory := broker.mlNodeClientFactory.(*mlnodeclient.MockClientFactory)
+
+ // Get the client using the actual key that would be used
+ allClients := mockFactory.GetAllClients()
+ var mockClient *mlnodeclient.MockClient
+ for _, client := range allClients {
+ mockClient = client
+ break // Get the first (and likely only) client
+ }
+ require.NotNil(t, mockClient, "Mock client should exist")
+
+ initialStopCalled := mockClient.StopCalled
+
+ // Dynamic client creation means refresh is effectively a no-op for the HTTP client.
+ worker.RefreshClientImmediate("v3.0.8", "v3.1.0")
+ time.Sleep(10 * time.Millisecond)
+ assert.Equal(t, initialStopCalled, mockClient.StopCalled, "Stop should not be invoked when clients are created per request")
+
+ worker.RefreshClientImmediate("v3.1.0", "v3.2.0")
+ time.Sleep(10 * time.Millisecond)
+ assert.Equal(t, initialStopCalled, mockClient.StopCalled, "Stop should remain unchanged on repeated refreshes")
+}
+
+func TestUpdateNodeConfiguration(t *testing.T) {
+ broker := NewTestBroker()
+ node := apiconfig.InferenceNodeConfig{
+ Host: "localhost",
+ InferencePort: 8080,
+ PoCPort: 5000,
+ Models: map[string]apiconfig.ModelConfig{"model1": {Args: make([]string, 0)}},
+ Id: "node1",
+ MaxConcurrent: 1,
+ }
+
+ registerNodeAndSetInferenceStatus(t, broker, node)
+
+ // Capture initial node info
+ nodesBefore, err := broker.GetNodes()
+ require.NoError(t, err)
+ require.Equal(t, 1, len(nodesBefore))
+ before := nodesBefore[0]
+ require.Equal(t, types.HardwareNodeStatus_INFERENCE, before.State.CurrentStatus)
+ beforeNodeNum := before.Node.NodeNum
+
+ // Get mock client and capture StopCalled baseline
+ mockFactory := broker.mlNodeClientFactory.(*mlnodeclient.MockClientFactory)
+ var mockClient *mlnodeclient.MockClient
+ for _, c := range mockFactory.GetAllClients() {
+ mockClient = c
+ break
+ }
+ require.NotNil(t, mockClient, "Mock client should exist")
+
+ // Prepare an update: change host, ports, models, maxConcurrent, hardware
+ updated := apiconfig.InferenceNodeConfig{
+ Host: "127.0.0.1",
+ InferenceSegment: "/api",
+ InferencePort: 9090,
+ PoCSegment: "/api",
+ PoCPort: 5050,
+ Models: map[string]apiconfig.ModelConfig{"model1": {Args: []string{"--foo", "bar"}}},
+ Id: "node1",
+ MaxConcurrent: 3,
+ Hardware: []apiconfig.Hardware{{Type: "GPU", Count: 2}},
+ }
+
+ // Queue UpdateNode
+ command := NewUpdateNodeCommand(updated)
+ resp := command.Response
+ err = broker.QueueMessage(command)
+ require.NoError(t, err)
+ out := <-resp
+ require.NotNil(t, out)
+ require.NotNil(t, out.Node)
+ require.Nil(t, out.Error)
+
+ // Validate updated view
+ nodesAfter, err := broker.GetNodes()
+ require.NoError(t, err)
+ require.Equal(t, 1, len(nodesAfter))
+ after := nodesAfter[0]
+
+ assert.Equal(t, updated.Host, after.Node.Host)
+ assert.Equal(t, updated.InferenceSegment, after.Node.InferenceSegment)
+ assert.Equal(t, updated.InferencePort, after.Node.InferencePort)
+ assert.Equal(t, updated.PoCSegment, after.Node.PoCSegment)
+ assert.Equal(t, updated.PoCPort, after.Node.PoCPort)
+ assert.Equal(t, updated.MaxConcurrent, after.Node.MaxConcurrent)
+ assert.Equal(t, beforeNodeNum, after.Node.NodeNum, "NodeNum should be preserved")
+ assert.Equal(t, types.HardwareNodeStatus_INFERENCE, after.State.CurrentStatus, "Current status should remain unchanged")
+
+ // Validate models args updated
+ require.Contains(t, after.Node.Models, "model1")
+ assert.Equal(t, []string{"--foo", "bar"}, after.Node.Models["model1"].Args)
+}
+
+func TestValidateInferenceNode_FieldCorrectness(t *testing.T) {
+ broker := NewTestBroker()
+
+ tests := []struct {
+ name string
+ node apiconfig.InferenceNodeConfig
+ wantErr bool
+ errMsg string
+ }{
+ {
+ name: "valid node",
+ node: apiconfig.InferenceNodeConfig{
+ Id: "node1",
+ Host: "localhost",
+ InferencePort: 8080,
+ PoCPort: 5000,
+ InferenceSegment: "/api",
+ PoCSegment: "/api",
+ MaxConcurrent: 5,
+ Models: map[string]apiconfig.ModelConfig{"model1": {}},
+ },
+ wantErr: false,
+ },
+ {
+ name: "empty node id",
+ node: apiconfig.InferenceNodeConfig{
+ Id: "",
+ Host: "localhost",
+ InferencePort: 8080,
+ PoCPort: 5000,
+ InferenceSegment: "/api",
+ PoCSegment: "/api",
+ MaxConcurrent: 5,
+ Models: map[string]apiconfig.ModelConfig{"model1": {}},
+ },
+ wantErr: true,
+ errMsg: "node id is required",
+ },
+ {
+ name: "whitespace only node id",
+ node: apiconfig.InferenceNodeConfig{
+ Id: " ",
+ Host: "localhost",
+ InferencePort: 8080,
+ PoCPort: 5000,
+ InferenceSegment: "/api",
+ PoCSegment: "/api",
+ MaxConcurrent: 5,
+ Models: map[string]apiconfig.ModelConfig{"model1": {}},
+ },
+ wantErr: true,
+ errMsg: "node id is required",
+ },
+ {
+ name: "empty host",
+ node: apiconfig.InferenceNodeConfig{
+ Id: "node1",
+ Host: "",
+ InferencePort: 8080,
+ PoCPort: 5000,
+ InferenceSegment: "/api",
+ PoCSegment: "/api",
+ MaxConcurrent: 5,
+ Models: map[string]apiconfig.ModelConfig{"model1": {}},
+ },
+ wantErr: true,
+ errMsg: "host is required",
+ },
+ {
+ name: "inference port too low",
+ node: apiconfig.InferenceNodeConfig{
+ Id: "node1",
+ Host: "localhost",
+ InferencePort: 0,
+ PoCPort: 5000,
+ InferenceSegment: "/api",
+ PoCSegment: "/api",
+ MaxConcurrent: 5,
+ Models: map[string]apiconfig.ModelConfig{"model1": {}},
+ },
+ wantErr: true,
+ errMsg: "inference_port must be between 1 and 65535",
+ },
+ {
+ name: "inference port too high",
+ node: apiconfig.InferenceNodeConfig{
+ Id: "node1",
+ Host: "localhost",
+ InferencePort: 65536,
+ PoCPort: 5000,
+ InferenceSegment: "/api",
+ PoCSegment: "/api",
+ MaxConcurrent: 5,
+ Models: map[string]apiconfig.ModelConfig{"model1": {}},
+ },
+ wantErr: true,
+ errMsg: "inference_port must be between 1 and 65535",
+ },
+ {
+ name: "poc port too low",
+ node: apiconfig.InferenceNodeConfig{
+ Id: "node1",
+ Host: "localhost",
+ InferencePort: 8080,
+ PoCPort: 0,
+ InferenceSegment: "/api",
+ PoCSegment: "/api",
+ MaxConcurrent: 5,
+ Models: map[string]apiconfig.ModelConfig{"model1": {}},
+ },
+ wantErr: true,
+ errMsg: "poc_port must be between 1 and 65535",
+ },
+ {
+ name: "poc port too high",
+ node: apiconfig.InferenceNodeConfig{
+ Id: "node1",
+ Host: "localhost",
+ InferencePort: 8080,
+ PoCPort: 70000,
+ InferenceSegment: "/api",
+ PoCSegment: "/api",
+ MaxConcurrent: 5,
+ Models: map[string]apiconfig.ModelConfig{"model1": {}},
+ },
+ wantErr: true,
+ errMsg: "poc_port must be between 1 and 65535",
+ },
+ {
+ name: "max concurrent zero",
+ node: apiconfig.InferenceNodeConfig{
+ Id: "node1",
+ Host: "localhost",
+ InferencePort: 8080,
+ PoCPort: 5000,
+ InferenceSegment: "/api",
+ PoCSegment: "/api",
+ MaxConcurrent: 0,
+ Models: map[string]apiconfig.ModelConfig{"model1": {}},
+ },
+ wantErr: true,
+ errMsg: "max_concurrent must be greater than 0",
+ },
+ {
+ name: "max concurrent negative",
+ node: apiconfig.InferenceNodeConfig{
+ Id: "node1",
+ Host: "localhost",
+ InferencePort: 8080,
+ PoCPort: 5000,
+ InferenceSegment: "/api",
+ PoCSegment: "/api",
+ MaxConcurrent: -1,
+ Models: map[string]apiconfig.ModelConfig{"model1": {}},
+ },
+ wantErr: true,
+ errMsg: "max_concurrent must be greater than 0",
+ },
+ {
+ name: "no models",
+ node: apiconfig.InferenceNodeConfig{
+ Id: "node1",
+ Host: "localhost",
+ InferencePort: 8080,
+ PoCPort: 5000,
+ InferenceSegment: "/api",
+ PoCSegment: "/api",
+ MaxConcurrent: 5,
+ Models: map[string]apiconfig.ModelConfig{},
+ },
+ wantErr: true,
+ errMsg: "at least one model must be specified",
+ },
+ {
+ name: "nil models",
+ node: apiconfig.InferenceNodeConfig{
+ Id: "node1",
+ Host: "localhost",
+ InferencePort: 8080,
+ PoCPort: 5000,
+ InferenceSegment: "/api",
+ PoCSegment: "/api",
+ MaxConcurrent: 5,
+ Models: nil,
+ },
+ wantErr: true,
+ errMsg: "at least one model must be specified",
+ },
+ {
+ name: "empty segments are allowed",
+ node: apiconfig.InferenceNodeConfig{
+ Id: "node1",
+ Host: "localhost",
+ InferencePort: 8080,
+ PoCPort: 5000,
+ InferenceSegment: "",
+ PoCSegment: "",
+ MaxConcurrent: 5,
+ Models: map[string]apiconfig.ModelConfig{"model1": {}},
+ },
+ wantErr: false,
+ },
+ {
+ name: "valid port boundaries",
+ node: apiconfig.InferenceNodeConfig{
+ Id: "node1",
+ Host: "localhost",
+ InferencePort: 1,
+ PoCPort: 65535,
+ InferenceSegment: "/api",
+ PoCSegment: "/api",
+ MaxConcurrent: 1,
+ Models: map[string]apiconfig.ModelConfig{"model1": {}},
+ },
+ wantErr: false,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ err := broker.validateInferenceNode(tt.node, "")
+ if tt.wantErr {
+ require.Error(t, err)
+ if tt.errMsg != "" {
+ assert.Contains(t, err.Error(), tt.errMsg)
+ }
+ } else {
+ require.NoError(t, err)
+ }
+ })
+ }
+}
+
+func TestValidateInferenceNode_StandardConfigs(t *testing.T) {
+ broker := NewTestBroker()
+
+ nodes := []apiconfig.InferenceNodeConfig{
+ {
+ Id: "node1",
+ Host: "inference",
+ InferencePort: 5000,
+ PoCPort: 8080,
+ MaxConcurrent: 500,
+ Models: map[string]apiconfig.ModelConfig{
+ "Qwen/Qwen3-32B-FP8": {
+ Args: []string{},
+ },
+ },
+ },
+ {
+ Id: "node1",
+ Host: "inference",
+ InferencePort: 5000,
+ PoCPort: 5000,
+ MaxConcurrent: 500,
+ Models: map[string]apiconfig.ModelConfig{
+ "Qwen/Qwen3-32B-FP8": {
+ Args: []string{},
+ },
+ },
+ },
+ {
+ Id: "node1",
+ Host: "inference",
+ InferencePort: 5000,
+ PoCPort: 8080,
+ MaxConcurrent: 500,
+ Models: map[string]apiconfig.ModelConfig{
+ "Qwen/Qwen2.5-7B-Instruct": {
+ Args: []string{
+ "--quantization", "fp8",
+ "--gpu-memory-utilization", "0.9",
+ },
+ },
+ },
+ },
+ {
+ Id: "node1",
+ Host: "inference",
+ InferencePort: 5000,
+ PoCPort: 8080,
+ MaxConcurrent: 500,
+ Models: map[string]apiconfig.ModelConfig{
+ "Qwen/Qwen2.5-7B-Instruct": {
+ Args: []string{
+ "--quantization", "fp8",
+ "--tensor-parallel-size", "4",
+ "--pipeline-parallel-size", "2",
+ },
+ },
+ },
+ },
+ {
+ Id: "node1",
+ Host: "inference",
+ InferencePort: 5000,
+ PoCPort: 8080,
+ MaxConcurrent: 500,
+ Models: map[string]apiconfig.ModelConfig{
+ "Qwen/QwQ-32B": {
+ Args: []string{
+ "--quantization", "fp8",
+ "--kv-cache-dtype", "fp8",
+ },
+ },
+ },
+ },
+ {
+ Id: "node1",
+ Host: "inference",
+ InferencePort: 5000,
+ PoCPort: 8080,
+ MaxConcurrent: 500,
+ Models: map[string]apiconfig.ModelConfig{
+ "Qwen/QwQ-32B": {
+ Args: []string{
+ "--quantization", "fp8",
+ "--tensor-parallel-size", "4",
+ "--kv-cache-dtype", "fp8",
+ },
+ },
+ },
+ },
+ {
+ Id: "node1",
+ Host: "inference",
+ InferencePort: 5000,
+ PoCPort: 8080,
+ MaxConcurrent: 500,
+ Models: map[string]apiconfig.ModelConfig{
+ "Qwen/QwQ-32B": {
+ Args: []string{
+ "--quantization", "fp8",
+ "--tensor-parallel-size", "4",
+ "--pipeline-parallel-size", "2",
+ "--kv-cache-dtype", "fp8",
+ },
+ },
+ },
+ },
+ }
+
+ for i, node := range nodes {
+ t.Run(fmt.Sprintf("QwenConfig%d", i+1), func(t *testing.T) {
+ require.NoError(t, broker.validateInferenceNode(node, ""))
+ })
+ }
+}
+
+func TestValidateInferenceNode_HostPortUniqueness(t *testing.T) {
+ broker := NewTestBroker()
+
+ // Register first node
+ node1 := apiconfig.InferenceNodeConfig{
+ Id: "node1",
+ Host: "localhost",
+ InferencePort: 8080,
+ PoCPort: 5000,
+ InferenceSegment: "/api",
+ PoCSegment: "/api",
+ MaxConcurrent: 5,
+ Models: map[string]apiconfig.ModelConfig{"model1": {}},
+ }
+
+ cmd := NewRegisterNodeCommand(node1)
+ err := broker.QueueMessage(cmd)
+ require.NoError(t, err)
+ response := <-cmd.Response
+ require.NotNil(t, response)
+ require.Nil(t, response.Error)
+ require.NotNil(t, response.Node)
+
+ // Give broker time to process the registration
+ time.Sleep(50 * time.Millisecond)
+
+ tests := []struct {
+ name string
+ node apiconfig.InferenceNodeConfig
+ wantErr bool
+ errMsg string
+ }{
+ {
+ name: "duplicate inference host+port",
+ node: apiconfig.InferenceNodeConfig{
+ Id: "node2",
+ Host: "localhost",
+ InferencePort: 8080, // Same as node1
+ PoCPort: 6000, // Different PoC port
+ InferenceSegment: "/api",
+ PoCSegment: "/api",
+ MaxConcurrent: 5,
+ Models: map[string]apiconfig.ModelConfig{"model1": {}},
+ },
+ wantErr: true,
+ errMsg: "duplicate inference host+port combination",
+ },
+ {
+ name: "duplicate poc host+port",
+ node: apiconfig.InferenceNodeConfig{
+ Id: "node3",
+ Host: "localhost",
+ InferencePort: 8081, // Different inference port
+ PoCPort: 5000, // Same as node1
+ InferenceSegment: "/api",
+ PoCSegment: "/api",
+ MaxConcurrent: 5,
+ Models: map[string]apiconfig.ModelConfig{"model1": {}},
+ },
+ wantErr: true,
+ errMsg: "duplicate PoC host+port combination",
+ },
+ {
+ name: "different host, same ports - should be valid",
+ node: apiconfig.InferenceNodeConfig{
+ Id: "node4",
+ Host: "127.0.0.1", // Different host
+ InferencePort: 8080, // Same ports
+ PoCPort: 5000,
+ InferenceSegment: "/api",
+ PoCSegment: "/api",
+ MaxConcurrent: 5,
+ Models: map[string]apiconfig.ModelConfig{"model1": {}},
+ },
+ wantErr: false,
+ },
+ {
+ name: "same host, different ports - should be valid",
+ node: apiconfig.InferenceNodeConfig{
+ Id: "node5",
+ Host: "localhost",
+ InferencePort: 8081, // Different ports
+ PoCPort: 5001,
+ InferenceSegment: "/api",
+ PoCSegment: "/api",
+ MaxConcurrent: 5,
+ Models: map[string]apiconfig.ModelConfig{"model1": {}},
+ },
+ wantErr: false,
+ },
+ {
+ name: "both ports duplicate on same host",
+ node: apiconfig.InferenceNodeConfig{
+ Id: "node6",
+ Host: "localhost",
+ InferencePort: 8080, // Same as node1
+ PoCPort: 5000, // Same as node1
+ InferenceSegment: "/api",
+ PoCSegment: "/api",
+ MaxConcurrent: 5,
+ Models: map[string]apiconfig.ModelConfig{"model1": {}},
+ },
+ wantErr: true,
+ errMsg: "duplicate inference host+port combination", // Should catch inference port first
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ err := broker.validateInferenceNode(tt.node, "")
+ if tt.wantErr {
+ require.Error(t, err)
+ if tt.errMsg != "" {
+ assert.Contains(t, err.Error(), tt.errMsg)
+ }
+ } else {
+ require.NoError(t, err)
+ }
+ })
+ }
+}
+
+func TestValidateInferenceNode_UpdateExcludesSelf(t *testing.T) {
+ broker := NewTestBroker()
+
+ // Register first node
+ node1 := apiconfig.InferenceNodeConfig{
+ Id: "node1",
+ Host: "localhost",
+ InferencePort: 8080,
+ PoCPort: 5000,
+ InferenceSegment: "/api",
+ PoCSegment: "/api",
+ MaxConcurrent: 5,
+ Models: map[string]apiconfig.ModelConfig{"model1": {}},
+ }
+
+ cmd := NewRegisterNodeCommand(node1)
+ err := broker.QueueMessage(cmd)
+ require.NoError(t, err)
+ response1 := <-cmd.Response
+ require.NotNil(t, response1)
+ require.Nil(t, response1.Error)
+ require.NotNil(t, response1.Node)
+
+ // Give broker time to process the registration
+ time.Sleep(50 * time.Millisecond)
+
+ // Register second node with different ports
+ node2 := apiconfig.InferenceNodeConfig{
+ Id: "node2",
+ Host: "localhost",
+ InferencePort: 8081,
+ PoCPort: 5001,
+ InferenceSegment: "/api",
+ PoCSegment: "/api",
+ MaxConcurrent: 5,
+ Models: map[string]apiconfig.ModelConfig{"model1": {}},
+ }
+
+ cmd2 := NewRegisterNodeCommand(node2)
+ err = broker.QueueMessage(cmd2)
+ require.NoError(t, err)
+ response2 := <-cmd2.Response
+ require.NotNil(t, response2)
+ require.Nil(t, response2.Error)
+ require.NotNil(t, response2.Node)
+
+ // Give broker time to process the second registration
+ time.Sleep(50 * time.Millisecond)
+
+ // Update node1 to use node2's ports - should fail (duplicate)
+ updatedNode1 := apiconfig.InferenceNodeConfig{
+ Id: "node1",
+ Host: "localhost",
+ InferencePort: 8081, // node2's port
+ PoCPort: 5001, // node2's port
+ InferenceSegment: "/api",
+ PoCSegment: "/api",
+ MaxConcurrent: 5,
+ Models: map[string]apiconfig.ModelConfig{"model1": {}},
+ }
+
+ err = broker.validateInferenceNode(updatedNode1, "node1") // Exclude node1 from check
+ require.Error(t, err)
+ assert.Contains(t, err.Error(), "duplicate")
+
+ // Update node1 to use same ports as itself - should succeed (excluded from check)
+ samePortsNode1 := apiconfig.InferenceNodeConfig{
+ Id: "node1",
+ Host: "localhost",
+ InferencePort: 8080, // node1's original port
+ PoCPort: 5000, // node1's original port
+ InferenceSegment: "/api",
+ PoCSegment: "/api",
+ MaxConcurrent: 10, // Changed max concurrent
+ Models: map[string]apiconfig.ModelConfig{"model1": {}},
+ }
+
+ err = broker.validateInferenceNode(samePortsNode1, "node1") // Exclude node1 from check
+ require.NoError(t, err, "Should allow updating node to keep same ports when excluding self")
+}
+
+// registerTwoNodesOnSameHost is a helper function that registers 2 nodes with the same host but different ports
+// and asserts both are successfully registered. Returns the broker and both node configs.
+// If node1 or node2 are nil, default configurations will be used.
+func registerTwoNodesOnSameHost(t *testing.T, broker *Broker, node1 *apiconfig.InferenceNodeConfig, node2 *apiconfig.InferenceNodeConfig) (apiconfig.InferenceNodeConfig, apiconfig.InferenceNodeConfig) {
+ defaultNode1 := apiconfig.InferenceNodeConfig{
+ Id: "node1",
+ Host: "localhost",
+ InferencePort: 8080,
+ PoCPort: 5000,
+ MaxConcurrent: 5,
+ Models: map[string]apiconfig.ModelConfig{"model1": {}},
+ }
+
+ defaultNode2 := apiconfig.InferenceNodeConfig{
+ Id: "node2",
+ Host: "localhost",
+ InferencePort: 8081,
+ PoCPort: 5001,
+ MaxConcurrent: 5,
+ Models: map[string]apiconfig.ModelConfig{"model1": {}},
+ }
+
+ // Use provided nodes or defaults
+ if node1 == nil {
+ node1 = &defaultNode1
+ }
+ if node2 == nil {
+ node2 = &defaultNode2
+ }
+
+ node1Config := *node1
+ node2Config := *node2
+
+ // Register node1
+ cmd1 := NewRegisterNodeCommand(node1Config)
+ err := broker.QueueMessage(cmd1)
+ require.NoError(t, err)
+ response1 := <-cmd1.Response
+ require.NotNil(t, response1)
+ require.Nil(t, response1.Error, "node1 registration should succeed")
+ require.NotNil(t, response1.Node)
+ require.Equal(t, node1Config.Id, response1.Node.Id)
+
+ // Give broker time to process the registration
+ time.Sleep(50 * time.Millisecond)
+
+ // Register node2
+ cmd2 := NewRegisterNodeCommand(node2Config)
+ err = broker.QueueMessage(cmd2)
+ require.NoError(t, err)
+ response2 := <-cmd2.Response
+ require.NotNil(t, response2)
+ require.Nil(t, response2.Error, "node2 registration should succeed")
+ require.NotNil(t, response2.Node)
+ require.Equal(t, node2Config.Id, response2.Node.Id)
+
+ // Give broker time to process the second registration
+ time.Sleep(50 * time.Millisecond)
+
+ // Verify both nodes are registered
+ nodes, err := broker.GetNodes()
+ require.NoError(t, err)
+ require.Equal(t, 2, len(nodes), "Both nodes should be registered")
+
+ // Verify node IDs
+ nodeIds := make(map[string]bool)
+ for _, node := range nodes {
+ nodeIds[node.Node.Id] = true
+ }
+ require.True(t, nodeIds[node1Config.Id], "node1 should be registered")
+ require.True(t, nodeIds[node2Config.Id], "node2 should be registered")
+
+ return node1Config, node2Config
+}
+
+func TestRegisterTwoNodesOnSameHost(t *testing.T) {
+ broker := NewTestBroker()
+ node1, node2 := registerTwoNodesOnSameHost(t, broker, nil, nil)
+
+ // Additional verification: check ports are different
+ nodes, err := broker.GetNodes()
+ require.NoError(t, err)
+
+ var foundNode1, foundNode2 *NodeResponse
+ for i := range nodes {
+ if nodes[i].Node.Id == node1.Id {
+ foundNode1 = &nodes[i]
+ }
+ if nodes[i].Node.Id == node2.Id {
+ foundNode2 = &nodes[i]
+ }
+ }
+
+ require.NotNil(t, foundNode1, "node1 should be found")
+ require.NotNil(t, foundNode2, "node2 should be found")
+ require.Equal(t, node1.InferencePort, foundNode1.Node.InferencePort)
+ require.Equal(t, node1.PoCPort, foundNode1.Node.PoCPort)
+ require.Equal(t, node2.InferencePort, foundNode2.Node.InferencePort)
+ require.Equal(t, node2.PoCPort, foundNode2.Node.PoCPort)
+ require.NotEqual(t, foundNode1.Node.InferencePort, foundNode2.Node.InferencePort, "Inference ports should be different")
+ require.NotEqual(t, foundNode1.Node.PoCPort, foundNode2.Node.PoCPort, "PoC ports should be different")
+}
+
+func TestUpdateNodePortCollision(t *testing.T) {
+ broker := NewTestBroker()
+ node1, node2 := registerTwoNodesOnSameHost(t, broker, nil, nil)
+
+ // Try to update node2 to use node1's ports - should fail
+ updatedNode2 := apiconfig.InferenceNodeConfig{
+ Id: node2.Id,
+ Host: node2.Host,
+ InferencePort: node1.InferencePort, // Collision with node1
+ PoCPort: node1.PoCPort, // Collision with node1
+ MaxConcurrent: node2.MaxConcurrent,
+ Models: node2.Models,
+ }
+
+ cmd := NewUpdateNodeCommand(updatedNode2)
+ err := broker.QueueMessage(cmd)
+ require.NoError(t, err)
+ response := <-cmd.Response
+ require.NotNil(t, response)
+ require.NotNil(t, response.Error, "Update should fail due to port collision")
+ require.Contains(t, response.Error.Error(), "duplicate", "Error should mention duplicate ports")
+ require.Nil(t, response.Node, "Node should be nil on error")
+
+ // Verify node2's ports haven't changed
+ nodes, err := broker.GetNodes()
+ require.NoError(t, err)
+ var foundNode2 *NodeResponse
+ for i := range nodes {
+ if nodes[i].Node.Id == node2.Id {
+ foundNode2 = &nodes[i]
+ break
+ }
+ }
+ require.NotNil(t, foundNode2)
+ require.Equal(t, node2.InferencePort, foundNode2.Node.InferencePort, "node2 inference port should remain unchanged")
+ require.Equal(t, node2.PoCPort, foundNode2.Node.PoCPort, "node2 PoC port should remain unchanged")
+}
+
+func TestUpdateNodeNoCollision(t *testing.T) {
+ broker := NewTestBroker()
+ node1, node2 := registerTwoNodesOnSameHost(t, broker, nil, nil)
+
+ // Update node2 to use different ports that don't collide with node1
+ updatedNode2 := apiconfig.InferenceNodeConfig{
+ Id: node2.Id,
+ Host: node2.Host,
+ InferencePort: 8082, // Different from both node1 (8080) and original node2 (8081)
+ PoCPort: 5002, // Different from both node1 (5000) and original node2 (5001)
+ MaxConcurrent: node2.MaxConcurrent,
+ Models: node2.Models,
+ }
+
+ cmd := NewUpdateNodeCommand(updatedNode2)
+ err := broker.QueueMessage(cmd)
+ require.NoError(t, err)
+ response := <-cmd.Response
+ require.NotNil(t, response)
+ require.Nil(t, response.Error, "Update should succeed")
+ require.NotNil(t, response.Node)
+ require.Equal(t, node2.Id, response.Node.Id)
+
+ // Give broker time to process the update
+ time.Sleep(50 * time.Millisecond)
+
+ // Verify node2's ports have been updated
+ nodes, err := broker.GetNodes()
+ require.NoError(t, err)
+ var foundNode2 *NodeResponse
+ for i := range nodes {
+ if nodes[i].Node.Id == node2.Id {
+ foundNode2 = &nodes[i]
+ break
+ }
+ }
+ require.NotNil(t, foundNode2)
+ require.Equal(t, updatedNode2.InferencePort, foundNode2.Node.InferencePort, "node2 inference port should be updated")
+ require.Equal(t, updatedNode2.PoCPort, foundNode2.Node.PoCPort, "node2 PoC port should be updated")
+
+ // Verify node1's ports remain unchanged
+ var foundNode1 *NodeResponse
+ for i := range nodes {
+ if nodes[i].Node.Id == node1.Id {
+ foundNode1 = &nodes[i]
+ break
+ }
+ }
+ require.NotNil(t, foundNode1)
+ require.Equal(t, node1.InferencePort, foundNode1.Node.InferencePort, "node1 inference port should remain unchanged")
+ require.Equal(t, node1.PoCPort, foundNode1.Node.PoCPort, "node1 PoC port should remain unchanged")
+}
+
+func TestUpdateNodeSwapPorts(t *testing.T) {
+ broker := NewTestBroker()
+ node1, node2 := registerTwoNodesOnSameHost(t, broker, nil, nil)
+
+ // Swap PoC and inference ports of node2
+ // Original: InferencePort=8081, PoCPort=5001
+ // After swap: InferencePort=5001, PoCPort=8081
+ swappedNode2 := apiconfig.InferenceNodeConfig{
+ Id: node2.Id,
+ Host: node2.Host,
+ InferencePort: node2.PoCPort, // Swap: use old PoC port for inference
+ PoCPort: node2.InferencePort, // Swap: use old inference port for PoC
+ MaxConcurrent: node2.MaxConcurrent,
+ Models: node2.Models,
+ }
+
+ cmd := NewUpdateNodeCommand(swappedNode2)
+ err := broker.QueueMessage(cmd)
+ require.NoError(t, err)
+ response := <-cmd.Response
+ require.NotNil(t, response)
+ require.Nil(t, response.Error, "Update should succeed when swapping ports")
+ require.NotNil(t, response.Node)
+ require.Equal(t, node2.Id, response.Node.Id)
+
+ // Give broker time to process the update
+ time.Sleep(50 * time.Millisecond)
+
+ // Verify node2's ports have been swapped
+ nodes, err := broker.GetNodes()
+ require.NoError(t, err)
+ var foundNode2 *NodeResponse
+ for i := range nodes {
+ if nodes[i].Node.Id == node2.Id {
+ foundNode2 = &nodes[i]
+ break
+ }
+ }
+ require.NotNil(t, foundNode2)
+ require.Equal(t, swappedNode2.InferencePort, foundNode2.Node.InferencePort, "node2 inference port should be swapped")
+ require.Equal(t, swappedNode2.PoCPort, foundNode2.Node.PoCPort, "node2 PoC port should be swapped")
+ require.Equal(t, node2.PoCPort, foundNode2.Node.InferencePort, "Inference port should equal original PoC port")
+ require.Equal(t, node2.InferencePort, foundNode2.Node.PoCPort, "PoC port should equal original inference port")
+
+ // Verify no collision occurred - node1 should still have its original ports
+ var foundNode1 *NodeResponse
+ for i := range nodes {
+ if nodes[i].Node.Id == node1.Id {
+ foundNode1 = &nodes[i]
+ break
+ }
+ }
+ require.NotNil(t, foundNode1)
+ require.Equal(t, node1.InferencePort, foundNode1.Node.InferencePort, "node1 inference port should remain unchanged")
+ require.Equal(t, node1.PoCPort, foundNode1.Node.PoCPort, "node1 PoC port should remain unchanged")
+}
+
+func TestUpdateNodeHostCollisionWithPortChange(t *testing.T) {
+ broker := NewTestBroker()
+
+ // Setup: Two nodes with same ports but different hosts
+ node1 := &apiconfig.InferenceNodeConfig{
+ Id: "node1",
+ Host: "host1",
+ InferencePort: 8080,
+ PoCPort: 5000,
+ MaxConcurrent: 5,
+ Models: map[string]apiconfig.ModelConfig{"model1": {}},
+ }
+
+ node2 := &apiconfig.InferenceNodeConfig{
+ Id: "node2",
+ Host: "host2",
+ InferencePort: 8080, // Same ports as node1
+ PoCPort: 5000, // Same ports as node1
+ MaxConcurrent: 5,
+ Models: map[string]apiconfig.ModelConfig{"model1": {}},
+ }
+
+ // Register both nodes
+ registeredNode1, registeredNode2 := registerTwoNodesOnSameHost(t, broker, node1, node2)
+
+ // Verify initial state: same ports, different hosts
+ nodes, err := broker.GetNodes()
+ require.NoError(t, err)
+ var foundNode1, foundNode2 *NodeResponse
+ for i := range nodes {
+ if nodes[i].Node.Id == registeredNode1.Id {
+ foundNode1 = &nodes[i]
+ }
+ if nodes[i].Node.Id == registeredNode2.Id {
+ foundNode2 = &nodes[i]
+ }
+ }
+ require.NotNil(t, foundNode1)
+ require.NotNil(t, foundNode2)
+ require.Equal(t, registeredNode1.InferencePort, foundNode2.Node.InferencePort, "Initial ports should be the same")
+ require.Equal(t, registeredNode1.PoCPort, foundNode2.Node.PoCPort, "Initial PoC ports should be the same")
+ require.NotEqual(t, foundNode1.Node.Host, foundNode2.Node.Host, "Initial hosts should be different")
+
+ // Step 1: Try to update node2 to have the same host as node1 (causing collision) - should fail
+ updatedNode2SameHost := apiconfig.InferenceNodeConfig{
+ Id: registeredNode2.Id,
+ Host: registeredNode1.Host, // Same host as node1
+ InferencePort: registeredNode2.InferencePort, // Same ports (collision!)
+ PoCPort: registeredNode2.PoCPort, // Same ports (collision!)
+ MaxConcurrent: registeredNode2.MaxConcurrent,
+ Models: registeredNode2.Models,
+ }
+
+ cmd1 := NewUpdateNodeCommand(updatedNode2SameHost)
+ err = broker.QueueMessage(cmd1)
+ require.NoError(t, err)
+ response1 := <-cmd1.Response
+ require.NotNil(t, response1)
+ require.NotNil(t, response1.Error, "Update should fail due to port collision when host becomes the same")
+ require.Contains(t, response1.Error.Error(), "duplicate", "Error should mention duplicate ports")
+ require.Nil(t, response1.Node, "Node should be nil on error")
+
+ // Verify node2 hasn't changed
+ time.Sleep(50 * time.Millisecond)
+ nodes, err = broker.GetNodes()
+ require.NoError(t, err)
+ for i := range nodes {
+ if nodes[i].Node.Id == registeredNode2.Id {
+ foundNode2 = &nodes[i]
+ break
+ }
+ }
+ require.NotNil(t, foundNode2)
+ require.Equal(t, registeredNode2.Host, foundNode2.Node.Host, "node2 host should remain unchanged after failed update")
+ require.Equal(t, registeredNode2.InferencePort, foundNode2.Node.InferencePort, "node2 inference port should remain unchanged")
+ require.Equal(t, registeredNode2.PoCPort, foundNode2.Node.PoCPort, "node2 PoC port should remain unchanged")
+
+ // Step 2: Update node2 to have the same host as node1 but change ports to avoid collision - should succeed
+ updatedNode2DifferentPorts := apiconfig.InferenceNodeConfig{
+ Id: registeredNode2.Id,
+ Host: registeredNode1.Host, // Same host as node1
+ InferencePort: 8082, // Different port to avoid collision
+ PoCPort: 5002, // Different port to avoid collision
+ MaxConcurrent: registeredNode2.MaxConcurrent,
+ Models: registeredNode2.Models,
+ }
+
+ cmd2 := NewUpdateNodeCommand(updatedNode2DifferentPorts)
+ err = broker.QueueMessage(cmd2)
+ require.NoError(t, err)
+ response2 := <-cmd2.Response
+ require.NotNil(t, response2)
+ require.Nil(t, response2.Error, "Update should succeed when changing ports to avoid collision")
+ require.NotNil(t, response2.Node)
+ require.Equal(t, registeredNode2.Id, response2.Node.Id)
+
+ // Give broker time to process the update
+ time.Sleep(50 * time.Millisecond)
+
+ // Verify node2 has been updated successfully
+ nodes, err = broker.GetNodes()
+ require.NoError(t, err)
+ for i := range nodes {
+ if nodes[i].Node.Id == registeredNode2.Id {
+ foundNode2 = &nodes[i]
+ break
+ }
+ }
+ require.NotNil(t, foundNode2)
+ require.Equal(t, updatedNode2DifferentPorts.Host, foundNode2.Node.Host, "node2 host should be updated to match node1")
+ require.Equal(t, updatedNode2DifferentPorts.InferencePort, foundNode2.Node.InferencePort, "node2 inference port should be updated")
+ require.Equal(t, updatedNode2DifferentPorts.PoCPort, foundNode2.Node.PoCPort, "node2 PoC port should be updated")
+
+ // Verify node1 remains unchanged
+ for i := range nodes {
+ if nodes[i].Node.Id == registeredNode1.Id {
+ foundNode1 = &nodes[i]
+ break
+ }
+ }
+ require.NotNil(t, foundNode1)
+ require.Equal(t, registeredNode1.Host, foundNode1.Node.Host, "node1 host should remain unchanged")
+ require.Equal(t, registeredNode1.InferencePort, foundNode1.Node.InferencePort, "node1 inference port should remain unchanged")
+ require.Equal(t, registeredNode1.PoCPort, foundNode1.Node.PoCPort, "node1 PoC port should remain unchanged")
+
+ // Verify both nodes now have the same host but different ports
+ require.Equal(t, foundNode1.Node.Host, foundNode2.Node.Host, "Both nodes should have the same host")
+ require.NotEqual(t, foundNode1.Node.InferencePort, foundNode2.Node.InferencePort, "Inference ports should be different")
+ require.NotEqual(t, foundNode1.Node.PoCPort, foundNode2.Node.PoCPort, "PoC ports should be different")
+}
diff --git a/decentralized-api/broker/commands.go b/decentralized-api/broker/commands.go
new file mode 100644
index 000000000..33e4ffed7
--- /dev/null
+++ b/decentralized-api/broker/commands.go
@@ -0,0 +1,272 @@
+package broker
+
+import (
+ "decentralized-api/apiconfig"
+ "decentralized-api/logging"
+
+ "github.com/productscience/inference/x/inference/types"
+)
+
+type Command interface {
+ GetResponseChannelCapacity() int
+}
+
+type LockAvailableNode struct {
+ Model string
+ Response chan *Node
+ SkipNodeIDs []string
+}
+
+func (g LockAvailableNode) GetResponseChannelCapacity() int {
+ return cap(g.Response)
+}
+
+type ReleaseNode struct {
+ NodeId string
+ Outcome InferenceResult
+ Response chan bool
+}
+
+func (r ReleaseNode) GetResponseChannelCapacity() int {
+ return cap(r.Response)
+}
+
+// GetNodesCommand retrieves all nodes from the broker and returns them as copies
+type GetNodesCommand struct {
+ Response chan []NodeResponse
+}
+
+func NewGetNodesCommand() GetNodesCommand {
+ return GetNodesCommand{
+ Response: make(chan []NodeResponse, 2),
+ }
+}
+
+func (c GetNodesCommand) GetResponseChannelCapacity() int {
+ return cap(c.Response)
+}
+
+func (c GetNodesCommand) Execute(b *Broker) {
+ b.mu.RLock()
+ defer b.mu.RUnlock()
+
+ nodeResponses := make([]NodeResponse, 0, len(b.nodes))
+ for _, nodeWithState := range b.nodes {
+ // --- Deep copy Node ---
+ nodeCopy := nodeWithState.Node // Start with a shallow copy
+
+ // Deep copy Models map
+ if nodeWithState.Node.Models != nil {
+ nodeCopy.Models = make(map[string]ModelArgs, len(nodeWithState.Node.Models))
+ for model, modelArgs := range nodeWithState.Node.Models {
+ newArgs := make([]string, len(modelArgs.Args))
+ copy(newArgs, modelArgs.Args)
+ nodeCopy.Models[model] = ModelArgs{Args: newArgs}
+ }
+ }
+
+ // Deep copy Hardware slice
+ if nodeWithState.Node.Hardware != nil {
+ nodeCopy.Hardware = make([]apiconfig.Hardware, len(nodeWithState.Node.Hardware))
+ copy(nodeCopy.Hardware, nodeWithState.Node.Hardware)
+ }
+
+ // --- Deep copy NodeState ---
+ stateCopy := nodeWithState.State // Start with a shallow copy
+
+ // Nil out internal-only fields
+ stateCopy.cancelInFlightTask = nil
+
+ // Deep copy pointer fields
+ if nodeWithState.State.ReconcileInfo != nil {
+ reconcileInfoCopy := *nodeWithState.State.ReconcileInfo
+ stateCopy.ReconcileInfo = &reconcileInfoCopy
+ }
+
+ if nodeWithState.State.TrainingTask != nil {
+ trainingTaskCopy := *nodeWithState.State.TrainingTask // shallow copy of struct
+
+ if nodeWithState.State.TrainingTask.NodeRanks != nil {
+ trainingTaskCopy.NodeRanks = make(map[string]int, len(nodeWithState.State.TrainingTask.NodeRanks))
+ for k, v := range nodeWithState.State.TrainingTask.NodeRanks {
+ trainingTaskCopy.NodeRanks[k] = v
+ }
+ }
+ stateCopy.TrainingTask = &trainingTaskCopy
+ }
+
+ nodeResponses = append(nodeResponses, NodeResponse{
+ Node: nodeCopy,
+ State: stateCopy,
+ })
+ }
+ logging.Debug("Got nodes", types.Nodes, "size", len(nodeResponses))
+ c.Response <- nodeResponses
+}
+
+type InferenceResult interface {
+ IsSuccess() bool
+ GetMessage() string
+}
+
+type InferenceSuccess struct {
+}
+
+type InferenceError struct {
+ Message string
+}
+
+func (i InferenceSuccess) IsSuccess() bool {
+ return true
+}
+
+func (i InferenceSuccess) GetMessage() string {
+ return "Success"
+}
+
+func (i InferenceError) IsSuccess() bool {
+ return false
+}
+
+func (i InferenceError) GetMessage() string {
+ return i.Message
+}
+
+type SyncNodesCommand struct {
+ Response chan bool
+}
+
+func NewSyncNodesCommand() SyncNodesCommand {
+ return SyncNodesCommand{
+ Response: make(chan bool, 2),
+ }
+}
+
+func (s SyncNodesCommand) GetResponseChannelCapacity() int {
+ return cap(s.Response)
+}
+
+type LockNodesForTrainingCommand struct {
+ NodeIds []string
+ // FIXME: maybe add description which exact nodes were busy?
+ Response chan bool
+}
+
+func NewLockNodesForTrainingCommand(nodeIds []string) LockNodesForTrainingCommand {
+ return LockNodesForTrainingCommand{
+ NodeIds: nodeIds,
+ Response: make(chan bool, 2),
+ }
+}
+
+func (c LockNodesForTrainingCommand) GetResponseChannelCapacity() int {
+ return cap(c.Response)
+}
+
+type PocStatus string
+
+const (
+ PocStatusIdle PocStatus = "IDLE"
+ PocStatusGenerating PocStatus = "GENERATING"
+ PocStatusValidating PocStatus = "VALIDATING"
+)
+
+type NodeResult struct {
+ Succeeded bool
+ FinalStatus types.HardwareNodeStatus // The status the node ended up in
+ OriginalTarget types.HardwareNodeStatus // The status it was trying to achieve
+ FinalPocStatus PocStatus
+ OriginalPocTarget PocStatus
+ Error string
+}
+
+type UpdateNodeResultCommand struct {
+ NodeId string
+ Result NodeResult
+ Response chan bool
+}
+
+func NewUpdateNodeResultCommand(nodeId string, result NodeResult) UpdateNodeResultCommand {
+ return UpdateNodeResultCommand{
+ NodeId: nodeId,
+ Result: result,
+ Response: make(chan bool, 2),
+ }
+}
+
+func (c UpdateNodeResultCommand) GetResponseChannelCapacity() int {
+ return cap(c.Response)
+}
+
+func (c UpdateNodeResultCommand) Execute(b *Broker) {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+
+ node, exists := b.nodes[c.NodeId]
+ if !exists {
+ logging.Warn("Received result for unknown node", types.Nodes, "node_id", c.NodeId)
+ c.Response <- false
+ return
+ }
+
+ // For logging and debugging purposes
+ var blockHeight int64
+ epochState := b.phaseTracker.GetCurrentEpochState()
+ if epochState != nil {
+ blockHeight = epochState.CurrentBlock.Height
+ } else {
+ logging.Warn("UpdateNodeResultCommand: epochState is nil!", types.Nodes, "node_id", c.NodeId)
+ }
+
+ // Critical safety check
+ if node.State.ReconcileInfo == nil {
+ logging.Info("Ignoring stale result for node. node.State.ReconcileInfo is already nil", types.Nodes,
+ "node_id", c.NodeId,
+ "original_target", c.Result.OriginalTarget,
+ "original_poc_target", c.Result.OriginalPocTarget,
+ "blockHeight", blockHeight)
+ c.Response <- false
+ return
+ }
+
+ if node.State.ReconcileInfo.Status != c.Result.OriginalTarget ||
+ (node.State.ReconcileInfo.Status == types.HardwareNodeStatus_POC && node.State.ReconcileInfo.PocStatus != c.Result.OriginalPocTarget) {
+ logging.Info("Ignoring stale result for node", types.Nodes,
+ "node_id", c.NodeId,
+ "original_target", c.Result.OriginalTarget,
+ "original_poc_target", c.Result.OriginalPocTarget,
+ "current_reconciling_target", node.State.ReconcileInfo.Status,
+ "current_reconciling_poc_target", node.State.ReconcileInfo.PocStatus,
+ "blockHeight", blockHeight)
+ c.Response <- false
+ return
+ }
+
+ // Update state
+ logging.Info("Finalizing state transition for node", types.Nodes,
+ "node_id", c.NodeId,
+ "from_status", node.State.CurrentStatus,
+ "to_status", c.Result.FinalStatus,
+ "from_poc_status", node.State.PocCurrentStatus,
+ "to_poc_status", c.Result.FinalPocStatus,
+ "succeeded", c.Result.Succeeded,
+ "blockHeight", blockHeight)
+
+ node.State.UpdateStatusWithPocStatusNow(c.Result.FinalStatus, c.Result.FinalPocStatus)
+ node.State.ReconcileInfo = nil
+ node.State.cancelInFlightTask = nil
+ if !c.Result.Succeeded {
+ node.State.FailureReason = c.Result.Error
+ } else {
+ // Clear failure reason on success
+ node.State.FailureReason = ""
+ }
+
+ // Reset POC fields when moving away from POC status
+ if c.Result.FinalStatus != types.HardwareNodeStatus_POC {
+ node.State.PocIntendedStatus = PocStatusIdle
+ node.State.PocCurrentStatus = PocStatusIdle
+ }
+
+ c.Response <- true
+}
diff --git a/decentralized-api/broker/lock_helpers.go b/decentralized-api/broker/lock_helpers.go
new file mode 100644
index 000000000..eca4c741f
--- /dev/null
+++ b/decentralized-api/broker/lock_helpers.go
@@ -0,0 +1,261 @@
+package broker
+
+import (
+ "decentralized-api/logging"
+ "errors"
+ "fmt"
+ "net/http"
+
+ "github.com/productscience/inference/x/inference/types"
+)
+
+// ActionErrorKind classifies action failures taken under a node lock
+type ActionErrorKind int
+
+const (
+ // ActionErrorTransport indicates a transport-level failure (e.g. POST could not connect/timeout)
+ ActionErrorTransport ActionErrorKind = iota
+ // ActionErrorApplication indicates an application-level failure that should not be retried by default
+ ActionErrorApplication
+)
+
+func (k ActionErrorKind) String() string {
+ switch k {
+ case ActionErrorTransport:
+ return "transport"
+ case ActionErrorApplication:
+ return "application"
+ default:
+ return "unknown"
+ }
+}
+
+// ActionError wraps an underlying error with a classification
+type ActionError struct {
+ Kind ActionErrorKind
+ Err error
+}
+
+func (e *ActionError) Error() string {
+ if e == nil {
+ return ""
+ }
+ return e.Err.Error()
+}
+
+func (e *ActionError) Unwrap() error { return e.Err }
+
+func NewTransportActionError(err error) *ActionError {
+ if err == nil {
+ err = errors.New("transport error")
+ }
+ return &ActionError{Kind: ActionErrorTransport, Err: err}
+}
+
+func NewApplicationActionError(err error) *ActionError {
+ if err == nil {
+ err = errors.New("application error")
+ }
+ return &ActionError{Kind: ActionErrorApplication, Err: err}
+}
+
+// DoWithLockedNodeHTTPRetry is a convenience helper for HTTP calls under a node lock.
+// It centralizes retry and status re-check logic:
+// - Transport errors (no HTTP response) trigger status re-check, node skip and retry.
+// - HTTP 5xx responses trigger status re-check, node skip and retry.
+// - HTTP 4xx responses are returned as-is without retry.
+// - 2xx responses are returned.
+func DoWithLockedNodeHTTPRetry(
+ b *Broker,
+ model string,
+ skipNodeIDs []string,
+ maxAttempts int,
+ doPost func(node *Node) (*http.Response, *ActionError),
+) (*http.Response, error) {
+ var zero *http.Response
+ if maxAttempts <= 0 {
+ maxAttempts = 1
+ }
+
+ skip := make(map[string]struct{}, len(skipNodeIDs))
+ orderedSkip := make([]string, 0, len(skipNodeIDs))
+ for _, id := range skipNodeIDs {
+ if id != "" {
+ if _, seen := skip[id]; !seen {
+ skip[id] = struct{}{}
+ orderedSkip = append(orderedSkip, id)
+ }
+ }
+ }
+
+ var lastErr error
+ attempts := 0
+
+ logging.Info("HTTP retry helper: starting inference request", types.Inferences,
+ "model", model,
+ "max_attempts", maxAttempts,
+ "initial_skip_count", len(orderedSkip))
+
+ for attempts < maxAttempts {
+ attempts++
+
+ nodeChan := make(chan *Node, 2)
+ if err := b.QueueMessage(LockAvailableNode{Model: model, Response: nodeChan, SkipNodeIDs: orderedSkip}); err != nil {
+ logging.Info("HTTP retry helper: failed to queue LockAvailableNode", types.Inferences,
+ "attempt", attempts,
+ "error", err)
+ return zero, err
+ }
+ node := <-nodeChan
+ if node == nil {
+ if lastErr != nil {
+ logging.Info("HTTP retry helper: no node available, returning last error", types.Inferences,
+ "attempt", attempts,
+ "error", lastErr)
+ return zero, lastErr
+ }
+ logging.Info("HTTP retry helper: no nodes available", types.Inferences,
+ "attempt", attempts)
+ return zero, ErrNoNodesAvailable
+ }
+
+ logging.Info("HTTP retry helper: acquired node lock", types.Inferences,
+ "attempt", attempts,
+ "node_id", node.Id)
+
+ resp, aerr := doPost(node)
+
+ // Decide outcome and retry policy
+ retry := false
+ triggerRecheck := false
+
+ if aerr != nil {
+ if aerr.Kind == ActionErrorTransport {
+ // Transport error: retry and recheck
+ retry = true
+ triggerRecheck = true
+ lastErr = fmt.Errorf("node %s transport failure: %w", node.Id, aerr)
+ logging.Info("HTTP retry helper: transport error from node", types.Inferences,
+ "attempt", attempts,
+ "node_id", node.Id,
+ "error_kind", aerr.Kind.String(),
+ "retry", retry,
+ "recheck", triggerRecheck,
+ "error", aerr.Err)
+ } else {
+ // Application error: do not retry
+ retry = false
+ triggerRecheck = false
+ lastErr = aerr
+ logging.Info("HTTP retry helper: application error from node (no retry)", types.Inferences,
+ "attempt", attempts,
+ "node_id", node.Id,
+ "error_kind", aerr.Kind.String(),
+ "retry", retry,
+ "recheck", triggerRecheck,
+ "error", aerr.Err)
+ }
+ } else if resp != nil {
+ if resp.StatusCode >= 500 {
+ // Server error: retry and recheck
+ retry = true
+ triggerRecheck = true
+ lastErr = fmt.Errorf("node %s server error: status=%d", node.Id, resp.StatusCode)
+ logging.Info("HTTP retry helper: received 5xx from node", types.Inferences,
+ "attempt", attempts,
+ "node_id", node.Id,
+ "http_status", resp.StatusCode,
+ "retry", retry,
+ "recheck", triggerRecheck)
+ } else if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+ // 4xx or other non-success (non-retryable)
+ retry = false
+ triggerRecheck = false
+ logging.Info("HTTP retry helper: received non-success non-retryable status from node", types.Inferences,
+ "attempt", attempts,
+ "node_id", node.Id,
+ "http_status", resp.StatusCode,
+ "retry", retry,
+ "recheck", triggerRecheck)
+ } else {
+ // Success path
+ logging.Info("HTTP retry helper: received success from node", types.Inferences,
+ "attempt", attempts,
+ "node_id", node.Id,
+ "http_status", resp.StatusCode)
+ }
+ } else {
+ logging.Info("HTTP retry helper: no response and no error from node", types.Inferences,
+ "attempt", attempts,
+ "node_id", node.Id,
+ "retry", retry,
+ "recheck", triggerRecheck)
+ }
+
+ // Release lock with outcome immediately
+ var outcome InferenceResult
+ if aerr == nil && resp != nil && resp.StatusCode >= 200 && resp.StatusCode < 300 {
+ outcome = InferenceSuccess{}
+ } else {
+ // Compose a concise message
+ msg := ""
+ if aerr != nil {
+ msg = aerr.Error()
+ } else if resp != nil {
+ msg = fmt.Sprintf("http status %d", resp.StatusCode)
+ } else {
+ msg = "unknown error"
+ }
+ outcome = InferenceError{Message: msg}
+ }
+ _ = b.QueueMessage(ReleaseNode{NodeId: node.Id, Outcome: outcome, Response: make(chan bool, 2)})
+
+ if retry {
+ if triggerRecheck {
+ b.TriggerStatusQuery(false)
+ }
+ if resp != nil && resp.Body != nil {
+ // Ensure we don't leak the body before retrying
+ _ = resp.Body.Close()
+ }
+ if _, seen := skip[node.Id]; !seen {
+ skip[node.Id] = struct{}{}
+ orderedSkip = append(orderedSkip, node.Id)
+ }
+ logging.Info("HTTP retry helper: retrying with next node", types.Inferences,
+ "attempt", attempts,
+ "node_id", node.Id,
+ "next_attempt", attempts+1,
+ "max_attempts", maxAttempts,
+ "skip_count", len(orderedSkip),
+ "recheck_triggered", triggerRecheck)
+ // Continue to next attempt
+ continue
+ }
+
+ // No retry: return
+ if aerr != nil {
+ logging.Info("HTTP retry helper: returning application error without retry", types.Inferences,
+ "attempt", attempts,
+ "node_id", node.Id,
+ "error_kind", aerr.Kind.String(),
+ "error", aerr.Err)
+ return zero, aerr
+ }
+ logging.Info("HTTP retry helper: returning response without retry", types.Inferences,
+ "attempt", attempts,
+ "node_id", node.Id,
+ "http_status", resp.StatusCode)
+ return resp, nil
+ }
+
+ if lastErr != nil {
+ logging.Info("HTTP retry helper: exhausted attempts, returning last error", types.Inferences,
+ "max_attempts", maxAttempts,
+ "error", lastErr)
+ return zero, lastErr
+ }
+ logging.Info("HTTP retry helper: exhausted attempts, no nodes available", types.Inferences,
+ "max_attempts", maxAttempts)
+ return zero, ErrNoNodesAvailable
+}
diff --git a/decentralized-api/broker/node_admin_commands.go b/decentralized-api/broker/node_admin_commands.go
new file mode 100644
index 000000000..ed80bfe83
--- /dev/null
+++ b/decentralized-api/broker/node_admin_commands.go
@@ -0,0 +1,362 @@
+package broker
+
+import (
+ "decentralized-api/apiconfig"
+ "decentralized-api/logging"
+ "fmt"
+ "strings"
+ "time"
+
+ "github.com/productscience/inference/x/inference/types"
+)
+
+// validateInferenceNode validates an InferenceNodeConfig and returns an error if invalid.
+// The error message describes what is wrong with the node configuration.
+// excludeNodeId is used when updating a node - it excludes that node from duplicate checks.
+// This method is exported so it can be called from admin handlers to provide clear error messages.
+func (b *Broker) validateInferenceNode(node apiconfig.InferenceNodeConfig, excludeNodeId string) error {
+ errors := apiconfig.ValidateInferenceNodeBasic(node)
+
+ // Check for duplicate host+port combinations
+ b.mu.RLock()
+ defer b.mu.RUnlock()
+
+ // Check inference port uniqueness
+ for id, existingNode := range b.nodes {
+ if excludeNodeId != "" && id == excludeNodeId {
+ continue
+ }
+ if existingNode.Node.Host == node.Host && existingNode.Node.InferencePort == node.InferencePort {
+ errors = append(errors, fmt.Sprintf("duplicate inference host+port combination: %s:%d (already used by node '%s')", node.Host, node.InferencePort, id))
+ break
+ }
+ }
+
+ // Check PoC port uniqueness
+ for id, existingNode := range b.nodes {
+ if excludeNodeId != "" && id == excludeNodeId {
+ continue
+ }
+ if existingNode.Node.Host == node.Host && existingNode.Node.PoCPort == node.PoCPort {
+ errors = append(errors, fmt.Sprintf("duplicate PoC host+port combination: %s:%d (already used by node '%s')", node.Host, node.PoCPort, id))
+ break
+ }
+ }
+
+ if len(errors) > 0 {
+ return fmt.Errorf("validation failed: %s", strings.Join(errors, "; "))
+ }
+
+ return nil
+}
+
+type RegisterNode struct {
+ Node apiconfig.InferenceNodeConfig
+ Response chan NodeCommandResponse
+}
+
+func NewRegisterNodeCommand(node apiconfig.InferenceNodeConfig) RegisterNode {
+ return RegisterNode{
+ Node: node,
+ Response: make(chan NodeCommandResponse, 2),
+ }
+}
+
+func (r RegisterNode) GetResponseChannelCapacity() int {
+ return cap(r.Response)
+}
+
+func (c RegisterNode) Execute(b *Broker) {
+ // Validate node configuration
+ if err := b.validateInferenceNode(c.Node, ""); err != nil {
+ logging.Error("RegisterNode. Node validation failed", types.Nodes, "node_id", c.Node.Id, "error", err)
+ c.Response <- NodeCommandResponse{Node: nil, Error: err}
+ return
+ }
+
+ govModels, err := b.chainBridge.GetGovernanceModels()
+ if err != nil {
+ logging.Error("RegisterNode. Failed to get governance models", types.Nodes, "error", err)
+ c.Response <- NodeCommandResponse{Node: nil, Error: err}
+ return
+ }
+
+ modelMap := make(map[string]struct{})
+ for _, model := range govModels.Model {
+ logging.Info("RegisterNode. Governance model", types.Nodes, "model_id", model.Id)
+ modelMap[model.Id] = struct{}{}
+ }
+
+ for modelId := range c.Node.Models {
+ if _, ok := modelMap[modelId]; !ok {
+ logging.Error("RegisterNode. Model is not a valid governance model", types.Nodes, "model_id", modelId)
+ c.Response <- NodeCommandResponse{Node: nil, Error: err}
+ return
+ }
+ }
+
+ b.curMaxNodesNum.Add(1)
+ curNum := b.curMaxNodesNum.Load()
+
+ models := make(map[string]ModelArgs)
+ for model, config := range c.Node.Models {
+ models[model] = ModelArgs{Args: config.Args}
+ }
+
+ node := Node{
+ Host: c.Node.Host,
+ InferenceSegment: c.Node.InferenceSegment,
+ InferencePort: c.Node.InferencePort,
+ PoCSegment: c.Node.PoCSegment,
+ PoCPort: c.Node.PoCPort,
+ Models: models,
+ Id: c.Node.Id,
+ MaxConcurrent: c.Node.MaxConcurrent,
+ NodeNum: curNum,
+ Hardware: c.Node.Hardware,
+ }
+
+ var currentEpoch uint64
+ if b.phaseTracker != nil {
+ epochState := b.phaseTracker.GetCurrentEpochState()
+ if epochState == nil {
+ currentEpoch = 0
+ } else {
+ currentEpoch = epochState.LatestEpoch.EpochIndex
+ }
+ }
+
+ nodeWithState := &NodeWithState{
+ Node: node,
+ State: NodeState{
+ IntendedStatus: types.HardwareNodeStatus_UNKNOWN,
+ CurrentStatus: types.HardwareNodeStatus_UNKNOWN,
+ ReconcileInfo: nil,
+ PocIntendedStatus: PocStatusIdle,
+ PocCurrentStatus: PocStatusIdle,
+ LockCount: 0,
+ FailureReason: "",
+ StatusTimestamp: time.Now(),
+ AdminState: AdminState{
+ Enabled: true,
+ Epoch: currentEpoch,
+ },
+ EpochModels: make(map[string]types.Model),
+ EpochMLNodes: make(map[string]types.MLNodeInfo),
+ },
+ }
+
+ func() {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+ b.nodes[c.Node.Id] = nodeWithState
+
+ // Create and register a worker for this node
+ worker := NewNodeWorker(c.Node.Id, nodeWithState, b)
+ b.nodeWorkGroup.AddWorker(c.Node.Id, worker)
+ }()
+
+ // Trigger a status check for the newly added node.
+ b.TriggerStatusQuery(true)
+
+ logging.Info("RegisterNode. Registered node", types.Nodes, "node", c.Node)
+ c.Response <- NodeCommandResponse{Node: &c.Node, Error: nil}
+}
+
+// UpdateNode updates an existing node's configuration while preserving runtime state
+type UpdateNode struct {
+ Node apiconfig.InferenceNodeConfig
+ Response chan NodeCommandResponse
+}
+
+type NodeCommandResponse struct {
+ Node *apiconfig.InferenceNodeConfig
+ Error error
+}
+
+func NewUpdateNodeCommand(node apiconfig.InferenceNodeConfig) UpdateNode {
+ return UpdateNode{
+ Node: node,
+ Response: make(chan NodeCommandResponse, 2),
+ }
+}
+
+func (u UpdateNode) GetResponseChannelCapacity() int {
+ return cap(u.Response)
+}
+
+func (c UpdateNode) Execute(b *Broker) {
+ // Fetch existing node first to check if it exists
+ b.mu.RLock()
+ existing, exists := b.nodes[c.Node.Id]
+ b.mu.RUnlock()
+
+ if !exists {
+ logging.Error("UpdateNode. Node not found", types.Nodes, "node_id", c.Node.Id)
+ c.Response <- NodeCommandResponse{Node: nil, Error: fmt.Errorf("node not found: %s", c.Node.Id)}
+ return
+ }
+
+ // Validate node configuration (exclude current node from duplicate checks)
+ if err := b.validateInferenceNode(c.Node, c.Node.Id); err != nil {
+ logging.Error("UpdateNode. Node validation failed", types.Nodes, "node_id", c.Node.Id, "error", err)
+ c.Response <- NodeCommandResponse{Node: nil, Error: err}
+ return
+ }
+
+ // Validate models exist in governance
+ govModels, err := b.chainBridge.GetGovernanceModels()
+ if err != nil {
+ logging.Error("UpdateNode. Failed to get governance models", types.Nodes, "error", err)
+ c.Response <- NodeCommandResponse{Node: nil, Error: err}
+ return
+ }
+
+ modelMap := make(map[string]struct{})
+ for _, model := range govModels.Model {
+ modelMap[model.Id] = struct{}{}
+ }
+
+ for modelId := range c.Node.Models {
+ if _, ok := modelMap[modelId]; !ok {
+ logging.Error("UpdateNode. Model is not a valid governance model", types.Nodes, "model_id", modelId)
+ c.Response <- NodeCommandResponse{Node: nil, Error: fmt.Errorf("model %s is not a valid governance model", modelId)}
+ return
+ }
+ }
+
+ // Apply update
+ b.mu.Lock()
+ defer b.mu.Unlock()
+
+ // Build updated Node struct, preserving node number
+ models := make(map[string]ModelArgs)
+ for model, config := range c.Node.Models {
+ models[model] = ModelArgs{Args: config.Args}
+ }
+
+ updated := Node{
+ Host: c.Node.Host,
+ InferenceSegment: c.Node.InferenceSegment,
+ InferencePort: c.Node.InferencePort,
+ PoCSegment: c.Node.PoCSegment,
+ PoCPort: c.Node.PoCPort,
+ Models: models,
+ Id: c.Node.Id,
+ MaxConcurrent: c.Node.MaxConcurrent,
+ NodeNum: existing.Node.NodeNum,
+ Hardware: c.Node.Hardware,
+ }
+
+ // Apply update
+ existing.Node = updated
+
+ // Optionally trigger a status re-check
+ b.TriggerStatusQuery(true)
+
+ logging.Info("UpdateNode. Updated node configuration", types.Nodes, "node_id", c.Node.Id)
+ c.Response <- NodeCommandResponse{Node: &c.Node, Error: nil}
+}
+
+type RemoveNode struct {
+ NodeId string
+ Response chan bool
+}
+
+func (r RemoveNode) GetResponseChannelCapacity() int {
+ return cap(r.Response)
+}
+
+func (command RemoveNode) Execute(b *Broker) {
+ // Remove the worker first (it will wait for pending jobs)
+ b.nodeWorkGroup.RemoveWorker(command.NodeId)
+
+ b.mu.Lock()
+ defer b.mu.Unlock()
+
+ if _, ok := b.nodes[command.NodeId]; !ok {
+ command.Response <- false
+ return
+ }
+ delete(b.nodes, command.NodeId)
+ logging.Debug("Removed node", types.Nodes, "node_id", command.NodeId)
+ command.Response <- true
+}
+
+// SetNodeAdminStateCommand enables or disables a node administratively
+type SetNodeAdminStateCommand struct {
+ NodeId string
+ Enabled bool
+ Response chan error
+}
+
+func (c SetNodeAdminStateCommand) GetResponseChannelCapacity() int {
+ return cap(c.Response)
+}
+
+func (c SetNodeAdminStateCommand) Execute(b *Broker) {
+ // Get current epoch
+ var currentEpoch uint64
+ if b.phaseTracker != nil {
+ epochState := b.phaseTracker.GetCurrentEpochState()
+ if epochState == nil {
+ currentEpoch = 0
+ } else {
+ currentEpoch = epochState.LatestEpoch.EpochIndex
+ }
+ }
+
+ err := c.modifyNodeAdminState(b, currentEpoch)
+ if err != nil {
+ logging.Error("Failed to set node admin state", types.Nodes, "node_id", c.NodeId, "error", err)
+ c.Response <- err
+ } else {
+ logging.Info("Updated node admin state", types.Nodes,
+ "node_id", c.NodeId,
+ "enabled", c.Enabled,
+ "epoch", currentEpoch)
+ c.Response <- nil
+ }
+}
+
+func (c SetNodeAdminStateCommand) modifyNodeAdminState(b *Broker, currentEpoch uint64) error {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+
+ node, exists := b.nodes[c.NodeId]
+ if !exists {
+ return fmt.Errorf("node not found: %s", c.NodeId)
+ }
+
+ // Update admin state
+ node.State.AdminState.Enabled = c.Enabled
+ node.State.AdminState.Epoch = currentEpoch
+
+ return nil
+}
+
+// UpdateNodeHardwareCommand updates the Hardware field for a specific node
+type UpdateNodeHardwareCommand struct {
+ NodeId string
+ Hardware []apiconfig.Hardware
+ Response chan error
+}
+
+func (c UpdateNodeHardwareCommand) GetResponseChannelCapacity() int {
+ return cap(c.Response)
+}
+
+func (c UpdateNodeHardwareCommand) Execute(b *Broker) {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+
+ node, exists := b.nodes[c.NodeId]
+ if !exists {
+ c.Response <- fmt.Errorf("node not found: %s", c.NodeId)
+ return
+ }
+
+ node.Node.Hardware = c.Hardware
+ logging.Info("Updated node hardware", types.Nodes, "node_id", c.NodeId, "hardware_count", len(c.Hardware))
+ c.Response <- nil
+}
diff --git a/decentralized-api/broker/node_worker.go b/decentralized-api/broker/node_worker.go
new file mode 100644
index 000000000..b57145fcf
--- /dev/null
+++ b/decentralized-api/broker/node_worker.go
@@ -0,0 +1,191 @@
+package broker
+
+import (
+ "context"
+ "decentralized-api/logging"
+ "decentralized-api/mlnodeclient"
+ "sync"
+
+ "github.com/productscience/inference/x/inference/types"
+)
+
+type commandWithContext struct {
+ cmd NodeWorkerCommand
+ ctx context.Context
+}
+
+// NodeWorker handles asynchronous operations for a specific node
+type NodeWorker struct {
+ nodeId string
+ node *NodeWithState
+ getClientFn func(*NodeWithState) mlnodeclient.MLNodeClient
+ broker *Broker
+ commands chan commandWithContext
+ shutdown chan struct{}
+ wg sync.WaitGroup
+ availableVersions map[string]bool
+ versionsMu sync.Mutex
+}
+
+// NewNodeWorker creates a worker that builds a new client for every operation using the latest node state.
+func NewNodeWorker(nodeId string, node *NodeWithState, broker *Broker) *NodeWorker {
+ return newNodeWorker(nodeId, node, broker, nil)
+}
+
+// NewNodeWorkerWithClient creates a new worker with a custom client provider (primarily for testing).
+func NewNodeWorkerWithClient(nodeId string, node *NodeWithState, client mlnodeclient.MLNodeClient, broker *Broker) *NodeWorker {
+ return newNodeWorker(nodeId, node, broker, func(*NodeWithState) mlnodeclient.MLNodeClient {
+ return client
+ })
+}
+
+func newNodeWorker(nodeId string, node *NodeWithState, broker *Broker, getClientFn func(*NodeWithState) mlnodeclient.MLNodeClient) *NodeWorker {
+ worker := &NodeWorker{
+ nodeId: nodeId,
+ node: node,
+ broker: broker,
+ commands: make(chan commandWithContext, 10),
+ availableVersions: make(map[string]bool),
+ shutdown: make(chan struct{}),
+ }
+ if getClientFn != nil {
+ worker.getClientFn = getClientFn
+ } else {
+ worker.getClientFn = func(nodeState *NodeWithState) mlnodeclient.MLNodeClient {
+ return broker.NewNodeClient(&nodeState.Node)
+ }
+ }
+ go worker.run()
+ return worker
+}
+
+// run is the main event loop for the worker
+func (w *NodeWorker) run() {
+ for {
+ select {
+ case item := <-w.commands:
+ result := item.cmd.Execute(item.ctx, w)
+
+ // Queue a command back to the broker to update the state
+ updateCmd := NewUpdateNodeResultCommand(w.nodeId, result)
+ if err := w.broker.QueueMessage(updateCmd); err != nil {
+ logging.Error("Failed to queue node result update command", types.Nodes,
+ "node_id", w.nodeId, "error", err)
+ }
+ // We don't wait for the response from updateCmd, the worker's job is done.
+ w.wg.Done()
+ case <-w.shutdown:
+ // Drain remaining commands before shutting down
+ close(w.commands)
+ for item := range w.commands {
+ result := item.cmd.Execute(item.ctx, w)
+ updateCmd := NewUpdateNodeResultCommand(w.nodeId, result)
+ if err := w.broker.QueueMessage(updateCmd); err != nil {
+ logging.Error("Failed to queue node result update command during shutdown", types.Nodes,
+ "node_id", w.nodeId, "error", err)
+ }
+ w.wg.Done()
+ }
+ return
+ }
+ }
+}
+
+// Submit queues a command for execution on this node
+func (w *NodeWorker) Submit(ctx context.Context, cmd NodeWorkerCommand) bool {
+ w.wg.Add(1)
+ select {
+ case w.commands <- commandWithContext{cmd: cmd, ctx: ctx}:
+ return true
+ default:
+ w.wg.Done()
+ return false
+ }
+}
+
+// Shutdown gracefully stops the worker
+func (w *NodeWorker) Shutdown() {
+ close(w.shutdown)
+ w.wg.Wait() // Wait for all pending commands to complete
+}
+
+func (w *NodeWorker) RefreshClientImmediate(oldVersion, newVersion string) {
+ logging.Info("Node worker uses dynamic MLNode clients per request; future calls will use latest version info", types.Nodes,
+ "node_id", w.nodeId, "oldVersion", oldVersion, "newVersion", newVersion)
+}
+
+// isVersionKnownAlive checks the cache to see if a version is already known to be alive.
+// It returns true if it's cached and alive, false otherwise.
+func (w *NodeWorker) isVersionKnownAlive(version string) bool {
+ w.versionsMu.Lock()
+ defer w.versionsMu.Unlock()
+ if alive, ok := w.availableVersions[version]; ok && alive {
+ return true
+ }
+ return false
+}
+
+func (w *NodeWorker) CheckClientVersionAlive(version string, factory mlnodeclient.ClientFactory) (bool, error) {
+ if w.isVersionKnownAlive(version) {
+ return true, nil
+ }
+
+ node := w.node.Node
+ pocUrl := node.PoCUrlWithVersion(version)
+ inferenceUrl := node.InferenceUrlWithVersion(version)
+
+ versionClient := factory.CreateClient(pocUrl, inferenceUrl)
+ _, err := versionClient.NodeState(context.Background())
+
+ w.versionsMu.Lock()
+ defer w.versionsMu.Unlock()
+ if err != nil {
+ w.availableVersions[version] = false
+ return false, err
+ }
+ w.availableVersions[version] = true
+ return true, nil
+}
+
+func (w *NodeWorker) GetClient() mlnodeclient.MLNodeClient {
+ return w.getClientFn(w.node)
+}
+
+// NodeWorkGroup manages parallel execution across multiple node workers
+type NodeWorkGroup struct {
+ workers map[string]*NodeWorker
+ mu sync.RWMutex
+}
+
+// NewNodeWorkGroup creates a new work group
+func NewNodeWorkGroup() *NodeWorkGroup {
+ return &NodeWorkGroup{
+ workers: make(map[string]*NodeWorker),
+ }
+}
+
+// AddWorker adds a new worker to the group
+func (g *NodeWorkGroup) AddWorker(nodeId string, worker *NodeWorker) {
+ g.mu.Lock()
+ defer g.mu.Unlock()
+ g.workers[nodeId] = worker
+}
+
+// RemoveWorker removes and shuts down a worker
+func (g *NodeWorkGroup) RemoveWorker(nodeId string) {
+ g.mu.Lock()
+ defer g.mu.Unlock()
+
+ if worker, exists := g.workers[nodeId]; exists {
+ worker.Shutdown()
+ delete(g.workers, nodeId)
+ }
+}
+
+// GetWorker returns a specific worker (useful for node-specific commands)
+func (g *NodeWorkGroup) GetWorker(nodeId string) (*NodeWorker, bool) {
+ g.mu.RLock()
+ defer g.mu.RUnlock()
+ worker, exists := g.workers[nodeId]
+ return worker, exists
+}
diff --git a/decentralized-api/broker/node_worker_commands.go b/decentralized-api/broker/node_worker_commands.go
new file mode 100644
index 000000000..76fe7a35a
--- /dev/null
+++ b/decentralized-api/broker/node_worker_commands.go
@@ -0,0 +1,356 @@
+package broker
+
+import (
+ "context"
+ "decentralized-api/logging"
+ "decentralized-api/mlnodeclient"
+ "errors"
+
+ "github.com/productscience/inference/x/inference/types"
+)
+
+// NodeWorkerCommand defines the interface for commands executed by NodeWorker
+type NodeWorkerCommand interface {
+ Execute(ctx context.Context, worker *NodeWorker) NodeResult
+}
+
+// StopNodeCommand stops the ML node
+type StopNodeCommand struct{}
+
+func (c StopNodeCommand) Execute(ctx context.Context, worker *NodeWorker) NodeResult {
+ result := NodeResult{
+ OriginalTarget: types.HardwareNodeStatus_STOPPED,
+ }
+
+ if ctx.Err() != nil {
+ result.Succeeded = false
+ result.Error = ctx.Err().Error()
+ result.FinalStatus = worker.node.State.CurrentStatus // Status is unchanged
+ result.FinalPocStatus = worker.node.State.PocCurrentStatus
+ return result
+ }
+
+ err := worker.GetClient().Stop(ctx)
+ if err != nil {
+ logging.Error("Failed to stop node", types.Nodes, "node_id", worker.nodeId, "error", err)
+ result.Succeeded = false
+ result.Error = err.Error()
+ result.FinalStatus = types.HardwareNodeStatus_FAILED
+ } else {
+ result.Succeeded = true
+ result.FinalStatus = types.HardwareNodeStatus_STOPPED
+ result.FinalPocStatus = PocStatusIdle
+ }
+ return result
+}
+
+// StartPoCNodeCommand starts PoC on a single node
+type StartPoCNodeCommand struct {
+ BlockHeight int64
+ BlockHash string
+ PubKey string
+ CallbackUrl string
+ TotalNodes int
+}
+
+func (c StartPoCNodeCommand) Execute(ctx context.Context, worker *NodeWorker) NodeResult {
+ result := NodeResult{
+ OriginalTarget: types.HardwareNodeStatus_POC,
+ OriginalPocTarget: PocStatusGenerating,
+ }
+
+ if ctx.Err() != nil {
+ result.Succeeded = false
+ result.Error = ctx.Err().Error()
+ result.FinalStatus = worker.node.State.CurrentStatus
+ result.FinalPocStatus = worker.node.State.PocCurrentStatus
+ return result
+ }
+
+ // Idempotency check
+ state, err := worker.GetClient().NodeState(ctx)
+ if err == nil && state.State == mlnodeclient.MlNodeState_POW {
+ powStatus, powErr := worker.GetClient().GetPowStatus(ctx)
+ if powErr == nil && powStatus.Status == mlnodeclient.POW_GENERATING {
+ logging.Info("[StartPoCNodeCommand] Node already in PoC generating state", types.PoC, "node_id", worker.nodeId)
+ result.Succeeded = true
+ result.FinalStatus = types.HardwareNodeStatus_POC
+ result.FinalPocStatus = PocStatusGenerating
+ return result
+ }
+ }
+
+ // Stop node if needed
+ if state != nil && state.State != mlnodeclient.MlNodeState_STOPPED {
+ if err := worker.GetClient().Stop(ctx); err != nil {
+ logging.Error("[StartPoCNodeCommand] Failed to stop node for PoC", types.PoC, "node_id", worker.nodeId, "error", err)
+ result.Succeeded = false
+ result.Error = err.Error()
+ result.FinalStatus = types.HardwareNodeStatus_FAILED
+ return result
+ }
+ }
+
+ // Start PoC
+ dto := mlnodeclient.BuildInitDto(
+ c.BlockHeight, c.PubKey, int64(c.TotalNodes),
+ worker.node.Node.NodeNum, c.BlockHash, c.CallbackUrl,
+ )
+ if err := worker.GetClient().InitGenerate(ctx, dto); err != nil {
+ logging.Error("[StartPoCNodeCommand] Failed to start PoC", types.PoC, "node_id", worker.nodeId, "error", err)
+ result.Succeeded = false
+ result.Error = err.Error()
+ result.FinalStatus = types.HardwareNodeStatus_FAILED
+ } else {
+ result.Succeeded = true
+ result.FinalStatus = types.HardwareNodeStatus_POC
+ result.FinalPocStatus = PocStatusGenerating
+ logging.Info("[StartPoCNodeCommand] Successfully started PoC on node", types.PoC, "node_id", worker.nodeId)
+ }
+ return result
+}
+
+type InitValidateNodeCommand struct {
+ BlockHeight int64
+ BlockHash string
+ PubKey string
+ CallbackUrl string
+ TotalNodes int
+}
+
+func (c InitValidateNodeCommand) Execute(ctx context.Context, worker *NodeWorker) NodeResult {
+ result := NodeResult{
+ OriginalTarget: types.HardwareNodeStatus_POC,
+ OriginalPocTarget: PocStatusValidating,
+ }
+
+ if ctx.Err() != nil {
+ result.Succeeded = false
+ result.Error = ctx.Err().Error()
+ result.FinalStatus = worker.node.State.CurrentStatus
+ result.FinalPocStatus = worker.node.State.PocCurrentStatus
+ return result
+ }
+
+ // Idempotency check
+ state, err := worker.GetClient().NodeState(ctx)
+ if err == nil && state.State == mlnodeclient.MlNodeState_POW {
+ powStatus, powErr := worker.GetClient().GetPowStatus(ctx)
+ if powErr == nil && powStatus.Status == mlnodeclient.POW_VALIDATING {
+ logging.Info("Node already in PoC validating state", types.PoC, "node_id", worker.nodeId)
+ result.Succeeded = true
+ result.FinalStatus = types.HardwareNodeStatus_POC
+ result.FinalPocStatus = PocStatusValidating
+ return result
+ }
+ }
+
+ // Stop node if needed
+ if state != nil && state.State != mlnodeclient.MlNodeState_STOPPED && state.State != mlnodeclient.MlNodeState_POW {
+ if err := worker.GetClient().Stop(ctx); err != nil {
+ logging.Error("Failed to stop node for PoC validation", types.PoC, "node_id", worker.nodeId, "error", err)
+ result.Succeeded = false
+ result.Error = err.Error()
+ result.FinalStatus = types.HardwareNodeStatus_FAILED
+ return result
+ }
+ }
+
+ dto := mlnodeclient.BuildInitDto(
+ c.BlockHeight, c.PubKey, int64(c.TotalNodes),
+ worker.node.Node.NodeNum, c.BlockHash, c.CallbackUrl,
+ )
+
+ if err := worker.GetClient().InitValidate(ctx, dto); err != nil {
+ logging.Error("Failed to transition to PoC validate", types.PoC, "node_id", worker.nodeId, "error", err)
+ result.Succeeded = false
+ result.Error = err.Error()
+ result.FinalStatus = types.HardwareNodeStatus_FAILED
+ } else {
+ result.Succeeded = true
+ result.FinalStatus = types.HardwareNodeStatus_POC
+ result.FinalPocStatus = PocStatusValidating
+ logging.Info("Successfully transitioned node to PoC init validate stage", types.PoC, "node_id", worker.nodeId)
+ }
+ return result
+}
+
+// InferenceUpNodeCommand brings up inference on a single node
+type InferenceUpNodeCommand struct{}
+
+func (c InferenceUpNodeCommand) Execute(ctx context.Context, worker *NodeWorker) NodeResult {
+ result := NodeResult{
+ OriginalTarget: types.HardwareNodeStatus_INFERENCE,
+ OriginalPocTarget: PocStatusIdle,
+ }
+ if ctx.Err() != nil {
+ result.Succeeded = false
+ result.Error = ctx.Err().Error()
+ result.FinalStatus = worker.node.State.CurrentStatus
+ result.FinalPocStatus = worker.node.State.PocCurrentStatus
+ return result
+ }
+
+ // Idempotency check
+ state, err := worker.GetClient().NodeState(ctx)
+ if err == nil && state.State == mlnodeclient.MlNodeState_INFERENCE {
+ if healthy, _ := worker.GetClient().InferenceHealth(ctx); healthy {
+ logging.Info("Node already in healthy inference state", types.Nodes, "node_id", worker.nodeId)
+ result.Succeeded = true
+ result.FinalStatus = types.HardwareNodeStatus_INFERENCE
+ result.FinalPocStatus = PocStatusIdle
+ return result
+ }
+ }
+
+ // Stop node first
+ if err := worker.GetClient().Stop(ctx); err != nil {
+ logging.Error("Failed to stop node for inference up", types.Nodes, "node_id", worker.nodeId, "error", err)
+ result.Succeeded = false
+ result.Error = err.Error()
+ result.FinalStatus = types.HardwareNodeStatus_FAILED
+ return result
+ }
+
+ var selectedModel *types.Model
+ if len(worker.node.State.EpochModels) == 0 {
+ govModels, err := worker.broker.chainBridge.GetGovernanceModels()
+ if err != nil {
+ result.Succeeded = false
+ result.Error = "Failed to get governance models: " + err.Error()
+ result.FinalStatus = types.HardwareNodeStatus_FAILED
+ logging.Error(result.Error, types.Nodes, "node_id", worker.nodeId)
+ return result
+ }
+
+ hasIntersection := false
+ for _, govModel := range govModels.Model {
+ if _, ok := worker.node.Node.Models[govModel.Id]; ok {
+ hasIntersection = true
+ selectedModel = &govModel
+ break
+ }
+ }
+
+ if !hasIntersection {
+ result.Succeeded = false
+ result.Error = "No epoch models available for this node"
+ result.FinalStatus = types.HardwareNodeStatus_FAILED
+ logging.Error(result.Error, types.Nodes, "node_id", worker.nodeId)
+ return result
+ }
+
+ logging.Info("No epoch models configured for this node, using a governance model from one the supported by the node", types.Nodes, "node_id", worker.nodeId, "selectedModel", selectedModel)
+ } else {
+ for _, m := range worker.node.State.EpochModels {
+ selectedModel = &m
+ break
+ }
+ }
+
+ if selectedModel == nil || selectedModel.Id == "" {
+ result.Succeeded = false
+ result.Error = "Could not select a model from epoch models"
+ result.FinalStatus = types.HardwareNodeStatus_FAILED
+ logging.Error(result.Error, types.Nodes, "node_id", worker.nodeId)
+ return result
+ }
+
+ logging.Info("Selected model for inference", types.Nodes, "node_id", worker.nodeId, "selectedModel", selectedModel)
+
+ // Merge epoch model args with local ones
+ var localArgs []string
+ if localModelConfig, ok := worker.node.Node.Models[selectedModel.Id]; ok {
+ localArgs = localModelConfig.Args
+ }
+ mergedArgs := worker.broker.MergeModelArgs(selectedModel.ModelArgs, localArgs)
+
+ if err := worker.GetClient().InferenceUp(ctx, selectedModel.Id, mergedArgs); err != nil {
+ logging.Error("Failed to bring up inference", types.Nodes, "node_id", worker.nodeId, "error", err)
+ result.Succeeded = false
+ result.Error = err.Error()
+ result.FinalStatus = types.HardwareNodeStatus_FAILED
+ } else {
+ result.Succeeded = true
+ result.FinalStatus = types.HardwareNodeStatus_INFERENCE
+ result.FinalPocStatus = PocStatusIdle
+ logging.Info("Successfully brought up inference on node", types.Nodes, "node_id", worker.nodeId)
+ }
+ return result
+}
+
+// StartTrainingNodeCommand starts training on a single node
+type StartTrainingNodeCommand struct {
+ TaskId uint64
+ Participant string
+ MasterNodeAddr string
+ NodeRanks map[string]int
+ WorldSize int
+}
+
+func (c StartTrainingNodeCommand) Execute(ctx context.Context, worker *NodeWorker) NodeResult {
+ result := NodeResult{
+ OriginalTarget: types.HardwareNodeStatus_TRAINING,
+ }
+
+ if ctx.Err() != nil {
+ result.Succeeded = false
+ result.Error = ctx.Err().Error()
+ result.FinalStatus = worker.node.State.CurrentStatus
+ result.FinalPocStatus = worker.node.State.PocCurrentStatus
+ return result
+ }
+
+ rank, ok := c.NodeRanks[worker.nodeId]
+ if !ok {
+ err := errors.New("rank not found for node")
+ logging.Error(err.Error(), types.Training, "node_id", worker.nodeId)
+ result.Succeeded = false
+ result.Error = err.Error()
+ result.FinalStatus = types.HardwareNodeStatus_FAILED
+ return result
+ }
+
+ // Stop node first
+ if err := worker.GetClient().Stop(ctx); err != nil {
+ logging.Error("Failed to stop node for training", types.Training, "node_id", worker.nodeId, "error", err)
+ result.Succeeded = false
+ result.Error = err.Error()
+ result.FinalStatus = types.HardwareNodeStatus_FAILED
+ return result
+ }
+
+ // Start training
+ trainingErr := worker.GetClient().StartTraining(
+ ctx, c.TaskId, c.Participant, worker.nodeId,
+ c.MasterNodeAddr, rank, c.WorldSize,
+ )
+ if trainingErr != nil {
+ logging.Error("Failed to start training", types.Training, "node_id", worker.nodeId, "error", trainingErr)
+ result.Succeeded = false
+ result.Error = trainingErr.Error()
+ result.FinalStatus = types.HardwareNodeStatus_FAILED
+ } else {
+ result.Succeeded = true
+ result.FinalStatus = types.HardwareNodeStatus_TRAINING
+ result.FinalPocStatus = PocStatusIdle
+ logging.Info("Successfully started training on node", types.Training, "node_id", worker.nodeId, "rank", rank, "task_id", c.TaskId)
+ }
+ return result
+}
+
+// NoOpNodeCommand is a command that does nothing (used as placeholder)
+type NoOpNodeCommand struct {
+ Message string
+}
+
+func (c *NoOpNodeCommand) Execute(ctx context.Context, worker *NodeWorker) NodeResult {
+ if c.Message != "" {
+ logging.Debug(c.Message, types.Nodes, "node_id", worker.nodeId)
+ }
+ return NodeResult{
+ Succeeded: true,
+ FinalStatus: worker.node.State.CurrentStatus,
+ OriginalTarget: worker.node.State.CurrentStatus,
+ }
+}
diff --git a/decentralized-api/broker/node_worker_test.go b/decentralized-api/broker/node_worker_test.go
new file mode 100644
index 000000000..830dbb2df
--- /dev/null
+++ b/decentralized-api/broker/node_worker_test.go
@@ -0,0 +1,354 @@
+package broker
+
+import (
+ "context"
+ "decentralized-api/mlnodeclient"
+ "errors"
+ "sync/atomic"
+ "testing"
+ "time"
+
+ "github.com/productscience/inference/x/inference/types"
+ "github.com/stretchr/testify/assert"
+)
+
+func createTestNode(id string) *NodeWithState {
+ return createTestNodeWithStatus(id, types.HardwareNodeStatus_UNKNOWN)
+}
+
+func createTestNodeWithStatus(id string, status types.HardwareNodeStatus) *NodeWithState {
+ return &NodeWithState{
+ Node: Node{
+ Id: id,
+ Host: "test-host",
+ InferencePort: 8080,
+ PoCPort: 8081,
+ InferenceSegment: "/inference",
+ PoCSegment: "/poc",
+ MaxConcurrent: 5,
+ NodeNum: 1,
+ },
+ State: NodeState{
+ CurrentStatus: status,
+ IntendedStatus: status,
+ AdminState: AdminState{
+ Enabled: true,
+ Epoch: 0,
+ },
+ EpochModels: make(map[string]types.Model),
+ EpochMLNodes: make(map[string]types.MLNodeInfo),
+ },
+ }
+}
+
+func NewTestBroker2(cap int) *Broker {
+ return &Broker{
+ highPriorityCommands: make(chan Command, cap),
+ lowPriorityCommands: make(chan Command, cap),
+ }
+}
+
+func TestNodeWorker_BasicOperation(t *testing.T) {
+ broker := NewTestBroker2(1)
+ node := createTestNode("test-node-1")
+ mockClient := mlnodeclient.NewMockClient()
+ worker := NewNodeWorkerWithClient("test-node-1", node, mockClient, broker)
+ defer worker.Shutdown()
+
+ // Test successful command submission
+ cmd := &TestCommand{
+ ExecuteFn: func(ctx context.Context, worker *NodeWorker) NodeResult {
+ return NodeResult{Succeeded: true, FinalStatus: types.HardwareNodeStatus_STOPPED}
+ },
+ }
+ success := worker.Submit(context.Background(), cmd)
+ assert.True(t, success, "Command submission should succeed")
+
+ // Wait for command execution and result submission
+ select {
+ case receivedCmd := <-broker.highPriorityCommands:
+ updateCmd, ok := receivedCmd.(UpdateNodeResultCommand)
+ assert.True(t, ok, "Broker should receive an UpdateNodeResultCommand")
+ assert.Equal(t, "test-node-1", updateCmd.NodeId)
+ assert.True(t, updateCmd.Result.Succeeded)
+ assert.Equal(t, types.HardwareNodeStatus_STOPPED, updateCmd.Result.FinalStatus)
+ case <-time.After(100 * time.Millisecond):
+ t.Fatal("timed out waiting for broker to receive command")
+ }
+}
+
+func TestNodeWorker_ErrorHandling(t *testing.T) {
+ broker := NewTestBroker2(1)
+ node := createTestNode("test-node-1")
+ mockClient := mlnodeclient.NewMockClient()
+ worker := NewNodeWorkerWithClient("test-node-1", node, mockClient, broker)
+ defer worker.Shutdown()
+
+ // Submit command that returns error
+ testErr := errors.New("test error")
+ cmd := &TestCommand{
+ ExecuteFn: func(ctx context.Context, worker *NodeWorker) NodeResult {
+ return NodeResult{Succeeded: false, Error: testErr.Error()}
+ },
+ }
+ success := worker.Submit(context.Background(), cmd)
+ assert.True(t, success, "Command submission should succeed")
+
+ // Wait for command execution and result submission
+ select {
+ case receivedCmd := <-broker.highPriorityCommands:
+ updateCmd, ok := receivedCmd.(UpdateNodeResultCommand)
+ assert.True(t, ok, "Broker should receive an UpdateNodeResultCommand")
+ assert.Equal(t, "test-node-1", updateCmd.NodeId)
+ assert.False(t, updateCmd.Result.Succeeded)
+ assert.Equal(t, "test error", updateCmd.Result.Error)
+ case <-time.After(100 * time.Millisecond):
+ t.Fatal("timed out waiting for broker to receive command")
+ }
+}
+
+func TestNodeWorker_QueueFull(t *testing.T) {
+ broker := NewTestBroker2(20) // Make it larger to handle results
+ node := createTestNode("test-node-1")
+ mockClient := mlnodeclient.NewMockClient()
+ worker := NewNodeWorkerWithClient("test-node-1", node, mockClient, broker)
+ defer worker.Shutdown()
+
+ // Fill the queue with slow commands
+ slowCmdSubmitted := 0
+ slowCmdFailed := 0
+ for i := 0; i < 25; i++ { // Queue size is 10, but we submit 10
+ cmd := &TestCommand{
+ ExecuteFn: func(ctx context.Context, worker *NodeWorker) NodeResult {
+ time.Sleep(100 * time.Millisecond)
+ return NodeResult{Succeeded: true}
+ },
+ }
+ success := worker.Submit(context.Background(), cmd)
+ if success {
+ slowCmdSubmitted++
+ } else {
+ slowCmdFailed++
+ }
+ }
+
+ // Only 10 should succeed
+ assert.Equal(t, 10, slowCmdSubmitted, "Should submit exactly 10 commands (queue size)")
+ assert.Equal(t, 15, slowCmdFailed, "Should fail exactly 15 commands (beyond queue size)")
+}
+
+func TestNodeWorker_GracefulShutdown(t *testing.T) {
+ broker := NewTestBroker2(10)
+ node := createTestNode("test-node-1")
+ mockClient := mlnodeclient.NewMockClient()
+ worker := NewNodeWorkerWithClient("test-node-1", node, mockClient, broker)
+
+ // Submit commands that will execute during shutdown
+ var executedCount int32
+ for i := 0; i < 5; i++ {
+ cmd := &TestCommand{
+ ExecuteFn: func(ctx context.Context, worker *NodeWorker) NodeResult {
+ atomic.AddInt32(&executedCount, 1)
+ time.Sleep(10 * time.Millisecond)
+ return NodeResult{Succeeded: true}
+ },
+ }
+ worker.Submit(context.Background(), cmd)
+ }
+
+ // Give first command time to start
+ time.Sleep(5 * time.Millisecond)
+
+ // Shutdown should wait for all commands
+ worker.Shutdown()
+
+ assert.Equal(t, int32(5), atomic.LoadInt32(&executedCount),
+ "All queued commands should execute before shutdown completes")
+
+ assert.Len(t, broker.highPriorityCommands, 5, "Should have 5 results in broker channel")
+}
+
+func TestNodeWorker_Cancellation(t *testing.T) {
+ broker := NewTestBroker2(1)
+ node := createTestNode("test-node-1")
+ mockClient := mlnodeclient.NewMockClient()
+ worker := NewNodeWorkerWithClient("test-node-1", node, mockClient, broker)
+ defer worker.Shutdown()
+
+ cmdStarted := make(chan struct{})
+ cmd := &TestCommand{
+ ExecuteFn: func(ctx context.Context, worker *NodeWorker) NodeResult {
+ close(cmdStarted)
+ <-ctx.Done() // Wait for cancellation
+ return NodeResult{
+ Succeeded: false,
+ Error: ctx.Err().Error(),
+ FinalStatus: worker.node.State.CurrentStatus,
+ OriginalTarget: types.HardwareNodeStatus_STOPPED,
+ }
+ },
+ }
+
+ ctx, cancel := context.WithCancel(context.Background())
+ worker.Submit(ctx, cmd)
+
+ <-cmdStarted // Ensure command has started execution
+ cancel() // Cancel it
+
+ select {
+ case receivedCmd := <-broker.highPriorityCommands:
+ updateCmd, ok := receivedCmd.(UpdateNodeResultCommand)
+ assert.True(t, ok)
+ assert.False(t, updateCmd.Result.Succeeded)
+ assert.Equal(t, context.Canceled.Error(), updateCmd.Result.Error)
+ case <-time.After(100 * time.Millisecond):
+ t.Fatal("timed out waiting for cancelled command result")
+ }
+}
+
+func TestNodeWorker_MLClientInteraction(t *testing.T) {
+ broker := NewTestBroker2(5)
+ node := createTestNode("test-node-1")
+ mockClient := mlnodeclient.NewMockClient()
+ worker := NewNodeWorkerWithClient("test-node-1", node, mockClient, broker)
+ defer worker.Shutdown()
+
+ // Test Stop operation
+ stopCmd := StopNodeCommand{}
+ worker.Submit(context.Background(), &stopCmd)
+
+ select {
+ case receivedCmd := <-broker.highPriorityCommands:
+ updateCmd, ok := receivedCmd.(UpdateNodeResultCommand)
+ assert.True(t, ok)
+ assert.True(t, updateCmd.Result.Succeeded)
+ assert.Equal(t, types.HardwareNodeStatus_STOPPED, updateCmd.Result.FinalStatus)
+ case <-time.After(100 * time.Millisecond):
+ t.Fatal("timed out waiting for stop command result")
+ }
+ assert.Equal(t, 1, mockClient.StopCalled, "Stop should be called once")
+
+ // Test InferenceUp operation
+ node.Node.Models = map[string]ModelArgs{
+ "test-model": {Args: []string{"--arg1", "--arg2"}},
+ }
+ // Manually populate the EpochModels for this test, as suggested.
+ node.State.EpochModels["test-model"] = types.Model{Id: "test-model", ModelArgs: []string{"--arg1", "--arg2"}}
+ node.State.EpochMLNodes["test-model"] = types.MLNodeInfo{
+ NodeId: "test-node-1",
+ }
+ inferenceCmd := InferenceUpNodeCommand{}
+ worker.Submit(context.Background(), &inferenceCmd)
+
+ select {
+ case receivedCmd := <-broker.highPriorityCommands:
+ updateCmd, ok := receivedCmd.(UpdateNodeResultCommand)
+ assert.True(t, ok)
+ assert.True(t, updateCmd.Result.Succeeded)
+ assert.Equal(t, types.HardwareNodeStatus_INFERENCE, updateCmd.Result.FinalStatus)
+ case <-time.After(100 * time.Millisecond):
+ t.Fatal("timed out waiting for inference up command result")
+ }
+ assert.Equal(t, 2, mockClient.StopCalled, "Stop should be called again for inference up")
+ assert.Equal(t, 1, mockClient.InferenceUpCalled, "InferenceUp should be called once")
+ assert.Equal(t, "test-model", mockClient.LastInferenceModel, "Model should be captured")
+ assert.Equal(t, []string{"--arg1", "--arg2"}, mockClient.LastInferenceArgs, "Args should be captured")
+}
+
+func TestNodeWorkGroup_AddRemoveWorkers(t *testing.T) {
+ group := NewNodeWorkGroup()
+ broker := NewTestBroker2(1)
+
+ // Add workers
+ node1 := createTestNode("node-1")
+ node2 := createTestNode("node-2")
+
+ worker1 := NewNodeWorkerWithClient("node-1", node1, mlnodeclient.NewMockClient(), broker)
+ worker2 := NewNodeWorkerWithClient("node-2", node2, mlnodeclient.NewMockClient(), broker)
+
+ group.AddWorker("node-1", worker1)
+ group.AddWorker("node-2", worker2)
+
+ // Check workers exist
+ w1, exists1 := group.GetWorker("node-1")
+ w2, exists2 := group.GetWorker("node-2")
+
+ assert.True(t, exists1, "Worker 1 should exist")
+ assert.True(t, exists2, "Worker 2 should exist")
+ assert.Equal(t, worker1, w1)
+ assert.Equal(t, worker2, w2)
+
+ // Remove worker
+ group.RemoveWorker("node-1")
+
+ _, exists1 = group.GetWorker("node-1")
+ assert.False(t, exists1, "Worker 1 should not exist after removal")
+}
+
+func TestNodeWorker_CheckClientVersionAlive(t *testing.T) {
+ broker := NewTestBroker2(1)
+ node := createTestNode("test-node-1")
+ mainClient := mlnodeclient.NewMockClient()
+ mockFactory := mlnodeclient.NewMockClientFactory()
+
+ worker := NewNodeWorkerWithClient("test-node-1", node, mainClient, broker)
+ defer worker.Shutdown()
+
+ version := "v1.0.0"
+ versionedPocUrl := node.Node.PoCUrlWithVersion(version)
+
+ // --- Test Case 1: Version is alive ---
+ versionClient := mockFactory.GetClientForNode(versionedPocUrl)
+ assert.Nil(t, versionClient, "Client should not exist yet")
+
+ alive, err := worker.CheckClientVersionAlive(version, mockFactory)
+ assert.NoError(t, err)
+ assert.True(t, alive)
+
+ versionClient = mockFactory.GetClientForNode(versionedPocUrl)
+ assert.NotNil(t, versionClient, "Client should be created for the version")
+ assert.Equal(t, 1, versionClient.NodeStateCalled)
+
+ // --- Test Case 2: Check caching - should not call NodeState again ---
+ alive, err = worker.CheckClientVersionAlive(version, mockFactory)
+ assert.NoError(t, err)
+ assert.True(t, alive)
+ assert.Equal(t, 1, versionClient.NodeStateCalled, "NodeState should not be called again due to cache")
+
+ // --- Test Case 3: Version is not alive ---
+ mockFactory.Reset()
+ worker.availableVersions = make(map[string]bool) // Reset internal cache
+ version2 := "v2.0.0"
+ versionedPocUrl2 := node.Node.PoCUrlWithVersion(version2)
+
+ // Configure the mock client for this version to return an error
+ version2Client := mockFactory.CreateClient(versionedPocUrl2, "").(*mlnodeclient.MockClient)
+ testErr := errors.New("node not ready")
+ version2Client.NodeStateError = testErr
+
+ alive, err = worker.CheckClientVersionAlive(version2, mockFactory)
+ assert.Error(t, err)
+ assert.Equal(t, testErr, err)
+ assert.False(t, alive)
+ assert.Equal(t, 1, version2Client.NodeStateCalled)
+
+ // --- Test Case 4: Retry after failure ---
+ // It should try again. Let's make it succeed this time.
+ version2Client.NodeStateError = nil
+ alive, err = worker.CheckClientVersionAlive(version2, mockFactory)
+ assert.NoError(t, err)
+ assert.True(t, alive)
+ assert.Equal(t, 2, version2Client.NodeStateCalled, "NodeState should be called again on retry")
+}
+
+// TestCommand is a simple command for testing
+type TestCommand struct {
+ ExecuteFn func(ctx context.Context, worker *NodeWorker) NodeResult
+}
+
+func (c *TestCommand) Execute(ctx context.Context, worker *NodeWorker) NodeResult {
+ if c.ExecuteFn != nil {
+ return c.ExecuteFn(ctx, worker)
+ }
+ return NodeResult{Succeeded: true}
+}
diff --git a/decentralized-api/broker/state_commands.go b/decentralized-api/broker/state_commands.go
new file mode 100644
index 000000000..67ba1bcb1
--- /dev/null
+++ b/decentralized-api/broker/state_commands.go
@@ -0,0 +1,375 @@
+package broker
+
+import (
+ "decentralized-api/chainphase"
+ "decentralized-api/logging"
+ "time"
+
+ "github.com/productscience/inference/x/inference/types"
+)
+
+type StartPocCommand struct {
+ Response chan bool
+}
+
+func NewStartPocCommand() StartPocCommand {
+ return StartPocCommand{
+ Response: make(chan bool, 2),
+ }
+}
+
+func (c StartPocCommand) GetResponseChannelCapacity() int {
+ return cap(c.Response)
+}
+
+// TODO: technically all 3 commands (StartPocCommand, InitValidateCommand, InferenceUpAllCommand)
+// could be merged into a single command with a phase parameter
+// for now we keep them separate for clarity and future extensibility
+
+func (c StartPocCommand) Execute(b *Broker) {
+ epochState := b.phaseTracker.GetCurrentEpochState()
+ if epochState.IsNilOrNotSynced() {
+ logging.Warn("StartPocCommand: skipping outdated command execution. epoch state is nil or not synced", types.PoC)
+ return
+ }
+
+ // Check if we should run PoC (regular OR confirmation)
+ shouldRunPoC := epochState.CurrentPhase == types.PoCGeneratePhase
+
+ // Confirmation PoC during inference phase
+ if epochState.CurrentPhase == types.InferencePhase && epochState.ActiveConfirmationPoCEvent != nil {
+ event := epochState.ActiveConfirmationPoCEvent
+ epochParams := &epochState.LatestEpoch.EpochParams
+ currentHeight := epochState.CurrentBlock.Height
+ if currentHeight >= event.GenerationStartHeight && currentHeight <= event.GetGenerationEnd(epochParams) {
+ shouldRunPoC = true
+ }
+ }
+
+ if !shouldRunPoC {
+ logging.Warn("StartPocCommand: skipping outdated command execution. current phase isn't PoCGeneratePhase and no active confirmation PoC", types.PoC,
+ "current_phase", epochState.CurrentPhase,
+ "current_block_height", epochState.CurrentBlock.Height,
+ "epoch_index", epochState.LatestEpoch.EpochIndex,
+ "epoch_start_block_height", epochState.LatestEpoch.PocStartBlockHeight)
+ return
+ }
+
+ defer func() {
+ logging.Info("StartPocCommand: completed, reconciliation triggered", types.PoC)
+ b.TriggerReconciliation()
+ }()
+
+ if !c.shouldMutateState(b, epochState) {
+ logging.Info("StartPocCommand: all nodes already have the desired intended status", types.PoC)
+ return
+ }
+
+ b.mu.Lock()
+ for _, node := range b.nodes {
+ // Check if node should be operational based on admin state
+ if !node.State.ShouldBeOperational(epochState.LatestEpoch.EpochIndex, epochState.CurrentPhase) {
+ logging.Info("Skipping PoC for administratively disabled node. Defaulting to INFERENCE state", types.PoC,
+ "node_id", node.Node.Id,
+ "admin_enabled", node.State.AdminState.Enabled,
+ "admin_epoch", node.State.AdminState.Epoch,
+ "current_epoch", epochState,
+ "current_phase", epochState.CurrentPhase)
+ node.State.IntendedStatus = types.HardwareNodeStatus_INFERENCE
+ } else if node.State.ShouldContinueInference() {
+ // Node should continue inference service based on POC_SLOT allocation
+ // TODO: change logs to debug
+ logging.Info("Keeping node in inference service mode due to POC_SLOT allocation", types.PoC,
+ "node_id", node.Node.Id,
+ "current_epoch", epochState,
+ "current_phase", epochState.CurrentPhase)
+ node.State.IntendedStatus = types.HardwareNodeStatus_INFERENCE
+ } else {
+ node.State.IntendedStatus = types.HardwareNodeStatus_POC
+ node.State.PocIntendedStatus = PocStatusGenerating
+ }
+ }
+ b.mu.Unlock()
+
+ c.Response <- true
+}
+
+func (c StartPocCommand) shouldMutateState(b *Broker, epochState *chainphase.EpochState) bool {
+ b.mu.RLock()
+ defer b.mu.RUnlock()
+
+ for _, node := range b.nodes {
+ if !node.State.ShouldBeOperational(epochState.LatestEpoch.EpochIndex, epochState.CurrentPhase) &&
+ node.State.IntendedStatus != types.HardwareNodeStatus_INFERENCE {
+
+ return true
+ }
+
+ // Check if node should continue inference based on POC_SLOT
+ if node.State.ShouldContinueInference() {
+ logging.Info("[StartPocCommand] Node should continue inference", types.PoC, "node_id", node.Node.Id)
+ if node.State.IntendedStatus != types.HardwareNodeStatus_INFERENCE {
+ return true
+ }
+ } else {
+ if node.State.IntendedStatus != types.HardwareNodeStatus_POC ||
+ node.State.PocIntendedStatus != PocStatusGenerating {
+ return true
+ }
+ }
+ }
+
+ return false
+}
+
+type InitValidateCommand struct {
+ Response chan bool
+}
+
+func NewInitValidateCommand() InitValidateCommand {
+ return InitValidateCommand{
+ Response: make(chan bool, 2),
+ }
+}
+
+func (c InitValidateCommand) GetResponseChannelCapacity() int {
+ return cap(c.Response)
+}
+
+func (c InitValidateCommand) Execute(b *Broker) {
+ epochState := b.phaseTracker.GetCurrentEpochState()
+ if epochState.IsNilOrNotSynced() {
+ logging.Warn("InitValidateCommand: skipping outdated command execution. epoch state is nil or not synced", types.PoC)
+ return
+ }
+
+ // Check validation phase (regular OR confirmation)
+ shouldValidate := epochState.CurrentPhase == types.PoCValidatePhase ||
+ // FIXME: A bit too wide, it should be PoCGenerateWindDownPhase AND after poc end,
+ // but we rely on node dispatcher to not send it too early
+ // if we want to be 100% sure we should check based on block height
+ // by adding some additional methods for getting block height stage cutoffs for current epoch
+ epochState.CurrentPhase == types.PoCGenerateWindDownPhase
+
+ // Confirmation PoC validation during inference phase
+ if epochState.CurrentPhase == types.InferencePhase && epochState.ActiveConfirmationPoCEvent != nil {
+ event := epochState.ActiveConfirmationPoCEvent
+ epochParams := &epochState.LatestEpoch.EpochParams
+ currentHeight := epochState.CurrentBlock.Height
+ // Accept at exchange end (transition) OR during validation window
+ if currentHeight == event.GetExchangeEnd(epochParams) || event.IsInValidationWindow(currentHeight, epochParams) {
+ shouldValidate = true
+ }
+ }
+
+ if !shouldValidate {
+ logging.Warn("InitValidateCommand: skipping outdated command execution. current phase isn't PoCValidatePhase and no active confirmation PoC", types.PoC,
+ "current_phase", epochState.CurrentPhase,
+ "current_block_height", epochState.CurrentBlock.Height,
+ "epoch_index", epochState.LatestEpoch.EpochIndex,
+ "epoch_start_block_height", epochState.LatestEpoch.PocStartBlockHeight)
+ return
+ }
+
+ defer func() {
+ logging.Info("InitValidateCommand: completed, reconciliation triggered for PoC validation", types.PoC)
+ b.TriggerReconciliation()
+ }()
+
+ if !c.shouldMutateState(b, epochState) {
+ logging.Info("InitValidateCommand: all nodes already have the desired intended status", types.PoC)
+ return
+ }
+
+ b.mu.Lock()
+ for _, node := range b.nodes {
+ // Check if node should be operational based on admin state
+ if !node.State.ShouldBeOperational(epochState.LatestEpoch.EpochIndex, epochState.CurrentPhase) {
+ logging.Info("Skipping PoC for administratively disabled node. Defaulting to INFERENCE state", types.PoC,
+ "node_id", node.Node.Id,
+ "admin_enabled", node.State.AdminState.Enabled,
+ "admin_epoch", node.State.AdminState.Epoch,
+ "current_epoch", epochState,
+ "current_phase", epochState.CurrentPhase)
+ node.State.IntendedStatus = types.HardwareNodeStatus_INFERENCE
+ } else if node.State.ShouldContinueInference() {
+ // Node should continue inference service based on POC_SLOT allocation
+ logging.Info("Keeping node in inference service mode due to POC_SLOT allocation", types.PoC,
+ "node_id", node.Node.Id,
+ "current_epoch", epochState,
+ "current_phase", epochState.CurrentPhase)
+ node.State.IntendedStatus = types.HardwareNodeStatus_INFERENCE
+ } else {
+ node.State.IntendedStatus = types.HardwareNodeStatus_POC
+ node.State.PocIntendedStatus = PocStatusValidating
+ }
+ }
+ b.mu.Unlock()
+
+ c.Response <- true
+}
+
+func (c InitValidateCommand) shouldMutateState(b *Broker, epochState *chainphase.EpochState) bool {
+ b.mu.RLock()
+ defer b.mu.RUnlock()
+
+ for _, node := range b.nodes {
+ if !node.State.ShouldBeOperational(epochState.LatestEpoch.EpochIndex, epochState.CurrentPhase) &&
+ node.State.IntendedStatus != types.HardwareNodeStatus_INFERENCE {
+ return true
+ }
+
+ // Check if node should continue inference based on POC_SLOT
+ if node.State.ShouldContinueInference() {
+ logging.Info("[InitValidateCommand] Node should continue inference", types.PoC, "node_id", node.Node.Id)
+ if node.State.IntendedStatus != types.HardwareNodeStatus_INFERENCE {
+ return true
+ }
+ } else {
+ if node.State.IntendedStatus != types.HardwareNodeStatus_POC ||
+ node.State.PocIntendedStatus != PocStatusValidating {
+ return true
+ }
+ }
+ }
+
+ return false
+}
+
+type InferenceUpAllCommand struct {
+ Response chan bool
+}
+
+func NewInferenceUpAllCommand() InferenceUpAllCommand {
+ return InferenceUpAllCommand{
+ Response: make(chan bool, 2),
+ }
+}
+
+func (c InferenceUpAllCommand) GetResponseChannelCapacity() int {
+ return cap(c.Response)
+}
+
+func (c InferenceUpAllCommand) Execute(b *Broker) {
+ epochState := b.phaseTracker.GetCurrentEpochState()
+ if epochState.IsNilOrNotSynced() {
+ logging.Warn("InferenceUpAllCommand: skipping outdated command execution. epoch state is nil or not synced", types.Nodes)
+ return
+ }
+
+ if epochState.CurrentPhase != types.InferencePhase &&
+ // FIXME: same as in InitValidateCommand, ideally we should check based on block height
+ epochState.CurrentPhase != types.PoCValidateWindDownPhase {
+ logging.Warn("InferenceUpAllCommand: skipping outdated command execution. current phase isn't InferencePhase", types.Nodes,
+ "current_phase", epochState.CurrentPhase,
+ "current_block_height", epochState.CurrentBlock.Height,
+ "epoch_index", epochState.LatestEpoch.EpochIndex,
+ "epoch_start_block_height", epochState.LatestEpoch.PocStartBlockHeight)
+ return
+ }
+
+ defer func() {
+ logging.Info("InferenceUpAllCommand: completed, reconciliation triggered", types.Nodes)
+ b.TriggerReconciliation()
+ }()
+
+ if !c.shouldMutateState(b, epochState) {
+ logging.Info("InferenceUpAllCommand: all nodes already have the desired intended status", types.Nodes)
+ return
+ }
+
+ b.mu.Lock()
+ for _, node := range b.nodes {
+ if node.State.IntendedStatus == types.HardwareNodeStatus_TRAINING {
+ logging.Info("Skipping inference up for node in training state", types.PoC,
+ "node_id", node.Node.Id,
+ "current_epoch", epochState,
+ "current_phase", epochState.CurrentPhase)
+ continue
+ } else {
+ if node.State.IntendedStatus != types.HardwareNodeStatus_INFERENCE {
+ logging.Info("Setting node status to Inference", types.PoC,
+ "node_id", node.Node.Id,
+ "current_epoch", epochState,
+ "current_phase", epochState.CurrentPhase,
+ "current_intended_status", node.State.IntendedStatus)
+ }
+
+ node.State.IntendedStatus = types.HardwareNodeStatus_INFERENCE
+ }
+ }
+ b.mu.Unlock()
+
+ c.Response <- true
+}
+
+func (c InferenceUpAllCommand) shouldMutateState(b *Broker, epochState *chainphase.EpochState) bool {
+ b.mu.RLock()
+ defer b.mu.RUnlock()
+
+ for _, node := range b.nodes {
+ if node.State.IntendedStatus == types.HardwareNodeStatus_TRAINING {
+ continue
+ }
+
+ if node.State.IntendedStatus != types.HardwareNodeStatus_INFERENCE {
+ return true
+ }
+ }
+
+ return false
+}
+
+type SetNodesActualStatusCommand struct {
+ StatusUpdates []StatusUpdate
+ Response chan bool
+}
+
+func NewSetNodesActualStatusCommand(statusUpdates []StatusUpdate) SetNodesActualStatusCommand {
+ return SetNodesActualStatusCommand{
+ StatusUpdates: statusUpdates,
+ Response: make(chan bool, 2),
+ }
+}
+
+type StatusUpdate struct {
+ NodeId string
+ PrevStatus types.HardwareNodeStatus
+ NewStatus types.HardwareNodeStatus
+ Timestamp time.Time
+}
+
+func (c SetNodesActualStatusCommand) GetResponseChannelCapacity() int {
+ return cap(c.Response)
+}
+
+func (c SetNodesActualStatusCommand) Execute(b *Broker) {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+
+ for _, update := range c.StatusUpdates {
+ nodeId := update.NodeId
+ node, exists := b.nodes[nodeId]
+ if !exists {
+ logging.Error("Cannot set status: node not found", types.Nodes, "node_id", nodeId)
+ continue
+ }
+
+ if node.State.StatusTimestamp.After(update.Timestamp) {
+ logging.Info("Skipping status update: older than current", types.Nodes, "node_id", nodeId)
+ continue
+ }
+
+ logging.Info("Setting actual status for node", types.Nodes,
+ "node_id", nodeId,
+ "update.status", update.NewStatus.String(),
+ "update.prev_status", update.PrevStatus.String(),
+ "update.timestamp", update.Timestamp,
+ "node.State.CurrentStatus", node.State.CurrentStatus,
+ "node.State.StatusTimestamp", node.State.StatusTimestamp)
+
+ node.State.UpdateStatusAt(update.Timestamp, update.NewStatus)
+ }
+
+ c.Response <- true
+}
diff --git a/decentralized-api/broker/state_commands_test.go b/decentralized-api/broker/state_commands_test.go
new file mode 100644
index 000000000..5ae3cdb0d
--- /dev/null
+++ b/decentralized-api/broker/state_commands_test.go
@@ -0,0 +1,326 @@
+package broker
+
+import (
+ "decentralized-api/chainphase"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+
+ "github.com/productscience/inference/x/inference/types"
+ "github.com/stretchr/testify/assert"
+)
+
+// newPhaseTrackerWithPhase creates a broker with a phase tracker initialized to a specific phase.
+func newPhaseTrackerWithPhase(t *testing.T, phase types.EpochPhase) *chainphase.ChainPhaseTracker {
+ tracker := chainphase.NewChainPhaseTracker()
+
+ // These params will result in the following phases for given block heights:
+ epoch := &types.Epoch{Index: 1, PocStartBlockHeight: 100}
+ params := &types.EpochParams{
+ EpochLength: 100,
+ EpochMultiplier: 1,
+ EpochShift: 0,
+ PocStageDuration: 20,
+ PocExchangeDuration: 1,
+ PocValidationDelay: 2,
+ PocValidationDuration: 10,
+ }
+
+ var blockHeight int64
+ switch phase {
+ case types.PoCGeneratePhase:
+ blockHeight = 105
+ case types.PoCGenerateWindDownPhase:
+ blockHeight = 122
+ case types.PoCValidatePhase:
+ blockHeight = 130
+ case types.PoCValidateWindDownPhase:
+ blockHeight = 137
+ case types.InferencePhase:
+ blockHeight = 145 // After all PoC phases
+ default:
+ // A phase that isn't one of the main ones, e.g., Prepare
+ blockHeight = 95
+ }
+
+ block := chainphase.BlockInfo{Height: blockHeight}
+ tracker.Update(block, epoch, params, true, nil)
+
+ return tracker
+}
+
+func TestStartPocCommand_Success(t *testing.T) {
+ node1 := createTestNode("node-1")
+ node2 := createTestNode("node-2")
+
+ tracker := newPhaseTrackerWithPhase(t, types.PoCGeneratePhase)
+ require.Equal(t, types.PoCGeneratePhase, tracker.GetCurrentEpochState().CurrentPhase)
+
+ broker := &Broker{
+ nodes: map[string]*NodeWithState{
+ "node-1": node1,
+ "node-2": node2,
+ },
+ phaseTracker: tracker,
+ }
+
+ cmd := StartPocCommand{
+ Response: make(chan bool, 1),
+ }
+
+ cmd.Execute(broker)
+
+ success := <-cmd.Response
+ assert.True(t, success, "Command should succeed")
+
+ assert.Equal(t, types.HardwareNodeStatus_POC, node1.State.IntendedStatus)
+ assert.Equal(t, types.HardwareNodeStatus_POC, node2.State.IntendedStatus)
+}
+
+func TestStartPocCommand_AlreadyInPoC(t *testing.T) {
+ node := createTestNode("node-1")
+
+ tracker := newPhaseTrackerWithPhase(t, types.PoCGeneratePhase)
+ require.Equal(t, types.PoCGeneratePhase, tracker.GetCurrentEpochState().CurrentPhase)
+
+ broker := &Broker{
+ nodes: map[string]*NodeWithState{
+ "node-1": node,
+ },
+ phaseTracker: tracker,
+ }
+
+ // Execute StartPocCommand
+ cmd := StartPocCommand{
+ Response: make(chan bool, 1),
+ }
+
+ cmd.Execute(broker)
+
+ require.Equal(t, types.HardwareNodeStatus_POC, node.State.IntendedStatus)
+ require.Equal(t, PocStatusGenerating, node.State.PocIntendedStatus)
+}
+
+func TestStartPocCommand_AdminDisabled(t *testing.T) {
+ node1 := createTestNode("node-1")
+ node2 := createTestNode("node-2")
+ node1.State.AdminState.Enabled = false
+ node1.State.AdminState.Epoch = 0
+
+ tracker := newPhaseTrackerWithPhase(t, types.PoCGeneratePhase)
+ require.Equal(t, uint64(1), tracker.GetCurrentEpochState().LatestEpoch.EpochIndex)
+ require.Equal(t, types.PoCGeneratePhase, tracker.GetCurrentEpochState().CurrentPhase)
+
+ broker := &Broker{
+ nodes: map[string]*NodeWithState{
+ "node-1": node1,
+ "node-2": node2,
+ },
+ phaseTracker: tracker,
+ }
+
+ cmd := StartPocCommand{
+ Response: make(chan bool, 1),
+ }
+
+ cmd.Execute(broker)
+
+ success := <-cmd.Response
+ require.True(t, success, "Command should succeed")
+
+ require.Equal(t, node1.State.IntendedStatus, types.HardwareNodeStatus_INFERENCE)
+ require.Equal(t, node2.State.IntendedStatus, types.HardwareNodeStatus_POC)
+ require.Equal(t, node2.State.PocIntendedStatus, PocStatusGenerating)
+}
+
+func TestStartPocCommand_ConfirmationPoC_Success(t *testing.T) {
+ node1 := createTestNode("node-1")
+ node2 := createTestNode("node-2")
+
+ tracker := newPhaseTrackerWithPhase(t, types.InferencePhase)
+ require.Equal(t, types.InferencePhase, tracker.GetCurrentEpochState().CurrentPhase)
+
+ confirmationEvent := &types.ConfirmationPoCEvent{
+ EpochIndex: 1,
+ EventSequence: 0,
+ TriggerHeight: 140,
+ GenerationStartHeight: 142,
+ Phase: types.ConfirmationPoCPhase_CONFIRMATION_POC_GENERATION,
+ PocSeedBlockHash: "test_hash",
+ }
+
+ epoch := &types.Epoch{Index: 1, PocStartBlockHeight: 100}
+ params := &types.EpochParams{
+ EpochLength: 100,
+ EpochMultiplier: 1,
+ EpochShift: 0,
+ PocStageDuration: 20,
+ PocExchangeDuration: 1,
+ PocValidationDelay: 2,
+ PocValidationDuration: 10,
+ }
+ block := chainphase.BlockInfo{Height: 150}
+ tracker.Update(block, epoch, params, true, confirmationEvent)
+
+ broker := &Broker{
+ nodes: map[string]*NodeWithState{
+ "node-1": node1,
+ "node-2": node2,
+ },
+ phaseTracker: tracker,
+ }
+
+ cmd := StartPocCommand{
+ Response: make(chan bool, 1),
+ }
+
+ cmd.Execute(broker)
+
+ success := <-cmd.Response
+ assert.True(t, success, "Command should succeed")
+
+ assert.Equal(t, types.HardwareNodeStatus_POC, node1.State.IntendedStatus)
+ assert.Equal(t, types.HardwareNodeStatus_POC, node2.State.IntendedStatus)
+}
+
+func TestStartPocCommand_InferencePhase_NoConfirmationEvent(t *testing.T) {
+ node1 := createTestNode("node-1")
+
+ tracker := newPhaseTrackerWithPhase(t, types.InferencePhase)
+ require.Equal(t, types.InferencePhase, tracker.GetCurrentEpochState().CurrentPhase)
+
+ broker := &Broker{
+ nodes: map[string]*NodeWithState{
+ "node-1": node1,
+ },
+ phaseTracker: tracker,
+ }
+
+ cmd := StartPocCommand{
+ Response: make(chan bool, 1),
+ }
+
+ cmd.Execute(broker)
+
+ select {
+ case <-cmd.Response:
+ t.Fatal("Command should not send response when skipping")
+ default:
+ }
+
+ // Node status should remain unchanged (UNKNOWN = 0)
+ assert.Equal(t, types.HardwareNodeStatus_UNKNOWN, node1.State.IntendedStatus)
+}
+
+func TestInitValidateCommand_Success(t *testing.T) {
+ node1 := createTestNode("node-1")
+ node2 := createTestNode("node-2")
+
+ // Use PoCGenerateWindDownPhase which is also valid for InitValidateCommand
+ tracker := newPhaseTrackerWithPhase(t, types.PoCGenerateWindDownPhase)
+ epochState := tracker.GetCurrentEpochState()
+ require.True(t, epochState.CurrentPhase == types.PoCValidatePhase || epochState.CurrentPhase == types.PoCGenerateWindDownPhase)
+
+ broker := &Broker{
+ nodes: map[string]*NodeWithState{
+ "node-1": node1,
+ "node-2": node2,
+ },
+ phaseTracker: tracker,
+ }
+
+ cmd := InitValidateCommand{
+ Response: make(chan bool, 1),
+ }
+
+ cmd.Execute(broker)
+
+ success := <-cmd.Response
+ assert.True(t, success, "Command should succeed")
+
+ assert.Equal(t, types.HardwareNodeStatus_POC, node1.State.IntendedStatus)
+ assert.Equal(t, PocStatusValidating, node1.State.PocIntendedStatus)
+ assert.Equal(t, types.HardwareNodeStatus_POC, node2.State.IntendedStatus)
+ assert.Equal(t, PocStatusValidating, node2.State.PocIntendedStatus)
+}
+
+func TestInitValidateCommand_ConfirmationPoC_Success(t *testing.T) {
+ node1 := createTestNode("node-1")
+ node2 := createTestNode("node-2")
+
+ tracker := newPhaseTrackerWithPhase(t, types.InferencePhase)
+ require.Equal(t, types.InferencePhase, tracker.GetCurrentEpochState().CurrentPhase)
+
+ confirmationEvent := &types.ConfirmationPoCEvent{
+ EpochIndex: 1,
+ EventSequence: 0,
+ TriggerHeight: 140,
+ GenerationStartHeight: 142,
+ Phase: types.ConfirmationPoCPhase_CONFIRMATION_POC_VALIDATION,
+ PocSeedBlockHash: "test_hash",
+ }
+
+ epoch := &types.Epoch{Index: 1, PocStartBlockHeight: 100}
+ params := &types.EpochParams{
+ EpochLength: 100,
+ EpochMultiplier: 1,
+ EpochShift: 0,
+ PocStageDuration: 20,
+ PocExchangeDuration: 1,
+ PocValidationDelay: 2,
+ PocValidationDuration: 10,
+ }
+ block := chainphase.BlockInfo{Height: 165}
+ tracker.Update(block, epoch, params, true, confirmationEvent)
+
+ broker := &Broker{
+ nodes: map[string]*NodeWithState{
+ "node-1": node1,
+ "node-2": node2,
+ },
+ phaseTracker: tracker,
+ }
+
+ cmd := InitValidateCommand{
+ Response: make(chan bool, 1),
+ }
+
+ cmd.Execute(broker)
+
+ success := <-cmd.Response
+ assert.True(t, success, "Command should succeed")
+
+ assert.Equal(t, types.HardwareNodeStatus_POC, node1.State.IntendedStatus)
+ assert.Equal(t, PocStatusValidating, node1.State.PocIntendedStatus)
+ assert.Equal(t, types.HardwareNodeStatus_POC, node2.State.IntendedStatus)
+ assert.Equal(t, PocStatusValidating, node2.State.PocIntendedStatus)
+}
+
+func TestInitValidateCommand_InferencePhase_NoConfirmationEvent(t *testing.T) {
+ node1 := createTestNode("node-1")
+
+ tracker := newPhaseTrackerWithPhase(t, types.InferencePhase)
+ require.Equal(t, types.InferencePhase, tracker.GetCurrentEpochState().CurrentPhase)
+
+ broker := &Broker{
+ nodes: map[string]*NodeWithState{
+ "node-1": node1,
+ },
+ phaseTracker: tracker,
+ }
+
+ cmd := InitValidateCommand{
+ Response: make(chan bool, 1),
+ }
+
+ cmd.Execute(broker)
+
+ select {
+ case <-cmd.Response:
+ t.Fatal("Command should not send response when skipping")
+ default:
+ }
+
+ // Node status should remain unchanged (UNKNOWN = 0)
+ assert.Equal(t, types.HardwareNodeStatus_UNKNOWN, node1.State.IntendedStatus)
+}
diff --git a/decentralized-api/broker/training_commands.go b/decentralized-api/broker/training_commands.go
new file mode 100644
index 000000000..2af4ed30d
--- /dev/null
+++ b/decentralized-api/broker/training_commands.go
@@ -0,0 +1,79 @@
+package broker
+
+import (
+ "decentralized-api/logging"
+
+ "github.com/productscience/inference/x/inference/types"
+)
+
+type StartTrainingCommand struct {
+ taskId uint64
+ masterNodeAddress string
+ worldSize int
+ nodeRanks map[string]int // Key is nodeId
+ Response chan bool
+}
+
+func NewStartTrainingCommand(taskId uint64, masterNodeAddress string, worldSize int, nodeRanks map[string]int) StartTrainingCommand {
+ return StartTrainingCommand{
+ taskId: taskId,
+ masterNodeAddress: masterNodeAddress,
+ worldSize: worldSize,
+ nodeRanks: nodeRanks,
+ Response: make(chan bool, 2),
+ }
+}
+
+func (c StartTrainingCommand) GetResponseChannelCapacity() int {
+ return cap(c.Response)
+}
+
+func (c StartTrainingCommand) Execute(broker *Broker) {
+ epochState := broker.phaseTracker.GetCurrentEpochState()
+ if epochState.IsNilOrNotSynced() {
+ logging.Error("StartTrainingCommand executed with nil or not synced epoch state", types.Training,
+ "epoch_state", epochState)
+ c.Response <- false
+ return
+ }
+
+ if epochState.CurrentPhase != types.InferencePhase {
+ logging.Error("StartTrainingCommand executed in wrong phase", types.Training,
+ "current_phase", epochState.CurrentPhase, "expected_phase", types.InferencePhase)
+ c.Response <- false
+ return
+ }
+
+ broker.mu.Lock()
+ defer broker.mu.Unlock()
+ for nodeId := range c.nodeRanks {
+ node, nodeFound := broker.nodes[nodeId]
+ if !nodeFound || node == nil {
+ logging.Error("Node not found or nil for training", types.Nodes,
+ "node_id", nodeId, "nodeFound", nodeFound, "node == nil", node == nil)
+ continue
+ }
+
+ if !node.State.ShouldBeOperational(epochState.LatestEpoch.EpochIndex, epochState.CurrentPhase) {
+ logging.Error("Selected disabled node for training", types.Nodes,
+ "node_id", nodeId,
+ "AdminState.Epoch", node.State.AdminState.Epoch,
+ "AdminState.Enabled", node.State.AdminState.Enabled,
+ "current_epoch", epochState.LatestEpoch.EpochIndex,
+ "current_phase", epochState.CurrentPhase)
+ continue
+ }
+
+ node.State.IntendedStatus = types.HardwareNodeStatus_TRAINING
+ node.State.TrainingTask = &TrainingTaskPayload{
+ Id: c.taskId,
+ MasterNodeAddr: c.masterNodeAddress,
+ NodeRanks: c.nodeRanks,
+ WorldSize: c.worldSize,
+ }
+ }
+
+ broker.TriggerReconciliation()
+
+ c.Response <- true
+}
diff --git a/decentralized-api/chainphase/phase_tracker.go b/decentralized-api/chainphase/phase_tracker.go
new file mode 100644
index 000000000..9c61285aa
--- /dev/null
+++ b/decentralized-api/chainphase/phase_tracker.go
@@ -0,0 +1,93 @@
+package chainphase
+
+import (
+ "sync"
+
+ "github.com/productscience/inference/x/inference/types"
+)
+
+// ChainPhaseTracker acts as a thread-safe cache for the current Epoch's state.
+// It is updated by the OnNewBlockDispatcher and used by other components like the Broker
+// to get consistent and reliable information about the current Epoch and phase.
+type ChainPhaseTracker struct {
+ mu sync.RWMutex
+
+ currentBlock BlockInfo
+ // latestEpoch is not the effective epoch, but the latest epoch that has been set
+ // so if PoC has just started it will be effectiveEpoch + 1
+ latestEpoch *types.Epoch
+ currentEpochParams *types.EpochParams
+ currentIsSynced bool
+ activeConfirmationPoCEvent *types.ConfirmationPoCEvent
+}
+
+type BlockInfo struct {
+ Height int64
+ Hash string
+}
+
+// NewChainPhaseTracker creates a new ChainPhaseTracker instance.
+func NewChainPhaseTracker() *ChainPhaseTracker {
+ return &ChainPhaseTracker{}
+}
+
+// Update caches the latest Epoch information from the network.
+// This method should be called by the OnNewBlockDispatcher on every new block.
+func (t *ChainPhaseTracker) Update(block BlockInfo, epoch *types.Epoch, params *types.EpochParams, isSynced bool, confirmationPoCEvent *types.ConfirmationPoCEvent) {
+ t.mu.Lock()
+ defer t.mu.Unlock()
+
+ t.currentBlock = block
+ t.latestEpoch = epoch
+ t.currentEpochParams = params
+ t.currentIsSynced = isSynced
+ t.activeConfirmationPoCEvent = confirmationPoCEvent
+}
+
+type EpochState struct {
+ LatestEpoch types.EpochContext
+ CurrentBlock BlockInfo
+ CurrentPhase types.EpochPhase
+ IsSynced bool
+ ActiveConfirmationPoCEvent *types.ConfirmationPoCEvent
+}
+
+func (es *EpochState) IsNilOrNotSynced() bool {
+ return es == nil || !es.IsSynced
+}
+
+func (t *ChainPhaseTracker) GetCurrentEpochState() *EpochState {
+ t.mu.RLock()
+ defer t.mu.RUnlock()
+
+ if t.latestEpoch == nil || t.currentEpochParams == nil {
+ return nil
+ }
+
+ // Create a new context for this specific query to ensure consistency
+ ec := types.NewEpochContext(*t.latestEpoch, *t.currentEpochParams)
+ phase := ec.GetCurrentPhase(t.currentBlock.Height)
+
+ return &EpochState{
+ LatestEpoch: ec,
+ CurrentBlock: t.currentBlock,
+ CurrentPhase: phase,
+ IsSynced: t.currentIsSynced,
+ ActiveConfirmationPoCEvent: t.activeConfirmationPoCEvent,
+ }
+}
+
+// To de deleted once you refactor validation
+func (t *ChainPhaseTracker) GetEpochParams() *types.EpochParams {
+ t.mu.RLock()
+ defer t.mu.RUnlock()
+
+ return t.currentEpochParams
+}
+
+func (t *ChainPhaseTracker) UpdateEpochParams(params types.EpochParams) {
+ t.mu.Lock()
+ defer t.mu.Unlock()
+
+ t.currentEpochParams = ¶ms
+}
diff --git a/decentralized-api/completionapi/completionresponse.go b/decentralized-api/completionapi/completionresponse.go
new file mode 100644
index 000000000..714e53fb9
--- /dev/null
+++ b/decentralized-api/completionapi/completionresponse.go
@@ -0,0 +1,365 @@
+package completionapi
+
+import (
+ "decentralized-api/logging"
+ "decentralized-api/utils"
+ "encoding/json"
+ "errors"
+ "strings"
+
+ "github.com/productscience/inference/x/inference/types"
+)
+
+type CompletionResponse interface {
+ GetModel() (string, error)
+ GetInferenceId() (string, error)
+ GetUsage() (*Usage, error)
+ GetBodyBytes() ([]byte, error)
+ GetHash() (string, error)
+
+ // Validation-related methods
+ GetEnforcedStr() (string, error)
+ GetEnforcedTokens() (EnforcedTokens, error)
+ ExtractLogits() []Logprob
+}
+
+type JsonCompletionResponse struct {
+ Bytes []byte
+ Resp Response
+}
+
+func (r *JsonCompletionResponse) GetModel() (string, error) {
+ return r.Resp.Model, nil
+}
+
+func (r *JsonCompletionResponse) GetInferenceId() (string, error) {
+ return r.Resp.ID, nil
+}
+
+func (r *JsonCompletionResponse) GetUsage() (*Usage, error) {
+ if r.Resp.Usage.IsEmpty() {
+ return nil, errors.New("JsonCompletionResponse: no usage found")
+ }
+ return &r.Resp.Usage, nil
+}
+
+func (r *JsonCompletionResponse) GetBodyBytes() ([]byte, error) {
+ return r.Bytes, nil
+}
+
+func (r *JsonCompletionResponse) GetHash() (string, error) {
+ var builder strings.Builder
+ for _, choice := range r.Resp.Choices {
+ builder.WriteString(choice.Message.Content)
+ }
+
+ return computeHash(builder.String())
+}
+
+func (r *JsonCompletionResponse) GetEnforcedStr() (string, error) {
+ if len(r.Resp.Choices) == 0 {
+ return "", errors.New("JsonResponse has no choices")
+ }
+
+ if len(r.Resp.Choices) > 1 {
+ // TODO: We should learn how to process/validate multiple options completions
+ logging.Warn("More than one choice in a non-steamed inference response, defaulting to first one", types.Validation, "choices", r.Resp.Choices)
+ }
+
+ content := r.Resp.Choices[0].Message.Content
+ if content == "" {
+ logging.Error("Model return empty response", types.Validation, "inference_id", r.Resp.ID)
+ return "", errors.New("JsonResponse has no content")
+ }
+
+ return content, nil
+}
+
+type EnforcedToken struct {
+ Token string `json:"token"`
+ TopTokens []string `json:"top_tokens"`
+}
+
+type EnforcedTokens struct {
+ Tokens []EnforcedToken `json:"tokens"`
+ RunSeed string `json:"run_seed,omitempty"`
+}
+
+func (r *JsonCompletionResponse) GetEnforcedTokens() (EnforcedTokens, error) {
+ if len(r.Resp.Choices) == 0 {
+ logging.Error("JsonCompletionResponse has no choices for enforced tokens", types.Validation, "inference_id", r.Resp.ID)
+ return EnforcedTokens{}, errors.New("JsonCompletionResponse: no choices found")
+ }
+
+ if len(r.Resp.Choices) > 1 {
+ logging.Warn(
+ "More than one choice in a non-streamed inference response for enforced tokens, defaulting to first one",
+ types.Validation,
+ "inference_id",
+ r.Resp.ID,
+ "choices",
+ r.Resp.Choices,
+ )
+ }
+
+ var enforcedTokens EnforcedTokens
+ enforcedTokens.RunSeed = r.Resp.Choices[0].Logprobs.RunSeed
+ for _, c := range r.Resp.Choices[0].Logprobs.Content {
+ if c.TopLogprobs == nil {
+ continue
+ }
+
+ if len(c.TopLogprobs) == 0 {
+ logging.Error(
+ "Choice has no logprobs content for enforced tokens",
+ types.Validation,
+ "inference_id",
+ r.Resp.ID,
+ )
+ return EnforcedTokens{}, errors.New("JsonCompletionResponse: choice has no logprobs content")
+ }
+
+ var topTokens []string
+ for _, topToken := range c.TopLogprobs {
+ topTokens = append(topTokens, topToken.Token)
+ }
+ enforcedTokens.Tokens = append(enforcedTokens.Tokens, EnforcedToken{
+ Token: c.Token,
+ TopTokens: topTokens,
+ })
+ }
+ return enforcedTokens, nil
+}
+
+func (r *StreamedCompletionResponse) GetEnforcedTokens() (EnforcedTokens, error) {
+ if len(r.Resp.Data) == 0 {
+ logging.Error("StreamedCompletionResponse has no data for enforced tokens", types.Validation)
+ return EnforcedTokens{}, ErrorNoDataAvailableInStreamedResponse
+ }
+
+ var enforcedTokens EnforcedTokens
+ for _, c := range r.Resp.Data {
+ if len(c.Choices) == 0 {
+ continue
+ }
+
+ if len(c.Choices) > 1 {
+ logging.Warn("More than one choice in a streamed inference response for enforced tokens, defaulting to first one", types.Validation, "inference_id", c.ID, "choices", c.Choices)
+ }
+
+ for _, choice := range c.Choices {
+ if enforcedTokens.RunSeed == "" {
+ enforcedTokens.RunSeed = choice.Logprobs.RunSeed
+ }
+
+ if choice.Logprobs.Content == nil {
+ continue
+ }
+
+ if len(choice.Logprobs.Content) == 0 {
+ logging.Error("Choice has no logprobs content for enforced tokens", types.Validation, "inference_id", c.ID)
+ return EnforcedTokens{}, errors.New("StreamedCompletionResponse: choice has no logprobs content")
+ }
+
+ var topTokens []string
+ for _, topToken := range choice.Logprobs.Content[0].TopLogprobs {
+ topTokens = append(topTokens, topToken.Token)
+ }
+ enforcedTokens.Tokens = append(enforcedTokens.Tokens, EnforcedToken{
+ Token: choice.Logprobs.Content[0].Token,
+ TopTokens: topTokens,
+ })
+ }
+ }
+
+ if len(enforcedTokens.Tokens) == 0 {
+ logging.Error("No enforced tokens found in streamed response", types.Validation)
+ return EnforcedTokens{}, errors.New("StreamedCompletionResponse: no enforced tokens found")
+ }
+
+ return enforcedTokens, nil
+}
+
+func computeHash(content string) (string, error) {
+ if content == "" {
+ return "", errors.New("CompletionResponse: can't compute hash, empty content")
+ }
+
+ hash := utils.GenerateSHA256Hash(content)
+ return hash, nil
+}
+
+type StreamedCompletionResponse struct {
+ Lines []string
+ Resp StreamedResponse
+}
+
+var ErrorNoDataAvailableInStreamedResponse = errors.New("no data available in streamed response")
+
+func (r *StreamedCompletionResponse) GetModel() (string, error) {
+ if len(r.Resp.Data) > 0 {
+ return r.Resp.Data[0].Model, nil
+ } else {
+ return "", ErrorNoDataAvailableInStreamedResponse
+ }
+}
+
+func (r *StreamedCompletionResponse) GetInferenceId() (string, error) {
+ if len(r.Resp.Data) > 0 {
+ return r.Resp.Data[0].ID, nil
+ } else {
+ return "", ErrorNoDataAvailableInStreamedResponse
+ }
+}
+
+func (r *StreamedCompletionResponse) GetUsage() (*Usage, error) {
+ backupLength := 0
+ if len(r.Resp.Data) > 0 {
+ for _, d := range r.Resp.Data {
+ if len(d.Choices) != 0 {
+ backupLength += len(d.Choices[0].Logprobs.Content)
+ }
+ if d.Usage.IsEmpty() {
+ continue
+ }
+ return &d.Usage, nil
+ }
+ usage := &Usage{
+ PromptTokens: 0,
+ CompletionTokens: uint64(backupLength),
+ }
+ return usage, nil
+ } else {
+ return nil, ErrorNoDataAvailableInStreamedResponse
+ }
+}
+
+func (r *StreamedCompletionResponse) GetBodyBytes() ([]byte, error) {
+ serialized := SerializedStreamedResponse{
+ Events: r.Lines,
+ }
+ return json.Marshal(&serialized)
+}
+
+func (r *StreamedCompletionResponse) GetHash() (string, error) {
+ var builder strings.Builder
+ for _, choice := range r.Resp.Data {
+ for _, c := range choice.Choices {
+ delta := c.Delta.Content
+ if delta != nil {
+ builder.WriteString(*delta)
+ }
+ }
+ }
+
+ return computeHash(builder.String())
+}
+
+func (r *StreamedCompletionResponse) GetEnforcedStr() (string, error) {
+ var id = ""
+ var stringBuilder strings.Builder
+ for _, event := range r.Resp.Data {
+ id = event.ID
+ if len(event.Choices) == 0 {
+ continue
+ }
+
+ if len(event.Choices) > 1 {
+ // TODO: We should learn how to process/validate multiple options completions
+ logging.Warn("More than one choice in a streamed inference response, defaulting to first one", types.Validation, "inferenceId", event.ID, "choices", event.Choices)
+ }
+
+ content := event.Choices[0].Delta.Content
+ if content != nil {
+ stringBuilder.WriteString(*content)
+ }
+ }
+
+ responseString := stringBuilder.String()
+ if responseString == "" {
+ logging.Error("Model return empty response", types.Validation, "inference_id", id)
+ return "", errors.New("StreamedResponse has no content")
+ }
+
+ return responseString, nil
+}
+
+func (r *JsonCompletionResponse) ExtractLogits() []Logprob {
+ var logits []Logprob
+ // Concatenate all logrpobs
+ for _, c := range r.Resp.Choices {
+ logits = append(logits, c.Logprobs.Content...)
+ }
+ return logits
+}
+
+func (r *StreamedCompletionResponse) ExtractLogits() []Logprob {
+ var logits []Logprob
+ for _, r := range r.Resp.Data {
+ for _, c := range r.Choices {
+ logits = append(logits, c.Logprobs.Content...)
+ }
+ }
+ return logits
+}
+
+func NewCompletionResponseFromBytes(bytes []byte) (CompletionResponse, error) {
+ var response Response
+ if err := json.Unmarshal(bytes, &response); err != nil {
+ logging.Error("Failed to unmarshal json response into completionapi.Response", types.Inferences, "responseString", string(bytes), "err", err)
+ return nil, err
+ }
+
+ return &JsonCompletionResponse{
+ Bytes: bytes,
+ Resp: response,
+ }, nil
+}
+
+func NewCompletionResponseFromLines(lines []string) (CompletionResponse, error) {
+ data := make([]Response, 0)
+ for _, event := range lines {
+ trimmedEvent := strings.TrimSpace(strings.TrimPrefix(strings.TrimSpace(event), "data:"))
+ if trimmedEvent == "[DONE]" || trimmedEvent == "" {
+ // TODO: should we make sure somehow that [DONE] was indeed received?
+ continue
+ }
+
+ var response Response
+ if err := json.Unmarshal([]byte(trimmedEvent), &response); err != nil {
+ logging.Error("Failed to unmarshal streamed response line into completionapi.Response", types.Inferences, "event", event, "trimmedEvent", trimmedEvent, "err", err)
+ return nil, err
+ }
+ data = append(data, response)
+ }
+ streamedResponse := StreamedResponse{
+ Data: data,
+ }
+ return &StreamedCompletionResponse{
+ Lines: lines,
+ Resp: streamedResponse,
+ }, nil
+}
+
+func NewCompletionResponseFromLinesFromResponsePayload(payload string) (CompletionResponse, error) {
+ var genericMap map[string]interface{}
+ bytes := []byte(payload)
+ if err := json.Unmarshal(bytes, &genericMap); err != nil {
+ logging.Error("Failed to unmarshal response payload into var genericMap map[string]interface{}", types.Inferences, "err", err)
+ return nil, err
+ }
+
+ if _, exists := genericMap["events"]; exists {
+ logging.Info("Unmarshaling streamed response", types.Inferences)
+
+ var serialized SerializedStreamedResponse
+ if err := json.Unmarshal(bytes, &serialized); err != nil {
+ logging.Error("Failed to unmarshal response payload into SerializedStreamedResponse", types.Inferences, "err", err)
+ return nil, err
+ }
+
+ return NewCompletionResponseFromLines(serialized.Events)
+ } else {
+ return NewCompletionResponseFromBytes(bytes)
+ }
+}
diff --git a/decentralized-api/completionapi/openai.go b/decentralized-api/completionapi/openai.go
new file mode 100644
index 000000000..6f7208dce
--- /dev/null
+++ b/decentralized-api/completionapi/openai.go
@@ -0,0 +1,65 @@
+package completionapi
+
+type Response struct {
+ ID string `json:"id"`
+ Object string `json:"object"`
+ Created int64 `json:"created"`
+ Model string `json:"model"`
+ SystemFingerprint string `json:"system_fingerprint"`
+ Choices []Choice `json:"choices"`
+ Usage Usage `json:"usage"`
+}
+
+type Choice struct {
+ Index int `json:"index"`
+ Message *Message `json:"message"`
+ Delta *Delta `json:"delta"`
+ Logprobs struct {
+ Content []Logprob `json:"content"`
+ RunSeed string `json:"run_seed,omitempty"`
+ } `json:"logprobs"`
+ FinishReason string `json:"finish_reason"`
+ StopReason string `json:"stop_reason"`
+}
+
+type Message struct {
+ Role string `json:"role"`
+ Content string `json:"content"`
+}
+
+type Delta struct {
+ Role *string `json:"role"`
+ Content *string `json:"content"`
+}
+
+type TopLogprobs struct {
+ Token string `json:"token"`
+ Logprob float64 `json:"logprob"`
+ Bytes []int `json:"bytes"`
+}
+
+type Logprob struct {
+ Token string `json:"token"`
+ Logprob float64 `json:"logprob"`
+ Bytes []int `json:"bytes"`
+ TopLogprobs []TopLogprobs `json:"top_logprobs"`
+}
+
+type Usage struct {
+ PromptTokens uint64 `json:"prompt_tokens"`
+ CompletionTokens uint64 `json:"completion_tokens"`
+}
+
+func (u *Usage) IsEmpty() bool {
+ return u.PromptTokens == 0 && u.CompletionTokens == 0
+}
+
+const DataPrefix = "data: "
+
+type SerializedStreamedResponse struct {
+ Events []string `json:"events"`
+}
+
+type StreamedResponse struct {
+ Data []Response `json:"data"`
+}
diff --git a/decentralized-api/completionapi/request.go b/decentralized-api/completionapi/request.go
new file mode 100644
index 000000000..f2670c295
--- /dev/null
+++ b/decentralized-api/completionapi/request.go
@@ -0,0 +1,128 @@
+package completionapi
+
+import (
+ "encoding/json"
+ "log"
+
+ "github.com/productscience/inference/x/inference/calculations"
+)
+
+type ModifiedRequest struct {
+ NewBody []byte
+ OriginalLogprobsValue *bool
+ OriginalTopLogprobsValue *int
+}
+
+func ModifyRequestBody(requestBytes []byte, defaultSeed int32) (*ModifiedRequest, error) {
+ var requestMap map[string]interface{}
+ if err := json.Unmarshal(requestBytes, &requestMap); err != nil {
+ return nil, err
+ }
+
+ originalLogprobsValue := getOriginalLogprobs(requestMap)
+ if originalLogprobsValue == nil || *originalLogprobsValue == false {
+ requestMap["logprobs"] = true
+ }
+
+ originalTopLogprobsValue := getOriginalTopLogprobs(requestMap)
+ if originalTopLogprobsValue == nil || *originalTopLogprobsValue < 5 {
+ requestMap["top_logprobs"] = 5
+ }
+
+ maxTokens := getMaxTokens(requestMap)
+
+ requestMap["max_tokens"] = maxTokens
+ requestMap["max_completion_tokens"] = maxTokens
+ requestMap["skip_special_tokens"] = false
+ if _, ok := requestMap["seed"]; !ok {
+ requestMap["seed"] = defaultSeed
+ }
+
+ if doStream, ok := requestMap["stream"]; ok && doStream.(bool) {
+ if _, ok := requestMap["stream_options"]; !ok {
+ requestMap["stream_options"] = map[string]interface{}{"include_usage": true}
+ } else {
+ requestMap["stream_options"].(map[string]interface{})["include_usage"] = true
+ }
+ }
+
+ modifiedRequestBytes, err := json.Marshal(requestMap)
+ if err != nil {
+ return nil, err
+ }
+
+ return &ModifiedRequest{
+ NewBody: modifiedRequestBytes,
+ OriginalLogprobsValue: originalLogprobsValue,
+ OriginalTopLogprobsValue: originalTopLogprobsValue,
+ }, nil
+}
+
+func getMaxTokens(requestMap map[string]interface{}) int {
+ if maxTokensValue, ok := requestMap["max_tokens"]; ok {
+ if maxTokensFloat, ok := maxTokensValue.(float64); ok {
+ return int(maxTokensFloat)
+ }
+ if maxTokensInt, ok := maxTokensValue.(int); ok {
+ return maxTokensInt
+ }
+ }
+ if maxCompletionTokensValue, ok := requestMap["max_completion_tokens"]; ok {
+ if maxCompletionTokensFloat, ok := maxCompletionTokensValue.(float64); ok {
+ return int(maxCompletionTokensFloat)
+ }
+ if maxCompletionTokensInt, ok := maxCompletionTokensValue.(int); ok {
+ return maxCompletionTokensInt
+ }
+ }
+ return calculations.DefaultMaxTokens // Default value if not specified
+}
+
+func getOriginalLogprobs(requestMap map[string]interface{}) *bool {
+ logprobsValue, ok := requestMap["logprobs"]
+ if !ok {
+ return nil
+ }
+
+ if logprobsValue == nil {
+ return nil
+ }
+
+ if logprobsValueBool, ok := logprobsValue.(bool); ok {
+ return &logprobsValueBool
+ }
+
+ // Interpret any non-boolean value as true
+ log.Printf("Original request logprobs = %v", logprobsValue)
+ trueValue := true
+ return &trueValue
+}
+
+func getOriginalTopLogprobs(requestMap map[string]interface{}) *int {
+ topLogprobsValue, ok := requestMap["top_logprobs"]
+ if !ok {
+ return nil
+ }
+
+ if topLogprobsValue == nil {
+ return nil
+ }
+
+ if topLogprobsValueInt, ok := topLogprobsValue.(int); ok {
+ return &topLogprobsValueInt
+ }
+
+ if topLogprobsValueBool, ok := topLogprobsValue.(bool); ok {
+ if topLogprobsValueBool {
+ one := 1
+ return &one
+ } else {
+ zero := 0
+ return &zero
+ }
+ }
+
+ // Discard any non-integer value
+ log.Printf("Original request top_logprobs = %v", topLogprobsValue)
+ return nil
+}
diff --git a/decentralized-api/completionapi/request_test.go b/decentralized-api/completionapi/request_test.go
new file mode 100644
index 000000000..dab752556
--- /dev/null
+++ b/decentralized-api/completionapi/request_test.go
@@ -0,0 +1,155 @@
+package completionapi
+
+import (
+ "encoding/json"
+ "log"
+ "testing"
+
+ "github.com/productscience/inference/x/inference/calculations"
+ "github.com/stretchr/testify/require"
+)
+
+const (
+ jsonBody = `{
+ "temperature": 0.8,
+ "model": "Qwen/Qwen2.5-7B-Instruct",
+ "messages": [{
+ "role": "system",
+ "content": "Regardless of the language of the question, answer in english"
+ },
+ {
+ "role": "user",
+ "content": "When did Hawaii become a state?"
+ }]
+ }`
+
+ jsonBodyNullLogprobs = `{
+ "temperature": 0.8,
+ "model": "Qwen/Qwen2.5-7B-Instruct",
+ "messages": [{
+ "role": "system",
+ "content": "Regardless of the language of the question, answer in english"
+ },
+ {
+ "role": "user",
+ "content": "When did Hawaii become a state?"
+ }],
+ "logprobs": null
+ }`
+
+ jsonBodyStreamNoStreamOptions = `{
+ "model": "Qwen/Qwen2.5-7B-Instruct",
+ "temperature": 0.8,
+ "stream": true,
+ "messages": [
+ { "role": "user", "content": "Hi!" }
+ ]
+ }`
+
+ jsonBodyStreamWithStreamOptions = `{
+ "model": "Qwen/Qwen2.5-7B-Instruct",
+ "temperature": 0.8,
+ "stream": true,
+ "stream_options": {"include_usage": false},
+ "messages": [
+ { "role": "user", "content": "Hi!" }
+ ]
+ }`
+
+ jsonBodyWithMaxTokens = `{
+ "model": "Qwen/Qwen2.5-7B-Instruct",
+ "temperature": 0.8,
+ "max_tokens": 100,
+ "messages": [
+ { "role": "user", "content": "Hi!" }
+ ]
+ }`
+
+ jsonBodyWithMaxCompletionTokens = `{
+ "model": "Qwen/Qwen2.5-7B-Instruct",
+ "temperature": 0.8,
+ "max_completion_tokens": 200,
+ "messages": [
+ { "role": "user", "content": "Hi!" }
+ ]
+ }`
+
+ jsonBodyNoTokenLimits = `{
+ "model": "Qwen/Qwen2.5-7B-Instruct",
+ "temperature": 0.8,
+ "messages": [
+ { "role": "user", "content": "Hi!" }
+ ]
+ }`
+)
+
+func Test(t *testing.T) {
+ r, err := ModifyRequestBody([]byte(jsonBodyNullLogprobs), 7)
+ if err != nil {
+ panic(err)
+ }
+ if r.OriginalLogprobsValue != nil {
+ t.Fatalf("expected nil, got %v", r.OriginalLogprobsValue)
+ }
+ if r.OriginalTopLogprobsValue != nil {
+ t.Fatalf("expected nil, got %v", r.OriginalTopLogprobsValue)
+ }
+ log.Printf(string(r.NewBody))
+}
+
+func TestStreamOptions_NoOptions(t *testing.T) {
+ r, err := ModifyRequestBody([]byte(jsonBodyStreamNoStreamOptions), 7)
+ require.NoError(t, err)
+ require.NotNil(t, r)
+ var requestMap map[string]interface{}
+ if err := json.Unmarshal(r.NewBody, &requestMap); err != nil {
+ require.NoError(t, err, "failed to unmarshal request body")
+ }
+
+ require.NotNil(t, requestMap["stream_options"])
+ require.True(t, requestMap["stream_options"].(map[string]interface{})["include_usage"].(bool), "expected include_usage to be true")
+ log.Printf(string(r.NewBody))
+}
+
+func TestStreamOptions_WithOptions(t *testing.T) {
+ r, err := ModifyRequestBody([]byte(jsonBodyStreamWithStreamOptions), 7)
+ require.NoError(t, err)
+ require.NotNil(t, r)
+ var requestMap map[string]interface{}
+ if err := json.Unmarshal(r.NewBody, &requestMap); err != nil {
+ require.NoError(t, err, "failed to unmarshal request body")
+ }
+
+ require.NotNil(t, requestMap["stream_options"])
+ require.True(t, requestMap["stream_options"].(map[string]interface{})["include_usage"].(bool), "expected include_usage to be true")
+ log.Printf(string(r.NewBody))
+}
+
+func TestMaxTokens(t *testing.T) {
+ tests := []struct {
+ name string
+ input string
+ expected int
+ }{
+ {"WithMaxTokens", jsonBodyWithMaxTokens, 100},
+ {"WithMaxCompletionTokens", jsonBodyWithMaxCompletionTokens, 200},
+ {"NoTokenLimits", jsonBodyNoTokenLimits, calculations.DefaultMaxTokens},
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ r, err := ModifyRequestBody([]byte(tt.input), 7)
+ require.NoError(t, err)
+ require.NotNil(t, r)
+
+ var requestMap map[string]interface{}
+ err = json.Unmarshal(r.NewBody, &requestMap)
+ require.NoError(t, err, "failed to unmarshal request body")
+
+ maxTokens := requestMap["max_tokens"].(float64)
+ maxCompletionTokens := requestMap["max_completion_tokens"].(float64)
+ require.Equal(t, float64(tt.expected), maxTokens)
+ require.Equal(t, float64(tt.expected), maxCompletionTokens)
+ })
+ }
+}
diff --git a/decentralized-api/completionapi/responseprocessor.go b/decentralized-api/completionapi/responseprocessor.go
new file mode 100644
index 000000000..1a56b5aac
--- /dev/null
+++ b/decentralized-api/completionapi/responseprocessor.go
@@ -0,0 +1,98 @@
+package completionapi
+
+import (
+ "encoding/json"
+ "errors"
+ "strings"
+)
+
+type ResponseProcessor interface {
+ ProcessJsonResponse(responseBytes []byte) ([]byte, error)
+
+ ProcessStreamedResponse(line string) (string, error)
+
+ GetResponseBytes() ([]byte, error)
+}
+
+type ExecutorResponseProcessor struct {
+ inferenceId string
+ jsonResponseBytes []byte
+ streamedResponse []string
+}
+
+func NewExecutorResponseProcessor(inferenceId string) *ExecutorResponseProcessor {
+ return &ExecutorResponseProcessor{
+ inferenceId: inferenceId,
+ jsonResponseBytes: nil,
+ streamedResponse: nil,
+ }
+}
+
+func (rt *ExecutorResponseProcessor) ProcessJsonResponse(responseBytes []byte) ([]byte, error) {
+ updatedBodyBytes, err := addOrReplaceIdValue(responseBytes, rt.inferenceId)
+ if err != nil {
+ return nil, err
+ }
+
+ rt.jsonResponseBytes = updatedBodyBytes
+
+ return updatedBodyBytes, nil
+}
+
+func (rt *ExecutorResponseProcessor) ProcessStreamedResponse(line string) (string, error) {
+ updatedLine, err := getUpdatedLine(line, rt.inferenceId)
+ rt.streamedResponse = append(rt.streamedResponse, updatedLine)
+ return updatedLine, err
+}
+
+func getUpdatedLine(line string, id string) (string, error) {
+ if !strings.HasPrefix(line, DataPrefix) {
+ return line, nil
+ }
+
+ trimmed := strings.TrimSpace(strings.TrimPrefix(line, DataPrefix))
+ if strings.HasPrefix(trimmed, "[DONE]") {
+ return line, nil
+ }
+
+ updatedBodyBytes, err := addOrReplaceIdValue([]byte(trimmed), id)
+ if err != nil {
+ return line, err
+ }
+
+ return DataPrefix + string(updatedBodyBytes), nil
+}
+
+func addOrReplaceIdValue(bytes []byte, id string) ([]byte, error) {
+ var bodyMap map[string]interface{}
+ err := json.Unmarshal(bytes, &bodyMap)
+ if err != nil {
+ return nil, err
+ }
+
+ bodyMap["id"] = id
+
+ return json.Marshal(bodyMap)
+}
+
+func (rt *ExecutorResponseProcessor) GetResponseBytes() ([]byte, error) {
+ if rt.jsonResponseBytes != nil {
+ return rt.jsonResponseBytes, nil
+ } else if rt.streamedResponse != nil {
+ response := SerializedStreamedResponse{
+ Events: rt.streamedResponse,
+ }
+ return json.Marshal(response)
+ }
+ return rt.jsonResponseBytes, nil
+}
+
+func (rt *ExecutorResponseProcessor) GetResponse() (CompletionResponse, error) {
+ if rt.jsonResponseBytes != nil {
+ return NewCompletionResponseFromBytes(rt.jsonResponseBytes)
+ } else if rt.streamedResponse != nil {
+ return NewCompletionResponseFromLines(rt.streamedResponse)
+ }
+
+ return nil, errors.New("ExecutorResponseProcessor: can't get response; both jsonResponseBytes and streamedResponse are empty")
+}
diff --git a/decentralized-api/completionapi/responseprocessor_test.go b/decentralized-api/completionapi/responseprocessor_test.go
new file mode 100644
index 000000000..632e461f4
--- /dev/null
+++ b/decentralized-api/completionapi/responseprocessor_test.go
@@ -0,0 +1,190 @@
+package completionapi
+
+import (
+ "bufio"
+ "fmt"
+ "os"
+ "strings"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+)
+
+func TestProcessingJsonResponse(t *testing.T) {
+ processor := NewExecutorResponseProcessor("dummy-id")
+ processor.ProcessJsonResponse([]byte("dummy-response"))
+}
+
+const EVENT = `
+data: {"id":"cmpl-3973dab1430143849df83d943ea0c7ac","object":"chat.completion.chunk","created":1726472629,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":"9"},"logprobs":{"content":[{"token":"9","logprob":0.0,"bytes":[57],"top_logprobs":[{"token":"9","logprob":0.0,"bytes":[57]},{"token":"8","logprob":-23.125,"bytes":[56]},{"token":"0","logprob":-24.125,"bytes":[48]}]}]},"finish_reason":null}]}
+`
+
+func TestProcessingStreamedEvents(t *testing.T) {
+ dummyId := "dummy-inference-id"
+ processor := NewExecutorResponseProcessor(dummyId)
+ var updatedLine string
+ var err error
+ updatedLine, err = processor.ProcessStreamedResponse(strings.TrimSpace(EVENT))
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+
+ println(updatedLine)
+
+ if !strings.Contains(updatedLine, dummyId) {
+ t.Fatalf("expected %s to contain %s", updatedLine, dummyId)
+ }
+
+ bytes, err := processor.GetResponseBytes()
+ if err != nil {
+ t.Fatalf("unexpected error for GetResponseBytes: %v", err)
+ }
+
+ println(string(bytes))
+}
+
+func TestCompletionTokenCountForStreamedResponse(t *testing.T) {
+ dummyId := "dummy-inference-id"
+ processor := NewExecutorResponseProcessor(dummyId)
+
+ events := readLines(t, "test_data/response_streamed.txt")
+ require.NotEmpty(t, events, "Read 0 events from responseprocessor_test_data.txt")
+ for _, event := range events {
+ _, err := processor.ProcessStreamedResponse(event)
+ require.NoError(t, err, "failed to process a line of a streamed response")
+ }
+
+ response, err := processor.GetResponse()
+ fmt.Printf("Response: %+v\n", response)
+ require.NoError(t, err, "GetResponse failed")
+ id, err := response.GetInferenceId()
+ require.Equal(t, dummyId, id, "expected inference id to be %s, got %s", dummyId, id)
+ model, err := response.GetModel()
+ require.Equal(t, "Qwen/Qwen2.5-7B-Instruct", model, "expected model to be %s, got %s", "Qwen/Qwen2.5-7B-Instruct", model)
+ usage, err := response.GetUsage()
+ expectedUsage := &Usage{
+ PromptTokens: 31,
+ CompletionTokens: 10,
+ }
+ require.NotNil(t, usage, "expected usage to be not nil")
+ require.Equal(t, *expectedUsage, *usage, "expected usage to be %v, got %v", *expectedUsage, *usage)
+
+ hash, err := response.GetHash()
+ require.NoError(t, err, "GetHash failed")
+ require.NotEmpty(t, hash, "expected hash to be not empty")
+}
+
+func TestCompletionTokenCountForStreamedResponseWithTokenIds(t *testing.T) {
+ dummyId := "dummy-inference-id"
+ processor := NewExecutorResponseProcessor(dummyId)
+
+ events := readLines(t, "test_data/response_streamed_token_ids.txt")
+ require.NotEmpty(t, events, "Read 0 events from responseprocessor_test_data.txt")
+ for _, event := range events {
+ _, err := processor.ProcessStreamedResponse(event)
+ require.NoError(t, err, "failed to process a line of a streamed response")
+ }
+
+ response, err := processor.GetResponse()
+
+ enforcedTokens, err := response.GetEnforcedTokens()
+ require.NoError(t, err, "GetEnforcedTokens failed")
+ require.NotEmpty(t, enforcedTokens, "expected enforced tokens to be not empty")
+ require.Equal(t, 44, len(enforcedTokens.Tokens), "expected 1 enforced token")
+
+ require.NoError(t, err, "GetResponse failed")
+ model, err := response.GetModel()
+ require.Equal(t, "Qwen/Qwen2.5-7B-Instruct", model, "expected model to be %s, got %s", "Qwen/Qwen2.5-7B-Instruct", model)
+
+ hash, err := response.GetHash()
+ require.NoError(t, err, "GetHash failed")
+ require.NotEmpty(t, hash, "expected hash to be not empty")
+}
+
+func TestCompletionTokenCountForWholeResponseWithTokenIds(t *testing.T) {
+ dummyId := "dummy-inference-id"
+ processor := NewExecutorResponseProcessor(dummyId)
+
+ responseBytes, err := loadJson("test_data/response_token_ids.json")
+ require.NoError(t, err, "failed to load json response")
+
+ _, err = processor.ProcessJsonResponse(responseBytes)
+ require.NoError(t, err, "failed to process json response")
+
+ response, err := processor.GetResponse()
+ require.NoError(t, err, "GetResponse failed")
+ model, err := response.GetModel()
+ require.NoError(t, err, "GetModel failed")
+ require.Equal(t, "Qwen/Qwen2.5-7B-Instruct", model, "expected model to be %s, got %s", "Qwen/Qwen2.5-7B-Instruct", model)
+ usage, err := response.GetUsage()
+ require.NoError(t, err, "GetUsage failed")
+ require.NotNil(t, usage, "expected usage to be not nil")
+
+ hash, err := response.GetHash()
+ require.NoError(t, err, "GetHash failed")
+ require.NotEmpty(t, hash, "expected hash to be not empty")
+
+ enforcedTokens, err := response.GetEnforcedTokens()
+ require.NoError(t, err, "GetEnforcedTokens failed")
+ require.NotEmpty(t, enforcedTokens, "expected enforced tokens to be not empty")
+ require.Equal(t, 28, len(enforcedTokens.Tokens), "expected 28 enforced tokens")
+}
+
+func readLines(t *testing.T, name string) []string {
+ t.Helper()
+
+ f, err := os.Open(name)
+ if err != nil {
+ t.Fatalf("open fixture: %v", err)
+ }
+ defer f.Close()
+
+ var lines []string
+ scanner := bufio.NewScanner(f)
+ for scanner.Scan() {
+ line := scanner.Text()
+ lines = append(lines, line)
+ }
+ if err := scanner.Err(); err != nil {
+ t.Fatalf("scan: %v", err)
+ }
+ return lines
+}
+
+func TestCompletionTokenCountForWholeResponse(t *testing.T) {
+ dummyId := "dummy-inference-id"
+ processor := NewExecutorResponseProcessor(dummyId)
+
+ responseBytes, err := loadJson("test_data/response.json")
+ require.NoError(t, err, "failed to load json response")
+
+ _, err = processor.ProcessJsonResponse(responseBytes)
+ require.NoError(t, err, "failed to process json response")
+
+ response, err := processor.GetResponse()
+ require.NoError(t, err, "GetResponse failed")
+ id, err := response.GetInferenceId()
+ require.Equal(t, dummyId, id, "expected inference id to be %s, got %s", dummyId, id)
+ model, err := response.GetModel()
+ require.Equal(t, "Qwen/Qwen2.5-7B-Instruct", model, "expected model to be %s, got %s", "Qwen/Qwen2.5-7B-Instruct", model)
+ usage, err := response.GetUsage()
+ expectedUsage := &Usage{
+ PromptTokens: 31,
+ CompletionTokens: 10,
+ }
+ require.NotNil(t, usage, "expected usage to be not nil")
+ require.Equal(t, *expectedUsage, *usage, "expected usage to be %v, got %v", *expectedUsage, *usage)
+
+ hash, err := response.GetHash()
+ require.NoError(t, err, "GetHash failed")
+ require.NotEmpty(t, hash, "expected hash to be not empty")
+}
+
+func loadJson(path string) ([]byte, error) {
+ data, err := os.ReadFile(path)
+ if err != nil {
+ return nil, fmt.Errorf("read %s: %w", path, err)
+ }
+
+ return data, nil
+}
diff --git a/decentralized-api/completionapi/serialization_test.go b/decentralized-api/completionapi/serialization_test.go
new file mode 100644
index 000000000..c7916a087
--- /dev/null
+++ b/decentralized-api/completionapi/serialization_test.go
@@ -0,0 +1,666 @@
+package completionapi
+
+import (
+ "encoding/json"
+ "github.com/stretchr/testify/require"
+ "testing"
+)
+
+const (
+ NO_LOGPROBS = `
+{
+ "id": "cmpl-2d320c7a47f24b02b48a376b979a9242",
+ "object": "chat.completion",
+ "created": 1722197559,
+ "model": "Qwen/Qwen2.5-7B-Instruct",
+ "choices": [
+ {
+ "index": 0,
+ "message": {
+ "role": "assistant",
+ "content": "August 21, 1959",
+ "tool_calls": []
+ },
+ "logprobs": null,
+ "finish_reason": "stop",
+ "stop_reason": null
+ }
+ ],
+ "usage": {
+ "prompt_tokens": 47,
+ "total_tokens": 55,
+ "completion_tokens": 8
+ }
+}`
+ LOGPROBS_NO_TOP_LOGPROBS = `
+{
+ "id": "cmpl-c5298389c6d34738b1ecb8a557ddfba3",
+ "object": "chat.completion",
+ "created": 1722197602,
+ "model": "Qwen/Qwen2.5-7B-Instruct",
+ "choices": [
+ {
+ "index": 0,
+ "message": {
+ "role": "assistant",
+ "content": "August 21, 1959",
+ "tool_calls": []
+ },
+ "logprobs": {
+ "content": [
+ {
+ "token": "August",
+ "logprob": -2.8729025871143676e-05,
+ "bytes": [
+ 65,
+ 117,
+ 103,
+ 117,
+ 115,
+ 116
+ ],
+ "top_logprobs": []
+ },
+ {
+ "token": " ",
+ "logprob": -2.1457441107486375e-05,
+ "bytes": [
+ 32
+ ],
+ "top_logprobs": []
+ },
+ {
+ "token": "21",
+ "logprob": -0.0001250427303602919,
+ "bytes": [
+ 50,
+ 49
+ ],
+ "top_logprobs": []
+ },
+ {
+ "token": ",",
+ "logprob": -0.0024951535742729902,
+ "bytes": [
+ 44
+ ],
+ "top_logprobs": []
+ },
+ {
+ "token": " ",
+ "logprob": -3.8742269680369645e-05,
+ "bytes": [
+ 32
+ ],
+ "top_logprobs": []
+ },
+ {
+ "token": "195",
+ "logprob": -1.1920928244535389e-07,
+ "bytes": [
+ 49,
+ 57,
+ 53
+ ],
+ "top_logprobs": []
+ },
+ {
+ "token": "9",
+ "logprob": 0.0,
+ "bytes": [
+ 57
+ ],
+ "top_logprobs": []
+ },
+ {
+ "token": "",
+ "logprob": -0.6931514739990234,
+ "bytes": [],
+ "top_logprobs": []
+ }
+ ]
+ },
+ "finish_reason": "stop",
+ "stop_reason": null
+ }
+ ],
+ "usage": {
+ "prompt_tokens": 47,
+ "total_tokens": 55,
+ "completion_tokens": 8
+ }
+}
+`
+ TOP_LOGPROBS = `
+{
+ "id": "cmpl-7804309bf8404215aefc67fd9275d1ff",
+ "object": "chat.completion",
+ "created": 1722197678,
+ "model": "Qwen/Qwen2.5-7B-Instruct",
+ "choices": [
+ {
+ "index": 0,
+ "message": {
+ "role": "assistant",
+ "content": "August 21, 1959",
+ "tool_calls": []
+ },
+ "logprobs": {
+ "content": [
+ {
+ "token": "August",
+ "logprob": -2.8729025871143676e-05,
+ "bytes": [
+ 65,
+ 117,
+ 103,
+ 117,
+ 115,
+ 116
+ ],
+ "top_logprobs": [
+ {
+ "token": "August",
+ "logprob": -2.8729025871143676e-05,
+ "bytes": [
+ 65,
+ 117,
+ 103,
+ 117,
+ 115,
+ 116
+ ]
+ },
+ {
+ "token": "H",
+ "logprob": -11.875028610229492,
+ "bytes": [
+ 72
+ ]
+ },
+ {
+ "token": "195",
+ "logprob": -12.125028610229492,
+ "bytes": [
+ 49,
+ 57,
+ 53
+ ]
+ }
+ ]
+ },
+ {
+ "token": " ",
+ "logprob": -2.1457441107486375e-05,
+ "bytes": [
+ 32
+ ],
+ "top_logprobs": [
+ {
+ "token": " ",
+ "logprob": -2.1457441107486375e-05,
+ "bytes": [
+ 32
+ ]
+ },
+ {
+ "token": " Fifty",
+ "logprob": -11.750020980834961,
+ "bytes": [
+ 32,
+ 70,
+ 105,
+ 102,
+ 116,
+ 121
+ ]
+ },
+ {
+ "token": " Nin",
+ "logprob": -12.500020980834961,
+ "bytes": [
+ 32,
+ 78,
+ 105,
+ 110
+ ]
+ }
+ ]
+ },
+ {
+ "token": "21",
+ "logprob": -0.0001250427303602919,
+ "bytes": [
+ 50,
+ 49
+ ],
+ "top_logprobs": [
+ {
+ "token": "21",
+ "logprob": -0.0001250427303602919,
+ "bytes": [
+ 50,
+ 49
+ ]
+ },
+ {
+ "token": "195",
+ "logprob": -9.12512493133545,
+ "bytes": [
+ 49,
+ 57,
+ 53
+ ]
+ },
+ {
+ "token": "196",
+ "logprob": -11.25012493133545,
+ "bytes": [
+ 49,
+ 57,
+ 54
+ ]
+ }
+ ]
+ },
+ {
+ "token": ",",
+ "logprob": -0.0024951535742729902,
+ "bytes": [
+ 44
+ ],
+ "top_logprobs": [
+ {
+ "token": ",",
+ "logprob": -0.0024951535742729902,
+ "bytes": [
+ 44
+ ]
+ },
+ {
+ "token": " ",
+ "logprob": -6.627495288848877,
+ "bytes": [
+ 32
+ ]
+ },
+ {
+ "token": "st",
+ "logprob": -6.752495288848877,
+ "bytes": [
+ 115,
+ 116
+ ]
+ }
+ ]
+ },
+ {
+ "token": " ",
+ "logprob": -3.8742269680369645e-05,
+ "bytes": [
+ 32
+ ],
+ "top_logprobs": [
+ {
+ "token": " ",
+ "logprob": -3.8742269680369645e-05,
+ "bytes": [
+ 32
+ ]
+ },
+ {
+ "token": "195",
+ "logprob": -10.250039100646973,
+ "bytes": [
+ 49,
+ 57,
+ 53
+ ]
+ },
+ {
+ "token": "196",
+ "logprob": -12.625039100646973,
+ "bytes": [
+ 49,
+ 57,
+ 54
+ ]
+ }
+ ]
+ },
+ {
+ "token": "195",
+ "logprob": -1.1920928244535389e-07,
+ "bytes": [
+ 49,
+ 57,
+ 53
+ ],
+ "top_logprobs": [
+ {
+ "token": "195",
+ "logprob": -1.1920928244535389e-07,
+ "bytes": [
+ 49,
+ 57,
+ 53
+ ]
+ },
+ {
+ "token": "196",
+ "logprob": -16.25,
+ "bytes": [
+ 49,
+ 57,
+ 54
+ ]
+ },
+ {
+ "token": "59",
+ "logprob": -21.625,
+ "bytes": [
+ 53,
+ 57
+ ]
+ }
+ ]
+ },
+ {
+ "token": "9",
+ "logprob": 0.0,
+ "bytes": [
+ 57
+ ],
+ "top_logprobs": [
+ {
+ "token": "9",
+ "logprob": 0.0,
+ "bytes": [
+ 57
+ ]
+ },
+ {
+ "token": "8",
+ "logprob": -17.5,
+ "bytes": [
+ 56
+ ]
+ },
+ {
+ "token": "0",
+ "logprob": -19.125,
+ "bytes": [
+ 48
+ ]
+ }
+ ]
+ },
+ {
+ "token": "",
+ "logprob": -0.6931514739990234,
+ "bytes": [],
+ "top_logprobs": [
+ {
+ "token": "",
+ "logprob": -0.6931514739990234,
+ "bytes": []
+ },
+ {
+ "token": ".",
+ "logprob": -0.6931514739990234,
+ "bytes": [
+ 46
+ ]
+ },
+ {
+ "token": "!",
+ "logprob": -12.443151473999023,
+ "bytes": [
+ 33
+ ]
+ }
+ ]
+ }
+ ]
+ },
+ "finish_reason": "stop",
+ "stop_reason": null
+ }
+ ],
+ "usage": {
+ "prompt_tokens": 47,
+ "total_tokens": 55,
+ "completion_tokens": 8
+ }
+}`
+ START_COMPLETION_STREAMED_EVENT = `
+{
+ "id": "cmpl-3973dab1430143849df83d943ea0c7ac",
+ "object": "chat.completion.chunk",
+ "created": 1726472629,
+ "model": "Qwen/Qwen2.5-7B-Instruct",
+ "choices": [
+ {
+ "index": 0,
+ "delta": {
+ "role": "assistant"
+ },
+ "logprobs": null,
+ "finish_reason": null
+ }
+ ]
+}
+`
+ MID_COMPLETION_STREAMED_EVENT = `
+{
+ "id": "cmpl-3973dab1430143849df83d943ea0c7ac",
+ "object": "chat.completion.chunk",
+ "created": 1726472629,
+ "model": "Qwen/Qwen2.5-7B-Instruct",
+ "choices": [
+ {
+ "index": 0,
+ "delta": {
+ "content": "."
+ },
+ "logprobs": {
+ "content": [
+ {
+ "token": ".",
+ "logprob": -0.04858766868710518,
+ "bytes": [
+ 46
+ ],
+ "top_logprobs": [
+ {
+ "token": ".",
+ "logprob": -0.04858766868710518,
+ "bytes": [
+ 46
+ ]
+ },
+ {
+ "token": ",",
+ "logprob": -3.0485875606536865,
+ "bytes": [
+ 44
+ ]
+ },
+ {
+ "token": " when",
+ "logprob": -15.673587799072266,
+ "bytes": [
+ 32,
+ 119,
+ 104,
+ 101,
+ 110
+ ]
+ }
+ ]
+ }
+ ]
+ },
+ "finish_reason": null
+ }
+ ]
+}
+`
+ END_COMPLETION_STREAMED_EVENT = `
+{
+ "id": "cmpl-3973dab1430143849df83d943ea0c7ac",
+ "object": "chat.completion.chunk",
+ "created": 1726472629,
+ "model": "Qwen/Qwen2.5-7B-Instruct",
+ "choices": [
+ {
+ "index": 0,
+ "delta": {
+ "content": ""
+ },
+ "logprobs": {
+ "content": [
+ {
+ "token": "",
+ "logprob": -2.264974000354414e-6,
+ "bytes": [],
+ "top_logprobs": [
+ {
+ "token": "",
+ "logprob": -2.264974000354414e-6,
+ "bytes": []
+ },
+ {
+ "token": " It",
+ "logprob": -13.000001907348633,
+ "bytes": [
+ 32,
+ 73,
+ 116
+ ]
+ },
+ {
+ "token": "",
+ "logprob": -19.000001907348633,
+ "bytes": []
+ }
+ ]
+ }
+ ]
+ },
+ "finish_reason": "stop",
+ "stop_reason": null
+ }
+ ]
+}
+`
+)
+
+func TestNoLogprobsAnswer(t *testing.T) {
+ var r Response
+ if err := json.Unmarshal([]byte(NO_LOGPROBS), &r); err != nil {
+ t.Fatalf("Failed to unmarshal r: %v", err)
+ }
+ t.Logf("Response: %v", r)
+
+ if len(r.Choices) != 1 {
+ t.Fatalf("Expected 1 choice, got %d", len(r.Choices))
+ }
+
+ if r.Choices[0].Logprobs.Content != nil {
+ t.Fatalf("Expected nil logprobs, got %v", r.Choices[0].Logprobs.Content)
+ }
+
+ if r.Choices[0].StopReason != "" {
+ t.Fatalf("Expected stop reason to be nil got %s", r.Choices[0].StopReason)
+ }
+}
+
+func TestLogprobsNoTopLogprobsAnswer(t *testing.T) {
+ var r Response
+ if err := json.Unmarshal([]byte(LOGPROBS_NO_TOP_LOGPROBS), &r); err != nil {
+ t.Fatalf("Failed to unmarshal r: %v", err)
+ }
+ t.Logf("Response: %v", r)
+}
+
+func TestTopLogprobsAnswer(t *testing.T) {
+ var r Response
+ if err := json.Unmarshal([]byte(TOP_LOGPROBS), &r); err != nil {
+ t.Fatalf("Failed to unmarshal r: %v", err)
+ }
+ t.Logf("Response: %v", r)
+}
+
+func TestStartCompletionStreamedEvent(t *testing.T) {
+ var r Response
+ if err := json.Unmarshal([]byte(START_COMPLETION_STREAMED_EVENT), &r); err != nil {
+ t.Fatalf("Failed to unmarshal r: %v", err)
+ }
+ t.Logf("Response: %v", r)
+
+ delta := assertStreamedEventChoices(t, r)
+
+ if *delta.Role != "assistant" {
+ t.Fatalf("Expected role to be assistant, got %s", *delta.Role)
+ }
+}
+
+func TestMidCompletionStreamedEvent(t *testing.T) {
+ var r Response
+ if err := json.Unmarshal([]byte(MID_COMPLETION_STREAMED_EVENT), &r); err != nil {
+ t.Fatalf("Failed to unmarshal r: %v", err)
+ }
+ t.Logf("Response: %v", r)
+
+ delta := assertStreamedEventChoices(t, r)
+
+ if delta.Content == nil {
+ t.Fatalf("Expected content to be non-empty, got empty")
+ }
+}
+
+func TestEndCompletionStreamedEvent(t *testing.T) {
+ var r Response
+ if err := json.Unmarshal([]byte(END_COMPLETION_STREAMED_EVENT), &r); err != nil {
+ t.Fatalf("Failed to unmarshal r: %v", err)
+ }
+ t.Logf("Response: %v", r)
+
+ delta := assertStreamedEventChoices(t, r)
+
+ if delta.Content == nil {
+ t.Fatalf("Expected content to be non-empty, got empty")
+ }
+}
+
+func assertStreamedEventChoices(t *testing.T, r Response) *Delta {
+ if len(r.Choices) != 1 {
+ t.Fatalf("Expected 1 choices, got %d", len(r.Choices))
+ }
+
+ if r.Choices[0].Delta == nil {
+ t.Fatalf("Expected delta to be non-nil, got nil")
+ }
+
+ return r.Choices[0].Delta
+}
+
+func TestStreamedResponseSerialization(t *testing.T) {
+ lines := readLines(t, "test_data/response_streamed.txt")
+ require.NotEmpty(t, lines, "Read 0 events from responseprocessor_test_data.txt")
+
+ resp, err := NewCompletionResponseFromLines(lines)
+ require.NoError(t, err)
+ require.IsType(t, &StreamedCompletionResponse{}, resp)
+
+ bytes, err := resp.GetBodyBytes()
+ bytesString := string(bytes)
+
+ resp2, err := NewCompletionResponseFromLinesFromResponsePayload(bytesString)
+ require.NoError(t, err)
+ require.IsType(t, &StreamedCompletionResponse{}, resp2)
+
+ require.Equal(t, len(resp.(*StreamedCompletionResponse).Lines), len(resp2.(*StreamedCompletionResponse).Lines))
+ require.Equal(t, len(resp.(*StreamedCompletionResponse).Resp.Data), len(resp2.(*StreamedCompletionResponse).Resp.Data))
+}
diff --git a/decentralized-api/completionapi/test_data/example_requests.sh b/decentralized-api/completionapi/test_data/example_requests.sh
new file mode 100644
index 000000000..657693ef8
--- /dev/null
+++ b/decentralized-api/completionapi/test_data/example_requests.sh
@@ -0,0 +1,25 @@
+# Streamed
+curl http://localhost:5000/v1/chat/completions \
+ -H "Content-Type: application/json" \
+ -N \
+ -d '{
+ "model": "Qwen/Qwen2.5-7B-Instruct",
+ "temperature": 0.8,
+ "stream": true,
+ "stream_options": { "include_usage": true },
+ "messages": [
+ { "role": "user", "content": "Hi!" }
+ ]
+ }'
+
+# Non-streamed
+curl http://localhost:5000/v1/chat/completions \
+ -H "Content-Type: application/json" \
+ -N \
+ -d '{
+ "model": "Qwen/Qwen2.5-7B-Instruct",
+ "temperature": 0.8,
+ "messages": [
+ { "role": "user", "content": "Hi!" }
+ ]
+ }'
diff --git a/decentralized-api/completionapi/test_data/response.json b/decentralized-api/completionapi/test_data/response.json
new file mode 100644
index 000000000..93a897f80
--- /dev/null
+++ b/decentralized-api/completionapi/test_data/response.json
@@ -0,0 +1,27 @@
+{
+ "id": "chatcmpl-25d88b4b7eb0458fa82588488da9d2a2",
+ "object": "chat.completion",
+ "created": 1747692816,
+ "model": "Qwen/Qwen2.5-7B-Instruct",
+ "choices": [
+ {
+ "index": 0,
+ "message": {
+ "role": "assistant",
+ "reasoning_content": null,
+ "content": "Hello! How can I assist you today?",
+ "tool_calls": []
+ },
+ "logprobs": null,
+ "finish_reason": "stop",
+ "stop_reason": null
+ }
+ ],
+ "usage": {
+ "prompt_tokens": 31,
+ "total_tokens": 41,
+ "completion_tokens": 10,
+ "prompt_tokens_details": null
+ },
+ "prompt_logprobs": null
+}
diff --git a/decentralized-api/completionapi/test_data/response_streamed.txt b/decentralized-api/completionapi/test_data/response_streamed.txt
new file mode 100644
index 000000000..67ed230d0
--- /dev/null
+++ b/decentralized-api/completionapi/test_data/response_streamed.txt
@@ -0,0 +1,25 @@
+data: {"id":"chatcmpl-747d884a63684dd78424cc8333fa3399","object":"chat.completion.chunk","created":1747687689,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"role":"assistant","content":""},"logprobs":null,"finish_reason":null}]}
+
+data: {"id":"chatcmpl-747d884a63684dd78424cc8333fa3399","object":"chat.completion.chunk","created":1747687689,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":"Hello"},"logprobs":null,"finish_reason":null}]}
+
+data: {"id":"chatcmpl-747d884a63684dd78424cc8333fa3399","object":"chat.completion.chunk","created":1747687689,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":"!"},"logprobs":null,"finish_reason":null}]}
+
+data: {"id":"chatcmpl-747d884a63684dd78424cc8333fa3399","object":"chat.completion.chunk","created":1747687689,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" How"},"logprobs":null,"finish_reason":null}]}
+
+data: {"id":"chatcmpl-747d884a63684dd78424cc8333fa3399","object":"chat.completion.chunk","created":1747687689,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" can"},"logprobs":null,"finish_reason":null}]}
+
+data: {"id":"chatcmpl-747d884a63684dd78424cc8333fa3399","object":"chat.completion.chunk","created":1747687689,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" I"},"logprobs":null,"finish_reason":null}]}
+
+data: {"id":"chatcmpl-747d884a63684dd78424cc8333fa3399","object":"chat.completion.chunk","created":1747687689,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" assist"},"logprobs":null,"finish_reason":null}]}
+
+data: {"id":"chatcmpl-747d884a63684dd78424cc8333fa3399","object":"chat.completion.chunk","created":1747687689,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" you"},"logprobs":null,"finish_reason":null}]}
+
+data: {"id":"chatcmpl-747d884a63684dd78424cc8333fa3399","object":"chat.completion.chunk","created":1747687689,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" today"},"logprobs":null,"finish_reason":null}]}
+
+data: {"id":"chatcmpl-747d884a63684dd78424cc8333fa3399","object":"chat.completion.chunk","created":1747687689,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":"?"},"logprobs":null,"finish_reason":null}]}
+
+data: {"id":"chatcmpl-747d884a63684dd78424cc8333fa3399","object":"chat.completion.chunk","created":1747687689,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":""},"logprobs":null,"finish_reason":"stop","stop_reason":null}]}
+
+data: {"id":"chatcmpl-747d884a63684dd78424cc8333fa3399","object":"chat.completion.chunk","created":1747687689,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[],"usage":{"prompt_tokens":31,"total_tokens":41,"completion_tokens":10}}
+
+data: [DONE]
diff --git a/decentralized-api/completionapi/test_data/response_streamed_token_ids.txt b/decentralized-api/completionapi/test_data/response_streamed_token_ids.txt
new file mode 100644
index 000000000..f4fb3251b
--- /dev/null
+++ b/decentralized-api/completionapi/test_data/response_streamed_token_ids.txt
@@ -0,0 +1,136 @@
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"role":"assistant","content":""},"logprobs":null,"finish_reason":null}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":"Hello","tool_calls":[]},"logprobs":{"content":[{"token":"9707","logprob":0.0,"bytes":[72,101,108,108,111],"top_logprobs":[{"token":"9707","logprob":0.0,"bytes":[57,55,48,55]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"4","logprob":-9999.0,"bytes":[52]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":"!","tool_calls":[]},"logprobs":{"content":[{"token":"0","logprob":0.0,"bytes":[33],"top_logprobs":[{"token":"0","logprob":0.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"4","logprob":-9999.0,"bytes":[52]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"9","logprob":-9999.0,"bytes":[57]},{"token":"5","logprob":-9999.0,"bytes":[53]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" I","tool_calls":[]},"logprobs":{"content":[{"token":"358","logprob":0.0,"bytes":[32,73],"top_logprobs":[{"token":"358","logprob":0.0,"bytes":[51,53,56]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"4","logprob":-9999.0,"bytes":[52]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":"'m","tool_calls":[]},"logprobs":{"content":[{"token":"2776","logprob":0.0,"bytes":[39,109],"top_logprobs":[{"token":"2776","logprob":0.0,"bytes":[50,55,55,54]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"4","logprob":-9999.0,"bytes":[52]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" just","tool_calls":[]},"logprobs":{"content":[{"token":"1101","logprob":-1.2367870807647705,"bytes":[32,106,117,115,116],"top_logprobs":[{"token":"1101","logprob":-1.2367870807647705,"bytes":[49,49,48,49]},{"token":"458","logprob":-0.34293481707572937,"bytes":[52,53,56]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"4","logprob":-9999.0,"bytes":[52]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"3","logprob":-9999.0,"bytes":[51]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" a","tool_calls":[]},"logprobs":{"content":[{"token":"264","logprob":0.0,"bytes":[32,97],"top_logprobs":[{"token":"264","logprob":0.0,"bytes":[50,54,52]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"4","logprob":-9999.0,"bytes":[52]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" piece","tool_calls":[]},"logprobs":{"content":[{"token":"6573","logprob":-1.7351740598678589,"bytes":[32,112,105,101,99,101],"top_logprobs":[{"token":"6573","logprob":-1.7351740598678589,"bytes":[54,53,55,51]},{"token":"7377","logprob":-1.0200899839401245,"bytes":[55,51,55,55]},{"token":"3460","logprob":-1.3776320219039917,"bytes":[51,52,54,48]},{"token":"6366","logprob":-1.5564039945602417,"bytes":[54,51,54,54]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"4","logprob":-9999.0,"bytes":[52]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"1","logprob":-9999.0,"bytes":[49]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" of","tool_calls":[]},"logprobs":{"content":[{"token":"315","logprob":0.0,"bytes":[32,111,102],"top_logprobs":[{"token":"315","logprob":0.0,"bytes":[51,49,53]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"4","logprob":-9999.0,"bytes":[52]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" software","tool_calls":[]},"logprobs":{"content":[{"token":"3162","logprob":0.0,"bytes":[32,115,111,102,116,119,97,114,101],"top_logprobs":[{"token":"3162","logprob":0.0,"bytes":[51,49,54,50]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"4","logprob":-9999.0,"bytes":[52]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":",","tool_calls":[]},"logprobs":{"content":[{"token":"11","logprob":0.0,"bytes":[44],"top_logprobs":[{"token":"11","logprob":0.0,"bytes":[49,49]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"4","logprob":-9999.0,"bytes":[52]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" so","tool_calls":[]},"logprobs":{"content":[{"token":"773","logprob":0.0,"bytes":[32,115,111],"top_logprobs":[{"token":"773","logprob":0.0,"bytes":[55,55,51]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"4","logprob":-9999.0,"bytes":[52]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" I","tool_calls":[]},"logprobs":{"content":[{"token":"358","logprob":0.0,"bytes":[32,73],"top_logprobs":[{"token":"358","logprob":0.0,"bytes":[51,53,56]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"4","logprob":-9999.0,"bytes":[52]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" don","tool_calls":[]},"logprobs":{"content":[{"token":"1513","logprob":0.0,"bytes":[32,100,111,110],"top_logprobs":[{"token":"1513","logprob":0.0,"bytes":[49,53,49,51]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"4","logprob":-9999.0,"bytes":[52]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":"'t","tool_calls":[]},"logprobs":{"content":[{"token":"944","logprob":0.0,"bytes":[39,116],"top_logprobs":[{"token":"944","logprob":0.0,"bytes":[57,52,52]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"4","logprob":-9999.0,"bytes":[52]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" have","tool_calls":[]},"logprobs":{"content":[{"token":"614","logprob":0.0,"bytes":[32,104,97,118,101],"top_logprobs":[{"token":"614","logprob":0.0,"bytes":[54,49,52]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"4","logprob":-9999.0,"bytes":[52]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" feelings","tool_calls":[]},"logprobs":{"content":[{"token":"15650","logprob":0.0,"bytes":[32,102,101,101,108,105,110,103,115],"top_logprobs":[{"token":"15650","logprob":0.0,"bytes":[49,53,54,53,48]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"4","logprob":-9999.0,"bytes":[52]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" or","tool_calls":[]},"logprobs":{"content":[{"token":"476","logprob":0.0,"bytes":[32,111,114],"top_logprobs":[{"token":"476","logprob":0.0,"bytes":[52,55,54]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"4","logprob":-9999.0,"bytes":[52]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" experiences","tool_calls":[]},"logprobs":{"content":[{"token":"11449","logprob":-1.1922807693481445,"bytes":[32,101,120,112,101,114,105,101,110,99,101,115],"top_logprobs":[{"token":"11449","logprob":-1.1922807693481445,"bytes":[49,49,52,52,57]},{"token":"6961","logprob":-0.655970573425293,"bytes":[54,57,54,49]},{"token":"21261","logprob":-1.7285947799682617,"bytes":[50,49,50,54,49]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"4","logprob":-9999.0,"bytes":[52]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"2","logprob":-9999.0,"bytes":[50]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":".","tool_calls":[]},"logprobs":{"content":[{"token":"13","logprob":0.0,"bytes":[46],"top_logprobs":[{"token":"13","logprob":0.0,"bytes":[49,51]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"4","logprob":-9999.0,"bytes":[52]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" But","tool_calls":[]},"logprobs":{"content":[{"token":"1988","logprob":0.0,"bytes":[32,66,117,116],"top_logprobs":[{"token":"1988","logprob":0.0,"bytes":[49,57,56,56]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"4","logprob":-9999.0,"bytes":[52]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" I","tool_calls":[]},"logprobs":{"content":[{"token":"358","logprob":0.0,"bytes":[32,73],"top_logprobs":[{"token":"358","logprob":0.0,"bytes":[51,53,56]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"4","logprob":-9999.0,"bytes":[52]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":"'m","tool_calls":[]},"logprobs":{"content":[{"token":"2776","logprob":0.0,"bytes":[39,109],"top_logprobs":[{"token":"2776","logprob":0.0,"bytes":[50,55,55,54]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"4","logprob":-9999.0,"bytes":[52]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" here","tool_calls":[]},"logprobs":{"content":[{"token":"1588","logprob":0.0,"bytes":[32,104,101,114,101],"top_logprobs":[{"token":"1588","logprob":0.0,"bytes":[49,53,56,56]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"4","logprob":-9999.0,"bytes":[52]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" and","tool_calls":[]},"logprobs":{"content":[{"token":"323","logprob":0.0,"bytes":[32,97,110,100],"top_logprobs":[{"token":"323","logprob":0.0,"bytes":[51,50,51]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"4","logprob":-9999.0,"bytes":[52]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" ready","tool_calls":[]},"logprobs":{"content":[{"token":"5527","logprob":0.0,"bytes":[32,114,101,97,100,121],"top_logprobs":[{"token":"5527","logprob":0.0,"bytes":[53,53,50,55]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"4","logprob":-9999.0,"bytes":[52]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" to","tool_calls":[]},"logprobs":{"content":[{"token":"311","logprob":0.0,"bytes":[32,116,111],"top_logprobs":[{"token":"311","logprob":0.0,"bytes":[51,49,49]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"4","logprob":-9999.0,"bytes":[52]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" help","tool_calls":[]},"logprobs":{"content":[{"token":"1492","logprob":0.0,"bytes":[32,104,101,108,112],"top_logprobs":[{"token":"1492","logprob":0.0,"bytes":[49,52,57,50]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"4","logprob":-9999.0,"bytes":[52]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" you","tool_calls":[]},"logprobs":{"content":[{"token":"498","logprob":0.0,"bytes":[32,121,111,117],"top_logprobs":[{"token":"498","logprob":0.0,"bytes":[52,57,56]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"4","logprob":-9999.0,"bytes":[52]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" with","tool_calls":[]},"logprobs":{"content":[{"token":"448","logprob":0.0,"bytes":[32,119,105,116,104],"top_logprobs":[{"token":"448","logprob":0.0,"bytes":[52,52,56]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"4","logprob":-9999.0,"bytes":[52]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" any","tool_calls":[]},"logprobs":{"content":[{"token":"894","logprob":0.0,"bytes":[32,97,110,121],"top_logprobs":[{"token":"894","logprob":0.0,"bytes":[56,57,52]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"4","logprob":-9999.0,"bytes":[52]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" questions","tool_calls":[]},"logprobs":{"content":[{"token":"4755","logprob":0.0,"bytes":[32,113,117,101,115,116,105,111,110,115],"top_logprobs":[{"token":"4755","logprob":0.0,"bytes":[52,55,53,53]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"4","logprob":-9999.0,"bytes":[52]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" or","tool_calls":[]},"logprobs":{"content":[{"token":"476","logprob":0.0,"bytes":[32,111,114],"top_logprobs":[{"token":"476","logprob":0.0,"bytes":[52,55,54]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"4","logprob":-9999.0,"bytes":[52]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" information","tool_calls":[]},"logprobs":{"content":[{"token":"1995","logprob":-0.3982061743736267,"bytes":[32,105,110,102,111,114,109,97,116,105,111,110],"top_logprobs":[{"token":"1995","logprob":-0.3982061743736267,"bytes":[49,57,57,53]},{"token":"9079","logprob":-1.1132903099060059,"bytes":[57,48,55,57]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"4","logprob":-9999.0,"bytes":[52]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"3","logprob":-9999.0,"bytes":[51]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" you","tool_calls":[]},"logprobs":{"content":[{"token":"498","logprob":0.0,"bytes":[32,121,111,117],"top_logprobs":[{"token":"498","logprob":0.0,"bytes":[52,57,56]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"4","logprob":-9999.0,"bytes":[52]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" need","tool_calls":[]},"logprobs":{"content":[{"token":"1184","logprob":-0.530270516872406,"bytes":[32,110,101,101,100],"top_logprobs":[{"token":"1184","logprob":-0.530270516872406,"bytes":[49,49,56,52]},{"token":"2578","logprob":-0.887814462184906,"bytes":[50,53,55,56]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"4","logprob":-9999.0,"bytes":[52]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"3","logprob":-9999.0,"bytes":[51]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":".","tool_calls":[]},"logprobs":{"content":[{"token":"13","logprob":0.0,"bytes":[46],"top_logprobs":[{"token":"13","logprob":0.0,"bytes":[49,51]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"4","logprob":-9999.0,"bytes":[52]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" How","tool_calls":[]},"logprobs":{"content":[{"token":"2585","logprob":0.0,"bytes":[32,72,111,119],"top_logprobs":[{"token":"2585","logprob":0.0,"bytes":[50,53,56,53]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"4","logprob":-9999.0,"bytes":[52]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" can","tool_calls":[]},"logprobs":{"content":[{"token":"646","logprob":0.0,"bytes":[32,99,97,110],"top_logprobs":[{"token":"646","logprob":0.0,"bytes":[54,52,54]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"4","logprob":-9999.0,"bytes":[52]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" I","tool_calls":[]},"logprobs":{"content":[{"token":"358","logprob":0.0,"bytes":[32,73],"top_logprobs":[{"token":"358","logprob":0.0,"bytes":[51,53,56]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"4","logprob":-9999.0,"bytes":[52]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" assist","tool_calls":[]},"logprobs":{"content":[{"token":"7789","logprob":0.0,"bytes":[32,97,115,115,105,115,116],"top_logprobs":[{"token":"7789","logprob":0.0,"bytes":[55,55,56,57]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"4","logprob":-9999.0,"bytes":[52]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" you","tool_calls":[]},"logprobs":{"content":[{"token":"498","logprob":0.0,"bytes":[32,121,111,117],"top_logprobs":[{"token":"498","logprob":0.0,"bytes":[52,57,56]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"4","logprob":-9999.0,"bytes":[52]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":" today","tool_calls":[]},"logprobs":{"content":[{"token":"3351","logprob":0.0,"bytes":[32,116,111,100,97,121],"top_logprobs":[{"token":"3351","logprob":0.0,"bytes":[51,51,53,49]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"4","logprob":-9999.0,"bytes":[52]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":"?","tool_calls":[]},"logprobs":{"content":[{"token":"30","logprob":0.0,"bytes":[63],"top_logprobs":[{"token":"30","logprob":0.0,"bytes":[51,48]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"4","logprob":-9999.0,"bytes":[52]}]}]}}]}
+
+
+data: {"id":"chatcmpl-0e83221e8ece4629b2b5151554d8c8f7","object":"chat.completion.chunk","created":1750454805,"model":"Qwen/Qwen2.5-7B-Instruct","choices":[{"index":0,"delta":{"content":"","tool_calls":[]},"logprobs":{"content":[{"token":"151645","logprob":0.0,"bytes":[],"top_logprobs":[{"token":"151645","logprob":0.0,"bytes":[49,53,49,54,52,53]},{"token":"1","logprob":-9999.0,"bytes":[49]},{"token":"3","logprob":-9999.0,"bytes":[51]},{"token":"6","logprob":-9999.0,"bytes":[54]},{"token":"7","logprob":-9999.0,"bytes":[55]},{"token":"0","logprob":-9999.0,"bytes":[48]},{"token":"2","logprob":-9999.0,"bytes":[50]},{"token":"5","logprob":-9999.0,"bytes":[53]},{"token":"8","logprob":-9999.0,"bytes":[56]},{"token":"4","logprob":-9999.0,"bytes":[52]}]}]},"finish_reason":"stop"}]}
+
+
+data: [DONE]
\ No newline at end of file
diff --git a/decentralized-api/completionapi/test_data/response_token_ids.json b/decentralized-api/completionapi/test_data/response_token_ids.json
new file mode 100644
index 000000000..3ff51c854
--- /dev/null
+++ b/decentralized-api/completionapi/test_data/response_token_ids.json
@@ -0,0 +1,1432 @@
+{"id": "chatcmpl-9278f63dd6e04c16847aa2f558caeadd", "object": "chat.completion", "created": 1750456846, "model": "Qwen/Qwen2.5-7B-Instruct", "choices": [
+ {"index": 0, "message": {"role": "assistant", "reasoning_content": null, "content": "Hello! I'm just a large language model, so I don't have feelings or physical form. How can I assist you today?", "tool_calls": []
+ }, "logprobs": {"content": [
+ {"token": "9707", "logprob": 0.0, "bytes": [
+ 72,
+ 101,
+ 108,
+ 108,
+ 111
+ ], "top_logprobs": [
+ {"token": "9707", "logprob": 0.0, "bytes": [
+ 57,
+ 55,
+ 48,
+ 55
+ ]
+ },
+ {"token": "1", "logprob": -9999.0, "bytes": [
+ 49
+ ]
+ },
+ {"token": "3", "logprob": -9999.0, "bytes": [
+ 51
+ ]
+ },
+ {"token": "6", "logprob": -9999.0, "bytes": [
+ 54
+ ]
+ },
+ {"token": "7", "logprob": -9999.0, "bytes": [
+ 55
+ ]
+ },
+ {"token": "0", "logprob": -9999.0, "bytes": [
+ 48
+ ]
+ },
+ {"token": "2", "logprob": -9999.0, "bytes": [
+ 50
+ ]
+ },
+ {"token": "5", "logprob": -9999.0, "bytes": [
+ 53
+ ]
+ },
+ {"token": "8", "logprob": -9999.0, "bytes": [
+ 56
+ ]
+ },
+ {"token": "4", "logprob": -9999.0, "bytes": [
+ 52
+ ]
+ }
+ ]
+ },
+ {"token": "0", "logprob": 0.0, "bytes": [
+ 33
+ ], "top_logprobs": [
+ {"token": "0", "logprob": 0.0, "bytes": [
+ 48
+ ]
+ },
+ {"token": "2", "logprob": -9999.0, "bytes": [
+ 50
+ ]
+ },
+ {"token": "4", "logprob": -9999.0, "bytes": [
+ 52
+ ]
+ },
+ {"token": "7", "logprob": -9999.0, "bytes": [
+ 55
+ ]
+ },
+ {"token": "8", "logprob": -9999.0, "bytes": [
+ 56
+ ]
+ },
+ {"token": "1", "logprob": -9999.0, "bytes": [
+ 49
+ ]
+ },
+ {"token": "3", "logprob": -9999.0, "bytes": [
+ 51
+ ]
+ },
+ {"token": "6", "logprob": -9999.0, "bytes": [
+ 54
+ ]
+ },
+ {"token": "9", "logprob": -9999.0, "bytes": [
+ 57
+ ]
+ },
+ {"token": "5", "logprob": -9999.0, "bytes": [
+ 53
+ ]
+ }
+ ]
+ },
+ {"token": "358", "logprob": 0.0, "bytes": [
+ 32,
+ 73
+ ], "top_logprobs": [
+ {"token": "358", "logprob": 0.0, "bytes": [
+ 51,
+ 53,
+ 56
+ ]
+ },
+ {"token": "1", "logprob": -9999.0, "bytes": [
+ 49
+ ]
+ },
+ {"token": "3", "logprob": -9999.0, "bytes": [
+ 51
+ ]
+ },
+ {"token": "6", "logprob": -9999.0, "bytes": [
+ 54
+ ]
+ },
+ {"token": "7", "logprob": -9999.0, "bytes": [
+ 55
+ ]
+ },
+ {"token": "0", "logprob": -9999.0, "bytes": [
+ 48
+ ]
+ },
+ {"token": "2", "logprob": -9999.0, "bytes": [
+ 50
+ ]
+ },
+ {"token": "5", "logprob": -9999.0, "bytes": [
+ 53
+ ]
+ },
+ {"token": "8", "logprob": -9999.0, "bytes": [
+ 56
+ ]
+ },
+ {"token": "4", "logprob": -9999.0, "bytes": [
+ 52
+ ]
+ }
+ ]
+ },
+ {"token": "2776", "logprob": 0.0, "bytes": [
+ 39,
+ 109
+ ], "top_logprobs": [
+ {"token": "2776", "logprob": 0.0, "bytes": [
+ 50,
+ 55,
+ 55,
+ 54
+ ]
+ },
+ {"token": "1", "logprob": -9999.0, "bytes": [
+ 49
+ ]
+ },
+ {"token": "3", "logprob": -9999.0, "bytes": [
+ 51
+ ]
+ },
+ {"token": "6", "logprob": -9999.0, "bytes": [
+ 54
+ ]
+ },
+ {"token": "7", "logprob": -9999.0, "bytes": [
+ 55
+ ]
+ },
+ {"token": "0", "logprob": -9999.0, "bytes": [
+ 48
+ ]
+ },
+ {"token": "2", "logprob": -9999.0, "bytes": [
+ 50
+ ]
+ },
+ {"token": "5", "logprob": -9999.0, "bytes": [
+ 53
+ ]
+ },
+ {"token": "8", "logprob": -9999.0, "bytes": [
+ 56
+ ]
+ },
+ {"token": "4", "logprob": -9999.0, "bytes": [
+ 52
+ ]
+ }
+ ]
+ },
+ {"token": "1101", "logprob": -1.2367870807647705, "bytes": [
+ 32,
+ 106,
+ 117,
+ 115,
+ 116
+ ], "top_logprobs": [
+ {"token": "1101", "logprob": -1.2367870807647705, "bytes": [
+ 49,
+ 49,
+ 48,
+ 49
+ ]
+ },
+ {"token": "458", "logprob": -0.34293481707572937, "bytes": [
+ 52,
+ 53,
+ 56
+ ]
+ },
+ {"token": "0", "logprob": -9999.0, "bytes": [
+ 48
+ ]
+ },
+ {"token": "1", "logprob": -9999.0, "bytes": [
+ 49
+ ]
+ },
+ {"token": "6", "logprob": -9999.0, "bytes": [
+ 54
+ ]
+ },
+ {"token": "7", "logprob": -9999.0, "bytes": [
+ 55
+ ]
+ },
+ {"token": "5", "logprob": -9999.0, "bytes": [
+ 53
+ ]
+ },
+ {"token": "4", "logprob": -9999.0, "bytes": [
+ 52
+ ]
+ },
+ {"token": "2", "logprob": -9999.0, "bytes": [
+ 50
+ ]
+ },
+ {"token": "3", "logprob": -9999.0, "bytes": [
+ 51
+ ]
+ }
+ ]
+ },
+ {"token": "264", "logprob": 0.0, "bytes": [
+ 32,
+ 97
+ ], "top_logprobs": [
+ {"token": "264", "logprob": 0.0, "bytes": [
+ 50,
+ 54,
+ 52
+ ]
+ },
+ {"token": "1", "logprob": -9999.0, "bytes": [
+ 49
+ ]
+ },
+ {"token": "3", "logprob": -9999.0, "bytes": [
+ 51
+ ]
+ },
+ {"token": "6", "logprob": -9999.0, "bytes": [
+ 54
+ ]
+ },
+ {"token": "7", "logprob": -9999.0, "bytes": [
+ 55
+ ]
+ },
+ {"token": "0", "logprob": -9999.0, "bytes": [
+ 48
+ ]
+ },
+ {"token": "2", "logprob": -9999.0, "bytes": [
+ 50
+ ]
+ },
+ {"token": "5", "logprob": -9999.0, "bytes": [
+ 53
+ ]
+ },
+ {"token": "8", "logprob": -9999.0, "bytes": [
+ 56
+ ]
+ },
+ {"token": "4", "logprob": -9999.0, "bytes": [
+ 52
+ ]
+ }
+ ]
+ },
+ {"token": "3460", "logprob": -1.3776320219039917, "bytes": [
+ 32,
+ 108,
+ 97,
+ 114,
+ 103,
+ 101
+ ], "top_logprobs": [
+ {"token": "3460", "logprob": -1.3776320219039917, "bytes": [
+ 51,
+ 52,
+ 54,
+ 48
+ ]
+ },
+ {"token": "7377", "logprob": -1.0200899839401245, "bytes": [
+ 55,
+ 51,
+ 55,
+ 55
+ ]
+ },
+ {"token": "6366", "logprob": -1.5564039945602417, "bytes": [
+ 54,
+ 51,
+ 54,
+ 54
+ ]
+ },
+ {"token": "6573", "logprob": -1.7351740598678589, "bytes": [
+ 54,
+ 53,
+ 55,
+ 51
+ ]
+ },
+ {"token": "3", "logprob": -9999.0, "bytes": [
+ 51
+ ]
+ },
+ {"token": "2", "logprob": -9999.0, "bytes": [
+ 50
+ ]
+ },
+ {"token": "4", "logprob": -9999.0, "bytes": [
+ 52
+ ]
+ },
+ {"token": "5", "logprob": -9999.0, "bytes": [
+ 53
+ ]
+ },
+ {"token": "0", "logprob": -9999.0, "bytes": [
+ 48
+ ]
+ },
+ {"token": "1", "logprob": -9999.0, "bytes": [
+ 49
+ ]
+ }
+ ]
+ },
+ {"token": "4128", "logprob": 0.0, "bytes": [
+ 32,
+ 108,
+ 97,
+ 110,
+ 103,
+ 117,
+ 97,
+ 103,
+ 101
+ ], "top_logprobs": [
+ {"token": "4128", "logprob": 0.0, "bytes": [
+ 52,
+ 49,
+ 50,
+ 56
+ ]
+ },
+ {"token": "1", "logprob": -9999.0, "bytes": [
+ 49
+ ]
+ },
+ {"token": "3", "logprob": -9999.0, "bytes": [
+ 51
+ ]
+ },
+ {"token": "6", "logprob": -9999.0, "bytes": [
+ 54
+ ]
+ },
+ {"token": "7", "logprob": -9999.0, "bytes": [
+ 55
+ ]
+ },
+ {"token": "0", "logprob": -9999.0, "bytes": [
+ 48
+ ]
+ },
+ {"token": "2", "logprob": -9999.0, "bytes": [
+ 50
+ ]
+ },
+ {"token": "5", "logprob": -9999.0, "bytes": [
+ 53
+ ]
+ },
+ {"token": "8", "logprob": -9999.0, "bytes": [
+ 56
+ ]
+ },
+ {"token": "4", "logprob": -9999.0, "bytes": [
+ 52
+ ]
+ }
+ ]
+ },
+ {"token": "1614", "logprob": 0.0, "bytes": [
+ 32,
+ 109,
+ 111,
+ 100,
+ 101,
+ 108
+ ], "top_logprobs": [
+ {"token": "1614", "logprob": 0.0, "bytes": [
+ 49,
+ 54,
+ 49,
+ 52
+ ]
+ },
+ {"token": "1", "logprob": -9999.0, "bytes": [
+ 49
+ ]
+ },
+ {"token": "3", "logprob": -9999.0, "bytes": [
+ 51
+ ]
+ },
+ {"token": "6", "logprob": -9999.0, "bytes": [
+ 54
+ ]
+ },
+ {"token": "7", "logprob": -9999.0, "bytes": [
+ 55
+ ]
+ },
+ {"token": "0", "logprob": -9999.0, "bytes": [
+ 48
+ ]
+ },
+ {"token": "2", "logprob": -9999.0, "bytes": [
+ 50
+ ]
+ },
+ {"token": "5", "logprob": -9999.0, "bytes": [
+ 53
+ ]
+ },
+ {"token": "8", "logprob": -9999.0, "bytes": [
+ 56
+ ]
+ },
+ {"token": "4", "logprob": -9999.0, "bytes": [
+ 52
+ ]
+ }
+ ]
+ },
+ {"token": "11", "logprob": 0.0, "bytes": [
+ 44
+ ], "top_logprobs": [
+ {"token": "11", "logprob": 0.0, "bytes": [
+ 49,
+ 49
+ ]
+ },
+ {"token": "1", "logprob": -9999.0, "bytes": [
+ 49
+ ]
+ },
+ {"token": "3", "logprob": -9999.0, "bytes": [
+ 51
+ ]
+ },
+ {"token": "6", "logprob": -9999.0, "bytes": [
+ 54
+ ]
+ },
+ {"token": "7", "logprob": -9999.0, "bytes": [
+ 55
+ ]
+ },
+ {"token": "0", "logprob": -9999.0, "bytes": [
+ 48
+ ]
+ },
+ {"token": "2", "logprob": -9999.0, "bytes": [
+ 50
+ ]
+ },
+ {"token": "5", "logprob": -9999.0, "bytes": [
+ 53
+ ]
+ },
+ {"token": "8", "logprob": -9999.0, "bytes": [
+ 56
+ ]
+ },
+ {"token": "4", "logprob": -9999.0, "bytes": [
+ 52
+ ]
+ }
+ ]
+ },
+ {"token": "773", "logprob": 0.0, "bytes": [
+ 32,
+ 115,
+ 111
+ ], "top_logprobs": [
+ {"token": "773", "logprob": 0.0, "bytes": [
+ 55,
+ 55,
+ 51
+ ]
+ },
+ {"token": "1", "logprob": -9999.0, "bytes": [
+ 49
+ ]
+ },
+ {"token": "3", "logprob": -9999.0, "bytes": [
+ 51
+ ]
+ },
+ {"token": "6", "logprob": -9999.0, "bytes": [
+ 54
+ ]
+ },
+ {"token": "7", "logprob": -9999.0, "bytes": [
+ 55
+ ]
+ },
+ {"token": "0", "logprob": -9999.0, "bytes": [
+ 48
+ ]
+ },
+ {"token": "2", "logprob": -9999.0, "bytes": [
+ 50
+ ]
+ },
+ {"token": "5", "logprob": -9999.0, "bytes": [
+ 53
+ ]
+ },
+ {"token": "8", "logprob": -9999.0, "bytes": [
+ 56
+ ]
+ },
+ {"token": "4", "logprob": -9999.0, "bytes": [
+ 52
+ ]
+ }
+ ]
+ },
+ {"token": "358", "logprob": 0.0, "bytes": [
+ 32,
+ 73
+ ], "top_logprobs": [
+ {"token": "358", "logprob": 0.0, "bytes": [
+ 51,
+ 53,
+ 56
+ ]
+ },
+ {"token": "1", "logprob": -9999.0, "bytes": [
+ 49
+ ]
+ },
+ {"token": "3", "logprob": -9999.0, "bytes": [
+ 51
+ ]
+ },
+ {"token": "6", "logprob": -9999.0, "bytes": [
+ 54
+ ]
+ },
+ {"token": "7", "logprob": -9999.0, "bytes": [
+ 55
+ ]
+ },
+ {"token": "0", "logprob": -9999.0, "bytes": [
+ 48
+ ]
+ },
+ {"token": "2", "logprob": -9999.0, "bytes": [
+ 50
+ ]
+ },
+ {"token": "5", "logprob": -9999.0, "bytes": [
+ 53
+ ]
+ },
+ {"token": "8", "logprob": -9999.0, "bytes": [
+ 56
+ ]
+ },
+ {"token": "4", "logprob": -9999.0, "bytes": [
+ 52
+ ]
+ }
+ ]
+ },
+ {"token": "1513", "logprob": 0.0, "bytes": [
+ 32,
+ 100,
+ 111,
+ 110
+ ], "top_logprobs": [
+ {"token": "1513", "logprob": 0.0, "bytes": [
+ 49,
+ 53,
+ 49,
+ 51
+ ]
+ },
+ {"token": "1", "logprob": -9999.0, "bytes": [
+ 49
+ ]
+ },
+ {"token": "3", "logprob": -9999.0, "bytes": [
+ 51
+ ]
+ },
+ {"token": "6", "logprob": -9999.0, "bytes": [
+ 54
+ ]
+ },
+ {"token": "7", "logprob": -9999.0, "bytes": [
+ 55
+ ]
+ },
+ {"token": "0", "logprob": -9999.0, "bytes": [
+ 48
+ ]
+ },
+ {"token": "2", "logprob": -9999.0, "bytes": [
+ 50
+ ]
+ },
+ {"token": "5", "logprob": -9999.0, "bytes": [
+ 53
+ ]
+ },
+ {"token": "8", "logprob": -9999.0, "bytes": [
+ 56
+ ]
+ },
+ {"token": "4", "logprob": -9999.0, "bytes": [
+ 52
+ ]
+ }
+ ]
+ },
+ {"token": "944", "logprob": 0.0, "bytes": [
+ 39,
+ 116
+ ], "top_logprobs": [
+ {"token": "944", "logprob": 0.0, "bytes": [
+ 57,
+ 52,
+ 52
+ ]
+ },
+ {"token": "1", "logprob": -9999.0, "bytes": [
+ 49
+ ]
+ },
+ {"token": "3", "logprob": -9999.0, "bytes": [
+ 51
+ ]
+ },
+ {"token": "6", "logprob": -9999.0, "bytes": [
+ 54
+ ]
+ },
+ {"token": "7", "logprob": -9999.0, "bytes": [
+ 55
+ ]
+ },
+ {"token": "0", "logprob": -9999.0, "bytes": [
+ 48
+ ]
+ },
+ {"token": "2", "logprob": -9999.0, "bytes": [
+ 50
+ ]
+ },
+ {"token": "5", "logprob": -9999.0, "bytes": [
+ 53
+ ]
+ },
+ {"token": "8", "logprob": -9999.0, "bytes": [
+ 56
+ ]
+ },
+ {"token": "4", "logprob": -9999.0, "bytes": [
+ 52
+ ]
+ }
+ ]
+ },
+ {"token": "614", "logprob": 0.0, "bytes": [
+ 32,
+ 104,
+ 97,
+ 118,
+ 101
+ ], "top_logprobs": [
+ {"token": "614", "logprob": 0.0, "bytes": [
+ 54,
+ 49,
+ 52
+ ]
+ },
+ {"token": "1", "logprob": -9999.0, "bytes": [
+ 49
+ ]
+ },
+ {"token": "3", "logprob": -9999.0, "bytes": [
+ 51
+ ]
+ },
+ {"token": "6", "logprob": -9999.0, "bytes": [
+ 54
+ ]
+ },
+ {"token": "7", "logprob": -9999.0, "bytes": [
+ 55
+ ]
+ },
+ {"token": "0", "logprob": -9999.0, "bytes": [
+ 48
+ ]
+ },
+ {"token": "2", "logprob": -9999.0, "bytes": [
+ 50
+ ]
+ },
+ {"token": "5", "logprob": -9999.0, "bytes": [
+ 53
+ ]
+ },
+ {"token": "8", "logprob": -9999.0, "bytes": [
+ 56
+ ]
+ },
+ {"token": "4", "logprob": -9999.0, "bytes": [
+ 52
+ ]
+ }
+ ]
+ },
+ {"token": "15650", "logprob": 0.0, "bytes": [
+ 32,
+ 102,
+ 101,
+ 101,
+ 108,
+ 105,
+ 110,
+ 103,
+ 115
+ ], "top_logprobs": [
+ {"token": "15650", "logprob": 0.0, "bytes": [
+ 49,
+ 53,
+ 54,
+ 53,
+ 48
+ ]
+ },
+ {"token": "1", "logprob": -9999.0, "bytes": [
+ 49
+ ]
+ },
+ {"token": "3", "logprob": -9999.0, "bytes": [
+ 51
+ ]
+ },
+ {"token": "6", "logprob": -9999.0, "bytes": [
+ 54
+ ]
+ },
+ {"token": "7", "logprob": -9999.0, "bytes": [
+ 55
+ ]
+ },
+ {"token": "0", "logprob": -9999.0, "bytes": [
+ 48
+ ]
+ },
+ {"token": "2", "logprob": -9999.0, "bytes": [
+ 50
+ ]
+ },
+ {"token": "5", "logprob": -9999.0, "bytes": [
+ 53
+ ]
+ },
+ {"token": "8", "logprob": -9999.0, "bytes": [
+ 56
+ ]
+ },
+ {"token": "4", "logprob": -9999.0, "bytes": [
+ 52
+ ]
+ }
+ ]
+ },
+ {"token": "476", "logprob": 0.0, "bytes": [
+ 32,
+ 111,
+ 114
+ ], "top_logprobs": [
+ {"token": "476", "logprob": 0.0, "bytes": [
+ 52,
+ 55,
+ 54
+ ]
+ },
+ {"token": "1", "logprob": -9999.0, "bytes": [
+ 49
+ ]
+ },
+ {"token": "3", "logprob": -9999.0, "bytes": [
+ 51
+ ]
+ },
+ {"token": "6", "logprob": -9999.0, "bytes": [
+ 54
+ ]
+ },
+ {"token": "7", "logprob": -9999.0, "bytes": [
+ 55
+ ]
+ },
+ {"token": "0", "logprob": -9999.0, "bytes": [
+ 48
+ ]
+ },
+ {"token": "2", "logprob": -9999.0, "bytes": [
+ 50
+ ]
+ },
+ {"token": "5", "logprob": -9999.0, "bytes": [
+ 53
+ ]
+ },
+ {"token": "8", "logprob": -9999.0, "bytes": [
+ 56
+ ]
+ },
+ {"token": "4", "logprob": -9999.0, "bytes": [
+ 52
+ ]
+ }
+ ]
+ },
+ {"token": "6961", "logprob": 0.0, "bytes": [
+ 32,
+ 112,
+ 104,
+ 121,
+ 115,
+ 105,
+ 99,
+ 97,
+ 108
+ ], "top_logprobs": [
+ {"token": "6961", "logprob": 0.0, "bytes": [
+ 54,
+ 57,
+ 54,
+ 49
+ ]
+ },
+ {"token": "1", "logprob": -9999.0, "bytes": [
+ 49
+ ]
+ },
+ {"token": "3", "logprob": -9999.0, "bytes": [
+ 51
+ ]
+ },
+ {"token": "6", "logprob": -9999.0, "bytes": [
+ 54
+ ]
+ },
+ {"token": "7", "logprob": -9999.0, "bytes": [
+ 55
+ ]
+ },
+ {"token": "0", "logprob": -9999.0, "bytes": [
+ 48
+ ]
+ },
+ {"token": "2", "logprob": -9999.0, "bytes": [
+ 50
+ ]
+ },
+ {"token": "5", "logprob": -9999.0, "bytes": [
+ 53
+ ]
+ },
+ {"token": "8", "logprob": -9999.0, "bytes": [
+ 56
+ ]
+ },
+ {"token": "4", "logprob": -9999.0, "bytes": [
+ 52
+ ]
+ }
+ ]
+ },
+ {"token": "1352", "logprob": -0.3982061743736267, "bytes": [
+ 32,
+ 102,
+ 111,
+ 114,
+ 109
+ ], "top_logprobs": [
+ {"token": "1352", "logprob": -0.3982061743736267, "bytes": [
+ 49,
+ 51,
+ 53,
+ 50
+ ]
+ },
+ {"token": "1584", "logprob": -1.1132903099060059, "bytes": [
+ 49,
+ 53,
+ 56,
+ 52
+ ]
+ },
+ {"token": "0", "logprob": -9999.0, "bytes": [
+ 48
+ ]
+ },
+ {"token": "1", "logprob": -9999.0, "bytes": [
+ 49
+ ]
+ },
+ {"token": "6", "logprob": -9999.0, "bytes": [
+ 54
+ ]
+ },
+ {"token": "7", "logprob": -9999.0, "bytes": [
+ 55
+ ]
+ },
+ {"token": "5", "logprob": -9999.0, "bytes": [
+ 53
+ ]
+ },
+ {"token": "4", "logprob": -9999.0, "bytes": [
+ 52
+ ]
+ },
+ {"token": "2", "logprob": -9999.0, "bytes": [
+ 50
+ ]
+ },
+ {"token": "3", "logprob": -9999.0, "bytes": [
+ 51
+ ]
+ }
+ ]
+ },
+ {"token": "13", "logprob": 0.0, "bytes": [
+ 46
+ ], "top_logprobs": [
+ {"token": "13", "logprob": 0.0, "bytes": [
+ 49,
+ 51
+ ]
+ },
+ {"token": "1", "logprob": -9999.0, "bytes": [
+ 49
+ ]
+ },
+ {"token": "3", "logprob": -9999.0, "bytes": [
+ 51
+ ]
+ },
+ {"token": "6", "logprob": -9999.0, "bytes": [
+ 54
+ ]
+ },
+ {"token": "7", "logprob": -9999.0, "bytes": [
+ 55
+ ]
+ },
+ {"token": "0", "logprob": -9999.0, "bytes": [
+ 48
+ ]
+ },
+ {"token": "2", "logprob": -9999.0, "bytes": [
+ 50
+ ]
+ },
+ {"token": "5", "logprob": -9999.0, "bytes": [
+ 53
+ ]
+ },
+ {"token": "8", "logprob": -9999.0, "bytes": [
+ 56
+ ]
+ },
+ {"token": "4", "logprob": -9999.0, "bytes": [
+ 52
+ ]
+ }
+ ]
+ },
+ {"token": "2585", "logprob": 0.0, "bytes": [
+ 32,
+ 72,
+ 111,
+ 119
+ ], "top_logprobs": [
+ {"token": "2585", "logprob": 0.0, "bytes": [
+ 50,
+ 53,
+ 56,
+ 53
+ ]
+ },
+ {"token": "1", "logprob": -9999.0, "bytes": [
+ 49
+ ]
+ },
+ {"token": "3", "logprob": -9999.0, "bytes": [
+ 51
+ ]
+ },
+ {"token": "6", "logprob": -9999.0, "bytes": [
+ 54
+ ]
+ },
+ {"token": "7", "logprob": -9999.0, "bytes": [
+ 55
+ ]
+ },
+ {"token": "0", "logprob": -9999.0, "bytes": [
+ 48
+ ]
+ },
+ {"token": "2", "logprob": -9999.0, "bytes": [
+ 50
+ ]
+ },
+ {"token": "5", "logprob": -9999.0, "bytes": [
+ 53
+ ]
+ },
+ {"token": "8", "logprob": -9999.0, "bytes": [
+ 56
+ ]
+ },
+ {"token": "4", "logprob": -9999.0, "bytes": [
+ 52
+ ]
+ }
+ ]
+ },
+ {"token": "646", "logprob": 0.0, "bytes": [
+ 32,
+ 99,
+ 97,
+ 110
+ ], "top_logprobs": [
+ {"token": "646", "logprob": 0.0, "bytes": [
+ 54,
+ 52,
+ 54
+ ]
+ },
+ {"token": "1", "logprob": -9999.0, "bytes": [
+ 49
+ ]
+ },
+ {"token": "3", "logprob": -9999.0, "bytes": [
+ 51
+ ]
+ },
+ {"token": "6", "logprob": -9999.0, "bytes": [
+ 54
+ ]
+ },
+ {"token": "7", "logprob": -9999.0, "bytes": [
+ 55
+ ]
+ },
+ {"token": "0", "logprob": -9999.0, "bytes": [
+ 48
+ ]
+ },
+ {"token": "2", "logprob": -9999.0, "bytes": [
+ 50
+ ]
+ },
+ {"token": "5", "logprob": -9999.0, "bytes": [
+ 53
+ ]
+ },
+ {"token": "8", "logprob": -9999.0, "bytes": [
+ 56
+ ]
+ },
+ {"token": "4", "logprob": -9999.0, "bytes": [
+ 52
+ ]
+ }
+ ]
+ },
+ {"token": "358", "logprob": 0.0, "bytes": [
+ 32,
+ 73
+ ], "top_logprobs": [
+ {"token": "358", "logprob": 0.0, "bytes": [
+ 51,
+ 53,
+ 56
+ ]
+ },
+ {"token": "1", "logprob": -9999.0, "bytes": [
+ 49
+ ]
+ },
+ {"token": "3", "logprob": -9999.0, "bytes": [
+ 51
+ ]
+ },
+ {"token": "6", "logprob": -9999.0, "bytes": [
+ 54
+ ]
+ },
+ {"token": "7", "logprob": -9999.0, "bytes": [
+ 55
+ ]
+ },
+ {"token": "0", "logprob": -9999.0, "bytes": [
+ 48
+ ]
+ },
+ {"token": "2", "logprob": -9999.0, "bytes": [
+ 50
+ ]
+ },
+ {"token": "5", "logprob": -9999.0, "bytes": [
+ 53
+ ]
+ },
+ {"token": "8", "logprob": -9999.0, "bytes": [
+ 56
+ ]
+ },
+ {"token": "4", "logprob": -9999.0, "bytes": [
+ 52
+ ]
+ }
+ ]
+ },
+ {"token": "7789", "logprob": 0.0, "bytes": [
+ 32,
+ 97,
+ 115,
+ 115,
+ 105,
+ 115,
+ 116
+ ], "top_logprobs": [
+ {"token": "7789", "logprob": 0.0, "bytes": [
+ 55,
+ 55,
+ 56,
+ 57
+ ]
+ },
+ {"token": "1", "logprob": -9999.0, "bytes": [
+ 49
+ ]
+ },
+ {"token": "3", "logprob": -9999.0, "bytes": [
+ 51
+ ]
+ },
+ {"token": "6", "logprob": -9999.0, "bytes": [
+ 54
+ ]
+ },
+ {"token": "7", "logprob": -9999.0, "bytes": [
+ 55
+ ]
+ },
+ {"token": "0", "logprob": -9999.0, "bytes": [
+ 48
+ ]
+ },
+ {"token": "2", "logprob": -9999.0, "bytes": [
+ 50
+ ]
+ },
+ {"token": "5", "logprob": -9999.0, "bytes": [
+ 53
+ ]
+ },
+ {"token": "8", "logprob": -9999.0, "bytes": [
+ 56
+ ]
+ },
+ {"token": "4", "logprob": -9999.0, "bytes": [
+ 52
+ ]
+ }
+ ]
+ },
+ {"token": "498", "logprob": 0.0, "bytes": [
+ 32,
+ 121,
+ 111,
+ 117
+ ], "top_logprobs": [
+ {"token": "498", "logprob": 0.0, "bytes": [
+ 52,
+ 57,
+ 56
+ ]
+ },
+ {"token": "1", "logprob": -9999.0, "bytes": [
+ 49
+ ]
+ },
+ {"token": "3", "logprob": -9999.0, "bytes": [
+ 51
+ ]
+ },
+ {"token": "6", "logprob": -9999.0, "bytes": [
+ 54
+ ]
+ },
+ {"token": "7", "logprob": -9999.0, "bytes": [
+ 55
+ ]
+ },
+ {"token": "0", "logprob": -9999.0, "bytes": [
+ 48
+ ]
+ },
+ {"token": "2", "logprob": -9999.0, "bytes": [
+ 50
+ ]
+ },
+ {"token": "5", "logprob": -9999.0, "bytes": [
+ 53
+ ]
+ },
+ {"token": "8", "logprob": -9999.0, "bytes": [
+ 56
+ ]
+ },
+ {"token": "4", "logprob": -9999.0, "bytes": [
+ 52
+ ]
+ }
+ ]
+ },
+ {"token": "3351", "logprob": 0.0, "bytes": [
+ 32,
+ 116,
+ 111,
+ 100,
+ 97,
+ 121
+ ], "top_logprobs": [
+ {"token": "3351", "logprob": 0.0, "bytes": [
+ 51,
+ 51,
+ 53,
+ 49
+ ]
+ },
+ {"token": "1", "logprob": -9999.0, "bytes": [
+ 49
+ ]
+ },
+ {"token": "3", "logprob": -9999.0, "bytes": [
+ 51
+ ]
+ },
+ {"token": "6", "logprob": -9999.0, "bytes": [
+ 54
+ ]
+ },
+ {"token": "7", "logprob": -9999.0, "bytes": [
+ 55
+ ]
+ },
+ {"token": "0", "logprob": -9999.0, "bytes": [
+ 48
+ ]
+ },
+ {"token": "2", "logprob": -9999.0, "bytes": [
+ 50
+ ]
+ },
+ {"token": "5", "logprob": -9999.0, "bytes": [
+ 53
+ ]
+ },
+ {"token": "8", "logprob": -9999.0, "bytes": [
+ 56
+ ]
+ },
+ {"token": "4", "logprob": -9999.0, "bytes": [
+ 52
+ ]
+ }
+ ]
+ },
+ {"token": "30", "logprob": 0.0, "bytes": [
+ 63
+ ], "top_logprobs": [
+ {"token": "30", "logprob": 0.0, "bytes": [
+ 51,
+ 48
+ ]
+ },
+ {"token": "1", "logprob": -9999.0, "bytes": [
+ 49
+ ]
+ },
+ {"token": "3", "logprob": -9999.0, "bytes": [
+ 51
+ ]
+ },
+ {"token": "6", "logprob": -9999.0, "bytes": [
+ 54
+ ]
+ },
+ {"token": "7", "logprob": -9999.0, "bytes": [
+ 55
+ ]
+ },
+ {"token": "0", "logprob": -9999.0, "bytes": [
+ 48
+ ]
+ },
+ {"token": "2", "logprob": -9999.0, "bytes": [
+ 50
+ ]
+ },
+ {"token": "5", "logprob": -9999.0, "bytes": [
+ 53
+ ]
+ },
+ {"token": "8", "logprob": -9999.0, "bytes": [
+ 56
+ ]
+ },
+ {"token": "4", "logprob": -9999.0, "bytes": [
+ 52
+ ]
+ }
+ ]
+ },
+ {"token": "151645", "logprob": 0.0, "bytes": [], "top_logprobs": [
+ {"token": "151645", "logprob": 0.0, "bytes": [
+ 49,
+ 53,
+ 49,
+ 54,
+ 52,
+ 53
+ ]
+ },
+ {"token": "1", "logprob": -9999.0, "bytes": [
+ 49
+ ]
+ },
+ {"token": "3", "logprob": -9999.0, "bytes": [
+ 51
+ ]
+ },
+ {"token": "6", "logprob": -9999.0, "bytes": [
+ 54
+ ]
+ },
+ {"token": "7", "logprob": -9999.0, "bytes": [
+ 55
+ ]
+ },
+ {"token": "0", "logprob": -9999.0, "bytes": [
+ 48
+ ]
+ },
+ {"token": "2", "logprob": -9999.0, "bytes": [
+ 50
+ ]
+ },
+ {"token": "5", "logprob": -9999.0, "bytes": [
+ 53
+ ]
+ },
+ {"token": "8", "logprob": -9999.0, "bytes": [
+ 56
+ ]
+ },
+ {"token": "4", "logprob": -9999.0, "bytes": [
+ 52
+ ]
+ }
+ ]
+ }
+ ]
+ }, "finish_reason": "stop", "stop_reason": null
+ }
+ ], "usage": {"prompt_tokens": 35, "total_tokens": 63, "completion_tokens": 28, "prompt_tokens_details": null
+ }, "prompt_logprobs": null, "kv_transfer_params": null
+}
\ No newline at end of file
diff --git a/decentralized-api/config-docker.yaml b/decentralized-api/config-docker.yaml
new file mode 100644
index 000000000..818c0e15e
--- /dev/null
+++ b/decentralized-api/config-docker.yaml
@@ -0,0 +1,19 @@
+api:
+ port: 8080
+ poc_callback_url: http://localhost:8080
+ public_url: http://localhost:8080
+nodes:
+ - id: node1
+ host: 34.171.235.205 # Deployed inference node
+ inference_port: 8080
+ poc_port: 5000
+ max_concurrent: 500
+ models:
+ - Qwen/Qwen2.5-7B-Instruct
+chain_node:
+ url: http://node:26657
+ account_public_key: ""
+ signer_key_name: "alice"
+ keyring_backend: "test"
+ keyring_dir: "/root/.inference"
+ is_genesis: false
diff --git a/decentralized-api/config-local.yaml b/decentralized-api/config-local.yaml
new file mode 100644
index 000000000..34c9f4e4e
--- /dev/null
+++ b/decentralized-api/config-local.yaml
@@ -0,0 +1,17 @@
+api:
+ port: 8080
+ poc_callback_url: http://localhost:8080
+ public_url: http://localhost:8080
+nodes:
+ - id: node1
+ host: 34.171.235.205:8080/ # Deployed inference node
+ max_concurrent: 500
+ models:
+ - Qwen/Qwen2.5-7B-Instruct
+chain_node:
+ url: http://localhost:26657
+ account_public_key: ""
+ signer_key_name: "alice"
+ keyring_backend: "test"
+ keyring_dir: "~/.inference" # We use a custom function to expand ~ to /root
+ is_genesis: false
diff --git a/decentralized-api/config-prod.yaml b/decentralized-api/config-prod.yaml
new file mode 100644
index 000000000..b23f25535
--- /dev/null
+++ b/decentralized-api/config-prod.yaml
@@ -0,0 +1,12 @@
+api:
+ port: 8080
+ poc_callback_url: http://localhost:8080
+ public_url: http://localhost:8080
+nodes:
+chain_node:
+ url: http://node:26657
+ account_public_key: ""
+ signer_key_name: "alice"
+ keyring_backend: "test"
+ keyring_dir: "/root/.inference"
+ is_genesis: false
diff --git a/decentralized-api/config.yaml b/decentralized-api/config.yaml
new file mode 100644
index 000000000..c7b5260e8
--- /dev/null
+++ b/decentralized-api/config.yaml
@@ -0,0 +1,20 @@
+api:
+ port: 8080
+ poc_callback_url: http://localhost:8080
+ public_url: http://localhost:8080
+nodes:
+ - id: node1
+ host: localhost
+ inference_port: 2020
+ max_concurrent: 1
+ models:
+ - Qwen/Qwen2.5-7B-Instruct
+chain_node:
+ url: http://localhost:26657
+ account_public_key: ""
+ signer_key_name: "alice"
+ keyring_backend: "test"
+ keyring_dir: "~/.inference" # We use a custom function to expand ~ to /root
+ is_genesis: false
+validator:
+ vllm_url: "http://localhost:8080"
diff --git a/decentralized-api/cosmosclient/account_client.go b/decentralized-api/cosmosclient/account_client.go
new file mode 100644
index 000000000..2bd78ae4d
--- /dev/null
+++ b/decentralized-api/cosmosclient/account_client.go
@@ -0,0 +1,52 @@
+package cosmosclient
+
+import (
+ "crypto/sha256"
+ "decentralized-api/logging"
+ "encoding/base64"
+ "encoding/hex"
+
+ "github.com/cosmos/btcutil/bech32"
+ cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
+ "github.com/productscience/inference/x/inference/types"
+ "golang.org/x/crypto/ripemd160"
+)
+
+// PubKeyToAddress Public key bytes to Cosmos address
+//
+// pubKeyHex := "A1B2C3..." // Replace with your public key hex string
+func PubKeyToAddress(pubKeyHex string) (string, error) {
+ pubKeyBytes, err := hex.DecodeString(pubKeyHex)
+ if err != nil {
+ logging.Error("Invalid public key hex", types.Participants, "err", err)
+ return "", err
+ }
+
+ // Step 1: SHA-256 hash
+ shaHash := sha256.Sum256(pubKeyBytes)
+
+ // Step 2: RIPEMD-160 hash
+ ripemdHasher := ripemd160.New()
+ ripemdHasher.Write(shaHash[:])
+ ripemdHash := ripemdHasher.Sum(nil)
+
+ // Step 3: Bech32 encode
+ prefix := "gonka"
+ fiveBitData, err := bech32.ConvertBits(ripemdHash, 8, 5, true)
+ if err != nil {
+ logging.Error("Failed to convert bits", types.Participants, "err", err)
+ return "", err
+ }
+
+ address, err := bech32.Encode(prefix, fiveBitData)
+ if err != nil {
+ logging.Error("Failed to encode address", types.Participants, "err", err)
+ return "", err
+ }
+
+ return address, nil
+}
+
+func PubKeyToString(pubKey cryptotypes.PubKey) string {
+ return base64.StdEncoding.EncodeToString(pubKey.Bytes())
+}
diff --git a/decentralized-api/cosmosclient/cosmosclient.go b/decentralized-api/cosmosclient/cosmosclient.go
new file mode 100644
index 000000000..6cfd01c77
--- /dev/null
+++ b/decentralized-api/cosmosclient/cosmosclient.go
@@ -0,0 +1,499 @@
+package cosmosclient
+
+import (
+ "context"
+ "crypto/rand"
+ "decentralized-api/apiconfig"
+ "decentralized-api/cosmosclient/tx_manager"
+ "decentralized-api/internal/nats/client"
+ "decentralized-api/logging"
+ "decentralized-api/utils"
+ "errors"
+ "fmt"
+ "log"
+ "os/user"
+ "path/filepath"
+ "strings"
+ "time"
+
+ ctypes "github.com/cometbft/cometbft/rpc/core/types"
+ sdkclient "github.com/cosmos/cosmos-sdk/client"
+
+ upgradetypes "cosmossdk.io/x/upgrade/types"
+ "github.com/cosmos/cosmos-sdk/client/grpc/cmtservice"
+ "github.com/cosmos/cosmos-sdk/codec"
+ codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+ cryptocodec "github.com/cosmos/cosmos-sdk/crypto/codec"
+ "github.com/cosmos/cosmos-sdk/crypto/keyring"
+ cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ "github.com/cosmos/cosmos-sdk/types/query"
+ "github.com/cosmos/cosmos-sdk/types/tx/signing"
+ "github.com/golang/protobuf/proto"
+ "github.com/ignite/cli/v28/ignite/pkg/cosmosclient"
+ "github.com/productscience/inference/api/inference/inference"
+ blstypes "github.com/productscience/inference/x/bls/types"
+ "github.com/productscience/inference/x/inference/types"
+ restrictionstypes "github.com/productscience/inference/x/restrictions/types"
+)
+
+type InferenceCosmosClient struct {
+ ctx context.Context
+ apiAccount *apiconfig.ApiAccount
+ Address string
+ manager tx_manager.TxManager
+}
+
+func NewInferenceCosmosClientWithRetry(
+ ctx context.Context,
+ addressPrefix string,
+ maxRetries int,
+ delay time.Duration,
+ config *apiconfig.ConfigManager) (*InferenceCosmosClient, error) {
+ var client *InferenceCosmosClient
+ var err error
+ logging.Info("Connecting to cosmos sdk node", types.System, "config", config, "height", config.GetHeight())
+ for i := 0; i < maxRetries; i++ {
+ client, err = NewInferenceCosmosClient(ctx, addressPrefix, config)
+ if err == nil {
+ return client, nil
+ }
+ log.Printf("Failed to connect to cosmos sdk node, retrying in %s. err = %s", delay, err)
+ time.Sleep(delay)
+ }
+
+ return nil, errors.New("failed to connect to cosmos sdk node after multiple retries")
+}
+
+func expandPath(path string) (string, error) {
+ if strings.HasPrefix(path, "~/") {
+ usr, err := user.Current()
+ if err != nil {
+ return "", err
+ }
+ path = filepath.Join(usr.HomeDir, path[2:])
+ }
+ return filepath.Abs(path)
+}
+
+// 'file' keyring backend to automatically provide interactive prompts for signing
+func updateKeyringIfNeeded(client *cosmosclient.Client, keyringDir string, config *apiconfig.ConfigManager) error {
+ nodeConfig := config.GetChainNodeConfig()
+ if nodeConfig.KeyringBackend == keyring.BackendFile {
+ interfaceRegistry := codectypes.NewInterfaceRegistry()
+ cryptocodec.RegisterInterfaces(interfaceRegistry)
+
+ cdc := codec.NewProtoCodec(interfaceRegistry)
+ kr, err := keyring.New(
+ "inferenced",
+ nodeConfig.KeyringBackend,
+ keyringDir,
+ strings.NewReader(nodeConfig.KeyringPassword),
+ cdc,
+ )
+ if err != nil {
+ log.Printf("Error creating keyring: %s", err)
+ return err
+ }
+ client.AccountRegistry.Keyring = kr
+ return nil
+ }
+ return nil
+}
+
+func NewInferenceCosmosClient(ctx context.Context, addressPrefix string, config *apiconfig.ConfigManager) (*InferenceCosmosClient, error) {
+ nodeConfig := config.GetChainNodeConfig()
+ keyringDir, err := expandPath(nodeConfig.KeyringDir)
+ if err != nil {
+ return nil, err
+ }
+
+ log.Printf("Initializing cosmos Client."+
+ "NodeUrl = %s. KeyringBackend = %s. KeyringDir = %s", nodeConfig.Url, nodeConfig.KeyringBackend, keyringDir)
+ cosmoclient, err := cosmosclient.New(
+ ctx,
+ cosmosclient.WithAddressPrefix(addressPrefix),
+ cosmosclient.WithKeyringServiceName("inferenced"),
+ cosmosclient.WithNodeAddress(nodeConfig.Url),
+ cosmosclient.WithKeyringDir(keyringDir),
+ cosmosclient.WithGasPrices("0ngonka"),
+ cosmosclient.WithFees("0ngonka"),
+ cosmosclient.WithGas("auto"),
+ cosmosclient.WithGasAdjustment(5),
+ )
+ if err != nil {
+ log.Printf("Error creating cosmos client: %s", err)
+ return nil, err
+ }
+ err = updateKeyringIfNeeded(&cosmoclient, keyringDir, config)
+ if err != nil {
+ log.Printf("Error updating keyring: %s", err)
+ return nil, err
+ }
+
+ apiAccount, err := apiconfig.NewApiAccount(addressPrefix, nodeConfig, &cosmoclient)
+ if err != nil {
+ log.Printf("Error creating api account: %s", err)
+ return nil, err
+ }
+ accAddress, err := apiAccount.AccountAddressBech32()
+ if err != nil {
+ log.Printf("Error getting account address: %s", err)
+ return nil, err
+ }
+ log.Printf("Account address: %s", accAddress)
+
+ natsConfig := config.GetNatsConfig()
+ natsConn, err := client.ConnectToNats(natsConfig.Host, natsConfig.Port, "tx_manager")
+ if err != nil {
+ return nil, err
+ }
+
+ mn, err := tx_manager.StartTxManager(ctx, &cosmoclient, apiAccount, time.Second*60, natsConn, accAddress)
+ if err != nil {
+ return nil, err
+ }
+
+ return &InferenceCosmosClient{
+ ctx: ctx,
+ Address: accAddress,
+ apiAccount: apiAccount,
+ manager: mn,
+ }, nil
+}
+
+type CosmosMessageClient interface {
+ SignBytes(seed []byte) ([]byte, error)
+ DecryptBytes(ciphertext []byte) ([]byte, error)
+ EncryptBytes(plaintext []byte) ([]byte, error)
+ StartInference(transaction *inference.MsgStartInference) error
+ FinishInference(transaction *inference.MsgFinishInference) error
+ ReportValidation(transaction *inference.MsgValidation) error
+ SubmitNewUnfundedParticipant(transaction *inference.MsgSubmitNewUnfundedParticipant) error
+ SubmitPocBatch(transaction *inference.MsgSubmitPocBatch) error
+ SubmitPoCValidation(transaction *inference.MsgSubmitPocValidation) error
+ SubmitSeed(transaction *inference.MsgSubmitSeed) error
+ ClaimRewards(transaction *inference.MsgClaimRewards) error
+ CreateTrainingTask(transaction *inference.MsgCreateTrainingTask) (*inference.MsgCreateTrainingTaskResponse, error)
+ ClaimTrainingTaskForAssignment(transaction *inference.MsgClaimTrainingTaskForAssignment) (*inference.MsgClaimTrainingTaskForAssignmentResponse, error)
+ AssignTrainingTask(transaction *inference.MsgAssignTrainingTask) (*inference.MsgAssignTrainingTaskResponse, error)
+ SubmitUnitOfComputePriceProposal(transaction *inference.MsgSubmitUnitOfComputePriceProposal) error
+ BridgeExchange(transaction *types.MsgBridgeExchange) error
+ GetBridgeAddresses(ctx context.Context, chainId string) ([]types.BridgeContractAddress, error)
+ NewInferenceQueryClient() types.QueryClient
+ NewCometQueryClient() cmtservice.ServiceClient
+ BankBalances(ctx context.Context, address string) ([]sdk.Coin, error)
+ SendTransactionAsyncWithRetry(rawTx sdk.Msg) (*sdk.TxResponse, error)
+ SendTransactionAsyncNoRetry(rawTx sdk.Msg) (*sdk.TxResponse, error)
+ SendTransactionSyncNoRetry(transaction proto.Message, dstMsg proto.Message) error
+ Status(ctx context.Context) (*ctypes.ResultStatus, error)
+ GetContext() context.Context
+ GetKeyring() *keyring.Keyring
+ GetClientContext() sdkclient.Context
+ GetAccountAddress() string
+ GetAccountPubKey() cryptotypes.PubKey
+ GetSignerAddress() string
+ SubmitDealerPart(transaction *blstypes.MsgSubmitDealerPart) error
+ SubmitVerificationVector(transaction *blstypes.MsgSubmitVerificationVector) (*sdk.TxResponse, error)
+ SubmitGroupKeyValidationSignature(transaction *blstypes.MsgSubmitGroupKeyValidationSignature) error
+ SubmitPartialSignature(requestId []byte, slotIndices []uint32, partialSignature []byte) error
+ NewBLSQueryClient() blstypes.QueryClient
+ NewRestrictionsQueryClient() restrictionstypes.QueryClient
+ GetAddress() string
+ GetApiAccount() apiconfig.ApiAccount
+}
+
+func (icc *InferenceCosmosClient) GetApiAccount() apiconfig.ApiAccount {
+ return icc.manager.GetApiAccount()
+}
+
+func (icc *InferenceCosmosClient) GetClientContext() sdkclient.Context {
+ return icc.manager.GetClientContext()
+}
+
+func (icc *InferenceCosmosClient) Status(ctx context.Context) (*ctypes.ResultStatus, error) {
+ return icc.manager.Status(ctx)
+}
+
+func (icc *InferenceCosmosClient) GetContext() context.Context {
+ return icc.ctx
+}
+
+func (icc *InferenceCosmosClient) GetAddress() string {
+ return icc.Address
+}
+
+func (icc *InferenceCosmosClient) GetKeyring() *keyring.Keyring {
+ return icc.manager.GetKeyring()
+}
+
+func (icc *InferenceCosmosClient) GetAccountAddress() string {
+ address, err := icc.apiAccount.AccountAddressBech32()
+ if err != nil {
+ logging.Error("Failed to get account address", types.Messages, "error", err)
+ return ""
+ }
+ return address
+}
+
+func (icc *InferenceCosmosClient) GetAccountPubKey() cryptotypes.PubKey {
+ return icc.apiAccount.AccountKey
+}
+
+func (icc *InferenceCosmosClient) GetSignerAddress() string {
+ address, err := icc.apiAccount.SignerAddressBech32()
+ if err != nil {
+ logging.Error("Failed to get signer address", types.Messages, "error", err)
+ return ""
+ }
+ return address
+}
+
+func (icc *InferenceCosmosClient) SignBytes(seed []byte) ([]byte, error) {
+ accName := icc.apiAccount.SignerAccount.Name
+ kr := *icc.GetKeyring()
+ bytes, _, err := kr.Sign(accName, seed, signing.SignMode_SIGN_MODE_DIRECT)
+ if err != nil {
+ return nil, err
+ }
+ return bytes, nil
+}
+
+func (icc *InferenceCosmosClient) DecryptBytes(ciphertext []byte) ([]byte, error) {
+ name := icc.apiAccount.SignerAccount.Name
+ // Use the new keyring Decrypt method
+ kr := *icc.GetKeyring()
+ bytes, err := kr.Decrypt(name, ciphertext, nil, nil)
+ if err != nil {
+ return nil, err
+ }
+ return bytes, nil
+}
+
+func (icc *InferenceCosmosClient) EncryptBytes(plaintext []byte) ([]byte, error) {
+ name := icc.apiAccount.SignerAccount.Name
+ // Use the new keyring Encrypt method with rand.Reader
+ kr := *icc.GetKeyring()
+ bytes, err := kr.Encrypt(rand.Reader, name, plaintext, nil, nil)
+ if err != nil {
+ return nil, err
+ }
+ return bytes, nil
+}
+
+func (icc *InferenceCosmosClient) StartInference(transaction *inference.MsgStartInference) error {
+ transaction.Creator = icc.Address
+ _, err := icc.manager.SendTransactionAsyncWithRetry(transaction)
+ return err
+}
+
+func (icc *InferenceCosmosClient) FinishInference(transaction *inference.MsgFinishInference) error {
+ transaction.Creator = icc.Address
+ transaction.ExecutedBy = icc.Address
+ _, err := icc.manager.SendTransactionAsyncWithRetry(transaction)
+ return err
+}
+
+func (icc *InferenceCosmosClient) ReportValidation(transaction *inference.MsgValidation) error {
+ transaction.Creator = icc.Address
+ logging.Info("Reporting validation", types.Validation, "value", transaction.Value, "type", fmt.Sprintf("%T", transaction), "creator", transaction.Creator)
+ _, err := icc.manager.SendTransactionAsyncWithRetry(transaction)
+ return err
+}
+
+func (icc *InferenceCosmosClient) SubmitNewUnfundedParticipant(transaction *inference.MsgSubmitNewUnfundedParticipant) error {
+ transaction.Creator = icc.Address
+ _, err := icc.manager.SendTransactionAsyncNoRetry(transaction)
+ return err
+}
+
+func (icc *InferenceCosmosClient) ClaimRewards(transaction *inference.MsgClaimRewards) error {
+ transaction.Creator = icc.Address
+ resp, err := icc.manager.SendTransactionAsyncWithRetry(transaction)
+ logging.Info("Claimed rewards", types.Validation, "TX", resp, "type")
+ return err
+}
+
+func (icc *InferenceCosmosClient) BankBalances(ctx context.Context, address string) ([]sdk.Coin, error) {
+ return icc.manager.BankBalances(ctx, address)
+}
+
+func (icc *InferenceCosmosClient) SubmitPocBatch(transaction *inference.MsgSubmitPocBatch) error {
+ transaction.Creator = icc.Address
+ _, err := icc.manager.SendTransactionAsyncWithRetry(transaction)
+ return err
+}
+
+func (icc *InferenceCosmosClient) SubmitPoCValidation(transaction *inference.MsgSubmitPocValidation) error {
+ transaction.Creator = icc.Address
+ _, err := icc.manager.SendTransactionAsyncWithRetry(transaction)
+ return err
+}
+
+func (icc *InferenceCosmosClient) SubmitSeed(transaction *inference.MsgSubmitSeed) error {
+ transaction.Creator = icc.Address
+ _, err := icc.manager.SendTransactionAsyncWithRetry(transaction)
+ return err
+}
+
+func (icc *InferenceCosmosClient) SubmitUnitOfComputePriceProposal(transaction *inference.MsgSubmitUnitOfComputePriceProposal) error {
+ transaction.Creator = icc.Address
+ _, err := icc.manager.SendTransactionAsyncNoRetry(transaction)
+ return err
+}
+
+func (icc *InferenceCosmosClient) CreateTrainingTask(transaction *inference.MsgCreateTrainingTask) (*inference.MsgCreateTrainingTaskResponse, error) {
+ transaction.Creator = icc.Address
+ msg := &inference.MsgCreateTrainingTaskResponse{}
+
+ if err := icc.SendTransactionSyncNoRetry(transaction, msg); err != nil {
+ return nil, err
+ }
+ return msg, nil
+}
+
+func (icc *InferenceCosmosClient) ClaimTrainingTaskForAssignment(transaction *inference.MsgClaimTrainingTaskForAssignment) (*inference.MsgClaimTrainingTaskForAssignmentResponse, error) {
+ transaction.Creator = icc.Address
+ msg := &inference.MsgClaimTrainingTaskForAssignmentResponse{}
+ if err := icc.SendTransactionSyncNoRetry(transaction, msg); err != nil {
+ return nil, err
+ }
+ return msg, nil
+}
+
+func (icc *InferenceCosmosClient) AssignTrainingTask(transaction *inference.MsgAssignTrainingTask) (*inference.MsgAssignTrainingTaskResponse, error) {
+ transaction.Creator = icc.Address
+ result, err := icc.manager.SendTransactionSyncNoRetry(transaction)
+ if err != nil {
+ logging.Error("Failed to send transaction", types.Messages, "error", err, "result", result)
+ return nil, err
+ }
+
+ msg := &inference.MsgAssignTrainingTaskResponse{}
+ err = tx_manager.ParseMsgResponse(result.TxResult.Data, 0, msg)
+ if err != nil {
+ logging.Error("Failed to parse message response", types.Messages, "error", err)
+ return nil, err
+ }
+ return msg, err
+}
+
+func (icc *InferenceCosmosClient) BridgeExchange(transaction *types.MsgBridgeExchange) error {
+ transaction.Validator = icc.Address
+ _, err := icc.manager.SendTransactionAsyncNoRetry(transaction)
+ return err
+}
+
+// GetBridgeAddresses retrieves all bridge addresses for a specific chain
+func (icc *InferenceCosmosClient) GetBridgeAddresses(ctx context.Context, chainId string) ([]types.BridgeContractAddress, error) {
+ queryClient := icc.NewInferenceQueryClient()
+
+ resp, err := queryClient.BridgeAddressesByChain(ctx, &types.QueryBridgeAddressesByChainRequest{
+ ChainId: chainId,
+ })
+ if err != nil {
+ return nil, err
+ }
+
+ return resp.Addresses, nil
+}
+
+func (icc *InferenceCosmosClient) SendTransactionAsyncWithRetry(msg sdk.Msg) (*sdk.TxResponse, error) {
+ return icc.manager.SendTransactionAsyncWithRetry(msg)
+}
+
+func (icc *InferenceCosmosClient) SendTransactionAsyncNoRetry(msg sdk.Msg) (*sdk.TxResponse, error) {
+ return icc.manager.SendTransactionAsyncNoRetry(msg)
+}
+
+func (icc *InferenceCosmosClient) GetUpgradePlan() (*upgradetypes.QueryCurrentPlanResponse, error) {
+ return icc.NewUpgradeQueryClient().CurrentPlan(icc.ctx, &upgradetypes.QueryCurrentPlanRequest{})
+}
+
+func (icc *InferenceCosmosClient) GetPartialUpgrades() (*types.QueryAllPartialUpgradeResponse, error) {
+ // Recommended: ensure icc.ctx is already pinned to a single height via metadata
+ // (caller can wrap icc.ctx with metadata.Pairs(grpctypes.GRPCBlockHeightHeader, strconv.FormatInt(height, 10))).
+
+ allUpgrades, err := utils.GetAllWithPagination(func(pageReq *query.PageRequest) ([]types.PartialUpgrade, *query.PageResponse, error) {
+ resp, err := icc.NewInferenceQueryClient().PartialUpgradeAll(icc.ctx, &types.QueryAllPartialUpgradeRequest{Pagination: pageReq})
+ if err != nil {
+ return nil, nil, err
+ }
+ return resp.PartialUpgrade, resp.Pagination, nil
+ })
+ if err != nil {
+ return nil, err
+ }
+
+ return &types.QueryAllPartialUpgradeResponse{
+ PartialUpgrade: allUpgrades,
+ Pagination: &query.PageResponse{Total: uint64(len(allUpgrades))},
+ }, nil
+}
+
+func (icc *InferenceCosmosClient) NewUpgradeQueryClient() upgradetypes.QueryClient {
+ return upgradetypes.NewQueryClient(icc.manager.GetClientContext())
+}
+
+func (icc *InferenceCosmosClient) NewInferenceQueryClient() types.QueryClient {
+ return types.NewQueryClient(icc.manager.GetClientContext())
+}
+
+func (icc *InferenceCosmosClient) NewCometQueryClient() cmtservice.ServiceClient {
+ return cmtservice.NewServiceClient(icc.manager.GetClientContext())
+}
+
+func (icc *InferenceCosmosClient) SendTransactionSyncNoRetry(transaction proto.Message, dstMsg proto.Message) error {
+ result, err := icc.manager.SendTransactionSyncNoRetry(transaction)
+ if err != nil {
+ logging.Error("Failed to send transaction", types.Messages, "error", err, "result", result)
+ return err
+ }
+
+ err = tx_manager.ParseMsgResponse(result.TxResult.Data, 0, dstMsg)
+ if err != nil {
+ logging.Error("Failed to parse message response", types.Messages, "error", err)
+ return err
+ }
+ return nil
+}
+
+func (icc *InferenceCosmosClient) SubmitDealerPart(transaction *blstypes.MsgSubmitDealerPart) error {
+ transaction.Creator = icc.Address
+ _, err := icc.manager.SendTransactionAsyncWithRetry(transaction)
+ return err
+}
+
+func (icc *InferenceCosmosClient) SubmitVerificationVector(transaction *blstypes.MsgSubmitVerificationVector) (*sdk.TxResponse, error) {
+ transaction.Creator = icc.Address
+ resp, err := icc.manager.SendTransactionAsyncWithRetry(transaction)
+ if err != nil {
+ return nil, err
+ }
+ return resp, err
+}
+
+func (icc *InferenceCosmosClient) SubmitGroupKeyValidationSignature(transaction *blstypes.MsgSubmitGroupKeyValidationSignature) error {
+ transaction.Creator = icc.Address
+ _, err := icc.manager.SendTransactionAsyncWithRetry(transaction)
+ return err
+}
+
+func (icc *InferenceCosmosClient) SubmitPartialSignature(requestId []byte, slotIndices []uint32, partialSignature []byte) error {
+ transaction := &blstypes.MsgSubmitPartialSignature{
+ Creator: icc.Address,
+ RequestId: requestId,
+ SlotIndices: slotIndices,
+ PartialSignature: partialSignature,
+ }
+ _, err := icc.manager.SendTransactionAsyncWithRetry(transaction)
+ return err
+}
+
+func (icc *InferenceCosmosClient) NewBLSQueryClient() blstypes.QueryClient {
+ return blstypes.NewQueryClient(icc.manager.GetClientContext())
+}
+
+func (icc *InferenceCosmosClient) NewRestrictionsQueryClient() restrictionstypes.QueryClient {
+ return restrictionstypes.NewQueryClient(icc.manager.GetClientContext())
+}
diff --git a/decentralized-api/cosmosclient/cosmosclient_test.go b/decentralized-api/cosmosclient/cosmosclient_test.go
new file mode 100644
index 000000000..be74b2dd5
--- /dev/null
+++ b/decentralized-api/cosmosclient/cosmosclient_test.go
@@ -0,0 +1,260 @@
+package cosmosclient
+
+import (
+ "context"
+ "decentralized-api/utils"
+ "fmt"
+ "testing"
+
+ "github.com/cosmos/cosmos-sdk/types/query"
+ "github.com/productscience/inference/x/inference/types"
+ "github.com/stretchr/testify/mock"
+ "github.com/stretchr/testify/require"
+)
+
+// MockInferenceQueryClient mocks the inference query client
+type MockInferenceQueryClient struct {
+ mock.Mock
+}
+
+func (m *MockInferenceQueryClient) PartialUpgradeAll(ctx context.Context, req *types.QueryAllPartialUpgradeRequest) (*types.QueryAllPartialUpgradeResponse, error) {
+ args := m.Called(ctx, req)
+ return args.Get(0).(*types.QueryAllPartialUpgradeResponse), args.Error(1)
+}
+
+// MockInferenceCosmosClient for testing
+type MockInferenceCosmosClientForTest struct {
+ queryClient *MockInferenceQueryClient
+ ctx context.Context
+}
+
+func (m *MockInferenceCosmosClientForTest) NewInferenceQueryClient() *MockInferenceQueryClient {
+ return m.queryClient
+}
+
+func TestGetPartialUpgrades_SinglePage(t *testing.T) {
+ mockQueryClient := &MockInferenceQueryClient{}
+ client := &MockInferenceCosmosClientForTest{
+ queryClient: mockQueryClient,
+ ctx: context.Background(),
+ }
+
+ // Mock single page of upgrades
+ upgrades := []types.PartialUpgrade{
+ {Name: "upgrade1", Height: 100},
+ {Name: "upgrade2", Height: 200},
+ {Name: "upgrade3", Height: 300},
+ }
+
+ mockQueryClient.On("PartialUpgradeAll", mock.Anything, mock.MatchedBy(func(req *types.QueryAllPartialUpgradeRequest) bool {
+ return req.Pagination != nil && req.Pagination.Limit == 1000 && req.Pagination.Key == nil
+ })).Return(&types.QueryAllPartialUpgradeResponse{
+ PartialUpgrade: upgrades,
+ Pagination: &query.PageResponse{
+ NextKey: nil,
+ Total: 3,
+ },
+ }, nil)
+
+ // Test the pagination wrapper logic directly
+ allUpgrades, err := utils.GetAllWithPagination(func(pageReq *query.PageRequest) ([]types.PartialUpgrade, *query.PageResponse, error) {
+ resp, err := mockQueryClient.PartialUpgradeAll(client.ctx, &types.QueryAllPartialUpgradeRequest{Pagination: pageReq})
+ if err != nil {
+ return nil, nil, err
+ }
+ return resp.PartialUpgrade, resp.Pagination, nil
+ })
+
+ require.NoError(t, err)
+ require.Len(t, allUpgrades, 3)
+ require.Equal(t, "upgrade1", allUpgrades[0].Name)
+ require.Equal(t, "upgrade2", allUpgrades[1].Name)
+ require.Equal(t, "upgrade3", allUpgrades[2].Name)
+
+ // Verify response structure
+ response := &types.QueryAllPartialUpgradeResponse{
+ PartialUpgrade: allUpgrades,
+ Pagination: &query.PageResponse{Total: uint64(len(allUpgrades))},
+ }
+ require.Equal(t, uint64(3), response.Pagination.Total)
+ require.Equal(t, upgrades, response.PartialUpgrade)
+
+ mockQueryClient.AssertExpectations(t)
+}
+
+func TestGetPartialUpgrades_MultiplePages(t *testing.T) {
+ mockQueryClient := &MockInferenceQueryClient{}
+ client := &MockInferenceCosmosClientForTest{
+ queryClient: mockQueryClient,
+ ctx: context.Background(),
+ }
+
+ // Mock multiple pages of upgrades
+ page1Upgrades := make([]types.PartialUpgrade, 50)
+ page2Upgrades := make([]types.PartialUpgrade, 75)
+
+ for i := 0; i < 50; i++ {
+ page1Upgrades[i] = types.PartialUpgrade{
+ Name: fmt.Sprintf("upgrade%d", i),
+ Height: uint64(100 + i),
+ }
+ }
+
+ for i := 0; i < 75; i++ {
+ page2Upgrades[i] = types.PartialUpgrade{
+ Name: fmt.Sprintf("upgrade%d", i+50),
+ Height: uint64(150 + i),
+ }
+ }
+
+ // First page
+ mockQueryClient.On("PartialUpgradeAll", mock.Anything, mock.MatchedBy(func(req *types.QueryAllPartialUpgradeRequest) bool {
+ return req.Pagination != nil && req.Pagination.Limit == 1000 && req.Pagination.Key == nil
+ })).Return(&types.QueryAllPartialUpgradeResponse{
+ PartialUpgrade: page1Upgrades,
+ Pagination: &query.PageResponse{
+ NextKey: []byte("next_key"),
+ Total: 125,
+ },
+ }, nil)
+
+ // Second page
+ mockQueryClient.On("PartialUpgradeAll", mock.Anything, mock.MatchedBy(func(req *types.QueryAllPartialUpgradeRequest) bool {
+ return req.Pagination != nil && req.Pagination.Limit == 1000 && string(req.Pagination.Key) == "next_key"
+ })).Return(&types.QueryAllPartialUpgradeResponse{
+ PartialUpgrade: page2Upgrades,
+ Pagination: &query.PageResponse{
+ NextKey: nil,
+ Total: 125,
+ },
+ }, nil)
+
+ // Test the pagination wrapper logic
+ allUpgrades, err := utils.GetAllWithPagination(func(pageReq *query.PageRequest) ([]types.PartialUpgrade, *query.PageResponse, error) {
+ resp, err := mockQueryClient.PartialUpgradeAll(client.ctx, &types.QueryAllPartialUpgradeRequest{Pagination: pageReq})
+ if err != nil {
+ return nil, nil, err
+ }
+ return resp.PartialUpgrade, resp.Pagination, nil
+ })
+
+ require.NoError(t, err)
+ require.Len(t, allUpgrades, 125)
+
+ // Verify first few and last few items
+ require.Equal(t, "upgrade0", allUpgrades[0].Name)
+ require.Equal(t, "upgrade49", allUpgrades[49].Name)
+ require.Equal(t, "upgrade50", allUpgrades[50].Name)
+ require.Equal(t, "upgrade124", allUpgrades[124].Name)
+
+ mockQueryClient.AssertExpectations(t)
+}
+
+func TestGetPartialUpgrades_ErrorHandling(t *testing.T) {
+ mockQueryClient := &MockInferenceQueryClient{}
+ client := &MockInferenceCosmosClientForTest{
+ queryClient: mockQueryClient,
+ ctx: context.Background(),
+ }
+
+ // Mock error on first page
+ mockQueryClient.On("PartialUpgradeAll", mock.Anything, mock.Anything).Return(
+ (*types.QueryAllPartialUpgradeResponse)(nil), fmt.Errorf("query failed"))
+
+ // Test the pagination wrapper logic
+ allUpgrades, err := utils.GetAllWithPagination(func(pageReq *query.PageRequest) ([]types.PartialUpgrade, *query.PageResponse, error) {
+ resp, err := mockQueryClient.PartialUpgradeAll(client.ctx, &types.QueryAllPartialUpgradeRequest{Pagination: pageReq})
+ if err != nil {
+ return nil, nil, err
+ }
+ return resp.PartialUpgrade, resp.Pagination, nil
+ })
+
+ require.Error(t, err)
+ require.Contains(t, err.Error(), "failed to fetch page (items so far: 0)")
+ require.Contains(t, err.Error(), "query failed")
+ require.Nil(t, allUpgrades)
+
+ mockQueryClient.AssertExpectations(t)
+}
+
+func TestGetPartialUpgrades_ErrorOnSecondPage(t *testing.T) {
+ mockQueryClient := &MockInferenceQueryClient{}
+ client := &MockInferenceCosmosClientForTest{
+ queryClient: mockQueryClient,
+ ctx: context.Background(),
+ }
+
+ // First page succeeds
+ mockQueryClient.On("PartialUpgradeAll", mock.Anything, mock.MatchedBy(func(req *types.QueryAllPartialUpgradeRequest) bool {
+ return req.Pagination != nil && req.Pagination.Key == nil
+ })).Return(&types.QueryAllPartialUpgradeResponse{
+ PartialUpgrade: []types.PartialUpgrade{
+ {Name: "upgrade1", Height: 100},
+ },
+ Pagination: &query.PageResponse{
+ NextKey: []byte("next_key"),
+ Total: 2,
+ },
+ }, nil)
+
+ // Second page fails
+ mockQueryClient.On("PartialUpgradeAll", mock.Anything, mock.MatchedBy(func(req *types.QueryAllPartialUpgradeRequest) bool {
+ return req.Pagination != nil && string(req.Pagination.Key) == "next_key"
+ })).Return((*types.QueryAllPartialUpgradeResponse)(nil), fmt.Errorf("second page failed"))
+
+ // Test the pagination wrapper logic
+ allUpgrades, err := utils.GetAllWithPagination(func(pageReq *query.PageRequest) ([]types.PartialUpgrade, *query.PageResponse, error) {
+ resp, err := mockQueryClient.PartialUpgradeAll(client.ctx, &types.QueryAllPartialUpgradeRequest{Pagination: pageReq})
+ if err != nil {
+ return nil, nil, err
+ }
+ return resp.PartialUpgrade, resp.Pagination, nil
+ })
+
+ require.Error(t, err)
+ require.Contains(t, err.Error(), "failed to fetch page (items so far: 1)")
+ require.Contains(t, err.Error(), "second page failed")
+ require.Nil(t, allUpgrades)
+
+ mockQueryClient.AssertExpectations(t)
+}
+
+func TestGetPartialUpgrades_EmptyResult(t *testing.T) {
+ mockQueryClient := &MockInferenceQueryClient{}
+ client := &MockInferenceCosmosClientForTest{
+ queryClient: mockQueryClient,
+ ctx: context.Background(),
+ }
+
+ // Mock empty response
+ mockQueryClient.On("PartialUpgradeAll", mock.Anything, mock.Anything).Return(&types.QueryAllPartialUpgradeResponse{
+ PartialUpgrade: []types.PartialUpgrade{},
+ Pagination: &query.PageResponse{
+ NextKey: nil,
+ Total: 0,
+ },
+ }, nil)
+
+ // Test the pagination wrapper logic
+ allUpgrades, err := utils.GetAllWithPagination(func(pageReq *query.PageRequest) ([]types.PartialUpgrade, *query.PageResponse, error) {
+ resp, err := mockQueryClient.PartialUpgradeAll(client.ctx, &types.QueryAllPartialUpgradeRequest{Pagination: pageReq})
+ if err != nil {
+ return nil, nil, err
+ }
+ return resp.PartialUpgrade, resp.Pagination, nil
+ })
+
+ require.NoError(t, err)
+ require.Empty(t, allUpgrades)
+
+ // Verify response structure
+ response := &types.QueryAllPartialUpgradeResponse{
+ PartialUpgrade: allUpgrades,
+ Pagination: &query.PageResponse{Total: uint64(len(allUpgrades))},
+ }
+ require.Equal(t, uint64(0), response.Pagination.Total)
+ require.Empty(t, response.PartialUpgrade)
+
+ mockQueryClient.AssertExpectations(t)
+}
diff --git a/decentralized-api/cosmosclient/governance.go b/decentralized-api/cosmosclient/governance.go
new file mode 100644
index 000000000..fd1ea6ead
--- /dev/null
+++ b/decentralized-api/cosmosclient/governance.go
@@ -0,0 +1,40 @@
+package cosmosclient
+
+import (
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+ govtypes "github.com/cosmos/cosmos-sdk/x/gov/types"
+ v1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1"
+ "github.com/productscience/inference/x/inference/types"
+)
+
+type ProposalData struct {
+ Metadata string
+ Title string
+ Summary string
+ Expedited bool
+}
+
+func SubmitProposal(cosmosClient CosmosMessageClient, msg sdk.Msg, proposalData *ProposalData) error {
+ // cannot return err with fixed amount
+ coins, _ := types.GetCoins(100000000)
+ proposalMsg, err := v1.NewMsgSubmitProposal(
+ []sdk.Msg{msg},
+ coins, // FIXME: this should be equal to min deposit
+ cosmosClient.GetAccountAddress(),
+ proposalData.Metadata,
+ proposalData.Title,
+ proposalData.Summary,
+ proposalData.Expedited,
+ )
+ if err != nil {
+ return err
+ }
+
+ _, err = cosmosClient.SendTransactionAsyncNoRetry(proposalMsg)
+ return err
+}
+
+func GetProposalMsgSigner() string {
+ return authtypes.NewModuleAddress(govtypes.ModuleName).String()
+}
diff --git a/decentralized-api/cosmosclient/mock_cosmos_message_client.go b/decentralized-api/cosmosclient/mock_cosmos_message_client.go
new file mode 100644
index 000000000..51883772c
--- /dev/null
+++ b/decentralized-api/cosmosclient/mock_cosmos_message_client.go
@@ -0,0 +1,234 @@
+package cosmosclient
+
+import (
+ "context"
+ "decentralized-api/apiconfig"
+
+ sdkclient "github.com/cosmos/cosmos-sdk/client"
+ "github.com/cosmos/cosmos-sdk/crypto/keyring"
+ cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ "github.com/golang/protobuf/proto"
+ "github.com/productscience/inference/api/inference/inference"
+ "github.com/productscience/inference/x/inference/types"
+ "github.com/stretchr/testify/mock"
+
+ upgradetypes "cosmossdk.io/x/upgrade/types"
+ ctypes "github.com/cometbft/cometbft/rpc/core/types"
+ cmtservice "github.com/cosmos/cosmos-sdk/client/grpc/cmtservice"
+ blstypes "github.com/productscience/inference/x/bls/types"
+ restrictionstypes "github.com/productscience/inference/x/restrictions/types"
+)
+
+type MockCosmosMessageClient struct {
+ mock.Mock
+ ctx context.Context
+}
+
+func (m *MockCosmosMessageClient) GetApiAccount() apiconfig.ApiAccount {
+ return apiconfig.ApiAccount{}
+}
+
+func (m *MockCosmosMessageClient) Status(ctx context.Context) (*ctypes.ResultStatus, error) {
+ args := m.Called(ctx)
+ return args.Get(0).(*ctypes.ResultStatus), args.Error(1)
+}
+
+func (m *MockCosmosMessageClient) GetAddress() string {
+ args := m.Called()
+ return args.String(0)
+}
+
+func (m *MockCosmosMessageClient) GetContext() context.Context {
+ args := m.Called()
+ res := args.Get(0)
+ if res == nil {
+ return context.Background()
+ }
+ return res.(context.Context)
+}
+
+func (m *MockCosmosMessageClient) GetKeyring() *keyring.Keyring {
+ args := m.Called()
+ return args.Get(0).(*keyring.Keyring)
+}
+
+func (m *MockCosmosMessageClient) GetClientContext() sdkclient.Context {
+ args := m.Called()
+ return args.Get(0).(sdkclient.Context)
+}
+
+func (m *MockCosmosMessageClient) GetAccountAddress() string {
+ args := m.Called()
+ return args.String(0)
+}
+
+func (m *MockCosmosMessageClient) GetAccountPubKey() cryptotypes.PubKey {
+ args := m.Called()
+ return args.Get(0).(cryptotypes.PubKey)
+}
+
+func (m *MockCosmosMessageClient) GetSignerAddress() string {
+ args := m.Called()
+ return args.String(0)
+}
+
+func (m *MockCosmosMessageClient) SignBytes(seed []byte) ([]byte, error) {
+ args := m.Called(seed)
+ return args.Get(0).([]byte), args.Error(1)
+}
+
+func (m *MockCosmosMessageClient) DecryptBytes(ciphertext []byte) ([]byte, error) {
+ args := m.Called(ciphertext)
+ return args.Get(0).([]byte), args.Error(1)
+}
+
+func (m *MockCosmosMessageClient) EncryptBytes(plaintext []byte) ([]byte, error) {
+ args := m.Called(plaintext)
+ return args.Get(0).([]byte), args.Error(1)
+}
+
+func (m *MockCosmosMessageClient) StartInference(transaction *inference.MsgStartInference) error {
+ args := m.Called(transaction)
+ return args.Error(0)
+}
+
+func (m *MockCosmosMessageClient) FinishInference(transaction *inference.MsgFinishInference) error {
+ args := m.Called(transaction)
+ return args.Error(0)
+}
+
+func (m *MockCosmosMessageClient) ReportValidation(transaction *inference.MsgValidation) error {
+ args := m.Called(transaction)
+ return args.Error(0)
+}
+
+func (m *MockCosmosMessageClient) SubmitNewUnfundedParticipant(transaction *inference.MsgSubmitNewUnfundedParticipant) error {
+ args := m.Called(transaction)
+ return args.Error(0)
+}
+
+func (m *MockCosmosMessageClient) ClaimRewards(transaction *inference.MsgClaimRewards) error {
+ args := m.Called(transaction)
+ return args.Error(0)
+}
+
+func (m *MockCosmosMessageClient) BankBalances(ctx context.Context, address string) ([]sdk.Coin, error) {
+ args := m.Called(ctx, address)
+ return args.Get(0).([]sdk.Coin), args.Error(1)
+}
+
+func (m *MockCosmosMessageClient) SubmitPocBatch(transaction *inference.MsgSubmitPocBatch) error {
+ args := m.Called(transaction)
+ return args.Error(0)
+}
+
+func (m *MockCosmosMessageClient) SubmitPoCValidation(transaction *inference.MsgSubmitPocValidation) error {
+ args := m.Called(transaction)
+ return args.Error(0)
+}
+
+func (m *MockCosmosMessageClient) SubmitSeed(transaction *inference.MsgSubmitSeed) error {
+ args := m.Called(transaction)
+ return args.Error(0)
+}
+
+func (m *MockCosmosMessageClient) SubmitUnitOfComputePriceProposal(transaction *inference.MsgSubmitUnitOfComputePriceProposal) error {
+ args := m.Called(transaction)
+ return args.Error(0)
+}
+
+func (m *MockCosmosMessageClient) CreateTrainingTask(transaction *inference.MsgCreateTrainingTask) (*inference.MsgCreateTrainingTaskResponse, error) {
+ args := m.Called(transaction)
+ return args.Get(0).(*inference.MsgCreateTrainingTaskResponse), args.Error(1)
+}
+
+func (m *MockCosmosMessageClient) ClaimTrainingTaskForAssignment(transaction *inference.MsgClaimTrainingTaskForAssignment) (*inference.MsgClaimTrainingTaskForAssignmentResponse, error) {
+ args := m.Called(transaction)
+ return args.Get(0).(*inference.MsgClaimTrainingTaskForAssignmentResponse), args.Error(1)
+}
+
+func (m *MockCosmosMessageClient) AssignTrainingTask(transaction *inference.MsgAssignTrainingTask) (*inference.MsgAssignTrainingTaskResponse, error) {
+ args := m.Called(transaction)
+ return args.Get(0).(*inference.MsgAssignTrainingTaskResponse), args.Error(1)
+}
+
+func (m *MockCosmosMessageClient) BridgeExchange(transaction *types.MsgBridgeExchange) error {
+ args := m.Called(transaction)
+ return args.Error(0)
+}
+
+func (m *MockCosmosMessageClient) GetBridgeAddresses(ctx context.Context, chainId string) ([]types.BridgeContractAddress, error) {
+ args := m.Called(ctx, chainId)
+ return args.Get(0).([]types.BridgeContractAddress), args.Error(1)
+}
+
+func (m *MockCosmosMessageClient) SendTransactionAsyncWithRetry(msg sdk.Msg) (*sdk.TxResponse, error) {
+ args := m.Called(msg)
+ return args.Get(0).(*sdk.TxResponse), args.Error(1)
+}
+
+func (m *MockCosmosMessageClient) SendTransactionAsyncNoRetry(msg sdk.Msg) (*sdk.TxResponse, error) {
+ args := m.Called(msg)
+ return args.Get(0).(*sdk.TxResponse), args.Error(1)
+}
+
+func (m *MockCosmosMessageClient) GetUpgradePlan() (*upgradetypes.QueryCurrentPlanResponse, error) {
+ args := m.Called()
+ return args.Get(0).(*upgradetypes.QueryCurrentPlanResponse), args.Error(1)
+}
+
+func (m *MockCosmosMessageClient) GetPartialUpgrades() (*types.QueryAllPartialUpgradeResponse, error) {
+ args := m.Called()
+ return args.Get(0).(*types.QueryAllPartialUpgradeResponse), args.Error(1)
+}
+
+func (m *MockCosmosMessageClient) NewUpgradeQueryClient() upgradetypes.QueryClient {
+ args := m.Called()
+ return args.Get(0).(upgradetypes.QueryClient)
+}
+
+func (m *MockCosmosMessageClient) NewInferenceQueryClient() types.QueryClient {
+ args := m.Called()
+ return args.Get(0).(types.QueryClient)
+}
+
+func (m *MockCosmosMessageClient) NewCometQueryClient() cmtservice.ServiceClient {
+ args := m.Called()
+ return args.Get(0).(cmtservice.ServiceClient)
+}
+
+func (m *MockCosmosMessageClient) SendTransactionSyncNoRetry(transaction proto.Message, dstMsg proto.Message) error {
+ args := m.Called(transaction, dstMsg)
+ return args.Error(0)
+}
+
+func (m *MockCosmosMessageClient) SubmitDealerPart(transaction *blstypes.MsgSubmitDealerPart) error {
+ args := m.Called(transaction)
+ return args.Error(0)
+}
+
+func (m *MockCosmosMessageClient) SubmitVerificationVector(transaction *blstypes.MsgSubmitVerificationVector) (*sdk.TxResponse, error) {
+ args := m.Called(transaction)
+ return args.Get(0).(*sdk.TxResponse), args.Error(1)
+}
+
+func (m *MockCosmosMessageClient) SubmitGroupKeyValidationSignature(transaction *blstypes.MsgSubmitGroupKeyValidationSignature) error {
+ args := m.Called(transaction)
+ return args.Error(0)
+}
+
+func (m *MockCosmosMessageClient) SubmitPartialSignature(requestId []byte, slotIndices []uint32, partialSignature []byte) error {
+ args := m.Called(requestId, slotIndices, partialSignature)
+ return args.Error(0)
+}
+
+func (m *MockCosmosMessageClient) NewBLSQueryClient() blstypes.QueryClient {
+ args := m.Called()
+ return args.Get(0).(blstypes.QueryClient)
+}
+
+func (m *MockCosmosMessageClient) NewRestrictionsQueryClient() restrictionstypes.QueryClient {
+ args := m.Called()
+ return args.Get(0).(restrictionstypes.QueryClient)
+}
diff --git a/decentralized-api/cosmosclient/query.go b/decentralized-api/cosmosclient/query.go
new file mode 100644
index 000000000..cc2a765dc
--- /dev/null
+++ b/decentralized-api/cosmosclient/query.go
@@ -0,0 +1,30 @@
+package cosmosclient
+
+import (
+ "context"
+ "decentralized-api/logging"
+ "fmt"
+ rpcclient "github.com/cometbft/cometbft/rpc/client"
+ "github.com/cometbft/cometbft/rpc/client/http"
+ coretypes "github.com/cometbft/cometbft/rpc/core/types"
+ "github.com/productscience/inference/x/inference/types"
+)
+
+// QueryByKeyWithOptions Query any stored value by key, e.g.:
+// storeKey: "inference",
+// dataKey: "ActiveParticipants/value/"
+func QueryByKeyWithOptions(rpcClient *http.HTTP, storeKey string, dataKey []byte, blockHeight int64, withProof bool) (*coretypes.ResultABCIQuery, error) {
+ logging.Info("Querying store", types.System, "storeKey", storeKey, "dataKey", dataKey)
+
+ path := fmt.Sprintf("store/%s/key", storeKey)
+
+ return rpcClient.ABCIQueryWithOptions(context.Background(), path, dataKey, rpcclient.ABCIQueryOptions{Height: blockHeight, Prove: withProof})
+}
+
+func QueryByKey(rpcClient *http.HTTP, storeKey string, dataKey []byte) (*coretypes.ResultABCIQuery, error) {
+ logging.Info("Querying store", types.System, "storeKey", storeKey, "dataKey", dataKey)
+
+ path := fmt.Sprintf("store/%s/key", storeKey)
+
+ return rpcClient.ABCIQuery(context.Background(), path, dataKey)
+}
diff --git a/decentralized-api/cosmosclient/rpcclient.go b/decentralized-api/cosmosclient/rpcclient.go
new file mode 100644
index 000000000..296398390
--- /dev/null
+++ b/decentralized-api/cosmosclient/rpcclient.go
@@ -0,0 +1,25 @@
+package cosmosclient
+
+import (
+ "context"
+ "github.com/cometbft/cometbft/rpc/client/http"
+ coretypes "github.com/cometbft/cometbft/rpc/core/types"
+)
+
+type TendermintClient struct {
+ ChainNodeUrl string
+}
+
+// NewRpcClient Can be used to query Block, Validators, and other data from the Cosmos SDK node.
+func NewRpcClient(address string) (*http.HTTP, error) {
+ return http.New(address, "/websocket")
+}
+
+func (c *TendermintClient) Status() (*coretypes.ResultStatus, error) {
+ client, err := NewRpcClient(c.ChainNodeUrl)
+ if err != nil {
+ return nil, err
+ }
+
+ return client.Status(context.Background())
+}
diff --git a/decentralized-api/cosmosclient/tx_manager/errors.go b/decentralized-api/cosmosclient/tx_manager/errors.go
new file mode 100644
index 000000000..f9c55e4da
--- /dev/null
+++ b/decentralized-api/cosmosclient/tx_manager/errors.go
@@ -0,0 +1,29 @@
+package tx_manager
+
+import (
+ "errors"
+ "strings"
+)
+
+var (
+ ErrBuildingUnsignedTx = errors.New("error building unsigned transaction")
+ ErrFailedToSignTx = errors.New("error signing transaction")
+ ErrFailedToEncodeTx = errors.New("error encoding transaction")
+ ErrAccountNotFound = errors.New("key not found")
+ ErrTxTooLarge = errors.New("tx too large")
+ ErrDecodingTxHash = errors.New("error decoding transaction hash")
+ ErrInvalidAddress = errors.New("invalid bech32 string")
+
+ ErrTxFailedToBroadcastAndPutOnRetry = errors.New("failed to broadcast and put on retry")
+ ErrTxNotFound = errors.New("tx not found")
+)
+
+func isTxErrorCritical(err error) bool {
+ errString := strings.ToLower(err.Error())
+ if errors.Is(err, ErrBuildingUnsignedTx) || errors.Is(err, ErrFailedToSignTx) ||
+ errors.Is(err, ErrFailedToEncodeTx) || strings.Contains(errString, ErrTxTooLarge.Error()) ||
+ strings.Contains(errString, ErrAccountNotFound.Error()) || strings.Contains(errString, ErrInvalidAddress.Error()) {
+ return true
+ }
+ return false
+}
diff --git a/decentralized-api/cosmosclient/tx_manager/transaction_error.go b/decentralized-api/cosmosclient/tx_manager/transaction_error.go
new file mode 100644
index 000000000..f552ce5ac
--- /dev/null
+++ b/decentralized-api/cosmosclient/tx_manager/transaction_error.go
@@ -0,0 +1,48 @@
+package tx_manager
+
+import (
+ "fmt"
+ ctypes "github.com/cometbft/cometbft/rpc/core/types"
+ sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+type TransactionError struct {
+ TxHash string
+ Code uint32
+ Codespace string
+ RawLog string
+}
+
+func (e *TransactionError) Error() string {
+ return fmt.Sprintf("transaction %s failed: code=%d, codespace=%s, log=%s", e.TxHash, e.Code, e.Codespace, e.RawLog)
+}
+
+func NewTransactionErrorFromResponse(resp *sdk.TxResponse) error {
+ if resp == nil {
+ return fmt.Errorf("cannot create TransactionError from nil TxResponse")
+ }
+ if resp.Code == 0 {
+ return nil
+ }
+ return &TransactionError{
+ TxHash: resp.TxHash,
+ Code: resp.Code,
+ Codespace: resp.Codespace,
+ RawLog: resp.RawLog,
+ }
+}
+
+func NewTransactionErrorFromResult(result *ctypes.ResultTx) error {
+ if result == nil {
+ return fmt.Errorf("cannot create TransactionError from nil ResultTx")
+ }
+ if result.TxResult.Code == 0 {
+ return nil
+ }
+ return &TransactionError{
+ TxHash: result.Hash.String(),
+ Code: result.TxResult.Code,
+ Codespace: result.TxResult.Codespace,
+ RawLog: result.TxResult.Log,
+ }
+}
diff --git a/decentralized-api/cosmosclient/tx_manager/tx_manager.go b/decentralized-api/cosmosclient/tx_manager/tx_manager.go
new file mode 100644
index 000000000..4fbc25ad4
--- /dev/null
+++ b/decentralized-api/cosmosclient/tx_manager/tx_manager.go
@@ -0,0 +1,609 @@
+package tx_manager
+
+import (
+ "context"
+ "decentralized-api/apiconfig"
+ "decentralized-api/internal/nats/server"
+ "decentralized-api/logging"
+ "encoding/hex"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "sync"
+ "sync/atomic"
+ "time"
+
+ ctypes "github.com/cometbft/cometbft/rpc/core/types"
+ "github.com/cosmos/cosmos-sdk/client"
+ "github.com/cosmos/cosmos-sdk/client/tx"
+ codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+ "github.com/cosmos/cosmos-sdk/crypto/keyring"
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+ authztypes "github.com/cosmos/cosmos-sdk/x/authz"
+ "github.com/golang/protobuf/proto"
+ "github.com/google/uuid"
+ "github.com/ignite/cli/v28/ignite/pkg/cosmosclient"
+
+ "strings"
+
+ "github.com/nats-io/nats.go"
+
+ upgradetypes "cosmossdk.io/x/upgrade/types"
+ banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
+ v1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1"
+ "github.com/productscience/inference/app"
+ blstypes "github.com/productscience/inference/x/bls/types"
+ collateraltypes "github.com/productscience/inference/x/collateral/types"
+ "github.com/productscience/inference/x/inference/types"
+ restrictionstypes "github.com/productscience/inference/x/restrictions/types"
+)
+
+const (
+ txSenderConsumer = "tx-sender"
+ txObserverConsumer = "tx-observer"
+
+ defaultSenderNackDelay = time.Second * 7
+ defaultObserverNackDelay = time.Second * 5
+)
+
+type TxManager interface {
+ SendTransactionAsyncWithRetry(rawTx sdk.Msg) (*sdk.TxResponse, error)
+ SendTransactionAsyncNoRetry(rawTx sdk.Msg) (*sdk.TxResponse, error)
+ SendTransactionSyncNoRetry(msg proto.Message) (*ctypes.ResultTx, error)
+ GetClientContext() client.Context
+ GetKeyring() *keyring.Keyring
+ GetApiAccount() apiconfig.ApiAccount
+ Status(ctx context.Context) (*ctypes.ResultStatus, error)
+ BankBalances(ctx context.Context, address string) ([]sdk.Coin, error)
+}
+
+type blockTimeTracker struct {
+ latestBlockTime atomic.Value
+ latestBlockHeight int64
+ lastUpdatedAt time.Time
+ maxBlockTimeout time.Duration
+ chainHalt bool
+ mtx sync.Mutex
+}
+
+type manager struct {
+ ctx context.Context
+ client *cosmosclient.Client
+ apiAccount *apiconfig.ApiAccount
+ txFactory *tx.Factory
+ accountRetriever client.AccountRetriever
+ address string
+ defaultTimeout time.Duration
+ natsConnection *nats.Conn
+ natsJetStream nats.JetStreamContext
+ blockTimeTracker *blockTimeTracker
+}
+
+func StartTxManager(
+ ctx context.Context,
+ client *cosmosclient.Client,
+ account *apiconfig.ApiAccount,
+ defaultTimeout time.Duration,
+ natsConnection *nats.Conn,
+ address string) (*manager, error) {
+ js, err := natsConnection.JetStream()
+ if err != nil {
+ return nil, err
+ }
+
+ // Register all module interfaces to match admin server codec
+ app.RegisterLegacyModules(client.Context().InterfaceRegistry)
+ types.RegisterInterfaces(client.Context().InterfaceRegistry)
+ banktypes.RegisterInterfaces(client.Context().InterfaceRegistry)
+ v1.RegisterInterfaces(client.Context().InterfaceRegistry)
+ upgradetypes.RegisterInterfaces(client.Context().InterfaceRegistry)
+ collateraltypes.RegisterInterfaces(client.Context().InterfaceRegistry)
+ restrictionstypes.RegisterInterfaces(client.Context().InterfaceRegistry)
+ blstypes.RegisterInterfaces(client.Context().InterfaceRegistry)
+
+ ts := atomic.Value{}
+ ts.Store(time.Time{})
+
+ m := &manager{
+ ctx: ctx,
+ client: client,
+ address: address,
+ apiAccount: account,
+ accountRetriever: authtypes.AccountRetriever{},
+ defaultTimeout: defaultTimeout,
+ natsConnection: natsConnection,
+ natsJetStream: js,
+ blockTimeTracker: &blockTimeTracker{
+ latestBlockTime: ts,
+ maxBlockTimeout: 10 * time.Second,
+ },
+ }
+ if err := m.sendTxs(); err != nil {
+ return nil, err
+ }
+
+ if err := m.observeTxs(); err != nil {
+ return nil, err
+ }
+
+ return m, nil
+}
+
+const maxAttempts = 100
+
+type txToSend struct {
+ TxInfo txInfo
+ Sent bool
+ Attempts int
+}
+
+type txInfo struct {
+ Id string
+ RawTx []byte
+ TxHash string
+ Timeout time.Time
+ Attempts int
+}
+
+func (m *manager) GetApiAccount() apiconfig.ApiAccount {
+ return *m.apiAccount
+}
+
+func (m *manager) Status(ctx context.Context) (*ctypes.ResultStatus, error) {
+ return m.client.Status(ctx)
+}
+
+func (m *manager) SendTransactionAsyncWithRetry(rawTx sdk.Msg) (*sdk.TxResponse, error) {
+ id := uuid.New().String()
+ logging.Debug("SendTransactionAsyncWithRetry: sending tx", types.Messages, "tx_id", id)
+
+ if halt, err := m.updateChainHalt(); err != nil || halt {
+ logging.Error("chain is slowing down or couldn't fetch actual chain status", types.Messages, "latest_block_timestamp", m.blockTimeTracker.latestBlockTime.Load().(time.Time))
+
+ if err := m.putOnRetry(id, "", time.Time{}, rawTx, 0, false); err != nil {
+ logging.Error("failed to put in queue", types.Messages, "tx_id", id, "resend_err", err)
+ return nil, ErrTxFailedToBroadcastAndPutOnRetry
+ }
+ return &sdk.TxResponse{}, nil
+ }
+
+ resp, timeout, broadcastErr := m.broadcastMessage(id, rawTx)
+ if broadcastErr != nil {
+ if isTxErrorCritical(broadcastErr) {
+ logging.Error("SendTransactionAsyncWithRetry: critical error sending tx", types.Messages, "tx_id", id, "err", broadcastErr)
+ return nil, broadcastErr
+ }
+
+ err := m.putOnRetry(id, "", timeout, rawTx, 1, false)
+ if err != nil {
+ logging.Error("tx failed to broadcast, failed to put in queue", types.Messages, "tx_id", id, "broadcast_err", broadcastErr, "resend_err", err)
+ }
+ return nil, ErrTxFailedToBroadcastAndPutOnRetry
+ }
+ if err := m.putOnRetry(id, resp.TxHash, timeout, rawTx, 1, true); err != nil {
+ logging.Error("tx broadcast, but failed to put in queue", types.Messages, "tx_id", id, "err", err)
+ }
+ return resp, nil
+}
+
+func (m *manager) SendTransactionAsyncNoRetry(rawTx sdk.Msg) (*sdk.TxResponse, error) {
+ id := uuid.New().String()
+ logging.Debug("SendTransactionAsyncNoRetry: sending tx", types.Messages, "tx_id", id, "originalMsgType", sdk.MsgTypeURL(rawTx))
+ _, err := m.updateChainHalt()
+ if err != nil {
+ return nil, err
+ }
+ resp, _, broadcastErr := m.broadcastMessage(id, rawTx)
+ return resp, broadcastErr
+}
+
+func (m *manager) SendTransactionSyncNoRetry(msg proto.Message) (*ctypes.ResultTx, error) {
+ id := uuid.New().String()
+ logging.Debug("SendTransactionSyncNoRetry: sending tx", types.Messages, "tx_id", id)
+ _, err := m.updateChainHalt()
+ if err != nil {
+ return nil, err
+ }
+ resp, _, err := m.broadcastMessage(id, msg)
+ if err != nil {
+ return nil, err
+ }
+
+ logging.Debug("Transaction broadcast successful", types.Messages, "tx_id", id, "tx_hash", resp.TxHash)
+ result, err := m.WaitForResponse(resp.TxHash)
+ if err != nil {
+ logging.Error("Failed to wait for transaction", types.Messages, "tx_id", id, "tx_hash", resp.TxHash, "error", err)
+ return nil, err
+ }
+ return result, nil
+}
+
+func (m *manager) GetKeyring() *keyring.Keyring {
+ return &m.client.AccountRegistry.Keyring
+}
+
+func (m *manager) putOnRetry(
+ id,
+ txHash string,
+ timeout time.Time,
+ rawTx sdk.Msg,
+ attempts int,
+ sent bool) error {
+ logging.Debug("putOnRetry: tx with params", types.Messages,
+ "tx_id", id,
+ "tx_hash", txHash,
+ "timeout", timeout.String(),
+ "sent", sent,
+ )
+
+ if attempts >= maxAttempts {
+ logging.Warn("tx reached max attempts", types.Messages, "tx_id", id)
+ return nil
+ }
+
+ bz, err := m.client.Context().Codec.MarshalInterfaceJSON(rawTx)
+ if err != nil {
+ return err
+ }
+
+ if id == "" {
+ id = uuid.New().String()
+ }
+
+ b, err := json.Marshal(&txToSend{
+ TxInfo: txInfo{
+ Id: id,
+ RawTx: bz,
+ TxHash: txHash,
+ Timeout: timeout,
+ },
+ Sent: sent,
+ Attempts: attempts,
+ })
+ if err != nil {
+ return err
+ }
+ _, err = m.natsJetStream.Publish(server.TxsToSendStream, b)
+ return err
+}
+
+func (m *manager) putTxToObserve(id string, rawTx sdk.Msg, txHash string, timeout time.Time, attempts int) error {
+ logging.Debug(" putTxToObserve: tx with params", types.Messages,
+ "tx_id", id,
+ "tx_hash", txHash,
+ "timeout", timeout.String(),
+ )
+
+ bz, err := m.client.Context().Codec.MarshalInterfaceJSON(rawTx)
+ if err != nil {
+ return err
+ }
+
+ b, err := json.Marshal(&txInfo{
+ Id: id,
+ RawTx: bz,
+ TxHash: txHash,
+ Timeout: timeout,
+ Attempts: attempts,
+ })
+ if err != nil {
+ return err
+ }
+ _, err = m.natsJetStream.Publish(server.TxsToObserveStream, b)
+ return err
+}
+
+func (m *manager) sendTxs() error {
+ logging.Info("Tx manager: sending txs: run in background", types.Messages)
+
+ _, err := m.natsJetStream.Subscribe(server.TxsToSendStream, func(msg *nats.Msg) {
+ if halt, err := m.updateChainHalt(); err != nil || halt {
+ logging.Error("chain is slowing down or couldn't fetch actual chain status", types.Messages, "latest_block_timestamp", m.blockTimeTracker.latestBlockTime.Load().(time.Time))
+ time.Sleep(3 * time.Second)
+ return
+ }
+
+ var tx txToSend
+ if err := json.Unmarshal(msg.Data, &tx); err != nil {
+ logging.Error("error unmarshaling tx_to_send", types.Messages, "err", err)
+ msg.Term() // malformed, drop it
+ return
+ }
+
+ logging.Debug("SendTxs: got tx", types.Messages, "id", tx.TxInfo.Id)
+
+ rawTx, err := m.unpackTx(tx.TxInfo.RawTx)
+ if err != nil {
+ logging.Error("error unpacking raw tx", types.Messages, "id", tx.TxInfo.Id, "err", err)
+ msg.Term() // malformed, drop it
+ return
+ }
+
+ if !tx.Sent {
+ logging.Debug("start broadcast tx async", types.Messages, "id", tx.TxInfo.Id)
+ resp, timeout, err := m.broadcastMessage(tx.TxInfo.Id, rawTx)
+ if err != nil {
+ if isTxErrorCritical(err) {
+ logging.Error("got critical error sending tx", types.Messages, "id", tx.TxInfo.Id)
+ msg.Term() // invalid tx, drop it
+ return
+ }
+ msg.NakWithDelay(defaultSenderNackDelay)
+ return
+ }
+ tx.TxInfo.Timeout = timeout
+ tx.TxInfo.TxHash = resp.TxHash
+ tx.Sent = true
+ }
+
+ logging.Debug("tx broadcast, put to observe", types.Messages, "id", tx.TxInfo.Id, "tx_hash", tx.TxInfo.TxHash, "timeout", tx.TxInfo.Timeout.String())
+
+ if err := m.putTxToObserve(tx.TxInfo.Id, rawTx, tx.TxInfo.TxHash, tx.TxInfo.Timeout, tx.Attempts); err != nil {
+ logging.Error("error pushing to observe queue", types.Messages, "id", tx.TxInfo.Id, "err", err)
+ msg.NakWithDelay(defaultSenderNackDelay)
+ } else {
+ msg.Ack()
+ }
+ }, nats.Durable(txSenderConsumer), nats.ManualAck())
+ return err
+}
+
+func (m *manager) observeTxs() error {
+ logging.Info("Tx manager: observeTxs txs: run in background", types.Messages)
+ _, err := m.natsJetStream.Subscribe(server.TxsToObserveStream, func(msg *nats.Msg) {
+ if halt, err := m.updateChainHalt(); err != nil || halt {
+ logging.Error("chain is slowing down or couldn't fetch actual chain status", types.Messages, "latest_block_timestamp", m.blockTimeTracker.latestBlockTime.Load().(time.Time))
+ }
+
+ var tx txInfo
+ if err := json.Unmarshal(msg.Data, &tx); err != nil {
+ logging.Error("error unmarshaling tx_to_observe", types.Messages, "err", err)
+ msg.Term()
+ return
+ }
+
+ rawTx, err := m.unpackTx(tx.RawTx)
+ if err != nil {
+ msg.Term()
+ return
+ }
+
+ if tx.TxHash == "" {
+ logging.Warn("tx hash is empty", types.Messages, "tx_id", tx.Id)
+
+ tx.Attempts++
+ if err := m.putOnRetry(tx.Id, "", time.Time{}, rawTx, tx.Attempts, false); err != nil {
+ msg.NakWithDelay(defaultObserverNackDelay)
+ return
+ }
+ msg.Ack()
+ return
+ }
+
+ found, err := m.checkTxStatus(tx.TxHash)
+ if found {
+ logging.Debug("tx found, remove tx from observer queue", types.Messages, "tx_id", tx.Id, "txHash", tx.TxHash)
+ if err := msg.Ack(); err != nil {
+ logging.Error("ack error", types.Messages, "tx_id", tx.Id, "err", err)
+ }
+ return
+ }
+
+ if errors.Is(err, ErrDecodingTxHash) {
+ msg.Term()
+ return
+ }
+
+ if errors.Is(err, ErrTxNotFound) {
+ if m.blockTimeTracker.latestBlockTime.Load().(time.Time).After(tx.Timeout) {
+ logging.Debug("tx expired", types.Messages, "tx_id", tx.Id, "tx_hash", tx.TxHash, "tx_timestamp", tx.Timeout, "latest_block_timestamp", m.blockTimeTracker.latestBlockTime)
+ tx.Attempts++
+ if err := m.putOnRetry(tx.Id, "", time.Time{}, rawTx, tx.Attempts, false); err != nil {
+ msg.NakWithDelay(defaultObserverNackDelay)
+ return
+ }
+ msg.Ack()
+ return
+ }
+ }
+
+ msg.NakWithDelay(defaultObserverNackDelay)
+ return
+ }, nats.Durable(txObserverConsumer), nats.ManualAck())
+ return err
+}
+
+func (m *manager) GetClientContext() client.Context {
+ return m.client.Context()
+}
+
+func (m *manager) checkTxStatus(hash string) (bool, error) {
+ bz, err := hex.DecodeString(hash)
+ if err != nil {
+ logging.Error("checkTxStatus: error decoding tx hash", types.Messages, "err", err)
+ return false, ErrDecodingTxHash
+ }
+
+ resp, err := m.client.Context().Client.Tx(m.ctx, bz, false)
+ if err != nil {
+ if strings.Contains(err.Error(), "not found") {
+ return false, ErrTxNotFound
+ }
+ return false, err
+ }
+
+ if resp.TxResult.Code != 0 {
+ logging.Error("checkTxStatus: tx failed on-chain", types.Messages, "txHash", hash, "code", resp.TxResult.Code, "codespace", resp.TxResult.Codespace, "rawLog", resp.TxResult.Log)
+ }
+ logging.Debug("checkTxStatus: found tx result", types.Messages, "txHash", hash, "resp", resp)
+ return true, nil
+}
+
+func (m *manager) WaitForResponse(txHash string) (*ctypes.ResultTx, error) {
+ ctx, cancel := context.WithTimeout(m.ctx, time.Second*15)
+ defer cancel()
+
+ transactionAppliedResult, err := m.client.WaitForTx(ctx, txHash)
+ if err != nil {
+ logging.Error("Failed to wait for transaction", types.Messages, "error", err, "result", transactionAppliedResult)
+ return nil, err
+ }
+
+ txResult := transactionAppliedResult.TxResult
+ if txResult.Code != 0 {
+ logging.Error("Transaction failed on-chain", types.Messages, "txHash", txHash, "code", txResult.Code, "codespace", txResult.Codespace, "rawLog", txResult.Log)
+ return nil, NewTransactionErrorFromResult(transactionAppliedResult)
+ }
+ return transactionAppliedResult, nil
+}
+
+func (m *manager) BankBalances(ctx context.Context, address string) ([]sdk.Coin, error) {
+ return m.client.BankBalances(ctx, address, nil)
+}
+
+func (m *manager) broadcastMessage(id string, rawTx sdk.Msg) (*sdk.TxResponse, time.Time, error) {
+ factory, err := m.getFactory(id)
+ if err != nil {
+ return nil, time.Time{}, err
+ }
+
+ var finalMsg sdk.Msg = rawTx
+ originalMsgType := sdk.MsgTypeURL(rawTx)
+ 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", originalMsgType)
+ }
+
+ 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
+ }
+
+ 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", originalMsgType)
+ } else {
+ logging.Debug("Broadcast successful", types.Messages, "tx_id", id, "originalMsgType", originalMsgType, "resp", resp)
+ }
+ return resp, timestamp, nil
+}
+
+func (m *manager) unpackTx(bz []byte) (sdk.Msg, error) {
+ var unpackedAny codectypes.Any
+ if err := m.client.Context().Codec.UnmarshalJSON(bz, &unpackedAny); err != nil {
+ return nil, err
+ }
+
+ var rawTx sdk.Msg
+ if err := m.client.Context().Codec.UnpackAny(&unpackedAny, &rawTx); err != nil {
+ return nil, err
+ }
+ return rawTx, nil
+}
+
+func (m *manager) getFactory(id string) (*tx.Factory, error) {
+ // Now that we don't need the sequence, we only need to create the factory if it doesn't exist
+ if m.txFactory != nil {
+ return m.txFactory, nil
+ }
+ address, err := m.apiAccount.SignerAddress()
+ if err != nil {
+ logging.Error("Failed to get account address", types.Messages, "tx_id", id, "error", err)
+ return nil, err
+ }
+ accountNumber, _, err := m.accountRetriever.GetAccountNumberSequence(m.client.Context(), address)
+ if err != nil {
+ logging.Error("Failed to get account number and sequence", types.Messages, "tx_id", id, "error", err)
+ return nil, err
+ }
+ factory := m.client.TxFactory.
+ WithAccountNumber(accountNumber).
+ WithGasAdjustment(10).
+ WithFees("").
+ WithGasPrices("").
+ WithGas(0).
+ WithUnordered(true).
+ WithKeybase(*m.GetKeyring())
+ m.txFactory = &factory
+ return &factory, nil
+}
+
+func (m *manager) getSignedBytes(id string, unsignedTx client.TxBuilder, factory *tx.Factory) ([]byte, time.Time, error) {
+ blockTs := m.blockTimeTracker.latestBlockTime.Load().(time.Time)
+ if blockTs.IsZero() {
+ _, err := m.updateChainHalt()
+ if err != nil {
+ return nil, time.Time{}, err
+ }
+ blockTs = m.blockTimeTracker.latestBlockTime.Load().(time.Time)
+ }
+
+ timestamp := getTimestamp(blockTs.UnixNano(), m.defaultTimeout)
+
+ // Gas is not charged, but without a high gas limit the transactions fail
+ unsignedTx.SetGasLimit(1000000000)
+ unsignedTx.SetFeeAmount(sdk.Coins{})
+ unsignedTx.SetUnordered(true)
+ unsignedTx.SetTimeoutTimestamp(timestamp)
+ name := m.apiAccount.SignerAccount.Name
+ logging.Debug("Signing transaction", types.Messages, "tx_id", id, "timeout", timestamp.String(), "name", name)
+
+ err := tx.Sign(m.ctx, *factory, name, unsignedTx, false)
+ if err != nil {
+ logging.Error("Failed to sign transaction", types.Messages, "tx_id", id, "error", err)
+ return nil, time.Time{}, err
+ }
+ txBytes, err := m.client.Context().TxConfig.TxEncoder()(unsignedTx.GetTx())
+ if err != nil {
+ logging.Error("Failed to encode transaction", types.Messages, "tx_id", id, "error", err)
+ return nil, time.Time{}, err
+ }
+ return txBytes, timestamp, nil
+}
+
+func (m *manager) updateChainHalt() (bool, error) {
+ now := time.Now()
+ if now.Sub(m.blockTimeTracker.lastUpdatedAt) < time.Second*3 {
+ return m.blockTimeTracker.chainHalt, nil
+ }
+
+ status, err := m.client.Status(m.ctx)
+ if err != nil {
+ logging.Error("error getting blockchain status", types.Messages, "err", err)
+ return false, err
+ }
+
+ m.blockTimeTracker.mtx.Lock()
+ defer m.blockTimeTracker.mtx.Unlock()
+
+ if status.SyncInfo.LatestBlockTime.Equal(m.blockTimeTracker.latestBlockTime.Load().(time.Time)) &&
+ status.SyncInfo.LatestBlockHeight == m.blockTimeTracker.latestBlockHeight &&
+ !m.blockTimeTracker.lastUpdatedAt.IsZero() && now.Sub(m.blockTimeTracker.lastUpdatedAt) > m.blockTimeTracker.maxBlockTimeout {
+ // same block, and we sow it more than N seconds ago -> chain halt
+ m.blockTimeTracker.chainHalt = true
+ }
+
+ if status.SyncInfo.LatestBlockTime.After(m.blockTimeTracker.latestBlockTime.Load().(time.Time)) &&
+ status.SyncInfo.LatestBlockHeight > m.blockTimeTracker.latestBlockHeight {
+ m.blockTimeTracker.latestBlockHeight = status.SyncInfo.LatestBlockHeight
+ m.blockTimeTracker.latestBlockTime.Store(status.SyncInfo.LatestBlockTime)
+ m.blockTimeTracker.chainHalt = false
+ }
+
+ m.blockTimeTracker.lastUpdatedAt = now
+ return m.blockTimeTracker.chainHalt, nil
+}
diff --git a/decentralized-api/cosmosclient/tx_manager/tx_manager_test.go b/decentralized-api/cosmosclient/tx_manager/tx_manager_test.go
new file mode 100644
index 000000000..edd79fcec
--- /dev/null
+++ b/decentralized-api/cosmosclient/tx_manager/tx_manager_test.go
@@ -0,0 +1,67 @@
+package tx_manager
+
+import (
+ "encoding/json"
+ codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ "github.com/google/uuid"
+ "github.com/ignite/cli/v28/ignite/pkg/cosmosclient/mocks"
+ "github.com/productscience/inference/api/inference/inference"
+ testutil "github.com/productscience/inference/testutil/cosmoclient"
+ "github.com/productscience/inference/x/inference/types"
+ "github.com/stretchr/testify/assert"
+ "testing"
+ "time"
+)
+
+func TestPack_Unpack_Msg(t *testing.T) {
+ const (
+ network = "cosmos"
+
+ accountName = "cosmosaccount"
+ mnemonic = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about"
+ passphrase = "testpass"
+ )
+
+ rpc := mocks.NewRPCClient(t)
+ client := testutil.NewMockClient(t, rpc, network, accountName, mnemonic, passphrase)
+
+ rawTx := &inference.MsgFinishInference{
+ Creator: "some_address",
+ InferenceId: uuid.New().String(),
+ ResponseHash: "some_hash",
+ ResponsePayload: "resp",
+ PromptTokenCount: 10,
+ CompletionTokenCount: 20,
+ ExecutedBy: "executor",
+ }
+
+ bz, err := client.Context().Codec.MarshalInterfaceJSON(rawTx)
+ assert.NoError(t, err)
+
+ timeout := getTimestamp(time.Now().UnixNano(), time.Second)
+ b, err := json.Marshal(&txToSend{TxInfo: txInfo{RawTx: bz, Timeout: timeout}})
+ assert.NoError(t, err)
+
+ var tx txToSend
+ err = json.Unmarshal(b, &tx)
+ assert.NoError(t, err)
+
+ var unpackedAny codectypes.Any
+ err = client.Context().Codec.UnmarshalJSON(tx.TxInfo.RawTx, &unpackedAny)
+ assert.NoError(t, err)
+
+ var unmarshalledRawTx sdk.Msg
+ err = client.Context().Codec.UnpackAny(&unpackedAny, &unmarshalledRawTx)
+ assert.NoError(t, err)
+
+ result := unmarshalledRawTx.(*types.MsgFinishInference)
+
+ assert.Equal(t, rawTx.InferenceId, result.InferenceId)
+ assert.Equal(t, rawTx.Creator, result.Creator)
+ assert.Equal(t, rawTx.ResponseHash, result.ResponseHash)
+ assert.Equal(t, rawTx.ResponsePayload, result.ResponsePayload)
+ assert.Equal(t, rawTx.PromptTokenCount, result.PromptTokenCount)
+ assert.Equal(t, rawTx.CompletionTokenCount, result.CompletionTokenCount)
+ assert.Equal(t, rawTx.ExecutedBy, result.ExecutedBy)
+}
diff --git a/decentralized-api/cosmosclient/tx_manager/utils.go b/decentralized-api/cosmosclient/tx_manager/utils.go
new file mode 100644
index 000000000..45db9330c
--- /dev/null
+++ b/decentralized-api/cosmosclient/tx_manager/utils.go
@@ -0,0 +1,56 @@
+package tx_manager
+
+import (
+ "decentralized-api/logging"
+ "fmt"
+ "sync/atomic"
+ "time"
+
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ "github.com/golang/protobuf/proto"
+ "github.com/productscience/inference/x/inference/types"
+)
+
+func ParseMsgResponse(data []byte, msgIndex int, dstMsg proto.Message) error {
+ var txMsgData sdk.TxMsgData
+ if err := proto.Unmarshal(data, &txMsgData); err != nil {
+ logging.Error("Failed to unmarshal TxMsgData", types.Messages, "error", err, "data", data)
+ return fmt.Errorf("failed to unmarshal TxMsgData: %w", err)
+ }
+
+ logging.Info("Found messages", types.Messages, "len(messages)", len(txMsgData.MsgResponses), "messages", txMsgData.MsgResponses)
+ if msgIndex < 0 || msgIndex >= len(txMsgData.MsgResponses) {
+ logging.Error("Message index out of range", types.Messages, "msgIndex", msgIndex, "len(messages)", len(txMsgData.MsgResponses))
+ return fmt.Errorf(
+ "message index %d out of range: got %d responses",
+ msgIndex, len(txMsgData.MsgResponses),
+ )
+ }
+
+ anyResp := txMsgData.MsgResponses[msgIndex]
+ if err := proto.Unmarshal(anyResp.Value, dstMsg); err != nil {
+ logging.Error("Failed to unmarshal response", types.Messages, "error", err, "msgIndex", msgIndex, "response", anyResp.Value)
+ return fmt.Errorf("failed to unmarshal response at index %d: %w", msgIndex, err)
+ }
+ return nil
+}
+
+var lastNanos atomic.Int64
+
+func nowNanoUnique(now int64) int64 {
+ for {
+ prev := lastNanos.Load()
+ next := now
+ if next <= prev {
+ next = prev + 1
+ }
+ if lastNanos.CompareAndSwap(prev, next) {
+ return next
+ }
+ }
+}
+
+func getTimestamp(timeNow int64, duration time.Duration) time.Time {
+ nanos := nowNanoUnique(timeNow)
+ return time.Unix(0, nanos).Add(duration)
+}
diff --git a/decentralized-api/cosmovisor/v1.7.0/linux-amd64/cosmovisor b/decentralized-api/cosmovisor/v1.7.0/linux-amd64/cosmovisor
new file mode 100755
index 000000000..f5096b186
Binary files /dev/null and b/decentralized-api/cosmovisor/v1.7.0/linux-amd64/cosmovisor differ
diff --git a/decentralized-api/cosmovisor/v1.7.0/linux-arm64/cosmovisor b/decentralized-api/cosmovisor/v1.7.0/linux-arm64/cosmovisor
new file mode 100755
index 000000000..8becb9da7
Binary files /dev/null and b/decentralized-api/cosmovisor/v1.7.0/linux-arm64/cosmovisor differ
diff --git a/decentralized-api/go.mod b/decentralized-api/go.mod
new file mode 100644
index 000000000..6050cf95b
--- /dev/null
+++ b/decentralized-api/go.mod
@@ -0,0 +1,271 @@
+module decentralized-api
+
+go 1.23.2
+
+toolchain go1.24.2
+
+require (
+ cosmossdk.io/errors v1.0.2
+ cosmossdk.io/store v1.1.2
+ cosmossdk.io/x/upgrade v0.1.4
+ github.com/cometbft/cometbft v0.38.17
+ github.com/consensys/gnark-crypto v0.18.0
+ github.com/cosmos/btcutil v1.0.5
+ github.com/cosmos/cosmos-sdk v0.53.3
+ github.com/cosmos/ibc-go/v8 v8.4.0
+ github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0
+ github.com/golang/protobuf v1.5.4
+ github.com/google/uuid v1.6.0
+ github.com/gorilla/websocket v1.5.3
+ github.com/ignite/cli/v28 v28.11.0
+ github.com/knadh/koanf/parsers/yaml v0.1.0
+ github.com/knadh/koanf/providers/env v1.0.0
+ github.com/knadh/koanf/providers/file v0.1.0
+ github.com/knadh/koanf/providers/rawbytes v0.1.0
+ github.com/knadh/koanf/providers/structs v0.1.0
+ github.com/knadh/koanf/v2 v2.1.1
+ github.com/labstack/echo/v4 v4.10.0
+ github.com/nats-io/nats-server/v2 v2.8.4
+ github.com/nats-io/nats.go v1.34.0
+ github.com/pkg/errors v0.9.1
+ github.com/productscience/inference v0.0.0-00010101000000-000000000000
+ github.com/stretchr/testify v1.10.0
+ golang.org/x/crypto v0.38.0
+ golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b
+ google.golang.org/grpc v1.72.2
+ modernc.org/sqlite v1.39.0
+)
+
+require (
+ cel.dev/expr v0.20.0 // indirect
+ cloud.google.com/go v0.116.0 // indirect
+ cloud.google.com/go/auth v0.13.0 // indirect
+ cloud.google.com/go/auth/oauth2adapt v0.2.6 // indirect
+ cloud.google.com/go/compute/metadata v0.6.0 // indirect
+ cloud.google.com/go/iam v1.2.2 // indirect
+ cloud.google.com/go/monitoring v1.21.2 // indirect
+ cloud.google.com/go/storage v1.49.0 // indirect
+ cosmossdk.io/api v0.9.2 // indirect
+ cosmossdk.io/client/v2 v2.0.0-beta.1 // indirect
+ cosmossdk.io/collections v1.2.1 // indirect
+ cosmossdk.io/core v0.11.3 // indirect
+ cosmossdk.io/depinject v1.2.1 // indirect
+ cosmossdk.io/log v1.6.0 // indirect
+ cosmossdk.io/math v1.5.3 // indirect
+ cosmossdk.io/schema v1.1.0 // indirect
+ cosmossdk.io/tools/confix v0.1.2 // indirect
+ cosmossdk.io/x/circuit v0.1.1 // indirect
+ cosmossdk.io/x/evidence v0.1.1 // indirect
+ cosmossdk.io/x/feegrant v0.1.1 // indirect
+ cosmossdk.io/x/nft v0.1.1 // indirect
+ cosmossdk.io/x/tx v0.14.0 // indirect
+ filippo.io/edwards25519 v1.1.0 // indirect
+ github.com/99designs/go-keychain v0.0.0-20191008050251-8e49817e8af4 // indirect
+ github.com/99designs/keyring v1.2.2 // indirect
+ github.com/CosmWasm/wasmd v0.54.2 // indirect
+ github.com/CosmWasm/wasmvm/v2 v2.2.4 // indirect
+ github.com/DataDog/datadog-go v3.2.0+incompatible // indirect
+ github.com/DataDog/zstd v1.5.7 // indirect
+ github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.26.0 // indirect
+ github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/metric v0.48.1 // indirect
+ github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/resourcemapping v0.48.1 // indirect
+ github.com/aws/aws-sdk-go v1.44.224 // indirect
+ github.com/beorn7/perks v1.0.1 // indirect
+ github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d // indirect
+ github.com/bgentry/speakeasy v0.2.0 // indirect
+ github.com/bits-and-blooms/bitset v1.22.0 // indirect
+ github.com/blang/semver/v4 v4.0.0 // indirect
+ github.com/bytedance/sonic v1.14.0 // indirect
+ github.com/bytedance/sonic/loader v0.3.0 // indirect
+ github.com/cenkalti/backoff v2.2.1+incompatible // indirect
+ github.com/cenkalti/backoff/v4 v4.3.0 // indirect
+ github.com/cespare/xxhash/v2 v2.3.0 // indirect
+ github.com/chzyer/readline v1.5.1 // indirect
+ github.com/cloudwego/base64x v0.1.6 // indirect
+ github.com/cncf/xds/go v0.0.0-20250121191232-2f005788dc42 // indirect
+ github.com/cockroachdb/apd/v2 v2.0.2 // indirect
+ github.com/cockroachdb/errors v1.12.0 // indirect
+ github.com/cockroachdb/fifo v0.0.0-20240606204812-0bbfbd93a7ce // indirect
+ github.com/cockroachdb/logtags v0.0.0-20241215232642-bb51bb14a506 // indirect
+ github.com/cockroachdb/pebble v1.1.5 // indirect
+ github.com/cockroachdb/redact v1.1.6 // indirect
+ github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 // indirect
+ github.com/cometbft/cometbft-db v0.14.1 // indirect
+ github.com/cosmos/cosmos-db v1.1.1 // indirect
+ github.com/cosmos/cosmos-proto v1.0.0-beta.5 // indirect
+ github.com/cosmos/go-bip39 v1.0.0 // indirect
+ github.com/cosmos/gogogateway v1.2.0 // indirect
+ github.com/cosmos/gogoproto v1.7.0 // indirect
+ github.com/cosmos/iavl v1.2.4 // indirect
+ github.com/cosmos/ibc-go/modules/capability v1.0.1 // indirect
+ github.com/cosmos/ics23/go v0.11.0 // indirect
+ github.com/cosmos/ledger-cosmos-go v0.14.0 // indirect
+ github.com/creachadair/atomicfile v0.3.1 // indirect
+ github.com/creachadair/tomledit v0.0.24 // indirect
+ github.com/danieljoos/wincred v1.2.1 // indirect
+ github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
+ github.com/desertbit/timer v0.0.0-20180107155436-c41aec40b27f // indirect
+ github.com/dgraph-io/badger/v4 v4.2.0 // indirect
+ github.com/dgraph-io/ristretto v0.1.1 // indirect
+ github.com/distribution/reference v0.6.0 // indirect
+ github.com/dustin/go-humanize v1.0.1 // indirect
+ github.com/dvsekhvalnov/jose2go v1.6.0 // indirect
+ github.com/emicklei/dot v1.6.2 // indirect
+ github.com/envoyproxy/go-control-plane/envoy v1.32.4 // indirect
+ github.com/envoyproxy/protoc-gen-validate v1.2.1 // indirect
+ github.com/fatih/color v1.17.0 // indirect
+ github.com/fatih/structs v1.1.0 // indirect
+ github.com/felixge/httpsnoop v1.0.4 // indirect
+ github.com/fsnotify/fsnotify v1.9.0 // indirect
+ github.com/getsentry/sentry-go v0.32.0 // indirect
+ github.com/go-jose/go-jose/v4 v4.0.4 // indirect
+ github.com/go-kit/kit v0.13.0 // indirect
+ github.com/go-kit/log v0.2.1 // indirect
+ github.com/go-logfmt/logfmt v0.6.0 // indirect
+ github.com/go-logr/logr v1.4.2 // indirect
+ github.com/go-logr/stdr v1.2.2 // indirect
+ github.com/go-viper/mapstructure/v2 v2.2.1 // indirect
+ github.com/godbus/dbus v0.0.0-20190726142602-4481cbc300e2 // indirect
+ github.com/gogo/googleapis v1.4.1 // indirect
+ github.com/gogo/protobuf v1.3.3 // indirect
+ github.com/golang/glog v1.2.4 // indirect
+ github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
+ github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb // indirect
+ github.com/google/btree v1.1.3 // indirect
+ github.com/google/flatbuffers v1.12.1 // indirect
+ github.com/google/go-cmp v0.7.0 // indirect
+ github.com/google/gofuzz v1.2.0 // indirect
+ github.com/google/orderedcode v0.0.1 // indirect
+ github.com/google/s2a-go v0.1.8 // indirect
+ github.com/googleapis/enterprise-certificate-proxy v0.3.4 // indirect
+ github.com/googleapis/gax-go/v2 v2.14.1 // indirect
+ github.com/gorilla/handlers v1.5.2 // indirect
+ github.com/gorilla/mux v1.8.1 // indirect
+ github.com/grpc-ecosystem/go-grpc-middleware v1.4.0 // indirect
+ github.com/grpc-ecosystem/grpc-gateway v1.16.0 // indirect
+ github.com/gsterjov/go-libsecret v0.0.0-20161001094733-a6f4afe4910c // indirect
+ github.com/hashicorp/go-cleanhttp v0.5.2 // indirect
+ github.com/hashicorp/go-getter v1.7.5 // indirect
+ github.com/hashicorp/go-hclog v1.6.3 // indirect
+ github.com/hashicorp/go-immutable-radix v1.3.1 // indirect
+ github.com/hashicorp/go-metrics v0.5.4 // indirect
+ github.com/hashicorp/go-plugin v1.6.3 // indirect
+ github.com/hashicorp/go-safetemp v1.0.0 // indirect
+ github.com/hashicorp/go-version v1.7.0 // indirect
+ github.com/hashicorp/golang-lru v1.0.2 // indirect
+ github.com/hashicorp/golang-lru/v2 v2.0.7 // indirect
+ github.com/hashicorp/yamux v0.1.2 // indirect
+ github.com/hdevalence/ed25519consensus v0.2.0 // indirect
+ github.com/huandu/skiplist v1.2.1 // indirect
+ github.com/iancoleman/strcase v0.3.0 // indirect
+ github.com/improbable-eng/grpc-web v0.15.0 // indirect
+ github.com/inconshreveable/mousetrap v1.1.0 // indirect
+ github.com/jmespath/go-jmespath v0.4.0 // indirect
+ github.com/jmhodges/levigo v1.0.0 // indirect
+ github.com/klauspost/compress v1.18.0 // indirect
+ github.com/klauspost/cpuid/v2 v2.3.0 // indirect
+ github.com/knadh/koanf/maps v0.1.1 // indirect
+ github.com/kr/pretty v0.3.1 // indirect
+ github.com/kr/text v0.2.0 // indirect
+ github.com/labstack/gommon v0.4.0 // indirect
+ github.com/lib/pq v1.10.9 // indirect
+ github.com/linxGnu/grocksdb v1.8.14 // indirect
+ github.com/manifoldco/promptui v0.9.0 // indirect
+ github.com/mattn/go-colorable v0.1.14 // indirect
+ github.com/mattn/go-isatty v0.0.20 // indirect
+ github.com/mdp/qrterminal/v3 v3.2.1 // indirect
+ github.com/minio/highwayhash v1.0.3 // indirect
+ github.com/mitchellh/copystructure v1.2.0 // indirect
+ github.com/mitchellh/go-homedir v1.1.0 // indirect
+ github.com/mitchellh/go-testing-interface v1.14.1 // indirect
+ github.com/mitchellh/reflectwalk v1.0.2 // indirect
+ github.com/mtibben/percent v0.2.1 // indirect
+ github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
+ github.com/nats-io/jwt/v2 v2.2.1-0.20220330180145-442af02fd36a // indirect
+ github.com/nats-io/nkeys v0.4.7 // indirect
+ github.com/nats-io/nuid v1.0.1 // indirect
+ github.com/ncruces/go-strftime v0.1.9 // indirect
+ github.com/oasisprotocol/curve25519-voi v0.0.0-20230904125328-1f23a7beb09a // indirect
+ github.com/oklog/run v1.1.0 // indirect
+ github.com/opencontainers/go-digest v1.0.0 // indirect
+ github.com/pelletier/go-toml v1.9.5 // indirect
+ github.com/pelletier/go-toml/v2 v2.2.4 // indirect
+ github.com/petermattis/goid v0.0.0-20240813172612-4fcff4a6cae7 // indirect
+ github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 // indirect
+ github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
+ github.com/prometheus/client_golang v1.22.0 // indirect
+ github.com/prometheus/client_model v0.6.1 // indirect
+ github.com/prometheus/common v0.63.0 // indirect
+ github.com/prometheus/procfs v0.15.1 // indirect
+ github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475 // indirect
+ github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
+ github.com/rogpeppe/go-internal v1.14.1 // indirect
+ github.com/rs/cors v1.11.1 // indirect
+ github.com/rs/zerolog v1.34.0 // indirect
+ github.com/sagikazarmark/locafero v0.7.0 // indirect
+ github.com/sasha-s/go-deadlock v0.3.5 // indirect
+ github.com/shamaton/msgpack/v2 v2.2.0 // indirect
+ github.com/shopspring/decimal v1.4.0 // indirect
+ github.com/sourcegraph/conc v0.3.0 // indirect
+ github.com/spf13/afero v1.12.0 // indirect
+ github.com/spf13/cast v1.8.0 // indirect
+ github.com/spf13/cobra v1.9.1 // indirect
+ github.com/spf13/pflag v1.0.6 // indirect
+ github.com/spf13/viper v1.20.1 // indirect
+ github.com/spiffe/go-spiffe/v2 v2.5.0 // indirect
+ github.com/stretchr/objx v0.5.2 // indirect
+ github.com/subosito/gotenv v1.6.0 // indirect
+ github.com/syndtr/goleveldb v1.0.1-0.20220721030215-126854af5e6d // indirect
+ github.com/tendermint/go-amino v0.16.0 // indirect
+ github.com/tidwall/btree v1.7.0 // indirect
+ github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
+ github.com/ulikunitz/xz v0.5.11 // indirect
+ github.com/valyala/bytebufferpool v1.0.0 // indirect
+ github.com/valyala/fasttemplate v1.2.2 // indirect
+ github.com/zeebo/errs v1.4.0 // indirect
+ github.com/zondax/hid v0.9.2 // indirect
+ github.com/zondax/ledger-go v0.14.3 // indirect
+ go.etcd.io/bbolt v1.4.0-alpha.0.0.20240404170359-43604f3112c5 // indirect
+ go.opencensus.io v0.24.0 // indirect
+ go.opentelemetry.io/auto/sdk v1.1.0 // indirect
+ go.opentelemetry.io/contrib/detectors/gcp v1.34.0 // indirect
+ go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.54.0 // indirect
+ go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.54.0 // indirect
+ go.opentelemetry.io/otel v1.34.0 // indirect
+ go.opentelemetry.io/otel/metric v1.34.0 // indirect
+ go.opentelemetry.io/otel/sdk v1.34.0 // indirect
+ go.opentelemetry.io/otel/sdk/metric v1.34.0 // indirect
+ go.opentelemetry.io/otel/trace v1.34.0 // indirect
+ go.uber.org/mock v0.5.2 // indirect
+ go.uber.org/multierr v1.11.0 // indirect
+ golang.org/x/arch v0.20.0 // indirect
+ golang.org/x/mod v0.25.0 // indirect
+ golang.org/x/net v0.40.0 // indirect
+ golang.org/x/oauth2 v0.26.0 // indirect
+ golang.org/x/sync v0.15.0 // indirect
+ golang.org/x/sys v0.35.0 // indirect
+ golang.org/x/term v0.32.0 // indirect
+ golang.org/x/text v0.25.0 // indirect
+ golang.org/x/time v0.9.0 // indirect
+ google.golang.org/api v0.215.0 // indirect
+ google.golang.org/genproto v0.0.0-20241118233622-e639e219e697 // indirect
+ google.golang.org/genproto/googleapis/api v0.0.0-20250528174236-200df99c418a // indirect
+ google.golang.org/genproto/googleapis/rpc v0.0.0-20250528174236-200df99c418a // indirect
+ google.golang.org/protobuf v1.36.6 // indirect
+ gopkg.in/yaml.v2 v2.4.0 // indirect
+ gopkg.in/yaml.v3 v3.0.1 // indirect
+ gotest.tools/v3 v3.5.2 // indirect
+ modernc.org/libc v1.66.3 // indirect
+ modernc.org/mathutil v1.7.1 // indirect
+ modernc.org/memory v1.11.0 // indirect
+ nhooyr.io/websocket v1.8.6 // indirect
+ pgregory.net/rapid v1.2.0 // indirect
+ rsc.io/qr v0.2.0 // indirect
+ sigs.k8s.io/yaml v1.4.0 // indirect
+)
+
+replace (
+ github.com/cosmos/cosmos-sdk => github.com/gonka-ai/cosmos-sdk v0.53.3-ps13
+ 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
new file mode 100644
index 000000000..826449357
--- /dev/null
+++ b/decentralized-api/go.sum
@@ -0,0 +1,1858 @@
+cel.dev/expr v0.20.0 h1:OunBvVCfvpWlt4dN7zg3FM6TDkzOePe1+foGJ9AXeeI=
+cel.dev/expr v0.20.0/go.mod h1:MrpN08Q+lEBs+bGYdLxxHkZoUSsCp0nSKTs0nTymJgw=
+cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU=
+cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU=
+cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY=
+cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc=
+cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0=
+cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To=
+cloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4=
+cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M=
+cloud.google.com/go v0.54.0/go.mod h1:1rq2OEkV3YMf6n/9ZvGWI3GWw0VoqH/1x2nd8Is/bPc=
+cloud.google.com/go v0.56.0/go.mod h1:jr7tqZxxKOVYizybht9+26Z/gUq7tiRzu+ACVAMbKVk=
+cloud.google.com/go v0.57.0/go.mod h1:oXiQ6Rzq3RAkkY7N6t3TcE6jE+CIBBbA36lwQ1JyzZs=
+cloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOYc=
+cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY=
+cloud.google.com/go v0.72.0/go.mod h1:M+5Vjvlc2wnp6tjzE102Dw08nGShTscUx2nZMufOKPI=
+cloud.google.com/go v0.74.0/go.mod h1:VV1xSbzvo+9QJOxLDaJfTjx5e+MePCpCWwvftOeQmWk=
+cloud.google.com/go v0.78.0/go.mod h1:QjdrLG0uq+YwhjoVOLsS1t7TW8fs36kLs4XO5R5ECHg=
+cloud.google.com/go v0.79.0/go.mod h1:3bzgcEeQlzbuEAYu4mrWhKqWjmpprinYgKJLgKHnbb8=
+cloud.google.com/go v0.81.0/go.mod h1:mk/AM35KwGk/Nm2YSeZbxXdrNK3KZOYHmLkOqC2V6E0=
+cloud.google.com/go v0.83.0/go.mod h1:Z7MJUsANfY0pYPdw0lbnivPx4/vhy/e2FEkSkF7vAVY=
+cloud.google.com/go v0.84.0/go.mod h1:RazrYuxIK6Kb7YrzzhPoLmCVzl7Sup4NrbKPg8KHSUM=
+cloud.google.com/go v0.87.0/go.mod h1:TpDYlFy7vuLzZMMZ+B6iRiELaY7z/gJPaqbMx6mlWcY=
+cloud.google.com/go v0.90.0/go.mod h1:kRX0mNRHe0e2rC6oNakvwQqzyDmg57xJ+SZU1eT2aDQ=
+cloud.google.com/go v0.93.3/go.mod h1:8utlLll2EF5XMAV15woO4lSbWQlk8rer9aLOfLh7+YI=
+cloud.google.com/go v0.94.1/go.mod h1:qAlAugsXlC+JWO+Bke5vCtc9ONxjQT3drlTTnAplMW4=
+cloud.google.com/go v0.97.0/go.mod h1:GF7l59pYBVlXQIBLx3a761cZ41F9bBH3JUlihCt2Udc=
+cloud.google.com/go v0.99.0/go.mod h1:w0Xx2nLzqWJPuozYQX+hFfCSI8WioryfRDzkoI/Y2ZA=
+cloud.google.com/go v0.100.2/go.mod h1:4Xra9TjzAeYHrl5+oeLlzbM2k3mjVhZh4UqTZ//w99A=
+cloud.google.com/go v0.102.0/go.mod h1:oWcCzKlqJ5zgHQt9YsaeTY9KzIvjyy0ArmiBUgpQ+nc=
+cloud.google.com/go v0.102.1/go.mod h1:XZ77E9qnTEnrgEOvr4xzfdX5TRo7fB4T2F4O6+34hIU=
+cloud.google.com/go v0.104.0/go.mod h1:OO6xxXdJyvuJPcEPBLN9BJPD+jep5G1+2U5B5gkRYtA=
+cloud.google.com/go v0.116.0 h1:B3fRrSDkLRt5qSHWe40ERJvhvnQwdZiHu0bJOpldweE=
+cloud.google.com/go v0.116.0/go.mod h1:cEPSRWPzZEswwdr9BxE6ChEn01dWlTaF05LiC2Xs70U=
+cloud.google.com/go/aiplatform v1.22.0/go.mod h1:ig5Nct50bZlzV6NvKaTwmplLLddFx0YReh9WfTO5jKw=
+cloud.google.com/go/aiplatform v1.24.0/go.mod h1:67UUvRBKG6GTayHKV8DBv2RtR1t93YRu5B1P3x99mYY=
+cloud.google.com/go/analytics v0.11.0/go.mod h1:DjEWCu41bVbYcKyvlws9Er60YE4a//bK6mnhWvQeFNI=
+cloud.google.com/go/analytics v0.12.0/go.mod h1:gkfj9h6XRf9+TS4bmuhPEShsh3hH8PAZzm/41OOhQd4=
+cloud.google.com/go/area120 v0.5.0/go.mod h1:DE/n4mp+iqVyvxHN41Vf1CR602GiHQjFPusMFW6bGR4=
+cloud.google.com/go/area120 v0.6.0/go.mod h1:39yFJqWVgm0UZqWTOdqkLhjoC7uFfgXRC8g/ZegeAh0=
+cloud.google.com/go/artifactregistry v1.6.0/go.mod h1:IYt0oBPSAGYj/kprzsBjZ/4LnG/zOcHyFHjWPCi6SAQ=
+cloud.google.com/go/artifactregistry v1.7.0/go.mod h1:mqTOFOnGZx8EtSqK/ZWcsm/4U8B77rbcLP6ruDU2Ixk=
+cloud.google.com/go/asset v1.5.0/go.mod h1:5mfs8UvcM5wHhqtSv8J1CtxxaQq3AdBxxQi2jGW/K4o=
+cloud.google.com/go/asset v1.7.0/go.mod h1:YbENsRK4+xTiL+Ofoj5Ckf+O17kJtgp3Y3nn4uzZz5s=
+cloud.google.com/go/asset v1.8.0/go.mod h1:mUNGKhiqIdbr8X7KNayoYvyc4HbbFO9URsjbytpUaW0=
+cloud.google.com/go/assuredworkloads v1.5.0/go.mod h1:n8HOZ6pff6re5KYfBXcFvSViQjDwxFkAkmUFffJRbbY=
+cloud.google.com/go/assuredworkloads v1.6.0/go.mod h1:yo2YOk37Yc89Rsd5QMVECvjaMKymF9OP+QXWlKXUkXw=
+cloud.google.com/go/assuredworkloads v1.7.0/go.mod h1:z/736/oNmtGAyU47reJgGN+KVoYoxeLBoj4XkKYscNI=
+cloud.google.com/go/auth v0.13.0 h1:8Fu8TZy167JkW8Tj3q7dIkr2v4cndv41ouecJx0PAHs=
+cloud.google.com/go/auth v0.13.0/go.mod h1:COOjD9gwfKNKz+IIduatIhYJQIc0mG3H102r/EMxX6Q=
+cloud.google.com/go/auth/oauth2adapt v0.2.6 h1:V6a6XDu2lTwPZWOawrAa9HUK+DB2zfJyTuciBG5hFkU=
+cloud.google.com/go/auth/oauth2adapt v0.2.6/go.mod h1:AlmsELtlEBnaNTL7jCj8VQFLy6mbZv0s4Q7NGBeQ5E8=
+cloud.google.com/go/automl v1.5.0/go.mod h1:34EjfoFGMZ5sgJ9EoLsRtdPSNZLcfflJR39VbVNS2M0=
+cloud.google.com/go/automl v1.6.0/go.mod h1:ugf8a6Fx+zP0D59WLhqgTDsQI9w07o64uf/Is3Nh5p8=
+cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o=
+cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE=
+cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc=
+cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg=
+cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc=
+cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ=
+cloud.google.com/go/bigquery v1.42.0/go.mod h1:8dRTJxhtG+vwBKzE5OseQn/hiydoQN3EedCaOdYmxRA=
+cloud.google.com/go/billing v1.4.0/go.mod h1:g9IdKBEFlItS8bTtlrZdVLWSSdSyFUZKXNS02zKMOZY=
+cloud.google.com/go/billing v1.5.0/go.mod h1:mztb1tBc3QekhjSgmpf/CV4LzWXLzCArwpLmP2Gm88s=
+cloud.google.com/go/binaryauthorization v1.1.0/go.mod h1:xwnoWu3Y84jbuHa0zd526MJYmtnVXn0syOjaJgy4+dM=
+cloud.google.com/go/binaryauthorization v1.2.0/go.mod h1:86WKkJHtRcv5ViNABtYMhhNWRrD1Vpi//uKEy7aYEfI=
+cloud.google.com/go/cloudtasks v1.5.0/go.mod h1:fD92REy1x5woxkKEkLdvavGnPJGEn8Uic9nWuLzqCpY=
+cloud.google.com/go/cloudtasks v1.6.0/go.mod h1:C6Io+sxuke9/KNRkbQpihnW93SWDU3uXt92nu85HkYI=
+cloud.google.com/go/compute v0.1.0/go.mod h1:GAesmwr110a34z04OlxYkATPBEfVhkymfTBXtfbBFow=
+cloud.google.com/go/compute v1.3.0/go.mod h1:cCZiE1NHEtai4wiufUhW8I8S1JKkAnhnQJWM7YD99wM=
+cloud.google.com/go/compute v1.5.0/go.mod h1:9SMHyhJlzhlkJqrPAc839t2BZFTSk6Jdj6mkzQJeu0M=
+cloud.google.com/go/compute v1.6.0/go.mod h1:T29tfhtVbq1wvAPo0E3+7vhgmkOYeXjhFvz/FMzPu0s=
+cloud.google.com/go/compute v1.6.1/go.mod h1:g85FgpzFvNULZ+S8AYq87axRKuf2Kh7deLqV/jJ3thU=
+cloud.google.com/go/compute v1.7.0/go.mod h1:435lt8av5oL9P3fv1OEzSbSUe+ybHXGMPQHHZWZxy9U=
+cloud.google.com/go/compute v1.10.0/go.mod h1:ER5CLbMxl90o2jtNbGSbtfOpQKR0t15FOtRsugnLrlU=
+cloud.google.com/go/compute/metadata v0.6.0 h1:A6hENjEsCDtC1k8byVsgwvVcioamEHvZ4j01OwKxG9I=
+cloud.google.com/go/compute/metadata v0.6.0/go.mod h1:FjyFAW1MW0C203CEOMDTu3Dk1FlqW3Rga40jzHL4hfg=
+cloud.google.com/go/containeranalysis v0.5.1/go.mod h1:1D92jd8gRR/c0fGMlymRgxWD3Qw9C1ff6/T7mLgVL8I=
+cloud.google.com/go/containeranalysis v0.6.0/go.mod h1:HEJoiEIu+lEXM+k7+qLCci0h33lX3ZqoYFdmPcoO7s4=
+cloud.google.com/go/datacatalog v1.3.0/go.mod h1:g9svFY6tuR+j+hrTw3J2dNcmI0dzmSiyOzm8kpLq0a0=
+cloud.google.com/go/datacatalog v1.5.0/go.mod h1:M7GPLNQeLfWqeIm3iuiruhPzkt65+Bx8dAKvScX8jvs=
+cloud.google.com/go/datacatalog v1.6.0/go.mod h1:+aEyF8JKg+uXcIdAmmaMUmZ3q1b/lKLtXCmXdnc0lbc=
+cloud.google.com/go/dataflow v0.6.0/go.mod h1:9QwV89cGoxjjSR9/r7eFDqqjtvbKxAK2BaYU6PVk9UM=
+cloud.google.com/go/dataflow v0.7.0/go.mod h1:PX526vb4ijFMesO1o202EaUmouZKBpjHsTlCtB4parQ=
+cloud.google.com/go/dataform v0.3.0/go.mod h1:cj8uNliRlHpa6L3yVhDOBrUXH+BPAO1+KFMQQNSThKo=
+cloud.google.com/go/dataform v0.4.0/go.mod h1:fwV6Y4Ty2yIFL89huYlEkwUPtS7YZinZbzzj5S9FzCE=
+cloud.google.com/go/datalabeling v0.5.0/go.mod h1:TGcJ0G2NzcsXSE/97yWjIZO0bXj0KbVlINXMG9ud42I=
+cloud.google.com/go/datalabeling v0.6.0/go.mod h1:WqdISuk/+WIGeMkpw/1q7bK/tFEZxsrFJOJdY2bXvTQ=
+cloud.google.com/go/dataqna v0.5.0/go.mod h1:90Hyk596ft3zUQ8NkFfvICSIfHFh1Bc7C4cK3vbhkeo=
+cloud.google.com/go/dataqna v0.6.0/go.mod h1:1lqNpM7rqNLVgWBJyk5NF6Uen2PHym0jtVJonplVsDA=
+cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE=
+cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk=
+cloud.google.com/go/datastream v1.2.0/go.mod h1:i/uTP8/fZwgATHS/XFu0TcNUhuA0twZxxQ3EyCUQMwo=
+cloud.google.com/go/datastream v1.3.0/go.mod h1:cqlOX8xlyYF/uxhiKn6Hbv6WjwPPuI9W2M9SAXwaLLQ=
+cloud.google.com/go/dialogflow v1.15.0/go.mod h1:HbHDWs33WOGJgn6rfzBW1Kv807BE3O1+xGbn59zZWI4=
+cloud.google.com/go/dialogflow v1.16.1/go.mod h1:po6LlzGfK+smoSmTBnbkIZY2w8ffjz/RcGSS+sh1el0=
+cloud.google.com/go/dialogflow v1.17.0/go.mod h1:YNP09C/kXA1aZdBgC/VtXX74G/TKn7XVCcVumTflA+8=
+cloud.google.com/go/documentai v1.7.0/go.mod h1:lJvftZB5NRiFSX4moiye1SMxHx0Bc3x1+p9e/RfXYiU=
+cloud.google.com/go/documentai v1.8.0/go.mod h1:xGHNEB7CtsnySCNrCFdCyyMz44RhFEEX2Q7UD0c5IhU=
+cloud.google.com/go/domains v0.6.0/go.mod h1:T9Rz3GasrpYk6mEGHh4rymIhjlnIuB4ofT1wTxDeT4Y=
+cloud.google.com/go/domains v0.7.0/go.mod h1:PtZeqS1xjnXuRPKE/88Iru/LdfoRyEHYA9nFQf4UKpg=
+cloud.google.com/go/edgecontainer v0.1.0/go.mod h1:WgkZ9tp10bFxqO8BLPqv2LlfmQF1X8lZqwW4r1BTajk=
+cloud.google.com/go/edgecontainer v0.2.0/go.mod h1:RTmLijy+lGpQ7BXuTDa4C4ssxyXT34NIuHIgKuP4s5w=
+cloud.google.com/go/functions v1.6.0/go.mod h1:3H1UA3qiIPRWD7PeZKLvHZ9SaQhR26XIJcC0A5GbvAk=
+cloud.google.com/go/functions v1.7.0/go.mod h1:+d+QBcWM+RsrgZfV9xo6KfA1GlzJfxcfZcRPEhDDfzg=
+cloud.google.com/go/gaming v1.5.0/go.mod h1:ol7rGcxP/qHTRQE/RO4bxkXq+Fix0j6D4LFPzYTIrDM=
+cloud.google.com/go/gaming v1.6.0/go.mod h1:YMU1GEvA39Qt3zWGyAVA9bpYz/yAhTvaQ1t2sK4KPUA=
+cloud.google.com/go/gkeconnect v0.5.0/go.mod h1:c5lsNAg5EwAy7fkqX/+goqFsU1Da/jQFqArp+wGNr/o=
+cloud.google.com/go/gkeconnect v0.6.0/go.mod h1:Mln67KyU/sHJEBY8kFZ0xTeyPtzbq9StAVvEULYK16A=
+cloud.google.com/go/gkehub v0.9.0/go.mod h1:WYHN6WG8w9bXU0hqNxt8rm5uxnk8IH+lPY9J2TV7BK0=
+cloud.google.com/go/gkehub v0.10.0/go.mod h1:UIPwxI0DsrpsVoWpLB0stwKCP+WFVG9+y977wO+hBH0=
+cloud.google.com/go/grafeas v0.2.0/go.mod h1:KhxgtF2hb0P191HlY5besjYm6MqTSTj3LSI+M+ByZHc=
+cloud.google.com/go/iam v0.3.0/go.mod h1:XzJPvDayI+9zsASAFO68Hk07u3z+f+JrT2xXNdp4bnY=
+cloud.google.com/go/iam v0.5.0/go.mod h1:wPU9Vt0P4UmCux7mqtRu6jcpPAb74cP1fh50J3QpkUc=
+cloud.google.com/go/iam v1.2.2 h1:ozUSofHUGf/F4tCNy/mu9tHLTaxZFLOUiKzjcgWHGIA=
+cloud.google.com/go/iam v1.2.2/go.mod h1:0Ys8ccaZHdI1dEUilwzqng/6ps2YB6vRsjIe00/+6JY=
+cloud.google.com/go/language v1.4.0/go.mod h1:F9dRpNFQmJbkaop6g0JhSBXCNlO90e1KWx5iDdxbWic=
+cloud.google.com/go/language v1.6.0/go.mod h1:6dJ8t3B+lUYfStgls25GusK04NLh3eDLQnWM3mdEbhI=
+cloud.google.com/go/lifesciences v0.5.0/go.mod h1:3oIKy8ycWGPUyZDR/8RNnTOYevhaMLqh5vLUXs9zvT8=
+cloud.google.com/go/lifesciences v0.6.0/go.mod h1:ddj6tSX/7BOnhxCSd3ZcETvtNr8NZ6t/iPhY2Tyfu08=
+cloud.google.com/go/logging v1.12.0 h1:ex1igYcGFd4S/RZWOCU51StlIEuey5bjqwH9ZYjHibk=
+cloud.google.com/go/logging v1.12.0/go.mod h1:wwYBt5HlYP1InnrtYI0wtwttpVU1rifnMT7RejksUAM=
+cloud.google.com/go/longrunning v0.6.2 h1:xjDfh1pQcWPEvnfjZmwjKQEcHnpz6lHjfy7Fo0MK+hc=
+cloud.google.com/go/longrunning v0.6.2/go.mod h1:k/vIs83RN4bE3YCswdXC5PFfWVILjm3hpEUlSko4PiI=
+cloud.google.com/go/mediatranslation v0.5.0/go.mod h1:jGPUhGTybqsPQn91pNXw0xVHfuJ3leR1wj37oU3y1f4=
+cloud.google.com/go/mediatranslation v0.6.0/go.mod h1:hHdBCTYNigsBxshbznuIMFNe5QXEowAuNmmC7h8pu5w=
+cloud.google.com/go/memcache v1.4.0/go.mod h1:rTOfiGZtJX1AaFUrOgsMHX5kAzaTQ8azHiuDoTPzNsE=
+cloud.google.com/go/memcache v1.5.0/go.mod h1:dk3fCK7dVo0cUU2c36jKb4VqKPS22BTkf81Xq617aWM=
+cloud.google.com/go/metastore v1.5.0/go.mod h1:2ZNrDcQwghfdtCwJ33nM0+GrBGlVuh8rakL3vdPY3XY=
+cloud.google.com/go/metastore v1.6.0/go.mod h1:6cyQTls8CWXzk45G55x57DVQ9gWg7RiH65+YgPsNh9s=
+cloud.google.com/go/monitoring v1.21.2 h1:FChwVtClH19E7pJ+e0xUhJPGksctZNVOk2UhMmblmdU=
+cloud.google.com/go/monitoring v1.21.2/go.mod h1:hS3pXvaG8KgWTSz+dAdyzPrGUYmi2Q+WFX8g2hqVEZU=
+cloud.google.com/go/networkconnectivity v1.4.0/go.mod h1:nOl7YL8odKyAOtzNX73/M5/mGZgqqMeryi6UPZTk/rA=
+cloud.google.com/go/networkconnectivity v1.5.0/go.mod h1:3GzqJx7uhtlM3kln0+x5wyFvuVH1pIBJjhCpjzSt75o=
+cloud.google.com/go/networksecurity v0.5.0/go.mod h1:xS6fOCoqpVC5zx15Z/MqkfDwH4+m/61A3ODiDV1xmiQ=
+cloud.google.com/go/networksecurity v0.6.0/go.mod h1:Q5fjhTr9WMI5mbpRYEbiexTzROf7ZbDzvzCrNl14nyU=
+cloud.google.com/go/notebooks v1.2.0/go.mod h1:9+wtppMfVPUeJ8fIWPOq1UnATHISkGXGqTkxeieQ6UY=
+cloud.google.com/go/notebooks v1.3.0/go.mod h1:bFR5lj07DtCPC7YAAJ//vHskFBxA5JzYlH68kXVdk34=
+cloud.google.com/go/osconfig v1.7.0/go.mod h1:oVHeCeZELfJP7XLxcBGTMBvRO+1nQ5tFG9VQTmYS2Fs=
+cloud.google.com/go/osconfig v1.8.0/go.mod h1:EQqZLu5w5XA7eKizepumcvWx+m8mJUhEwiPqWiZeEdg=
+cloud.google.com/go/oslogin v1.4.0/go.mod h1:YdgMXWRaElXz/lDk1Na6Fh5orF7gvmJ0FGLIs9LId4E=
+cloud.google.com/go/oslogin v1.5.0/go.mod h1:D260Qj11W2qx/HVF29zBg+0fd6YCSjSqLUkY/qEenQU=
+cloud.google.com/go/phishingprotection v0.5.0/go.mod h1:Y3HZknsK9bc9dMi+oE8Bim0lczMU6hrX0UpADuMefr0=
+cloud.google.com/go/phishingprotection v0.6.0/go.mod h1:9Y3LBLgy0kDTcYET8ZH3bq/7qni15yVUoAxiFxnlSUA=
+cloud.google.com/go/privatecatalog v0.5.0/go.mod h1:XgosMUvvPyxDjAVNDYxJ7wBW8//hLDDYmnsNcMGq1K0=
+cloud.google.com/go/privatecatalog v0.6.0/go.mod h1:i/fbkZR0hLN29eEWiiwue8Pb+GforiEIBnV9yrRUOKI=
+cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I=
+cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw=
+cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA=
+cloud.google.com/go/pubsub v1.3.1/go.mod h1:i+ucay31+CNRpDW4Lu78I4xXG+O1r/MAHgjpRVR+TSU=
+cloud.google.com/go/recaptchaenterprise v1.3.1/go.mod h1:OdD+q+y4XGeAlxRaMn1Y7/GveP6zmq76byL6tjPE7d4=
+cloud.google.com/go/recaptchaenterprise/v2 v2.1.0/go.mod h1:w9yVqajwroDNTfGuhmOjPDN//rZGySaf6PtFVcSCa7o=
+cloud.google.com/go/recaptchaenterprise/v2 v2.2.0/go.mod h1:/Zu5jisWGeERrd5HnlS3EUGb/D335f9k51B/FVil0jk=
+cloud.google.com/go/recaptchaenterprise/v2 v2.3.0/go.mod h1:O9LwGCjrhGHBQET5CA7dd5NwwNQUErSgEDit1DLNTdo=
+cloud.google.com/go/recommendationengine v0.5.0/go.mod h1:E5756pJcVFeVgaQv3WNpImkFP8a+RptV6dDLGPILjvg=
+cloud.google.com/go/recommendationengine v0.6.0/go.mod h1:08mq2umu9oIqc7tDy8sx+MNJdLG0fUi3vaSVbztHgJ4=
+cloud.google.com/go/recommender v1.5.0/go.mod h1:jdoeiBIVrJe9gQjwd759ecLJbxCDED4A6p+mqoqDvTg=
+cloud.google.com/go/recommender v1.6.0/go.mod h1:+yETpm25mcoiECKh9DEScGzIRyDKpZ0cEhWGo+8bo+c=
+cloud.google.com/go/redis v1.7.0/go.mod h1:V3x5Jq1jzUcg+UNsRvdmsfuFnit1cfe3Z/PGyq/lm4Y=
+cloud.google.com/go/redis v1.8.0/go.mod h1:Fm2szCDavWzBk2cDKxrkmWBqoCiL1+Ctwq7EyqBCA/A=
+cloud.google.com/go/retail v1.8.0/go.mod h1:QblKS8waDmNUhghY2TI9O3JLlFk8jybHeV4BF19FrE4=
+cloud.google.com/go/retail v1.9.0/go.mod h1:g6jb6mKuCS1QKnH/dpu7isX253absFl6iE92nHwlBUY=
+cloud.google.com/go/scheduler v1.4.0/go.mod h1:drcJBmxF3aqZJRhmkHQ9b3uSSpQoltBPGPxGAWROx6s=
+cloud.google.com/go/scheduler v1.5.0/go.mod h1:ri073ym49NW3AfT6DZi21vLZrG07GXr5p3H1KxN5QlI=
+cloud.google.com/go/secretmanager v1.6.0/go.mod h1:awVa/OXF6IiyaU1wQ34inzQNc4ISIDIrId8qE5QGgKA=
+cloud.google.com/go/security v1.5.0/go.mod h1:lgxGdyOKKjHL4YG3/YwIL2zLqMFCKs0UbQwgyZmfJl4=
+cloud.google.com/go/security v1.7.0/go.mod h1:mZklORHl6Bg7CNnnjLH//0UlAlaXqiG7Lb9PsPXLfD0=
+cloud.google.com/go/security v1.8.0/go.mod h1:hAQOwgmaHhztFhiQ41CjDODdWP0+AE1B3sX4OFlq+GU=
+cloud.google.com/go/securitycenter v1.13.0/go.mod h1:cv5qNAqjY84FCN6Y9z28WlkKXyWsgLO832YiWwkCWcU=
+cloud.google.com/go/securitycenter v1.14.0/go.mod h1:gZLAhtyKv85n52XYWt6RmeBdydyxfPeTrpToDPw4Auc=
+cloud.google.com/go/servicedirectory v1.4.0/go.mod h1:gH1MUaZCgtP7qQiI+F+A+OpeKF/HQWgtAddhTbhL2bs=
+cloud.google.com/go/servicedirectory v1.5.0/go.mod h1:QMKFL0NUySbpZJ1UZs3oFAmdvVxhhxB6eJ/Vlp73dfg=
+cloud.google.com/go/speech v1.6.0/go.mod h1:79tcr4FHCimOp56lwC01xnt/WPJZc4v3gzyT7FoBkCM=
+cloud.google.com/go/speech v1.7.0/go.mod h1:KptqL+BAQIhMsj1kOP2la5DSEEerPDuOP/2mmkhHhZQ=
+cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw=
+cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos=
+cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk=
+cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs=
+cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0=
+cloud.google.com/go/storage v1.22.1/go.mod h1:S8N1cAStu7BOeFfE8KAQzmyyLkK8p/vmRq6kuBTW58Y=
+cloud.google.com/go/storage v1.23.0/go.mod h1:vOEEDNFnciUMhBeT6hsJIn3ieU5cFRmzeLgDvXzfIXc=
+cloud.google.com/go/storage v1.27.0/go.mod h1:x9DOL8TK/ygDUMieqwfhdpQryTeEkhGKMi80i/iqR2s=
+cloud.google.com/go/storage v1.49.0 h1:zenOPBOWHCnojRd9aJZAyQXBYqkJkdQS42dxL55CIMw=
+cloud.google.com/go/storage v1.49.0/go.mod h1:k1eHhhpLvrPjVGfo0mOUPEJ4Y2+a/Hv5PiwehZI9qGU=
+cloud.google.com/go/talent v1.1.0/go.mod h1:Vl4pt9jiHKvOgF9KoZo6Kob9oV4lwd/ZD5Cto54zDRw=
+cloud.google.com/go/talent v1.2.0/go.mod h1:MoNF9bhFQbiJ6eFD3uSsg0uBALw4n4gaCaEjBw9zo8g=
+cloud.google.com/go/trace v1.11.2 h1:4ZmaBdL8Ng/ajrgKqY5jfvzqMXbrDcBsUGXOT9aqTtI=
+cloud.google.com/go/trace v1.11.2/go.mod h1:bn7OwXd4pd5rFuAnTrzBuoZ4ax2XQeG3qNgYmfCy0Io=
+cloud.google.com/go/videointelligence v1.6.0/go.mod h1:w0DIDlVRKtwPCn/C4iwZIJdvC69yInhW0cfi+p546uU=
+cloud.google.com/go/videointelligence v1.7.0/go.mod h1:k8pI/1wAhjznARtVT9U1llUaFNPh7muw8QyOUpavru4=
+cloud.google.com/go/vision v1.2.0/go.mod h1:SmNwgObm5DpFBme2xpyOyasvBc1aPdjvMk2bBk0tKD0=
+cloud.google.com/go/vision/v2 v2.2.0/go.mod h1:uCdV4PpN1S0jyCyq8sIM42v2Y6zOLkZs+4R9LrGYwFo=
+cloud.google.com/go/vision/v2 v2.3.0/go.mod h1:UO61abBx9QRMFkNBbf1D8B1LXdS2cGiiCRx0vSpZoUo=
+cloud.google.com/go/webrisk v1.4.0/go.mod h1:Hn8X6Zr+ziE2aNd8SliSDWpEnSS1u4R9+xXZmFiHmGE=
+cloud.google.com/go/webrisk v1.5.0/go.mod h1:iPG6fr52Tv7sGk0H6qUFzmL3HHZev1htXuWDEEsqMTg=
+cloud.google.com/go/workflows v1.6.0/go.mod h1:6t9F5h/unJz41YqfBmqSASJSXccBLtD1Vwf+KmJENM0=
+cloud.google.com/go/workflows v1.7.0/go.mod h1:JhSrZuVZWuiDfKEFxU0/F1PQjmpnpcoISEXH2bcHC3M=
+cosmossdk.io/api v0.9.2 h1:9i9ptOBdmoIEVEVWLtYYHjxZonlF/aOVODLFaxpmNtg=
+cosmossdk.io/api v0.9.2/go.mod h1:CWt31nVohvoPMTlPv+mMNCtC0a7BqRdESjCsstHcTkU=
+cosmossdk.io/client/v2 v2.0.0-beta.1 h1:XkHh1lhrLYIT9zKl7cIOXUXg2hdhtjTPBUfqERNA1/Q=
+cosmossdk.io/client/v2 v2.0.0-beta.1/go.mod h1:JEUSu9moNZQ4kU3ir1DKD5eU4bllmAexrGWjmb9k8qU=
+cosmossdk.io/collections v1.2.1 h1:mAlNMs5vJwkda4TA+k5q/43p24RVAQ/qyDrjANu3BXE=
+cosmossdk.io/collections v1.2.1/go.mod h1:PSsEJ/fqny0VPsHLFT6gXDj/2C1tBOTS9eByK0+PBFU=
+cosmossdk.io/core v0.11.3 h1:mei+MVDJOwIjIniaKelE3jPDqShCc/F4LkNNHh+4yfo=
+cosmossdk.io/core v0.11.3/go.mod h1:9rL4RE1uDt5AJ4Tg55sYyHWXA16VmpHgbe0PbJc6N2Y=
+cosmossdk.io/depinject v1.2.1 h1:eD6FxkIjlVaNZT+dXTQuwQTKZrFZ4UrfCq1RKgzyhMw=
+cosmossdk.io/depinject v1.2.1/go.mod h1:lqQEycz0H2JXqvOgVwTsjEdMI0plswI7p6KX+MVqFOM=
+cosmossdk.io/errors v1.0.2 h1:wcYiJz08HThbWxd/L4jObeLaLySopyyuUFB5w4AGpCo=
+cosmossdk.io/errors v1.0.2/go.mod h1:0rjgiHkftRYPj//3DrD6y8hcm40HcPv/dR4R/4efr0k=
+cosmossdk.io/log v1.6.0 h1:SJIOmJ059wi1piyRgNRXKXhlDXGqnB5eQwhcZKv2tOk=
+cosmossdk.io/log v1.6.0/go.mod h1:5cXXBvfBkR2/BcXmosdCSLXllvgSjphrrDVdfVRmBGM=
+cosmossdk.io/math v1.5.3 h1:WH6tu6Z3AUCeHbeOSHg2mt9rnoiUWVWaQ2t6Gkll96U=
+cosmossdk.io/math v1.5.3/go.mod h1:uqcZv7vexnhMFJF+6zh9EWdm/+Ylyln34IvPnBauPCQ=
+cosmossdk.io/schema v1.1.0 h1:mmpuz3dzouCoyjjcMcA/xHBEmMChN+EHh8EHxHRHhzE=
+cosmossdk.io/schema v1.1.0/go.mod h1:Gb7pqO+tpR+jLW5qDcNOSv0KtppYs7881kfzakguhhI=
+cosmossdk.io/store v1.1.2 h1:3HOZG8+CuThREKv6cn3WSohAc6yccxO3hLzwK6rBC7o=
+cosmossdk.io/store v1.1.2/go.mod h1:60rAGzTHevGm592kFhiUVkNC9w7gooSEn5iUBPzHQ6A=
+cosmossdk.io/tools/confix v0.1.2 h1:2hoM1oFCNisd0ltSAAZw2i4ponARPmlhuNu3yy0VwI4=
+cosmossdk.io/tools/confix v0.1.2/go.mod h1:7XfcbK9sC/KNgVGxgLM0BrFbVcR/+6Dg7MFfpx7duYo=
+cosmossdk.io/x/circuit v0.1.1 h1:KPJCnLChWrxD4jLwUiuQaf5mFD/1m7Omyo7oooefBVQ=
+cosmossdk.io/x/circuit v0.1.1/go.mod h1:B6f/urRuQH8gjt4eLIXfZJucrbreuYrKh5CSjaOxr+Q=
+cosmossdk.io/x/evidence v0.1.1 h1:Ks+BLTa3uftFpElLTDp9L76t2b58htjVbSZ86aoK/E4=
+cosmossdk.io/x/evidence v0.1.1/go.mod h1:OoDsWlbtuyqS70LY51aX8FBTvguQqvFrt78qL7UzeNc=
+cosmossdk.io/x/feegrant v0.1.1 h1:EKFWOeo/pup0yF0svDisWWKAA9Zags6Zd0P3nRvVvw8=
+cosmossdk.io/x/feegrant v0.1.1/go.mod h1:2GjVVxX6G2fta8LWj7pC/ytHjryA6MHAJroBWHFNiEQ=
+cosmossdk.io/x/nft v0.1.1 h1:pslAVS8P5NkW080+LWOamInjDcq+v2GSCo+BjN9sxZ8=
+cosmossdk.io/x/nft v0.1.1/go.mod h1:Kac6F6y2gsKvoxU+fy8uvxRTi4BIhLOor2zgCNQwVgY=
+cosmossdk.io/x/tx v0.14.0 h1:hB3O25kIcyDW/7kMTLMaO8Ripj3yqs5imceVd6c/heA=
+cosmossdk.io/x/tx v0.14.0/go.mod h1:Tn30rSRA1PRfdGB3Yz55W4Sn6EIutr9xtMKSHij+9PM=
+cosmossdk.io/x/upgrade v0.1.4 h1:/BWJim24QHoXde8Bc64/2BSEB6W4eTydq0X/2f8+g38=
+cosmossdk.io/x/upgrade v0.1.4/go.mod h1:9v0Aj+fs97O+Ztw+tG3/tp5JSlrmT7IcFhAebQHmOPo=
+dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
+filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
+filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
+github.com/99designs/go-keychain v0.0.0-20191008050251-8e49817e8af4 h1:/vQbFIOMbk2FiG/kXiLl8BRyzTWDw7gX/Hz7Dd5eDMs=
+github.com/99designs/go-keychain v0.0.0-20191008050251-8e49817e8af4/go.mod h1:hN7oaIRCjzsZ2dE+yG5k+rsdt3qcwykqK6HVGcKwsw4=
+github.com/99designs/keyring v1.2.2 h1:pZd3neh/EmUzWONb35LxQfvuY7kiSXAq3HQd97+XBn0=
+github.com/99designs/keyring v1.2.2/go.mod h1:wes/FrByc8j7lFOAGLGSNEg8f/PaI3cgTBqhFkHUrPk=
+github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161 h1:L/gRVlceqvL25UVaW/CKtUDjefjrs0SPonmDGUVOYP0=
+github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E=
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
+github.com/CosmWasm/wasmd v0.54.2 h1:FIaiHSDXPwiKY6YuupqJDenGXz70mq11HOTC538RYyc=
+github.com/CosmWasm/wasmd v0.54.2/go.mod h1:33OJ+Rj6nhX1HAPMvNo2WyuaNc+CgAEg24TPXjefdM0=
+github.com/CosmWasm/wasmvm/v2 v2.2.4 h1:V3UwXJMA8TNOuQETppDQkaXAevF7gOWLYpKvrThPv7o=
+github.com/CosmWasm/wasmvm/v2 v2.2.4/go.mod h1:Aj/rB2KMRM8nAdbWxkO23rnQYb5KsoPuH9ZizSi0sVg=
+github.com/DataDog/datadog-go v3.2.0+incompatible h1:qSG2N4FghB1He/r2mFrWKCaL7dXCilEuNEeAn20fdD4=
+github.com/DataDog/datadog-go v3.2.0+incompatible/go.mod h1:LButxg5PwREeZtORoXG3tL4fMGNddJ+vMq1mwgfaqoQ=
+github.com/DataDog/zstd v1.5.7 h1:ybO8RBeh29qrxIhCA9E8gKY6xfONU9T6G6aP9DTKfLE=
+github.com/DataDog/zstd v1.5.7/go.mod h1:g4AWEaM3yOg3HYfnJ3YIawPnVdXJh9QME85blwSAmyw=
+github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.26.0 h1:f2Qw/Ehhimh5uO1fayV0QIW7DShEQqhtUfhYc+cBPlw=
+github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.26.0/go.mod h1:2bIszWvQRlJVmJLiuLhukLImRjKPcYdzzsx6darK02A=
+github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/metric v0.48.1 h1:UQ0AhxogsIRZDkElkblfnwjc3IaltCm2HUMvezQaL7s=
+github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/metric v0.48.1/go.mod h1:jyqM3eLpJ3IbIFDTKVz2rF9T/xWGW0rIriGwnz8l9Tk=
+github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/cloudmock v0.48.1 h1:oTX4vsorBZo/Zdum6OKPA4o7544hm6smoRv1QjpTwGo=
+github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/cloudmock v0.48.1/go.mod h1:0wEl7vrAD8mehJyohS9HZy+WyEOaQO2mJx86Cvh93kM=
+github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/resourcemapping v0.48.1 h1:8nn+rsCvTq9axyEh382S0PFLBeaFwNsT43IrPWzctRU=
+github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/resourcemapping v0.48.1/go.mod h1:viRWSEhtMZqz1rhwmOVKkWl6SwmVowfL9O2YR5gI2PE=
+github.com/Knetic/govaluate v3.0.1-0.20171022003610-9aa49832a739+incompatible/go.mod h1:r7JcOSlj0wfOMncg0iLm8Leh48TZaKVeNIfJntJ2wa0=
+github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY=
+github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU=
+github.com/Nvveen/Gotty v0.0.0-20120604004816-cd527374f1e5 h1:TngWCqHvy9oXAN6lEVMRuU21PR1EtLVZJmdB18Gu3Rw=
+github.com/Nvveen/Gotty v0.0.0-20120604004816-cd527374f1e5/go.mod h1:lmUJ/7eu/Q8D7ML55dXQrVaamCz2vxCfdQBasLZfHKk=
+github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
+github.com/Shopify/sarama v1.19.0/go.mod h1:FVkBWblsNy7DGZRfXLU0O9RCGt5g3g3yEuWXgklEdEo=
+github.com/Shopify/toxiproxy v2.1.4+incompatible/go.mod h1:OXgGpZ6Cli1/URJOF1DMxUHB2q5Ap20/P/eIdh4G0pI=
+github.com/VividCortex/gohistogram v1.0.0 h1:6+hBz+qvs0JOrrNhhmR7lFxo5sINxBCGXrdtl/UvroE=
+github.com/VividCortex/gohistogram v1.0.0/go.mod h1:Pf5mBqqDxYaXu3hDrrU+w6nw50o/4+TcAqDqk/vUH7g=
+github.com/adlio/schema v1.3.6 h1:k1/zc2jNfeiZBA5aFTRy37jlBIuCkXCm0XmvpzCKI9I=
+github.com/adlio/schema v1.3.6/go.mod h1:qkxwLgPBd1FgLRHYVCmQT/rrBr3JH38J9LjmVzWNudg=
+github.com/afex/hystrix-go v0.0.0-20180502004556-fa1af6a1f4f5/go.mod h1:SkGFH1ia65gfNATL8TAiHDNxPzPdmEL5uirI2Uyuz6c=
+github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
+github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
+github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
+github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
+github.com/alecthomas/units v0.0.0-20190924025748-f65c72e2690d/go.mod h1:rBZYJk541a8SKzHPHnH3zbiI+7dagKZ0cgpgrD7Fyho=
+github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY=
+github.com/apache/thrift v0.12.0/go.mod h1:cp2SuWMxlEZw2r+iP2GNCdIi4C1qmUzdZFSVb+bacwQ=
+github.com/apache/thrift v0.13.0/go.mod h1:cp2SuWMxlEZw2r+iP2GNCdIi4C1qmUzdZFSVb+bacwQ=
+github.com/armon/circbuf v0.0.0-20150827004946-bbbad097214e/go.mod h1:3U/XgcO3hCbHZ8TKRvWD2dDTCfh9M9ya+I9JpbB7O8o=
+github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da/go.mod h1:Q73ZrmVTwzkszR9V5SSuryQ31EELlFMUz1kKyl939pY=
+github.com/armon/go-metrics v0.4.1/go.mod h1:E6amYzXo6aW1tqzoZGT755KkbgrJsSdpwZ+3JqfkOG4=
+github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8=
+github.com/aryann/difflib v0.0.0-20170710044230-e206f873d14a/go.mod h1:DAHtR1m6lCRdSC2Tm3DSWRPvIPr6xNKyeHdqDQSQT+A=
+github.com/aws/aws-lambda-go v1.13.3/go.mod h1:4UKl9IzQMoD+QF79YdCuzCwp8VbmG4VAQwij/eHl5CU=
+github.com/aws/aws-sdk-go v1.27.0/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo=
+github.com/aws/aws-sdk-go v1.44.122/go.mod h1:y4AeaBuwd2Lk+GepC1E9v0qOiTws0MIWAX4oIKwKHZo=
+github.com/aws/aws-sdk-go v1.44.224 h1:09CiaaF35nRmxrzWZ2uRq5v6Ghg/d2RiPjZnSgtt+RQ=
+github.com/aws/aws-sdk-go v1.44.224/go.mod h1:aVsgQcEevwlmQ7qHE9I3h+dtQgpqhFB+i8Phjh7fkwI=
+github.com/aws/aws-sdk-go-v2 v0.18.0/go.mod h1:JWVYvqSMppoMJC0x5wdwiImzgXTI9FuZwxzkQq9wy+g=
+github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA=
+github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
+github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
+github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
+github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
+github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d h1:xDfNPAt8lFiC1UJrqV3uuy861HCTo708pDMbjHHdCas=
+github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d/go.mod h1:6QX/PXZ00z/TKoufEY6K/a0k6AhaJrQKdFe6OfVXsa4=
+github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs=
+github.com/bgentry/speakeasy v0.2.0 h1:tgObeVOf8WAvtuAX6DhJ4xks4CFNwPDZiqzGqIHE51E=
+github.com/bgentry/speakeasy v0.2.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs=
+github.com/bits-and-blooms/bitset v1.22.0 h1:Tquv9S8+SGaS3EhyA+up3FXzmkhxPGjQQCkcs2uw7w4=
+github.com/bits-and-blooms/bitset v1.22.0/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8=
+github.com/blang/semver/v4 v4.0.0 h1:1PFHFE6yCCTv8C1TeyNNarDzntLi7wMI5i/pzqYIsAM=
+github.com/blang/semver/v4 v4.0.0/go.mod h1:IbckMUScFkM3pff0VJDNKRiT6TG/YpiHIM2yvyW5YoQ=
+github.com/btcsuite/btcd/btcec/v2 v2.3.2 h1:5n0X6hX0Zk+6omWcihdYvdAlGf2DfasC0GMf7DClJ3U=
+github.com/btcsuite/btcd/btcec/v2 v2.3.2/go.mod h1:zYzJ8etWJQIv1Ogk7OzpWjowwOdXY1W/17j2MW85J04=
+github.com/btcsuite/btcd/btcutil v1.1.6 h1:zFL2+c3Lb9gEgqKNzowKUPQNb8jV7v5Oaodi/AYFd6c=
+github.com/btcsuite/btcd/btcutil v1.1.6/go.mod h1:9dFymx8HpuLqBnsPELrImQeTQfKBQqzqGbbV3jK55aE=
+github.com/bufbuild/protocompile v0.14.1 h1:iA73zAf/fyljNjQKwYzUHD6AD4R8KMasmwa/FBatYVw=
+github.com/bufbuild/protocompile v0.14.1/go.mod h1:ppVdAIhbr2H8asPk6k4pY7t9zB1OU5DoEw9xY/FUi1c=
+github.com/bytedance/sonic v1.14.0 h1:/OfKt8HFw0kh2rj8N0F6C/qPGRESq0BbaNZgcNXXzQQ=
+github.com/bytedance/sonic v1.14.0/go.mod h1:WoEbx8WTcFJfzCe0hbmyTGrfjt8PzNEBdxlNUO24NhA=
+github.com/bytedance/sonic/loader v0.3.0 h1:dskwH8edlzNMctoruo8FPTJDF3vLtDT0sXZwvZJyqeA=
+github.com/bytedance/sonic/loader v0.3.0/go.mod h1:N8A3vUdtUebEY2/VQC0MyhYeKUFosQU6FxH2JmUe6VI=
+github.com/casbin/casbin/v2 v2.1.2/go.mod h1:YcPU1XXisHhLzuxH9coDNf2FbKpjGlbCg3n9yuLkIJQ=
+github.com/cenkalti/backoff v2.2.1+incompatible h1:tNowT99t7UNflLxfYYSlKYsBpXdEet03Pg2g16Swow4=
+github.com/cenkalti/backoff v2.2.1+incompatible/go.mod h1:90ReRw6GdpyfrHakVjL/QHaoyV4aDUVVkXQJJJ3NXXM=
+github.com/cenkalti/backoff/v4 v4.1.1/go.mod h1:scbssz8iZGpm3xbr14ovlUdkxfGXNInqkPWOWmG2CLw=
+github.com/cenkalti/backoff/v4 v4.3.0 h1:MyRJ/UdXutAwSAT+s3wNd7MfTIcy71VQueUuFK343L8=
+github.com/cenkalti/backoff/v4 v4.3.0/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE=
+github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
+github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
+github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
+github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/cheggaaa/pb v1.0.27/go.mod h1:pQciLPpbU0oxA0h+VJYYLxO+XeDQb5pZijXscXHm81s=
+github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
+github.com/chzyer/logex v1.2.1 h1:XHDu3E6q+gdHgsdTPH6ImJMIp436vR6MPtH8gP05QzM=
+github.com/chzyer/logex v1.2.1/go.mod h1:JLbx6lG2kDbNRFnfkgvh4eRJRPX1QCoOIWomwysCBrQ=
+github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
+github.com/chzyer/readline v1.5.1 h1:upd/6fQk4src78LMRzh5vItIt361/o4uq553V8B5sGI=
+github.com/chzyer/readline v1.5.1/go.mod h1:Eh+b79XXUwfKfcPLepksvw2tcLE/Ct21YObkaSkeBlk=
+github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
+github.com/chzyer/test v1.0.0 h1:p3BQDXSxOhOG0P9z6/hGnII4LGiEPOYBhs8asl/fC04=
+github.com/chzyer/test v1.0.0/go.mod h1:2JlltgoNkt4TW/z9V/IzDdFaMTM2JPIi26O1pF38GC8=
+github.com/circonus-labs/circonus-gometrics v2.3.1+incompatible/go.mod h1:nmEj6Dob7S7YxXgwXpfOuvO54S+tGdZdw9fuRZt25Ag=
+github.com/circonus-labs/circonusllhist v0.1.3/go.mod h1:kMXHVDlOchFAehlya5ePtbp5jckzBHf4XRpQvBOLI+I=
+github.com/clbanning/x2j v0.0.0-20191024224557-825249438eec/go.mod h1:jMjuTZXRI4dUb/I5gc9Hdhagfvm9+RyrPryS/auMzxE=
+github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
+github.com/cloudwego/base64x v0.1.6 h1:t11wG9AECkCDk5fMSoxmufanudBtJ+/HemLstXDLI2M=
+github.com/cloudwego/base64x v0.1.6/go.mod h1:OFcloc187FXDaYHvrNIjxSe8ncn0OOM8gEHfghB2IPU=
+github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
+github.com/cncf/udpa/go v0.0.0-20200629203442-efcf912fb354/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
+github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
+github.com/cncf/udpa/go v0.0.0-20210930031921-04548b0d99d4/go.mod h1:6pvJx4me5XPnfI9Z40ddWsdw2W/uZgQLFXToKeRcDiI=
+github.com/cncf/xds/go v0.0.0-20210312221358-fbca930ec8ed/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
+github.com/cncf/xds/go v0.0.0-20210805033703-aa0b78936158/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
+github.com/cncf/xds/go v0.0.0-20210922020428-25de7278fc84/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
+github.com/cncf/xds/go v0.0.0-20211001041855-01bcc9b48dfe/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
+github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
+github.com/cncf/xds/go v0.0.0-20250121191232-2f005788dc42 h1:Om6kYQYDUk5wWbT0t0q6pvyM49i9XZAv9dDrkDA7gjk=
+github.com/cncf/xds/go v0.0.0-20250121191232-2f005788dc42/go.mod h1:W+zGtBO5Y1IgJhy4+A9GOqVhqLpfZi+vwmdNXUehLA8=
+github.com/cockroachdb/apd/v2 v2.0.2 h1:weh8u7Cneje73dDh+2tEVLUvyBc89iwepWCD8b8034E=
+github.com/cockroachdb/apd/v2 v2.0.2/go.mod h1:DDxRlzC2lo3/vSlmSoS7JkqbbrARPuFOGr0B9pvN3Gw=
+github.com/cockroachdb/datadriven v0.0.0-20190809214429-80d97fb3cbaa/go.mod h1:zn76sxSg3SzpJ0PPJaLDCu+Bu0Lg3sKTORVIj19EIF8=
+github.com/cockroachdb/datadriven v1.0.3-0.20230413201302-be42291fc80f h1:otljaYPt5hWxV3MUfO5dFPFiOXg9CyG5/kCfayTqsJ4=
+github.com/cockroachdb/datadriven v1.0.3-0.20230413201302-be42291fc80f/go.mod h1:a9RdTaap04u637JoCzcUoIcDmvwSUtcUFtT/C3kJlTU=
+github.com/cockroachdb/errors v1.12.0 h1:d7oCs6vuIMUQRVbi6jWWWEJZahLCfJpnJSVobd1/sUo=
+github.com/cockroachdb/errors v1.12.0/go.mod h1:SvzfYNNBshAVbZ8wzNc/UPK3w1vf0dKDUP41ucAIf7g=
+github.com/cockroachdb/fifo v0.0.0-20240606204812-0bbfbd93a7ce h1:giXvy4KSc/6g/esnpM7Geqxka4WSqI1SZc7sMJFd3y4=
+github.com/cockroachdb/fifo v0.0.0-20240606204812-0bbfbd93a7ce/go.mod h1:9/y3cnZ5GKakj/H4y9r9GTjCvAFta7KLgSHPJJYc52M=
+github.com/cockroachdb/logtags v0.0.0-20241215232642-bb51bb14a506 h1:ASDL+UJcILMqgNeV5jiqR4j+sTuvQNHdf2chuKj1M5k=
+github.com/cockroachdb/logtags v0.0.0-20241215232642-bb51bb14a506/go.mod h1:Mw7HqKr2kdtu6aYGn3tPmAftiP3QPX63LdK/zcariIo=
+github.com/cockroachdb/pebble v1.1.5 h1:5AAWCBWbat0uE0blr8qzufZP5tBjkRyy/jWe1QWLnvw=
+github.com/cockroachdb/pebble v1.1.5/go.mod h1:17wO9el1YEigxkP/YtV8NtCivQDgoCyBg5c4VR/eOWo=
+github.com/cockroachdb/redact v1.1.6 h1:zXJBwDZ84xJNlHl1rMyCojqyIxv+7YUpQiJLQ7n4314=
+github.com/cockroachdb/redact v1.1.6/go.mod h1:BVNblN9mBWFyMyqK1k3AAiSxhvhfK2oOZZ2lK+dpvRg=
+github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 h1:zuQyyAKVxetITBuuhv3BI9cMrmStnpT18zmgmTxunpo=
+github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06/go.mod h1:7nc4anLGjupUW/PeY5qiNYsdNXj7zopG+eqsS7To5IQ=
+github.com/codahale/hdrhistogram v0.0.0-20161010025455-3a0bb77429bd/go.mod h1:sE/e/2PUdi/liOCUjSTXgM1o87ZssimdTWN964YiIeI=
+github.com/cometbft/cometbft v0.38.17 h1:FkrQNbAjiFqXydeAO81FUzriL4Bz0abYxN/eOHrQGOk=
+github.com/cometbft/cometbft v0.38.17/go.mod h1:5l0SkgeLRXi6bBfQuevXjKqML1jjfJJlvI1Ulp02/o4=
+github.com/cometbft/cometbft-db v0.14.1 h1:SxoamPghqICBAIcGpleHbmoPqy+crij/++eZz3DlerQ=
+github.com/cometbft/cometbft-db v0.14.1/go.mod h1:KHP1YghilyGV/xjD5DP3+2hyigWx0WTp9X+0Gnx0RxQ=
+github.com/consensys/gnark-crypto v0.18.0 h1:vIye/FqI50VeAr0B3dx+YjeIvmc3LWz4yEfbWBpTUf0=
+github.com/consensys/gnark-crypto v0.18.0/go.mod h1:L3mXGFTe1ZN+RSJ+CLjUt9x7PNdx8ubaYfDROyp2Z8c=
+github.com/containerd/continuity v0.3.0 h1:nisirsYROK15TAMVukJOUyGJjz4BNQJBVsNvAXZJ/eg=
+github.com/containerd/continuity v0.3.0/go.mod h1:wJEAIwKOm/pBZuBd0JmeTvnLquTB1Ag8espWhkykbPM=
+github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
+github.com/coreos/go-systemd v0.0.0-20180511133405-39ca1b05acc7/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
+github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
+github.com/coreos/pkg v0.0.0-20160727233714-3ac0863d7acf/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA=
+github.com/cosmos/btcutil v1.0.5 h1:t+ZFcX77LpKtDBhjucvnOH8C2l2ioGsBNEQ3jef8xFk=
+github.com/cosmos/btcutil v1.0.5/go.mod h1:IyB7iuqZMJlthe2tkIFL33xPyzbFYP0XVdS8P5lUPis=
+github.com/cosmos/cosmos-db v1.1.1 h1:FezFSU37AlBC8S98NlSagL76oqBRWq/prTPvFcEJNCM=
+github.com/cosmos/cosmos-db v1.1.1/go.mod h1:AghjcIPqdhSLP/2Z0yha5xPH3nLnskz81pBx3tcVSAw=
+github.com/cosmos/cosmos-proto v1.0.0-beta.5 h1:eNcayDLpip+zVLRLYafhzLvQlSmyab+RC5W7ZfmxJLA=
+github.com/cosmos/cosmos-proto v1.0.0-beta.5/go.mod h1:hQGLpiIUloJBMdQMMWb/4wRApmI9hjHH05nefC0Ojec=
+github.com/cosmos/go-bip39 v1.0.0 h1:pcomnQdrdH22njcAatO0yWojsUnCO3y2tNoV1cb6hHY=
+github.com/cosmos/go-bip39 v1.0.0/go.mod h1:RNJv0H/pOIVgxw6KS7QeX2a0Uo0aKUlfhZ4xuwvCdJw=
+github.com/cosmos/gogogateway v1.2.0 h1:Ae/OivNhp8DqBi/sh2A8a1D0y638GpL3tkmLQAiKxTE=
+github.com/cosmos/gogogateway v1.2.0/go.mod h1:iQpLkGWxYcnCdz5iAdLcRBSw3h7NXeOkZ4GUkT+tbFI=
+github.com/cosmos/gogoproto v1.4.2/go.mod h1:cLxOsn1ljAHSV527CHOtaIP91kK6cCrZETRBrkzItWU=
+github.com/cosmos/gogoproto v1.7.0 h1:79USr0oyXAbxg3rspGh/m4SWNyoz/GLaAh0QlCe2fro=
+github.com/cosmos/gogoproto v1.7.0/go.mod h1:yWChEv5IUEYURQasfyBW5ffkMHR/90hiHgbNgrtp4j0=
+github.com/cosmos/iavl v1.2.4 h1:IHUrG8dkyueKEY72y92jajrizbkZKPZbMmG14QzsEkw=
+github.com/cosmos/iavl v1.2.4/go.mod h1:GiM43q0pB+uG53mLxLDzimxM9l/5N9UuSY3/D0huuVw=
+github.com/cosmos/ibc-go/modules/capability v1.0.1 h1:ibwhrpJ3SftEEZRxCRkH0fQZ9svjthrX2+oXdZvzgGI=
+github.com/cosmos/ibc-go/modules/capability v1.0.1/go.mod h1:rquyOV262nGJplkumH+/LeYs04P3eV8oB7ZM4Ygqk4E=
+github.com/cosmos/ibc-go/v8 v8.4.0 h1:K2PfX0AZ+1XKZytHGEMuSjQXG/MZshPb83RSTQt2+cE=
+github.com/cosmos/ibc-go/v8 v8.4.0/go.mod h1:zh6x1osR0hNvEcFrC/lhGD08sMfQmr9wHVvZ/mRWMCs=
+github.com/cosmos/ics23/go v0.11.0 h1:jk5skjT0TqX5e5QJbEnwXIS2yI2vnmLOgpQPeM5RtnU=
+github.com/cosmos/ics23/go v0.11.0/go.mod h1:A8OjxPE67hHST4Icw94hOxxFEJMBG031xIGF/JHNIY0=
+github.com/cosmos/ledger-cosmos-go v0.14.0 h1:WfCHricT3rPbkPSVKRH+L4fQGKYHuGOK9Edpel8TYpE=
+github.com/cosmos/ledger-cosmos-go v0.14.0/go.mod h1:E07xCWSBl3mTGofZ2QnL4cIUzMbbGVyik84QYKbX3RA=
+github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
+github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
+github.com/creachadair/atomicfile v0.3.1 h1:yQORkHjSYySh/tv5th1dkKcn02NEW5JleB84sjt+W4Q=
+github.com/creachadair/atomicfile v0.3.1/go.mod h1:mwfrkRxFKwpNAflYZzytbSwxvbK6fdGRRlp0KEQc0qU=
+github.com/creachadair/tomledit v0.0.24 h1:5Xjr25R2esu1rKCbQEmjZYlrhFkDspoAbAKb6QKQDhQ=
+github.com/creachadair/tomledit v0.0.24/go.mod h1:9qHbShRWQzSCcn617cMzg4eab1vbLCOjOshAWSzWr8U=
+github.com/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7DoTY=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
+github.com/danieljoos/wincred v1.2.1 h1:dl9cBrupW8+r5250DYkYxocLeZ1Y4vB1kxgtjxw8GQs=
+github.com/danieljoos/wincred v1.2.1/go.mod h1:uGaFL9fDn3OLTvzCGulzE+SzjEe5NGlh5FdCcyfPwps=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/decred/dcrd/crypto/blake256 v1.1.0 h1:zPMNGQCm0g4QTY27fOCorQW7EryeQ/U0x++OzVrdms8=
+github.com/decred/dcrd/crypto/blake256 v1.1.0/go.mod h1:2OfgNZ5wDpcsFmHmCK5gZTPcCXqlm2ArzUIkw9czNJo=
+github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0 h1:NMZiJj8QnKe1LgsbDayM4UoHwbvwDRwnI3hwNaAHRnc=
+github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0/go.mod h1:ZXNYxsqcloTdSy/rNShjYzMhyjf0LaoftYK0p+A3h40=
+github.com/desertbit/timer v0.0.0-20180107155436-c41aec40b27f h1:U5y3Y5UE0w7amNe7Z5G/twsBW0KEalRQXZzf8ufSh9I=
+github.com/desertbit/timer v0.0.0-20180107155436-c41aec40b27f/go.mod h1:xH/i4TFMt8koVQZ6WFms69WAsDWr2XsYL3Hkl7jkoLE=
+github.com/dgraph-io/badger/v4 v4.2.0 h1:kJrlajbXXL9DFTNuhhu9yCx7JJa4qpYWxtE8BzuWsEs=
+github.com/dgraph-io/badger/v4 v4.2.0/go.mod h1:qfCqhPoWDFJRx1gp5QwwyGo8xk1lbHUxvK9nK0OGAak=
+github.com/dgraph-io/ristretto v0.1.1 h1:6CWw5tJNgpegArSHpNHJKldNeq03FQCwYvfMVWajOK8=
+github.com/dgraph-io/ristretto v0.1.1/go.mod h1:S1GPSBCYCIhmVNfcth17y2zZtQT6wzkzgwUve0VDWWA=
+github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
+github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw=
+github.com/dgryski/go-farm v0.0.0-20200201041132-a6ae2369ad13 h1:fAjc9m62+UWV/WAFKLNi6ZS0675eEUC9y3AlwSbQu1Y=
+github.com/dgryski/go-farm v0.0.0-20200201041132-a6ae2369ad13/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw=
+github.com/distribution/reference v0.6.0 h1:0IXCQ5g4/QMHHkarYzh5l+u8T3t73zM5QvfrDyIgxBk=
+github.com/distribution/reference v0.6.0/go.mod h1:BbU0aIcezP1/5jX/8MP0YiH4SdvB5Y4f/wlDRiLyi3E=
+github.com/docker/go-connections v0.5.0 h1:USnMq7hx7gwdVZq1L49hLXaFtUdTADjXGp+uj1Br63c=
+github.com/docker/go-connections v0.5.0/go.mod h1:ov60Kzw0kKElRwhNs9UlUHAE/F9Fe6GLaXnqyDdmEXc=
+github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4=
+github.com/docker/go-units v0.5.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
+github.com/dustin/go-humanize v0.0.0-20171111073723-bb3d318650d4/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
+github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
+github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
+github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
+github.com/dvsekhvalnov/jose2go v1.6.0 h1:Y9gnSnP4qEI0+/uQkHvFXeD2PLPJeXEL+ySMEA2EjTY=
+github.com/dvsekhvalnov/jose2go v1.6.0/go.mod h1:QsHjhyTlD/lAVqn/NSbVZmSCGeDehTB/mPZadG+mhXU=
+github.com/eapache/go-resiliency v1.1.0/go.mod h1:kFI+JgMyC7bLPUVY133qvEBtVayf5mFgVsvEsIPBvNs=
+github.com/eapache/go-xerial-snappy v0.0.0-20180814174437-776d5712da21/go.mod h1:+020luEh2TKB4/GOp8oxxtq0Daoen/Cii55CzbTV6DU=
+github.com/eapache/queue v1.1.0/go.mod h1:6eCeP0CKFpHLu8blIFXhExK/dRa7WDZfr6jVFPTqq+I=
+github.com/edsrzf/mmap-go v1.0.0/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M=
+github.com/emicklei/dot v1.6.2 h1:08GN+DD79cy/tzN6uLCT84+2Wk9u+wvqP+Hkx/dIR8A=
+github.com/emicklei/dot v1.6.2/go.mod h1:DeV7GvQtIw4h2u73RKBkkFdvVAz0D9fzeJrgPW6gy/s=
+github.com/envoyproxy/go-control-plane v0.6.9/go.mod h1:SBwIajubJHhxtWwsL9s8ss4safvEdbitLhGGK48rN6g=
+github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
+github.com/envoyproxy/go-control-plane v0.9.7/go.mod h1:cwu0lG7PUMfa9snN8LXBig5ynNVH9qI8YYLbd1fK2po=
+github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
+github.com/envoyproxy/go-control-plane v0.9.9-0.20210217033140-668b12f5399d/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
+github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.mod h1:hliV/p42l8fGbc6Y9bQ70uLwIvmJyVE5k4iMKlh8wCQ=
+github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021/go.mod h1:AFq3mo9L8Lqqiid3OhADV3RfLJnjiw63cSpi+fDTRC0=
+github.com/envoyproxy/go-control-plane v0.10.2-0.20220325020618-49ff273808a1/go.mod h1:KJwIaB5Mv44NWtYuAOFCVOjcI94vtpEz2JU/D2v6IjE=
+github.com/envoyproxy/go-control-plane v0.13.4 h1:zEqyPVyku6IvWCFwux4x9RxkLOMUL+1vC9xUFv5l2/M=
+github.com/envoyproxy/go-control-plane v0.13.4/go.mod h1:kDfuBlDVsSj2MjrLEtRWtHlsWIFcGyB2RMO44Dc5GZA=
+github.com/envoyproxy/go-control-plane/envoy v1.32.4 h1:jb83lalDRZSpPWW2Z7Mck/8kXZ5CQAFYVjQcdVIr83A=
+github.com/envoyproxy/go-control-plane/envoy v1.32.4/go.mod h1:Gzjc5k8JcJswLjAx1Zm+wSYE20UrLtt7JZMWiWQXQEw=
+github.com/envoyproxy/go-control-plane/ratelimit v0.1.0 h1:/G9QYbddjL25KvtKTv3an9lx6VBE2cnb8wp1vEGNYGI=
+github.com/envoyproxy/go-control-plane/ratelimit v0.1.0/go.mod h1:Wk+tMFAFbCXaJPzVVHnPgRKdUdwW/KdbRt94AzgRee4=
+github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
+github.com/envoyproxy/protoc-gen-validate v1.2.1 h1:DEo3O99U8j4hBFwbJfrz9VtgcDfUKS7KJ7spH3d86P8=
+github.com/envoyproxy/protoc-gen-validate v1.2.1/go.mod h1:d/C80l/jxXLdfEIhX1W2TmLfsJ31lvEjwamM4DxlWXU=
+github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
+github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk=
+github.com/fatih/color v1.17.0 h1:GlRw1BRJxkpqUCBKzKOw098ed57fEsKeNjpTe3cSjK4=
+github.com/fatih/color v1.17.0/go.mod h1:YZ7TlrGPkiz6ku9fK3TLD/pl3CpsiFyu8N92HLgmosI=
+github.com/fatih/structs v1.1.0 h1:Q7juDM0QtcnhCpeyLGQKyg4TOIghuNXrkL32pHAUMxo=
+github.com/fatih/structs v1.1.0/go.mod h1:9NiDSp5zOcgEDl+j00MP/WkGVPOlPRLejGD8Ga6PJ7M=
+github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg=
+github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
+github.com/fortytw2/leaktest v1.3.0 h1:u8491cBMTQ8ft8aeV+adlcytMZylmA5nnwwkRZjI8vw=
+github.com/fortytw2/leaktest v1.3.0/go.mod h1:jDsjWgpAGjm2CA7WthBh/CdZYEPF31XHquHwclZch5g=
+github.com/franela/goblin v0.0.0-20200105215937-c9ffbefa60db/go.mod h1:7dvUGVsVBjqR7JHJk0brhHOZYGmfBYOrK0ZhYMEtBr4=
+github.com/franela/goreq v0.0.0-20171204163338-bcd34c9993f8/go.mod h1:ZhphrRTfi2rbfLwlschooIH4+wKKDR4Pdxhh+TRoA20=
+github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
+github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
+github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
+github.com/fsnotify/fsnotify v1.5.4/go.mod h1:OVB6XrOHzAwXMpEM7uPOzcehqUV2UqJxmVXmkdnm1bU=
+github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
+github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0=
+github.com/getsentry/sentry-go v0.32.0 h1:YKs+//QmwE3DcYtfKRH8/KyOOF/I6Qnx7qYGNHCGmCY=
+github.com/getsentry/sentry-go v0.32.0/go.mod h1:CYNcMMz73YigoHljQRG+qPF+eMq8gG72XcGN/p71BAY=
+github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
+github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
+github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
+github.com/gin-gonic/gin v1.6.3 h1:ahKqKTFpO5KTPHxWZjEdPScmYaGtLo8Y4DMHoEsnp14=
+github.com/gin-gonic/gin v1.6.3/go.mod h1:75u5sXoLsGZoRN5Sgbi1eraJ4GU3++wFwWzhwvtwp4M=
+github.com/go-errors/errors v1.4.2 h1:J6MZopCL4uSllY1OfXM374weqZFFItUbrImctkmUxIA=
+github.com/go-errors/errors v1.4.2/go.mod h1:sIVyrIiJhuEF+Pj9Ebtd6P/rEYROXFi3BopGUQ5a5Og=
+github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
+github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
+github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
+github.com/go-jose/go-jose/v4 v4.0.4 h1:VsjPI33J0SB9vQM6PLmNjoHqMQNGPiZ0rHL7Ni7Q6/E=
+github.com/go-jose/go-jose/v4 v4.0.4/go.mod h1:NKb5HO1EZccyMpiZNbdUw/14tiXNyUJh188dfnMCAfc=
+github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
+github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
+github.com/go-kit/kit v0.10.0/go.mod h1:xUsJbQ/Fp4kEt7AFgCuvyX4a71u8h9jB8tj/ORgOZ7o=
+github.com/go-kit/kit v0.13.0 h1:OoneCcHKHQ03LfBpoQCUfCluwd2Vt3ohz+kvbJneZAU=
+github.com/go-kit/kit v0.13.0/go.mod h1:phqEHMMUbyrCFCTgH48JueqrM3md2HcAZ8N3XE4FKDg=
+github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY=
+github.com/go-kit/log v0.2.1 h1:MRVx0/zhvdseW+Gza6N9rVzU/IVzaeE1SFI4raAhmBU=
+github.com/go-kit/log v0.2.1/go.mod h1:NwTd00d/i8cPZ3xOwwiv2PO5MOcx78fFErGNcVmBjv0=
+github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
+github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
+github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A=
+github.com/go-logfmt/logfmt v0.6.0 h1:wGYYu3uicYdqXVgoYbvnkrPVXkuLM1p1ifugDMEdRi4=
+github.com/go-logfmt/logfmt v0.6.0/go.mod h1:WYhtIu8zTZfxdn5+rREduYbwxfcBr/Vr6KEVveWlfTs=
+github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
+github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=
+github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
+github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
+github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
+github.com/go-playground/locales v0.13.0 h1:HyWk6mgj5qFqCT5fjGBuRArbVDfE4hi8+e8ceBS/t7Q=
+github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8=
+github.com/go-playground/universal-translator v0.17.0 h1:icxd5fm+REJzpZx7ZfpaD876Lmtgy7VtROAbHHXk8no=
+github.com/go-playground/universal-translator v0.17.0/go.mod h1:UkSxE5sNxxRwHyU+Scu5vgOQjsIJAF8j9muTVoKLVtA=
+github.com/go-playground/validator/v10 v10.2.0 h1:KgJ0snyC2R9VXYN2rneOtQcw5aHQB1Vv0sFl1UcHBOY=
+github.com/go-playground/validator/v10 v10.2.0/go.mod h1:uOYAAleCW8F/7oMFd6aG0GOhaH6EGOAJShg8Id5JGkI=
+github.com/go-sql-driver/mysql v1.4.0/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w=
+github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
+github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE=
+github.com/go-viper/mapstructure/v2 v2.2.1 h1:ZAaOCxANMuZx5RCeg0mBdEZk7DZasvvZIxtHqx8aGss=
+github.com/go-viper/mapstructure/v2 v2.2.1/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM=
+github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee/go.mod h1:L0fX3K22YWvt/FAX9NnzrNzcI4wNYi9Yku4O0LKYflo=
+github.com/gobwas/httphead v0.1.0 h1:exrUm0f4YX0L7EBwZHuCF4GDp8aJfVeBrlLQrs6NqWU=
+github.com/gobwas/httphead v0.1.0/go.mod h1:O/RXo79gxV8G+RqlR/otEwx4Q36zl9rqC5u12GKvMCM=
+github.com/gobwas/pool v0.2.0/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
+github.com/gobwas/pool v0.2.1 h1:xfeeEhW7pwmX8nuLVlqbzVc7udMDrwetjEv+TZIz1og=
+github.com/gobwas/pool v0.2.1/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
+github.com/gobwas/ws v1.0.2 h1:CoAavW/wd/kulfZmSIBt6p24n4j7tHgNVCjsfHVNUbo=
+github.com/gobwas/ws v1.0.2/go.mod h1:szmBTxLgaFppYjEmNtny/v3w89xOydFnnZMcgRRu/EM=
+github.com/godbus/dbus v0.0.0-20190726142602-4481cbc300e2 h1:ZpnhV/YsD2/4cESfV5+Hoeu/iUR3ruzNvZ+yQfO03a0=
+github.com/godbus/dbus v0.0.0-20190726142602-4481cbc300e2/go.mod h1:bBOAhwG1umN6/6ZUMtDFBMQR8jRg9O75tm9K00oMsK4=
+github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
+github.com/gogo/googleapis v1.1.0/go.mod h1:gf4bu3Q80BeJ6H1S1vYPm8/ELATdvryBaNFGgqEef3s=
+github.com/gogo/googleapis v1.4.1-0.20201022092350-68b0159b7869/go.mod h1:5YRNX2z1oM5gXdAkurHa942MDgEJyk02w4OecKY87+c=
+github.com/gogo/googleapis v1.4.1 h1:1Yx4Myt7BxzvUr5ldGSbwYiZG6t9wGBZ+8/fX3Wvtq0=
+github.com/gogo/googleapis v1.4.1/go.mod h1:2lpHqI5OcWCtVElxXnPt+s8oJvMpySlOyM6xDCrzib4=
+github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
+github.com/golang/glog v1.2.4 h1:CNNw5U8lSiiBk7druxtSHHTsRWcxKoac6kZKm2peBBc=
+github.com/golang/glog v1.2.4/go.mod h1:6AhwSGph0fcJtXVM/PEHPqZlFeoLxhs7/t5UDAwmO+w=
+github.com/golang/groupcache v0.0.0-20160516000752-02826c3e7903/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da h1:oI5xCqsCo564l8iNU+DwB5epxmsaqB+rhGL0m5jtYqE=
+github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y=
+github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
+github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
+github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
+github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4=
+github.com/golang/mock v1.5.0/go.mod h1:CWnOUgYIOo4TcNZ0wHX3YZCqsaM1I1Jvs6v3mP3KVu8=
+github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc=
+github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.0/go.mod h1:Qd/q+1AKNOZr9uGQzbzCmRO6sUih6GTPZv6a1/R87v0=
+github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
+github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
+github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk=
+github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
+github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
+github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
+github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
+github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
+github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
+github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
+github.com/golang/protobuf v1.5.1/go.mod h1:DopwsBzvsk0Fs44TXzsVbJyPhcCPeIwnvohx4u74HPM=
+github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
+github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
+github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
+github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb h1:PBC98N2aIaM3XXiurYmW7fx4GZkL8feAMVq7nEjURHk=
+github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/gonka-ai/cosmos-sdk v0.53.3-ps13 h1:5/8GzgGwnWubVtO/0YKPlMITlbh1C/SMJpS+mxTuywg=
+github.com/gonka-ai/cosmos-sdk v0.53.3-ps13/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=
+github.com/google/btree v1.1.3/go.mod h1:qOPhT0dTNdNzV6Z/lhRX0YXUafgPLFUh+gZMl761Gm4=
+github.com/google/flatbuffers v1.12.1 h1:MVlul7pQNoDzWRLTw5imwYsl+usrS1TXG2H4jg6ImGw=
+github.com/google/flatbuffers v1.12.1/go.mod h1:1AeVuKshWv4vARoZatz6mlQ0JxURH0Kv5+zNeJKJCa8=
+github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
+github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.7/go.mod h1:n+brtR0CgQNWTVd5ZUFpTBC8YFBDLK/h/bpaJ8/DtOE=
+github.com/google/go-cmp v0.5.8/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/google/gofuzz v0.0.0-20170612174753-24818f796faf/go.mod h1:HP5RmnzzSNb993RKQDq4+1A4ia9nllfqcQFTQJedwGI=
+github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0=
+github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/martian v2.1.0+incompatible h1:/CP5g8u/VJHijgedC/Legn3BAbAaWPgecwXBIDzw5no=
+github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
+github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0=
+github.com/google/martian/v3 v3.1.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0=
+github.com/google/martian/v3 v3.2.1/go.mod h1:oBOf6HBosgwRXnUGWUB05QECsc6uvmMiJ3+6W4l/CUk=
+github.com/google/martian/v3 v3.3.3 h1:DIhPTQrbPkgs2yJYdXU/eNACCG5DVQjySNRNlflZ9Fc=
+github.com/google/martian/v3 v3.3.3/go.mod h1:iEPrYcgCF7jA9OtScMFQyAlZZ4YXTKEtJ1E6RWzmBA0=
+github.com/google/orderedcode v0.0.1 h1:UzfcAexk9Vhv8+9pNOgRu41f16lHq725vPwnSeiG/Us=
+github.com/google/orderedcode v0.0.1/go.mod h1:iVyU4/qPKHY5h/wSd6rZZCDcLJNxiWO6dvsYES2Sb20=
+github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
+github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
+github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20200229191704-1ebb73c60ed3/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20201023163331-3e6fc7fc9c4c/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
+github.com/google/pprof v0.0.0-20201203190320-1bf35d6f28c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
+github.com/google/pprof v0.0.0-20210122040257-d980be63207e/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
+github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
+github.com/google/pprof v0.0.0-20210407192527-94a9f03dee38/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
+github.com/google/pprof v0.0.0-20210601050228-01bbb1931b22/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
+github.com/google/pprof v0.0.0-20210609004039-a478d1d731e9/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
+github.com/google/pprof v0.0.0-20210720184732-4bb14d4b1be1/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
+github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e h1:ijClszYn+mADRFY17kjQEVQ1XRhq2/JR1M3sGqeJoxs=
+github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e/go.mod h1:boTsfXsheKC2y+lKOCMpSfarhxDeIzfZG1jqGcPl3cA=
+github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
+github.com/google/s2a-go v0.1.8 h1:zZDs9gcbt9ZPLV0ndSyQk6Kacx2g/X+SKYovpnz3SMM=
+github.com/google/s2a-go v0.1.8/go.mod h1:6iNWHTpQ+nfNRN5E00MSdfDwVesa8hhS32PhPO8deJA=
+github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/googleapis/enterprise-certificate-proxy v0.0.0-20220520183353-fd19c99a87aa/go.mod h1:17drOmN3MwGY7t0e+Ei9b45FFGA3fBs3x36SsCg1hq8=
+github.com/googleapis/enterprise-certificate-proxy v0.1.0/go.mod h1:17drOmN3MwGY7t0e+Ei9b45FFGA3fBs3x36SsCg1hq8=
+github.com/googleapis/enterprise-certificate-proxy v0.2.0/go.mod h1:8C0jb7/mgJe/9KK8Lm7X9ctZC2t60YyIpYEI16jx0Qg=
+github.com/googleapis/enterprise-certificate-proxy v0.3.4 h1:XYIDZApgAnrN1c855gTgghdIA6Stxb52D5RnLI1SLyw=
+github.com/googleapis/enterprise-certificate-proxy v0.3.4/go.mod h1:YKe7cfqYXjKGpGvmSg28/fFvhNzinZQm8DGnaburhGA=
+github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
+github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=
+github.com/googleapis/gax-go/v2 v2.1.0/go.mod h1:Q3nei7sK6ybPYH7twZdmQpAd1MKb7pfu6SK+H1/DsU0=
+github.com/googleapis/gax-go/v2 v2.1.1/go.mod h1:hddJymUZASv3XPyGkUpKj8pPO47Rmb0eJc8R6ouapiM=
+github.com/googleapis/gax-go/v2 v2.2.0/go.mod h1:as02EH8zWkzwUoLbBaFeQ+arQaj/OthfcblKl4IGNaM=
+github.com/googleapis/gax-go/v2 v2.3.0/go.mod h1:b8LNqSzNabLiUpXKkY7HAR5jr6bIT99EXz9pXxye9YM=
+github.com/googleapis/gax-go/v2 v2.4.0/go.mod h1:XOTVJ59hdnfJLIP/dh8n5CGryZR2LxK9wbMD5+iXC6c=
+github.com/googleapis/gax-go/v2 v2.5.1/go.mod h1:h6B0KMMFNtI2ddbGJn3T3ZbwkeT6yqEF02fYlzkUCyo=
+github.com/googleapis/gax-go/v2 v2.6.0/go.mod h1:1mjbznJAPHFpesgE5ucqfYEscaz5kMdcIDwU/6+DDoY=
+github.com/googleapis/gax-go/v2 v2.14.1 h1:hb0FFeiPaQskmvakKu5EbCbpntQn48jyHuvrkurSS/Q=
+github.com/googleapis/gax-go/v2 v2.14.1/go.mod h1:Hb/NubMaVM88SrNkvl8X/o8XWwDJEPqouaLeN2IUxoA=
+github.com/googleapis/go-type-adapters v1.0.0/go.mod h1:zHW75FOG2aur7gAO2B+MLby+cLsWGBF62rFAi7WjWO4=
+github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
+github.com/gorilla/context v1.1.1/go.mod h1:kBGZzfjB9CEq2AlWe17Uuf7NDRt0dE0s8S51q0aT7Yg=
+github.com/gorilla/handlers v1.5.2 h1:cLTUSsNkgcwhgRqvCNmdbRWG0A3N4F+M2nWKdScwyEE=
+github.com/gorilla/handlers v1.5.2/go.mod h1:dX+xVpaxdSw+q0Qek8SSsl3dfMk3jNddUkMzo0GtH0w=
+github.com/gorilla/mux v1.6.2/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs=
+github.com/gorilla/mux v1.7.3/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs=
+github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY=
+github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ=
+github.com/gorilla/websocket v0.0.0-20170926233335-4201258b820c/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
+github.com/gorilla/websocket v1.4.1/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
+github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/grpc-ecosystem/go-grpc-middleware v1.0.1-0.20190118093823-f849b5445de4/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs=
+github.com/grpc-ecosystem/go-grpc-middleware v1.2.2/go.mod h1:EaizFBKfUKtMIF5iaDEhniwNedqGo9FuLFzppDr3uwI=
+github.com/grpc-ecosystem/go-grpc-middleware v1.4.0 h1:UH//fgunKIs4JdUbpDl1VZCDaL56wXCB/5+wF6uHfaI=
+github.com/grpc-ecosystem/go-grpc-middleware v1.4.0/go.mod h1:g5qyo/la0ALbONm6Vbp88Yd8NsDy6rZz+RcrMPxvld8=
+github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk=
+github.com/grpc-ecosystem/grpc-gateway v1.9.5/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
+github.com/grpc-ecosystem/grpc-gateway v1.16.0 h1:gmcG1KaJ57LophUzW0Hy8NmPhnMZb4M0+kPpLofRdBo=
+github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw=
+github.com/gsterjov/go-libsecret v0.0.0-20161001094733-a6f4afe4910c h1:6rhixN/i8ZofjG1Y75iExal34USq5p+wiN1tpie8IrU=
+github.com/gsterjov/go-libsecret v0.0.0-20161001094733-a6f4afe4910c/go.mod h1:NMPJylDgVpX0MLRlPy15sqSwOFv/U1GZ2m21JhFfek0=
+github.com/hashicorp/consul/api v1.3.0/go.mod h1:MmDNSzIMUjNpY/mQ398R4bk2FnqQLoPndWW5VkKPlCE=
+github.com/hashicorp/consul/sdk v0.3.0/go.mod h1:VKf9jXwCTEY1QZP2MOLRhb5i/I/ssyNV1vwHyQBF0x8=
+github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
+github.com/hashicorp/go-cleanhttp v0.5.0/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80=
+github.com/hashicorp/go-cleanhttp v0.5.1/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80=
+github.com/hashicorp/go-cleanhttp v0.5.2 h1:035FKYIWjmULyFRBKPs8TBQoi0x6d9G4xc9neXJWAZQ=
+github.com/hashicorp/go-cleanhttp v0.5.2/go.mod h1:kO/YDlP8L1346E6Sodw+PrpBSV4/SoxCXGY6BqNFT48=
+github.com/hashicorp/go-getter v1.7.5 h1:dT58k9hQ/vbxNMwoI5+xFYAJuv6152UNvdHokfI5wE4=
+github.com/hashicorp/go-getter v1.7.5/go.mod h1:W7TalhMmbPmsSMdNjD0ZskARur/9GJ17cfHTRtXV744=
+github.com/hashicorp/go-hclog v1.6.3 h1:Qr2kF+eVWjTiYmU7Y31tYlP1h0q/X3Nl3tPGdaB11/k=
+github.com/hashicorp/go-hclog v1.6.3/go.mod h1:W4Qnvbt70Wk/zYJryRzDRU/4r0kIg0PVHBcfoyhpF5M=
+github.com/hashicorp/go-immutable-radix v1.0.0/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60=
+github.com/hashicorp/go-immutable-radix v1.3.1 h1:DKHmCUm2hRBK510BaiZlwvpD40f8bJFeZnpfm2KLowc=
+github.com/hashicorp/go-immutable-radix v1.3.1/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60=
+github.com/hashicorp/go-metrics v0.5.4 h1:8mmPiIJkTPPEbAiV97IxdAGNdRdaWwVap1BU6elejKY=
+github.com/hashicorp/go-metrics v0.5.4/go.mod h1:CG5yz4NZ/AI/aQt9Ucm/vdBnbh7fvmv4lxZ350i+QQI=
+github.com/hashicorp/go-msgpack v0.5.3/go.mod h1:ahLV/dePpqEmjfWmKiqvPkv/twdG7iPBM1vqhUKIvfM=
+github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk=
+github.com/hashicorp/go-plugin v1.6.3 h1:xgHB+ZUSYeuJi96WtxEjzi23uh7YQpznjGh0U0UUrwg=
+github.com/hashicorp/go-plugin v1.6.3/go.mod h1:MRobyh+Wc/nYy1V4KAXUiYfzxoYhs7V1mlH1Z7iY2h0=
+github.com/hashicorp/go-retryablehttp v0.5.3/go.mod h1:9B5zBasrRhHXnJnui7y6sL7es7NDiJgTc6Er0maI1Xs=
+github.com/hashicorp/go-rootcerts v1.0.0/go.mod h1:K6zTfqpRlCUIjkwsN4Z+hiSfzSTQa6eBIzfwKfwNnHU=
+github.com/hashicorp/go-safetemp v1.0.0 h1:2HR189eFNrjHQyENnQMMpCiBAsRxzbTMIgBhEyExpmo=
+github.com/hashicorp/go-safetemp v1.0.0/go.mod h1:oaerMy3BhqiTbVye6QuFhFtIceqFoDHxNAB65b+Rj1I=
+github.com/hashicorp/go-sockaddr v1.0.0/go.mod h1:7Xibr9yA9JjQq1JpNB2Vw7kxv8xerXegt+ozgdvDeDU=
+github.com/hashicorp/go-syslog v1.0.0/go.mod h1:qPfqrKkXGihmCqbJM2mZgkZGvKG1dFdvsLplgctolz4=
+github.com/hashicorp/go-uuid v1.0.0/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
+github.com/hashicorp/go-uuid v1.0.1/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
+github.com/hashicorp/go-uuid v1.0.2 h1:cfejS+Tpcp13yd5nYHWDI6qVCny6wyX2Mt5SGur2IGE=
+github.com/hashicorp/go-uuid v1.0.2/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
+github.com/hashicorp/go-version v1.2.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
+github.com/hashicorp/go-version v1.6.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
+github.com/hashicorp/go-version v1.7.0 h1:5tqGy27NaOTB8yJKUZELlFAS/LTKJkrmONwQKeRZfjY=
+github.com/hashicorp/go-version v1.7.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
+github.com/hashicorp/go.net v0.0.1/go.mod h1:hjKkEWcCURg++eb33jQU7oqQcI9XDCnUzHA0oac0k90=
+github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
+github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
+github.com/hashicorp/golang-lru v1.0.2 h1:dV3g9Z/unq5DpblPpw+Oqcv4dU/1omnb4Ok8iPY6p1c=
+github.com/hashicorp/golang-lru v1.0.2/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4=
+github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k=
+github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM=
+github.com/hashicorp/logutils v1.0.0/go.mod h1:QIAnNjmIWmVIIkWDTG1z5v++HQmx9WQRO+LraFDTW64=
+github.com/hashicorp/mdns v1.0.0/go.mod h1:tL+uN++7HEJ6SQLQ2/p+z2pH24WQKWjBPkE0mNTz8vQ=
+github.com/hashicorp/memberlist v0.1.3/go.mod h1:ajVTdAv/9Im8oMAAj5G31PhhMCZJV2pPBoIllUwCN7I=
+github.com/hashicorp/serf v0.8.2/go.mod h1:6hOLApaqBFA1NXqRQAsxw9QxuDEvNxSQRwA/JwenrHc=
+github.com/hashicorp/yamux v0.1.2 h1:XtB8kyFOyHXYVFnwT5C3+Bdo8gArse7j2AQ0DA0Uey8=
+github.com/hashicorp/yamux v0.1.2/go.mod h1:C+zze2n6e/7wshOZep2A70/aQU6QBRWJO/G6FT1wIns=
+github.com/hdevalence/ed25519consensus v0.2.0 h1:37ICyZqdyj0lAZ8P4D1d1id3HqbbG1N3iBb1Tb4rdcU=
+github.com/hdevalence/ed25519consensus v0.2.0/go.mod h1:w3BHWjwJbFU29IRHL1Iqkw3sus+7FctEyM4RqDxYNzo=
+github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
+github.com/huandu/go-assert v1.1.5 h1:fjemmA7sSfYHJD7CUqs9qTwwfdNAx7/j2/ZlHXzNB3c=
+github.com/huandu/go-assert v1.1.5/go.mod h1:yOLvuqZwmcHIC5rIzrBhT7D3Q9c3GFnd0JrPVhn/06U=
+github.com/huandu/skiplist v1.2.1 h1:dTi93MgjwErA/8idWTzIw4Y1kZsMWx35fmI2c8Rij7w=
+github.com/huandu/skiplist v1.2.1/go.mod h1:7v3iFjLcSAzO4fN5B8dvebvo/qsfumiLiDXMrPiHF9w=
+github.com/hudl/fargo v1.3.0/go.mod h1:y3CKSmjA+wD2gak7sUSXTAoopbhU08POFhmITJgmKTg=
+github.com/iancoleman/strcase v0.3.0 h1:nTXanmYxhfFAMjZL34Ov6gkzEsSJZ5DbhxWjvSASxEI=
+github.com/iancoleman/strcase v0.3.0/go.mod h1:iwCmte+B7n89clKwxIoIXy/HfoL7AsD47ZCWhYzw7ho=
+github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
+github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
+github.com/ignite/cli/v28 v28.11.0 h1:BXaSiSCOmNDuF8dTckGa3GjtPvGjKnaFl2cnGM1huvE=
+github.com/ignite/cli/v28 v28.11.0/go.mod h1:ZH0nGhg82iaeXr1hZ2QmnF9rUD35nwD3ILlIZe1zcXE=
+github.com/improbable-eng/grpc-web v0.15.0 h1:BN+7z6uNXZ1tQGcNAuaU1YjsLTApzkjt2tzCixLaUPQ=
+github.com/improbable-eng/grpc-web v0.15.0/go.mod h1:1sy9HKV4Jt9aEs9JSnkWlRJPuPtwNr0l57L4f878wP8=
+github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
+github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
+github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
+github.com/influxdata/influxdb1-client v0.0.0-20191209144304-8bf82d3c094d/go.mod h1:qj24IKcXYK6Iy9ceXlo3Tc+vtHo9lIhSX5JddghvEPo=
+github.com/jhump/protoreflect v1.17.0 h1:qOEr613fac2lOuTgWN4tPAtLL7fUSbuJL5X5XumQh94=
+github.com/jhump/protoreflect v1.17.0/go.mod h1:h9+vUUL38jiBzck8ck+6G/aeMX8Z4QUY/NiJPwPNi+8=
+github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k=
+github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9YPoQUg=
+github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo=
+github.com/jmespath/go-jmespath/internal/testify v1.5.1 h1:shLQSRRSCCPj3f2gpwzGwWFoC7ycTf1rcQZHOlsJ6N8=
+github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U=
+github.com/jmhodges/levigo v1.0.0 h1:q5EC36kV79HWeTBWsod3mG11EgStG3qArTKcvlksN1U=
+github.com/jmhodges/levigo v1.0.0/go.mod h1:Q6Qx+uH3RAqyK4rFQroq9RL7mdkABMcfhEI+nNuzMJQ=
+github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
+github.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX5e0EB2j4=
+github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
+github.com/json-iterator/go v1.1.7/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/json-iterator/go v1.1.8/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/json-iterator/go v1.1.11/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
+github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
+github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
+github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk=
+github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
+github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
+github.com/julienschmidt/httprouter v1.3.0/go.mod h1:JR6WtHb+2LUe8TCKY3cZOxFyyO8IZAc4RVcycCCAKdM=
+github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
+github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
+github.com/klauspost/compress v1.10.3/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
+github.com/klauspost/compress v1.11.7/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
+github.com/klauspost/compress v1.15.11/go.mod h1:QPwzmACJjUTFsnSHH934V6woptycfrDDJnH7hvFVbGM=
+github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
+github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
+github.com/klauspost/cpuid/v2 v2.3.0 h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzhA9Y=
+github.com/klauspost/cpuid/v2 v2.3.0/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
+github.com/knadh/koanf/maps v0.1.1 h1:G5TjmUh2D7G2YWf5SQQqSiHRJEjaicvU0KpypqB3NIs=
+github.com/knadh/koanf/maps v0.1.1/go.mod h1:npD/QZY3V6ghQDdcQzl1W4ICNVTkohC8E73eI2xW4yI=
+github.com/knadh/koanf/parsers/yaml v0.1.0 h1:ZZ8/iGfRLvKSaMEECEBPM1HQslrZADk8fP1XFUxVI5w=
+github.com/knadh/koanf/parsers/yaml v0.1.0/go.mod h1:cvbUDC7AL23pImuQP0oRw/hPuccrNBS2bps8asS0CwY=
+github.com/knadh/koanf/providers/env v1.0.0 h1:ufePaI9BnWH+ajuxGGiJ8pdTG0uLEUWC7/HDDPGLah0=
+github.com/knadh/koanf/providers/env v1.0.0/go.mod h1:mzFyRZueYhb37oPmC1HAv/oGEEuyvJDA98r3XAa8Gak=
+github.com/knadh/koanf/providers/file v0.1.0 h1:fs6U7nrV58d3CFAFh8VTde8TM262ObYf3ODrc//Lp+c=
+github.com/knadh/koanf/providers/file v0.1.0/go.mod h1:rjJ/nHQl64iYCtAW2QQnF0eSmDEX/YZ/eNFj5yR6BvA=
+github.com/knadh/koanf/providers/rawbytes v0.1.0 h1:dpzgu2KO6uf6oCb4aP05KDmKmAmI51k5pe8RYKQ0qME=
+github.com/knadh/koanf/providers/rawbytes v0.1.0/go.mod h1:mMTB1/IcJ/yE++A2iEZbY1MLygX7vttU+C+S/YmPu9c=
+github.com/knadh/koanf/providers/structs v0.1.0 h1:wJRteCNn1qvLtE5h8KQBvLJovidSdntfdyIbbCzEyE0=
+github.com/knadh/koanf/providers/structs v0.1.0/go.mod h1:sw2YZ3txUcqA3Z27gPlmmBzWn1h8Nt9O6EP/91MkcWE=
+github.com/knadh/koanf/v2 v2.1.1 h1:/R8eXqasSTsmDCsAyYj+81Wteg8AqrV9CP6gvsTsOmM=
+github.com/knadh/koanf/v2 v2.1.1/go.mod h1:4mnTRbZCK+ALuBXHZMjDfG9y714L7TykVnZkXbMU3Es=
+github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
+github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
+github.com/labstack/echo/v4 v4.10.0 h1:5CiyngihEO4HXsz3vVsJn7f8xAlWwRr3aY6Ih280ZKA=
+github.com/labstack/echo/v4 v4.10.0/go.mod h1:S/T/5fy/GigaXnHTkh0ZGe4LpkkQysvRjFMSUTkDRNQ=
+github.com/labstack/gommon v0.4.0 h1:y7cvthEAEbU0yHOf4axH8ZG2NH8knB9iNSoTO8dyIk8=
+github.com/labstack/gommon v0.4.0/go.mod h1:uW6kP17uPlLJsD3ijUYn3/M5bAxtlZhMI6m3MFxTMTM=
+github.com/leanovate/gopter v0.2.11 h1:vRjThO1EKPb/1NsDXuDrzldR28RLkBflWYcU9CvzWu4=
+github.com/leanovate/gopter v0.2.11/go.mod h1:aK3tzZP/C+p1m3SPRE4SYZFGP7jjkuSI4f7Xvpt0S9c=
+github.com/leodido/go-urn v1.2.0 h1:hpXL4XnriNwQ/ABnpepYM/1vCLWNDfUNts8dX3xTG6Y=
+github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII=
+github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw=
+github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
+github.com/lightstep/lightstep-tracer-common/golang/gogo v0.0.0-20190605223551-bc2310a04743/go.mod h1:qklhhLq1aX+mtWk9cPHPzaBjWImj5ULL6C7HFJtXQMM=
+github.com/lightstep/lightstep-tracer-go v0.18.1/go.mod h1:jlF1pusYV4pidLvZ+XD0UBX0ZE6WURAspgAczcDHrL4=
+github.com/linxGnu/grocksdb v1.8.14 h1:HTgyYalNwBSG/1qCQUIott44wU5b2Y9Kr3z7SK5OfGQ=
+github.com/linxGnu/grocksdb v1.8.14/go.mod h1:QYiYypR2d4v63Wj1adOOfzglnoII0gLj3PNh4fZkcFA=
+github.com/lyft/protoc-gen-validate v0.0.13/go.mod h1:XbGvPuh87YZc5TdIa2/I4pLk0QoUACkjt2znoq26NVQ=
+github.com/magiconair/properties v1.8.10 h1:s31yESBquKXCV9a/ScB3ESkOjUYYv+X0rg8SYxI99mE=
+github.com/magiconair/properties v1.8.10/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
+github.com/manifoldco/promptui v0.9.0 h1:3V4HzJk1TtXW1MTZMP7mdlwbBpIinw3HztaIlYthEiA=
+github.com/manifoldco/promptui v0.9.0/go.mod h1:ka04sppxSGFAtxX0qhlYQjISsg9mR4GWtQEhdbn6Pgg=
+github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
+github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
+github.com/mattn/go-colorable v0.1.11/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4=
+github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
+github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
+github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
+github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
+github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
+github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-runewidth v0.0.2/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
+github.com/mattn/go-runewidth v0.0.4/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
+github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
+github.com/mdp/qrterminal/v3 v3.2.1 h1:6+yQjiiOsSuXT5n9/m60E54vdgFsw0zhADHhHLrFet4=
+github.com/mdp/qrterminal/v3 v3.2.1/go.mod h1:jOTmXvnBsMy5xqLniO0R++Jmjs2sTm9dFSuQ5kpz/SU=
+github.com/miekg/dns v1.0.14/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg=
+github.com/minio/highwayhash v1.0.3 h1:kbnuUMoHYyVl7szWjSxJnxw11k2U709jqFPPmIUyD6Q=
+github.com/minio/highwayhash v1.0.3/go.mod h1:GGYsuwP/fPD6Y9hMiXuapVvlIUEhFhMTh0rxU3ik1LQ=
+github.com/mitchellh/cli v1.0.0/go.mod h1:hNIlj7HEI86fIcpObd7a0FcrxTWetlwJDGcceTlRvqc=
+github.com/mitchellh/copystructure v1.2.0 h1:vpKXTN4ewci03Vljg/q9QvCGUDttBOGBIa15WveJJGw=
+github.com/mitchellh/copystructure v1.2.0/go.mod h1:qLl+cE2AmVv+CoeAwDPye/v+N2HKCj9FbZEVFJRxO9s=
+github.com/mitchellh/go-homedir v1.0.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
+github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
+github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
+github.com/mitchellh/go-testing-interface v1.0.0/go.mod h1:kRemZodwjscx+RGhAo8eIhFbs2+BFgRtFPeD/KE+zxI=
+github.com/mitchellh/go-testing-interface v1.14.1 h1:jrgshOhYAUVNMAJiKbEu7EqAwgJJ2JqpQmpLJOu07cU=
+github.com/mitchellh/go-testing-interface v1.14.1/go.mod h1:gfgS7OtZj6MA4U1UrDRp04twqAjfvlZyCfX3sDjEym8=
+github.com/mitchellh/gox v0.4.0/go.mod h1:Sd9lOJ0+aimLBi73mGofS1ycjY8lL3uZM3JPS42BGNg=
+github.com/mitchellh/iochan v1.0.0/go.mod h1:JwYml1nuB7xOzsp52dPpHFffvOCDupsG0QubkSMEySY=
+github.com/mitchellh/mapstructure v0.0.0-20160808181253-ca63d7c062ee/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
+github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
+github.com/mitchellh/reflectwalk v1.0.2 h1:G2LzWKi524PWgd3mLHV8Y5k7s6XUvT0Gef6zxSIeXaQ=
+github.com/mitchellh/reflectwalk v1.0.2/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
+github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
+github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
+github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
+github.com/mtibben/percent v0.2.1 h1:5gssi8Nqo8QU/r2pynCm+hBQHpkB/uNK7BJCFogWdzs=
+github.com/mtibben/percent v0.2.1/go.mod h1:KG9uO+SZkUp+VkRHsCdYQV3XSZrrSpR3O9ibNBTZrns=
+github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA=
+github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
+github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
+github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f h1:KUppIJq7/+SVif2QVs3tOP0zanoHgBEVAwHxUSIzRqU=
+github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
+github.com/mwitkow/grpc-proxy v0.0.0-20181017164139-0f1106ef9c76/go.mod h1:x5OoJHDHqxHS801UIuhqGl6QdSAEJvtausosHSdazIo=
+github.com/nats-io/jwt v0.3.0/go.mod h1:fRYCDE99xlTsqUzISS1Bi75UBJ6ljOJQOAAu5VglpSg=
+github.com/nats-io/jwt v0.3.2/go.mod h1:/euKqTS1ZD+zzjYrY7pseZrTtWQSjujC7xjPc8wL6eU=
+github.com/nats-io/jwt/v2 v2.2.1-0.20220330180145-442af02fd36a h1:lem6QCvxR0Y28gth9P+wV2K/zYUUAkJ+55U8cpS0p5I=
+github.com/nats-io/jwt/v2 v2.2.1-0.20220330180145-442af02fd36a/go.mod h1:0tqz9Hlu6bCBFLWAASKhE5vUA4c24L9KPUUgvwumE/k=
+github.com/nats-io/nats-server/v2 v2.1.2/go.mod h1:Afk+wRZqkMQs/p45uXdrVLuab3gwv3Z8C4HTBu8GD/k=
+github.com/nats-io/nats-server/v2 v2.8.4 h1:0jQzze1T9mECg8YZEl8+WYUXb9JKluJfCBriPUtluB4=
+github.com/nats-io/nats-server/v2 v2.8.4/go.mod h1:8zZa+Al3WsESfmgSs98Fi06dRWLH5Bnq90m5bKD/eT4=
+github.com/nats-io/nats.go v1.9.1/go.mod h1:ZjDU1L/7fJ09jvUSRVBR2e7+RnLiiIQyqyzEE/Zbp4w=
+github.com/nats-io/nats.go v1.34.0 h1:fnxnPCNiwIG5w08rlMcEKTUw4AV/nKyGCOJE8TdhSPk=
+github.com/nats-io/nats.go v1.34.0/go.mod h1:Ubdu4Nh9exXdSz0RVWRFBbRfrbSxOYd26oF0wkWclB8=
+github.com/nats-io/nkeys v0.1.0/go.mod h1:xpnFELMwJABBLVhffcfd1MZx6VsNRFpEugbxziKVo7w=
+github.com/nats-io/nkeys v0.1.3/go.mod h1:xpnFELMwJABBLVhffcfd1MZx6VsNRFpEugbxziKVo7w=
+github.com/nats-io/nkeys v0.3.0/go.mod h1:gvUNGjVcM2IPr5rCsRsC6Wb3Hr2CQAm08dsxtV6A5y4=
+github.com/nats-io/nkeys v0.4.7 h1:RwNJbbIdYCoClSDNY7QVKZlyb/wfT6ugvFCiKy6vDvI=
+github.com/nats-io/nkeys v0.4.7/go.mod h1:kqXRgRDPlGy7nGaEDMuYzmiJCIAAWDK0IMBtDmGD0nc=
+github.com/nats-io/nuid v1.0.1 h1:5iA8DT8V7q8WK2EScv2padNa/rTESc1KdnPw4TC2paw=
+github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c=
+github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdhx/f4=
+github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
+github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
+github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
+github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU=
+github.com/nxadm/tail v1.4.11 h1:8feyoE3OzPrcshW5/MJ4sGESc5cqmGkGCWlco4l0bqY=
+github.com/nxadm/tail v1.4.11/go.mod h1:OTaG3NK980DZzxbRq6lEuzgU+mug70nY11sMd4JXXHc=
+github.com/oasisprotocol/curve25519-voi v0.0.0-20230904125328-1f23a7beb09a h1:dlRvE5fWabOchtH7znfiFCcOvmIYgOeAS5ifBXBlh9Q=
+github.com/oasisprotocol/curve25519-voi v0.0.0-20230904125328-1f23a7beb09a/go.mod h1:hVoHR2EVESiICEMbg137etN/Lx+lSrHPTD39Z/uE+2s=
+github.com/oklog/oklog v0.3.2/go.mod h1:FCV+B7mhrz4o+ueLpx+KqkyXRGMWOYEvfiXtdGtbWGs=
+github.com/oklog/run v1.0.0/go.mod h1:dlhp/R75TPv97u0XWUtDeV/lRKWPKSdTuV0TZvrmrQA=
+github.com/oklog/run v1.1.0 h1:GEenZ1cK0+q0+wsJew9qUg/DyD8k3JzYsZAi5gYi2mA=
+github.com/oklog/run v1.1.0/go.mod h1:sVPdnTZT1zYwAJeCMu2Th4T21pA3FPOQRfWjQlk7DVU=
+github.com/olekukonko/tablewriter v0.0.0-20170122224234-a0225b3f23b5/go.mod h1:vsDQFd/mU46D+Z4whnwzcISnGGzXWMclvtLoiIKAKIo=
+github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk=
+github.com/onsi/ginkgo v1.16.4/go.mod h1:dX+/inL/fNMqNlz0e9LfyB9TswhZpCVdJM/Z6Vvnwo0=
+github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE=
+github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042wbpU=
+github.com/onsi/ginkgo/v2 v2.1.3/go.mod h1:vw5CSIxN1JObi/U8gcbwft7ZxR2dgaR70JSE3/PpL4c=
+github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
+github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
+github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
+github.com/onsi/gomega v1.17.0/go.mod h1:HnhC7FXeEQY45zxNK3PPoIUhzk/80Xly9PcubAlGdZY=
+github.com/onsi/gomega v1.19.0/go.mod h1:LY+I3pBVzYsTBU1AnDwOSxaYi9WoWiqgwooUqq9yPro=
+github.com/onsi/gomega v1.26.0 h1:03cDLK28U6hWvCAns6NeydX3zIm4SF3ci69ulidS32Q=
+github.com/onsi/gomega v1.26.0/go.mod h1:r+zV744Re+DiYCIPRlYOTxn0YkOLcAnW8k1xXdMPGhM=
+github.com/op/go-logging v0.0.0-20160315200505-970db520ece7/go.mod h1:HzydrMdWErDVzsI23lYNej1Htcns9BCg93Dk0bBINWk=
+github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U=
+github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM=
+github.com/opencontainers/image-spec v1.1.0 h1:8SG7/vwALn54lVB/0yZ/MMwhFrPYtpEHQb2IpWsCzug=
+github.com/opencontainers/image-spec v1.1.0/go.mod h1:W4s4sFTMaBeK1BQLXbG4AdM2szdn85PY75RI83NrTrM=
+github.com/opencontainers/runc v1.1.12 h1:BOIssBaW1La0/qbNZHXOOa71dZfZEQOzW7dqQf3phss=
+github.com/opencontainers/runc v1.1.12/go.mod h1:S+lQwSfncpBha7XTy/5lBwWgm5+y5Ma/O44Ekby9FK8=
+github.com/opentracing-contrib/go-observer v0.0.0-20170622124052-a52f23424492/go.mod h1:Ngi6UdF0k5OKD5t5wlmGhe/EDKPoUM3BXZSSfIuJbis=
+github.com/opentracing/basictracer-go v1.0.0/go.mod h1:QfBfYuafItcjQuMwinw9GhYKwFXS9KnPs5lxoYwgW74=
+github.com/opentracing/opentracing-go v1.0.2/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o=
+github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o=
+github.com/openzipkin-contrib/zipkin-go-opentracing v0.4.5/go.mod h1:/wsWhb9smxSfWAKL3wpBW7V8scJMt8N8gnaMCS9E/cA=
+github.com/openzipkin/zipkin-go v0.1.6/go.mod h1:QgAqvLzwWbR/WpD4A3cGpPtJrZXNIiJc5AZX7/PBEpw=
+github.com/openzipkin/zipkin-go v0.2.1/go.mod h1:NaW6tEwdmWMaCDZzg8sh+IBNOxHMPnhQw8ySjnjRyN4=
+github.com/openzipkin/zipkin-go v0.2.2/go.mod h1:NaW6tEwdmWMaCDZzg8sh+IBNOxHMPnhQw8ySjnjRyN4=
+github.com/ory/dockertest v3.3.5+incompatible h1:iLLK6SQwIhcbrG783Dghaaa3WPzGc+4Emza6EbVUUGA=
+github.com/ory/dockertest v3.3.5+incompatible/go.mod h1:1vX4m9wsvi00u5bseYwXaSnhNrne+V0E6LAcBILJdPs=
+github.com/pact-foundation/pact-go v1.0.4/go.mod h1:uExwJY4kCzNPcHRj+hCR/HBbOOIwwtUjcrb0b5/5kLM=
+github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
+github.com/pascaldekloe/goe v0.1.0 h1:cBOtyMzM9HTpWjXfbbunk26uA6nG3a8n06Wieeh0MwY=
+github.com/pascaldekloe/goe v0.1.0/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
+github.com/pborman/uuid v1.2.0/go.mod h1:X/NO0urCmaxf9VXbdlT7C2Yzkj2IKimNn4k+gtPdI/k=
+github.com/pelletier/go-toml v1.9.5 h1:4yBQzkHv+7BHq2PQUZF3Mx0IYxG7LsP222s7Agd3ve8=
+github.com/pelletier/go-toml v1.9.5/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCkoOuaOx1Y+c=
+github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4=
+github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=
+github.com/performancecopilot/speed v3.0.0+incompatible/go.mod h1:/CLtqpZ5gBg1M9iaPbIdPPGyKcA8hKdoy6hAWba7Yac=
+github.com/petermattis/goid v0.0.0-20240813172612-4fcff4a6cae7 h1:Dx7Ovyv/SFnMFw3fD4oEoeorXc6saIiQ23LrGLth0Gw=
+github.com/petermattis/goid v0.0.0-20240813172612-4fcff4a6cae7/go.mod h1:pxMtw7cyUw6B2bRH0ZBANSPg+AoSud1I1iyJHI69jH4=
+github.com/pierrec/lz4 v1.0.2-0.20190131084431-473cd7ce01a1/go.mod h1:3/3N9NVKO0jef7pBehbT1qWhCMrIgbYNnFAZCqQ5LRc=
+github.com/pierrec/lz4 v2.0.5+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY=
+github.com/pingcap/errors v0.11.4 h1:lFuQV/oaUMGcD2tqt+01ROSmJs75VG1ToEOkZIZ4nE4=
+github.com/pingcap/errors v0.11.4/go.mod h1:Oi8TUi2kEtXXLMJk9l1cGmz20kV3TaQ0usTwv5KuLY8=
+github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
+github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/profile v1.2.1/go.mod h1:hJw3o1OdXxsrSjjVksARp5W95eeEaEfptyVZyv6JUPA=
+github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 h1:GFCKgmp0tecUJ0sJuv4pzYCqS9+RGSn52M3FUwPs+uo=
+github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10/go.mod h1:t/avpk3KcrXxUnYOhZhMXJlSEyie6gQbtLq5NM3loB8=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI=
+github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
+github.com/prometheus/client_golang v0.9.3-0.20190127221311-3c4408c8b829/go.mod h1:p2iRAGwDERtqlqzRXnrOVns+ignqQo//hLXqYxZYVNs=
+github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
+github.com/prometheus/client_golang v1.3.0/go.mod h1:hJaj2vgQTGQmVCsAACORcieXFeDPbaTKGT+JTgUa3og=
+github.com/prometheus/client_golang v1.4.0/go.mod h1:e9GMxYsXl05ICDXkRhurwBS4Q3OK1iX/F2sw+iXX5zU=
+github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M=
+github.com/prometheus/client_golang v1.11.1/go.mod h1:Z6t4BnS23TR94PD6BsDNk8yVqroYurpAkEiz0P2BEV0=
+github.com/prometheus/client_golang v1.22.0 h1:rb93p9lokFEsctTys46VnV1kLCDpVZ0a/Y92Vm0Zc6Q=
+github.com/prometheus/client_golang v1.22.0/go.mod h1:R7ljNsLXhuQXYZYtw6GAE9AZg8Y7vEW5scdCXrWRXC0=
+github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
+github.com/prometheus/client_model v0.0.0-20190115171406-56726106282f/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
+github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.1.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E=
+github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY=
+github.com/prometheus/common v0.2.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
+github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
+github.com/prometheus/common v0.7.0/go.mod h1:DjGbpBbp5NYNiECxcL/VnbXCCaQpKd3tt26CguLLsqA=
+github.com/prometheus/common v0.9.1/go.mod h1:yhUN8i9wzaXS3w1O07YhxHEBxD+W35wd8bs7vj7HSQ4=
+github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo=
+github.com/prometheus/common v0.15.0/go.mod h1:U+gB1OBLb1lF3O42bTCL+FK18tX9Oar16Clt/msog/s=
+github.com/prometheus/common v0.26.0/go.mod h1:M7rCNAaPfAosfx8veZJCuw84e35h3Cfd9VFqTh1DIvc=
+github.com/prometheus/common v0.63.0 h1:YR/EIY1o3mEFP/kZCD7iDMnLPlGyuU2Gb3HIcXnA98k=
+github.com/prometheus/common v0.63.0/go.mod h1:VVFF/fBIoToEnWRVkYoXEkq3R3paCoxG9PXP74SnV18=
+github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
+github.com/prometheus/procfs v0.0.0-20190117184657-bf6a532e95b1/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
+github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
+github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A=
+github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
+github.com/prometheus/procfs v0.3.0/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
+github.com/prometheus/procfs v0.6.0/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
+github.com/prometheus/procfs v0.15.1 h1:YagwOFzUgYfKKHX6Dr+sHT7km/hxC76UB0learggepc=
+github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk=
+github.com/rcrowley/go-metrics v0.0.0-20181016184325-3113b8401b8a/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4=
+github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475 h1:N/ElC8H3+5XpJzTSTfLsJV/mx9Q9g7kxmchpfZyxgzM=
+github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4=
+github.com/regen-network/protobuf v1.3.3-alpha.regen.1 h1:OHEc+q5iIAXpqiqFKeLpu5NwTIkVXUs48vFMwzqpqY4=
+github.com/regen-network/protobuf v1.3.3-alpha.regen.1/go.mod h1:2DjTFR1HhMQhiWC5sZ4OhQ3+NtdbZ6oBDKQwq5Ou+FI=
+github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
+github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
+github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg=
+github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
+github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
+github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
+github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
+github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
+github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU=
+github.com/rs/cors v1.11.1 h1:eU3gRzXLRK57F5rKMGMZURNdIG4EoAmX8k94r9wXWHA=
+github.com/rs/cors v1.11.1/go.mod h1:XyqrcTp5zjWr1wsJ8PIRZssZ8b/WMcMf71DJnit4EMU=
+github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0=
+github.com/rs/zerolog v1.34.0 h1:k43nTLIwcTVQAncfCw4KZ2VY6ukYoZaBPNOE8txlOeY=
+github.com/rs/zerolog v1.34.0/go.mod h1:bJsvje4Z08ROH4Nhs5iH600c3IkWhwp44iRc54W6wYQ=
+github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts=
+github.com/sagikazarmark/locafero v0.7.0 h1:5MqpDsTGNDhY8sGp0Aowyf0qKsPrhewaLSsFaodPcyo=
+github.com/sagikazarmark/locafero v0.7.0/go.mod h1:2za3Cg5rMaTMoG/2Ulr9AwtFaIppKXTRYnozin4aB5k=
+github.com/samuel/go-zookeeper v0.0.0-20190923202752-2cc03de413da/go.mod h1:gi+0XIa01GRL2eRQVjQkKGqKF3SF9vZR/HnPullcV2E=
+github.com/sasha-s/go-deadlock v0.3.5 h1:tNCOEEDG6tBqrNDOX35j/7hL5FcFViG6awUGROb2NsU=
+github.com/sasha-s/go-deadlock v0.3.5/go.mod h1:bugP6EGbdGYObIlx7pUZtWqlvo8k9H6vCBBsiChJQ5U=
+github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc=
+github.com/shamaton/msgpack/v2 v2.2.0 h1:IP1m01pHwCrMa6ZccP9B3bqxEMKMSmMVAVKk54g3L/Y=
+github.com/shamaton/msgpack/v2 v2.2.0/go.mod h1:6khjYnkx73f7VQU7wjcFS9DFjs+59naVWJv1TB7qdOI=
+github.com/shopspring/decimal v1.4.0 h1:bxl37RwXBklmTi0C79JfXCEBD1cqqHt0bbgBAGFp81k=
+github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+DMd9qYNcwME=
+github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
+github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
+github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
+github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88=
+github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
+github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
+github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
+github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
+github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
+github.com/soheilhy/cmux v0.1.4/go.mod h1:IM3LyeVVIOuxMH7sFAkER9+bJ4dT7Ms6E4xg4kGIyLM=
+github.com/sony/gobreaker v0.4.1/go.mod h1:ZKptC7FHNvhBz7dN2LGjPVBz2sZJmc0/PkyDJOjmxWY=
+github.com/sourcegraph/conc v0.3.0 h1:OQTbbt6P72L20UqAkXXuLOj79LfEanQ+YQFNpLA9ySo=
+github.com/sourcegraph/conc v0.3.0/go.mod h1:Sdozi7LEKbFPqYX2/J+iBAM6HpqSLTASQIKqDmF7Mt0=
+github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
+github.com/spf13/afero v1.12.0 h1:UcOPyRBYczmFn6yvphxkn9ZEOY65cpwGKb5mL36mrqs=
+github.com/spf13/afero v1.12.0/go.mod h1:ZTlWwG4/ahT8W7T0WQ5uYmjI9duaLQGy3Q2OAl4sk/4=
+github.com/spf13/cast v1.8.0 h1:gEN9K4b8Xws4EX0+a0reLmhq8moKn7ntRlQYgjPeCDk=
+github.com/spf13/cast v1.8.0/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cAdo=
+github.com/spf13/cobra v0.0.3/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ=
+github.com/spf13/cobra v1.9.1 h1:CXSaggrXdbHK9CF+8ywj8Amf7PBRmPCOJugH954Nnlo=
+github.com/spf13/cobra v1.9.1/go.mod h1:nDyEzZ8ogv936Cinf6g1RU9MRY64Ir93oCnqb9wxYW0=
+github.com/spf13/pflag v1.0.1/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
+github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/spf13/pflag v1.0.6 h1:jFzHGLGAlb3ruxLB8MhbI6A8+AQX/2eW4qeyNZXNp2o=
+github.com/spf13/pflag v1.0.6/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/spf13/viper v1.20.1 h1:ZMi+z/lvLyPSCoNtFCpqjy0S4kPbirhpTMwl8BkW9X4=
+github.com/spf13/viper v1.20.1/go.mod h1:P9Mdzt1zoHIG8m2eZQinpiBjo6kCmZSKBClNNqjJvu4=
+github.com/spiffe/go-spiffe/v2 v2.5.0 h1:N2I01KCUkv1FAjZXJMwh95KK1ZIQLYbPfhaxw8WS0hE=
+github.com/spiffe/go-spiffe/v2 v2.5.0/go.mod h1:P+NxobPc6wXhVtINNtFjNWGBTreew1GBUCwT2wPmb7g=
+github.com/streadway/amqp v0.0.0-20190404075320-75d898a42a94/go.mod h1:AZpEONHx3DKn8O/DFsRAY58/XVQiIPMTMB1SddzLXVw=
+github.com/streadway/amqp v0.0.0-20190827072141-edfb9018d271/go.mod h1:AZpEONHx3DKn8O/DFsRAY58/XVQiIPMTMB1SddzLXVw=
+github.com/streadway/handy v0.0.0-20190108123426-d5acb3125c2a/go.mod h1:qNTQ5P5JnDBl6z3cMAg/SywNDC5ABu5ApDIw6lUbRmI=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=
+github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
+github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.2/go.mod h1:R6va5+xMeoiuVRoj+gSkQ7d3FALtqAAGI1FQKckRals=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8=
+github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU=
+github.com/syndtr/goleveldb v1.0.1-0.20220721030215-126854af5e6d h1:vfofYNRScrDdvS342BElfbETmL1Aiz3i2t0zfRj16Hs=
+github.com/syndtr/goleveldb v1.0.1-0.20220721030215-126854af5e6d/go.mod h1:RRCYJbIwD5jmqPI9XoAFR0OcDxqUctll6zUj/+B4S48=
+github.com/tendermint/go-amino v0.16.0 h1:GyhmgQKvqF82e2oZeuMSp9JTN0N09emoSZlb2lyGa2E=
+github.com/tendermint/go-amino v0.16.0/go.mod h1:TQU0M1i/ImAo+tYpZi73AU3V/dKeCoMC9Sphe2ZwGME=
+github.com/tidwall/btree v1.7.0 h1:L1fkJH/AuEh5zBnnBbmTwQ5Lt+bRJ5A8EWecslvo9iI=
+github.com/tidwall/btree v1.7.0/go.mod h1:twD9XRA5jj9VUQGELzDO4HPQTNJsoWWfYEL+EUQ2cKY=
+github.com/tmc/grpc-websocket-proxy v0.0.0-20170815181823-89b8d40f7ca8/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
+github.com/tv42/httpunix v0.0.0-20150427012821-b75d8614f926/go.mod h1:9ESjWnEqriFuLhtthL60Sar/7RFoluCcXsuvEwTV5KM=
+github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
+github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
+github.com/ugorji/go v1.1.7 h1:/68gy2h+1mWMrwZFeD1kQialdSzAb432dtpeJ42ovdo=
+github.com/ugorji/go v1.1.7/go.mod h1:kZn38zHttfInRq0xu/PH0az30d+z6vm202qpg1oXVMw=
+github.com/ugorji/go/codec v1.1.7/go.mod h1:Ax+UKWsSmolVDwsd+7N3ZtXu+yMGCf907BLYF3GoBXY=
+github.com/ugorji/go/codec v1.2.11 h1:BMaWp1Bb6fHwEtbplGBGJ498wD+LKlNSl25MjdZY4dU=
+github.com/ugorji/go/codec v1.2.11/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
+github.com/ulikunitz/xz v0.5.10/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
+github.com/ulikunitz/xz v0.5.11 h1:kpFauv27b6ynzBNT/Xy+1k+fK4WswhN/6PN5WhFAGw8=
+github.com/ulikunitz/xz v0.5.11/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
+github.com/urfave/cli v1.20.0/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijbERA=
+github.com/urfave/cli v1.22.1/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0=
+github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
+github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
+github.com/valyala/fasttemplate v1.2.1/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ=
+github.com/valyala/fasttemplate v1.2.2 h1:lxLXG0uE3Qnshl9QyaK6XJxMXlQZELvChBOCmQD0Loo=
+github.com/valyala/fasttemplate v1.2.2/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ=
+github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=
+github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+github.com/zeebo/errs v1.4.0 h1:XNdoD/RRMKP7HD0UhJnIzUy74ISdGGxURlYG8HSWSfM=
+github.com/zeebo/errs v1.4.0/go.mod h1:sgbWHsvVuTPHcqJJGQ1WhI5KbWlHYz+2+2C/LSEtCw4=
+github.com/zondax/hid v0.9.2 h1:WCJFnEDMiqGF64nlZz28E9qLVZ0KSJ7xpc5DLEyma2U=
+github.com/zondax/hid v0.9.2/go.mod h1:l5wttcP0jwtdLjqjMMWFVEE7d1zO0jvSPA9OPZxWpEM=
+github.com/zondax/ledger-go v0.14.3 h1:wEpJt2CEcBJ428md/5MgSLsXLBos98sBOyxNmCjfUCw=
+github.com/zondax/ledger-go v0.14.3/go.mod h1:IKKaoxupuB43g4NxeQmbLXv7T9AlQyie1UpHb342ycI=
+go.etcd.io/bbolt v1.3.3/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU=
+go.etcd.io/bbolt v1.4.0-alpha.0.0.20240404170359-43604f3112c5 h1:qxen9oVGzDdIRP6ejyAJc760RwW4SnVDiTYTzwnXuxo=
+go.etcd.io/bbolt v1.4.0-alpha.0.0.20240404170359-43604f3112c5/go.mod h1:eW0HG9/oHQhvRCvb1/pIXW4cOvtDqeQK+XSi3TnwaXY=
+go.etcd.io/etcd v0.0.0-20191023171146-3cf2f69b5738/go.mod h1:dnLIgRNXwCJa5e+c6mIZCrds/GIG4ncV9HhK5PX7jPg=
+go.opencensus.io v0.20.1/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk=
+go.opencensus.io v0.20.2/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk=
+go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
+go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
+go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
+go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
+go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
+go.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk=
+go.opencensus.io v0.23.0/go.mod h1:XItmlyltB5F7CS4xOC1DcqMoFqwtC6OG2xF7mCv7P7E=
+go.opencensus.io v0.24.0 h1:y73uSU6J157QMP2kn2r30vwW1A2W2WFwSCGnAVxeaD0=
+go.opencensus.io v0.24.0/go.mod h1:vNK8G9p7aAivkbmorf4v+7Hgx+Zs0yY+0fOtgBfjQKo=
+go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
+go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
+go.opentelemetry.io/contrib/detectors/gcp v1.34.0 h1:JRxssobiPg23otYU5SbWtQC//snGVIM3Tx6QRzlQBao=
+go.opentelemetry.io/contrib/detectors/gcp v1.34.0/go.mod h1:cV4BMFcscUR/ckqLkbfQmF0PRsq8w/lMGzdbCSveBHo=
+go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.54.0 h1:r6I7RJCN86bpD/FQwedZ0vSixDpwuWREjW9oRMsmqDc=
+go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.54.0/go.mod h1:B9yO6b04uB80CzjedvewuqDhxJxi11s7/GtiGa8bAjI=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.54.0 h1:TT4fX+nBOA/+LUkobKGW1ydGcn+G3vRw9+g5HwCphpk=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.54.0/go.mod h1:L7UH0GbB0p47T4Rri3uHjbpCFYrVrwc1I25QhNPiGK8=
+go.opentelemetry.io/otel v1.34.0 h1:zRLXxLCgL1WyKsPVrgbSdMN4c0FMkDAskSTQP+0hdUY=
+go.opentelemetry.io/otel v1.34.0/go.mod h1:OWFPOQ+h4G8xpyjgqo4SxJYdDQ/qmRH+wivy7zzx9oI=
+go.opentelemetry.io/otel/exporters/stdout/stdoutmetric v1.29.0 h1:WDdP9acbMYjbKIyJUhTvtzj601sVJOqgWdUxSdR/Ysc=
+go.opentelemetry.io/otel/exporters/stdout/stdoutmetric v1.29.0/go.mod h1:BLbf7zbNIONBLPwvFnwNHGj4zge8uTCM/UPIVW1Mq2I=
+go.opentelemetry.io/otel/metric v1.34.0 h1:+eTR3U0MyfWjRDhmFMxe2SsW64QrZ84AOhvqS7Y+PoQ=
+go.opentelemetry.io/otel/metric v1.34.0/go.mod h1:CEDrp0fy2D0MvkXE+dPV7cMi8tWZwX3dmaIhwPOaqHE=
+go.opentelemetry.io/otel/sdk v1.34.0 h1:95zS4k/2GOy069d321O8jWgYsW3MzVV+KuSPKp7Wr1A=
+go.opentelemetry.io/otel/sdk v1.34.0/go.mod h1:0e/pNiaMAqaykJGKbi+tSjWfNNHMTxoC9qANsCzbyxU=
+go.opentelemetry.io/otel/sdk/metric v1.34.0 h1:5CeK9ujjbFVL5c1PhLuStg1wxA7vQv7ce1EK0Gyvahk=
+go.opentelemetry.io/otel/sdk/metric v1.34.0/go.mod h1:jQ/r8Ze28zRKoNRdkjCZxfs6YvBTG1+YIqyFVFYec5w=
+go.opentelemetry.io/otel/trace v1.34.0 h1:+ouXS2V8Rd4hp4580a8q23bg0azF2nI8cqLYnC8mh/k=
+go.opentelemetry.io/otel/trace v1.34.0/go.mod h1:Svm7lSjQD7kG7KJ/MUHPVXSDGz2OX4h0M2jHBhmSfRE=
+go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI=
+go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
+go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
+go.uber.org/atomic v1.5.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ=
+go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
+go.uber.org/goleak v1.1.10/go.mod h1:8a7PlsEVH3e/a/GLqe5IIrQx6GzcnRmZEufDUTk4A7A=
+go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
+go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
+go.uber.org/mock v0.5.2 h1:LbtPTcP8A5k9WPXj54PPPbjcI4Y6lhyOZXn+VS7wNko=
+go.uber.org/mock v0.5.2/go.mod h1:wLlUxC2vVTPTaE3UD51E0BGOAElKrILxhVSDYQLld5o=
+go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
+go.uber.org/multierr v1.3.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4=
+go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU=
+go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
+go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
+go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9Ejo0C68/HhF8uaILCdgjnY+goOA=
+go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
+go.uber.org/zap v1.13.0/go.mod h1:zwrFLgMcdUuIBviXEYEH1YKNaOBnKXsx2IPda5bBwHM=
+go.uber.org/zap v1.18.1/go.mod h1:xg/QME4nWcxGxrpdeYfq7UvYrLh66cuVKdrbD1XF/NI=
+golang.org/x/arch v0.20.0 h1:dx1zTU0MAE98U+TQ8BLl7XsJbgze2WnNKF/8tGp/Q6c=
+golang.org/x/arch v0.20.0/go.mod h1:bdwinDaKcfZUGpH09BB7ZmOfhalA8lQdzl62l8gGWsk=
+golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20181029021203-45a5f77698d3/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20200728195943-123391ffb6de/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20210314154223-e6e6c4f2bb5b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/crypto v0.38.0 h1:jt+WWG8IZlBnVbomuhg2Mdq0+BBQaHbtqHEFEigjUV8=
+golang.org/x/crypto v0.38.0/go.mod h1:MvrbAqul58NNYPKnOra203SB9vpuZW0e+RRZV+Ggqjw=
+golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
+golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek=
+golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY=
+golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
+golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
+golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
+golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM=
+golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU=
+golang.org/x/exp v0.0.0-20200331195152-e8c3332aa8e5/go.mod h1:4M0jN8W1tt0AVLNr8HDosyJCDCDuyL9N9+3m7wDWgKw=
+golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b h1:M2rDM6z3Fhozi9O7NWsxAkg/yqS/lQJ6PmkyIV3YP+o=
+golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b/go.mod h1:3//PLf8L/X+8b4vuAfHzxeRUl04Adcb341+IGKfnqS8=
+golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
+golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
+golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
+golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs=
+golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
+golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
+golang.org/x/lint v0.0.0-20201208152925-83fdc39ff7b5/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
+golang.org/x/lint v0.0.0-20210508222113-6edffad5e616/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
+golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE=
+golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o=
+golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=
+golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY=
+golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
+golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
+golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
+golang.org/x/mod v0.25.0 h1:n7a+ZbQKQA/Ysbyb0/6IbB1H/X41mKgbhfv7AfG/44w=
+golang.org/x/mod v0.25.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww=
+golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181023162649-9b4f9f5ad519/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181201002055-351d144fa1fc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190125091013-d26f9f9a57f3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
+golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190813141303-74dc4d7220e7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200421231249-e086a090c8fd/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
+golang.org/x/net v0.0.0-20201031054903-ff519b6c9102/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
+golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
+golang.org/x/net v0.0.0-20201209123823-ac852fbbde11/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4/go.mod h1:RBQZq4jEuRlivfhVLdyRGr576XBO4/greRjx4P4O3yc=
+golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
+golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk=
+golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.0.0-20210805182204-aaa1db679c0d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
+golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
+golang.org/x/net v0.0.0-20220325170049-de3da57026de/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
+golang.org/x/net v0.0.0-20220412020605-290c469a71a5/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
+golang.org/x/net v0.0.0-20220425223048-2871e0cb64e4/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
+golang.org/x/net v0.0.0-20220607020251-c690dde0001d/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.0.0-20220617184016-355a448f1bc9/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.0.0-20220624214902-1bab6f366d9e/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.0.0-20220909164309-bea034e7d591/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk=
+golang.org/x/net v0.0.0-20221014081412-f15817d10f9b/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk=
+golang.org/x/net v0.1.0/go.mod h1:Cx3nUiGt4eDBEyega/BKRp+/AlGL8hYe7U9odMt2Cco=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
+golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
+golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20200902213428-5d25da1a8d43/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
+golang.org/x/oauth2 v0.0.0-20201109201403-9fd604954f58/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
+golang.org/x/oauth2 v0.0.0-20201208152858-08078c50e5b5/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
+golang.org/x/oauth2 v0.0.0-20210218202405-ba52d332ba99/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
+golang.org/x/oauth2 v0.0.0-20210220000619-9bb904979d93/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
+golang.org/x/oauth2 v0.0.0-20210313182246-cd4f82c27b84/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
+golang.org/x/oauth2 v0.0.0-20210514164344-f6687ab2804c/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
+golang.org/x/oauth2 v0.0.0-20210628180205-a41e5a781914/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
+golang.org/x/oauth2 v0.0.0-20210805134026-6f1e6394065a/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
+golang.org/x/oauth2 v0.0.0-20210819190943-2bc19b11175f/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
+golang.org/x/oauth2 v0.0.0-20211104180415-d3ed0bb246c8/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
+golang.org/x/oauth2 v0.0.0-20220223155221-ee480838109b/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc=
+golang.org/x/oauth2 v0.0.0-20220309155454-6242fa91716a/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc=
+golang.org/x/oauth2 v0.0.0-20220411215720-9780585627b5/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc=
+golang.org/x/oauth2 v0.0.0-20220608161450-d0670ef3b1eb/go.mod h1:jaDAt6Dkxork7LmZnYtzbRWj0W47D86a3TGe0YHBvmE=
+golang.org/x/oauth2 v0.0.0-20220622183110-fd043fe589d2/go.mod h1:jaDAt6Dkxork7LmZnYtzbRWj0W47D86a3TGe0YHBvmE=
+golang.org/x/oauth2 v0.0.0-20220822191816-0ebed06d0094/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg=
+golang.org/x/oauth2 v0.0.0-20220909003341-f21342109be1/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg=
+golang.org/x/oauth2 v0.0.0-20221014153046-6fdb5e3db783/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg=
+golang.org/x/oauth2 v0.1.0/go.mod h1:G9FE4dLTsbXUu90h/Pf85g4w1D+SSAgR+q46nJZ8M4A=
+golang.org/x/oauth2 v0.26.0 h1:afQXWNNaeC4nvZ0Ed9XvCCzXM6UHJG7iCg0W4fPqSBE=
+golang.org/x/oauth2 v0.26.0/go.mod h1:XYTD2NtWslqkgxebSiOHnXEap4TF09sJSc7H1sXbhtI=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20220601150217-0de741cfad7f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20220929204114-8fcdb60fdcc0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.15.0 h1:KWH3jNZsfyT6xfAfKiz6MRNmd46ByHDYaZ7KSkCtdW8=
+golang.org/x/sync v0.15.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181026203630-95b1ffbd15a5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181122145206-62eef0e2fa9b/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190826190057-c7b8b68b1456/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191220142924-d4481acd189f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200420163511-1957bb5e6d1f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200501052902-10377860bb8e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200905004654-be1d3432aa8f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201201145000-ef89a241ccb3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210104204734-6f8348627aad/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210220050731-9a76102bfb43/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210305230114-8fe3ee5dd75b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210315160823-c6e025ad8005/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210514084401-e8d321eab015/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210603125802-9665404d3644/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210806184541-e5e7981a1069/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210823070655-63515b42dcdf/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210908233432-aa78b53d3365/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20211025201205-69cdffdb9359/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20211103235746-7861aae1554b/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20211124211545-fe61309f8881/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20211210111614-af8b64212486/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220128215802-99c3d69c2c27/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220209214540-3681064d5158/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220227234510-4e6760a101f9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220310020820-b874c991c1a5/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220315194320-039c03cc5b86/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220328115105-d36c6a25d886/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220412211240-33da011f77ad/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220502124256-b6088ccd6cba/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220503163025-988cb79eb6c6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220610221304-9f5ed59c137d/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220615213510-4f61da869c0c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220624220833-87e55d714810/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20221010170243-090e33056c14/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
+golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.1.0/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.32.0 h1:DR4lr0TjUs3epypdhTOkMmuF5CDFJ/8pOnbzMZPQ7bg=
+golang.org/x/term v0.32.0/go.mod h1:uZG1FhGx848Sqfsq4/DlJr3xGGsYMu/L5GW4abiaEPQ=
+golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
+golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.9.0 h1:EsRrnYcQiGH+5FfbgvV4AP7qEZstoyrHB0DzarOQ4ZY=
+golang.org/x/time v0.9.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
+golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
+golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191108193012-7d206e10da11/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200103221440-774c71fcf114/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200117161641-43d50277825c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200122220014-bf1340f18c4a/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200204074204-1cc6d1ef6c74/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200212150539-ea181f53ac56/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200224181240-023911ca70b2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200227222343-706bc42d1f0d/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=
+golang.org/x/tools v0.0.0-20200312045724-11d5b4c81c7d/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=
+golang.org/x/tools v0.0.0-20200331025713-a30bf2db82d4/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8=
+golang.org/x/tools v0.0.0-20200501065659-ab2804fb9c9d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200512131952-2bc93b1c0c88/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200515010526-7d3b6ebf133d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200618134242-20370b0cb4b2/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200729194436-6467de6f59a7/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
+golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
+golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
+golang.org/x/tools v0.0.0-20200904185747-39188db58858/go.mod h1:Cj7w3i3Rnn0Xh82ur9kSqwfTHTeVxaDqrfMjpcNT6bE=
+golang.org/x/tools v0.0.0-20201110124207-079ba7bd75cd/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/tools v0.0.0-20201201161351-ac6f37ff4c2a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/tools v0.0.0-20201208233053-a543418bbed2/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/tools v0.0.0-20201224043029-2b0845dc783e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/tools v0.0.0-20210105154028-b0ab187a4818/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0=
+golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
+golang.org/x/tools v0.1.2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
+golang.org/x/tools v0.1.3/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
+golang.org/x/tools v0.1.4/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
+golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/tools v0.34.0 h1:qIpSLOxeCYGg9TrcJokLBG4KFA6d795g0xkBkiESGlo=
+golang.org/x/tools v0.34.0/go.mod h1:pAP9OwEaY1CAW3HOmg3hLZC5Z0CCmzjAF2UQMSqNARg=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20220411194840-2f41105eb62f/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20220517211312-f3a8303e98df/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8=
+golang.org/x/xerrors v0.0.0-20220609144429-65e65417b02f/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8=
+golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8=
+google.golang.org/api v0.3.1/go.mod h1:6wY9I6uQWHQ8EM57III9mq/AjF+i8G65rmVagqKMtkk=
+google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
+google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M=
+google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
+google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
+google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
+google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
+google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
+google.golang.org/api v0.17.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.18.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.19.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.20.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.22.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.24.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE=
+google.golang.org/api v0.28.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE=
+google.golang.org/api v0.29.0/go.mod h1:Lcubydp8VUV7KeIHD9z2Bys/sm/vGKnG1UHuDBSrHWM=
+google.golang.org/api v0.30.0/go.mod h1:QGmEvQ87FHZNiUVJkT14jQNYJ4ZJjdRF23ZXz5138Fc=
+google.golang.org/api v0.35.0/go.mod h1:/XrVsuzM0rZmrsbjJutiuftIzeuTQcEeaYcSk/mQ1dg=
+google.golang.org/api v0.36.0/go.mod h1:+z5ficQTmoYpPn8LCUNVpK5I7hwkpjbcgqA7I34qYtE=
+google.golang.org/api v0.40.0/go.mod h1:fYKFpnQN0DsDSKRVRcQSDQNtqWPfM9i+zNPxepjRCQ8=
+google.golang.org/api v0.41.0/go.mod h1:RkxM5lITDfTzmyKFPt+wGrCJbVfniCr2ool8kTBzRTU=
+google.golang.org/api v0.43.0/go.mod h1:nQsDGjRXMo4lvh5hP0TKqF244gqhGcr/YSIykhUk/94=
+google.golang.org/api v0.47.0/go.mod h1:Wbvgpq1HddcWVtzsVLyfLp8lDg6AA241LmgIL59tHXo=
+google.golang.org/api v0.48.0/go.mod h1:71Pr1vy+TAZRPkPs/xlCf5SsU8WjuAWv1Pfjbtukyy4=
+google.golang.org/api v0.50.0/go.mod h1:4bNT5pAuq5ji4SRZm+5QIkjny9JAyVD/3gaSihNefaw=
+google.golang.org/api v0.51.0/go.mod h1:t4HdrdoNgyN5cbEfm7Lum0lcLDLiise1F8qDKX00sOU=
+google.golang.org/api v0.54.0/go.mod h1:7C4bFFOvVDGXjfDTAsgGwDgAxRDeQ4X8NvUedIt6z3k=
+google.golang.org/api v0.55.0/go.mod h1:38yMfeP1kfjsl8isn0tliTjIb1rJXcQi4UXlbqivdVE=
+google.golang.org/api v0.56.0/go.mod h1:38yMfeP1kfjsl8isn0tliTjIb1rJXcQi4UXlbqivdVE=
+google.golang.org/api v0.57.0/go.mod h1:dVPlbZyBo2/OjBpmvNdpn2GRm6rPy75jyU7bmhdrMgI=
+google.golang.org/api v0.61.0/go.mod h1:xQRti5UdCmoCEqFxcz93fTl338AVqDgyaDRuOZ3hg9I=
+google.golang.org/api v0.63.0/go.mod h1:gs4ij2ffTRXwuzzgJl/56BdwJaA194ijkfn++9tDuPo=
+google.golang.org/api v0.67.0/go.mod h1:ShHKP8E60yPsKNw/w8w+VYaj9H6buA5UqDp8dhbQZ6g=
+google.golang.org/api v0.70.0/go.mod h1:Bs4ZM2HGifEvXwd50TtW70ovgJffJYw2oRCOFU/SkfA=
+google.golang.org/api v0.71.0/go.mod h1:4PyU6e6JogV1f9eA4voyrTY2batOLdgZ5qZ5HOCc4j8=
+google.golang.org/api v0.74.0/go.mod h1:ZpfMZOVRMywNyvJFeqL9HRWBgAuRfSjJFpe9QtRRyDs=
+google.golang.org/api v0.75.0/go.mod h1:pU9QmyHLnzlpar1Mjt4IbapUCy8J+6HD6GeELN69ljA=
+google.golang.org/api v0.77.0/go.mod h1:pU9QmyHLnzlpar1Mjt4IbapUCy8J+6HD6GeELN69ljA=
+google.golang.org/api v0.78.0/go.mod h1:1Sg78yoMLOhlQTeF+ARBoytAcH1NNyyl390YMy6rKmw=
+google.golang.org/api v0.80.0/go.mod h1:xY3nI94gbvBrE0J6NHXhxOmW97HG7Khjkku6AFB3Hyg=
+google.golang.org/api v0.84.0/go.mod h1:NTsGnUFJMYROtiquksZHBWtHfeMC7iYthki7Eq3pa8o=
+google.golang.org/api v0.85.0/go.mod h1:AqZf8Ep9uZ2pyTvgL+x0D3Zt0eoT9b5E8fmzfu6FO2g=
+google.golang.org/api v0.90.0/go.mod h1:+Sem1dnrKlrXMR/X0bPnMWyluQe4RsNoYfmNLhOIkzw=
+google.golang.org/api v0.93.0/go.mod h1:+Sem1dnrKlrXMR/X0bPnMWyluQe4RsNoYfmNLhOIkzw=
+google.golang.org/api v0.95.0/go.mod h1:eADj+UBuxkh5zlrSntJghuNeg8HwQ1w5lTKkuqaETEI=
+google.golang.org/api v0.96.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ13s=
+google.golang.org/api v0.97.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ13s=
+google.golang.org/api v0.98.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ13s=
+google.golang.org/api v0.100.0/go.mod h1:ZE3Z2+ZOr87Rx7dqFsdRQkRBk36kDtp/h+QpHbB7a70=
+google.golang.org/api v0.215.0 h1:jdYF4qnyczlEz2ReWIsosNLDuzXyvFHJtI5gcr0J7t0=
+google.golang.org/api v0.215.0/go.mod h1:fta3CVtuJYOEdugLNWm6WodzOS8KdFckABwN4I40hzY=
+google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
+google.golang.org/appengine v1.2.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0=
+google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
+google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
+google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
+google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/genproto v0.0.0-20180831171423-11092d34479b/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190530194941-fb225487d101/go.mod h1:z3L6/3dTEVtUr6QSP8miRzeRqwQOioJ9I66odjN4I7s=
+google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
+google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
+google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8=
+google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20200115191322-ca5a22157cba/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA=
+google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200224152610-e50cd9704f63/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200228133532-8c2c7df3a383/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200305110556-506484158171/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200312145019-da6875a35672/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200324203455-a04cca1dde73/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200331122359-1ee6d9798940/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200423170343-7949de9c1215/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200430143042-b979b6f78d84/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200511104702-f5ebc3bea380/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200513103714-09dca8ec2884/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200515170657-fc4c6c6a6587/go.mod h1:YsZOwe1myG/8QRHRsmBRE1LrgQY60beZKjly0O1fX9U=
+google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
+google.golang.org/genproto v0.0.0-20200618031413-b414f8b61790/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA=
+google.golang.org/genproto v0.0.0-20200729003335-053ba62fc06f/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20200804131852-c06518451d9c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20200825200019-8632dd797987/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20200904004341-0bd0a958aa1d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20201109203340-2640f1f9cdfb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20201201144952-b05cb90ed32e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20201210142538-e3217bee35cc/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20201214200347-8c77b98c765d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20210126160654-44e461bb6506/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20210222152913-aa3ee6e6a81c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20210303154014-9728d6b83eeb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20210310155132-4ce2db91004e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20210319143718-93e7006c17a6/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20210329143202-679c6ae281ee/go.mod h1:9lPAdzaEmUacj36I+k7YKbEc5CXzPIeORRgDAUOu28A=
+google.golang.org/genproto v0.0.0-20210402141018-6c239bbf2bb1/go.mod h1:9lPAdzaEmUacj36I+k7YKbEc5CXzPIeORRgDAUOu28A=
+google.golang.org/genproto v0.0.0-20210513213006-bf773b8c8384/go.mod h1:P3QM42oQyzQSnHPnZ/vqoCdDmzH28fzWByN9asMeM8A=
+google.golang.org/genproto v0.0.0-20210602131652-f16073e35f0c/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0=
+google.golang.org/genproto v0.0.0-20210604141403-392c879c8b08/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0=
+google.golang.org/genproto v0.0.0-20210608205507-b6d2f5bf0d7d/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0=
+google.golang.org/genproto v0.0.0-20210624195500-8bfb893ecb84/go.mod h1:SzzZ/N+nwJDaO1kznhnlzqS8ocJICar6hYhVyhi++24=
+google.golang.org/genproto v0.0.0-20210713002101-d411969a0d9a/go.mod h1:AxrInvYm1dci+enl5hChSFPOmmUF1+uAa/UsgNRWd7k=
+google.golang.org/genproto v0.0.0-20210716133855-ce7ef5c701ea/go.mod h1:AxrInvYm1dci+enl5hChSFPOmmUF1+uAa/UsgNRWd7k=
+google.golang.org/genproto v0.0.0-20210728212813-7823e685a01f/go.mod h1:ob2IJxKrgPT52GcgX759i1sleT07tiKowYBGbczaW48=
+google.golang.org/genproto v0.0.0-20210805201207-89edb61ffb67/go.mod h1:ob2IJxKrgPT52GcgX759i1sleT07tiKowYBGbczaW48=
+google.golang.org/genproto v0.0.0-20210813162853-db860fec028c/go.mod h1:cFeNkxwySK631ADgubI+/XFU/xp8FD5KIVV4rj8UC5w=
+google.golang.org/genproto v0.0.0-20210821163610-241b8fcbd6c8/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY=
+google.golang.org/genproto v0.0.0-20210828152312-66f60bf46e71/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY=
+google.golang.org/genproto v0.0.0-20210831024726-fe130286e0e2/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY=
+google.golang.org/genproto v0.0.0-20210903162649-d08c68adba83/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY=
+google.golang.org/genproto v0.0.0-20210909211513-a8c4777a87af/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY=
+google.golang.org/genproto v0.0.0-20210924002016-3dee208752a0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
+google.golang.org/genproto v0.0.0-20211118181313-81c1377c94b1/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
+google.golang.org/genproto v0.0.0-20211206160659-862468c7d6e0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
+google.golang.org/genproto v0.0.0-20211208223120-3a66f561d7aa/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
+google.golang.org/genproto v0.0.0-20211221195035-429b39de9b1c/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
+google.golang.org/genproto v0.0.0-20220126215142-9970aeb2e350/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
+google.golang.org/genproto v0.0.0-20220207164111-0872dc986b00/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
+google.golang.org/genproto v0.0.0-20220218161850-94dd64e39d7c/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI=
+google.golang.org/genproto v0.0.0-20220222213610-43724f9ea8cf/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI=
+google.golang.org/genproto v0.0.0-20220304144024-325a89244dc8/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI=
+google.golang.org/genproto v0.0.0-20220310185008-1973136f34c6/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI=
+google.golang.org/genproto v0.0.0-20220314164441-57ef72a4c106/go.mod h1:hAL49I2IFola2sVEjAn7MEwsja0xp51I0tlGAf9hz4E=
+google.golang.org/genproto v0.0.0-20220324131243-acbaeb5b85eb/go.mod h1:hAL49I2IFola2sVEjAn7MEwsja0xp51I0tlGAf9hz4E=
+google.golang.org/genproto v0.0.0-20220407144326-9054f6ed7bac/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo=
+google.golang.org/genproto v0.0.0-20220413183235-5e96e2839df9/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo=
+google.golang.org/genproto v0.0.0-20220414192740-2d67ff6cf2b4/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo=
+google.golang.org/genproto v0.0.0-20220421151946-72621c1f0bd3/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo=
+google.golang.org/genproto v0.0.0-20220429170224-98d788798c3e/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo=
+google.golang.org/genproto v0.0.0-20220502173005-c8bf987b8c21/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4=
+google.golang.org/genproto v0.0.0-20220505152158-f39f71e6c8f3/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4=
+google.golang.org/genproto v0.0.0-20220518221133-4f43b3371335/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4=
+google.golang.org/genproto v0.0.0-20220523171625-347a074981d8/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4=
+google.golang.org/genproto v0.0.0-20220608133413-ed9918b62aac/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA=
+google.golang.org/genproto v0.0.0-20220616135557-88e70c0c3a90/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA=
+google.golang.org/genproto v0.0.0-20220617124728-180714bec0ad/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA=
+google.golang.org/genproto v0.0.0-20220624142145-8cd45d7dbd1f/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA=
+google.golang.org/genproto v0.0.0-20220628213854-d9e0b6570c03/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA=
+google.golang.org/genproto v0.0.0-20220722212130-b98a9ff5e252/go.mod h1:GkXuJDJ6aQ7lnJcRF+SJVgFdQhypqgl3LB1C9vabdRE=
+google.golang.org/genproto v0.0.0-20220801145646-83ce21fca29f/go.mod h1:iHe1svFLAZg9VWz891+QbRMwUv9O/1Ww+/mngYeThbc=
+google.golang.org/genproto v0.0.0-20220815135757-37a418bb8959/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk=
+google.golang.org/genproto v0.0.0-20220817144833-d7fd3f11b9b1/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk=
+google.golang.org/genproto v0.0.0-20220822174746-9e6da59bd2fc/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk=
+google.golang.org/genproto v0.0.0-20220829144015-23454907ede3/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk=
+google.golang.org/genproto v0.0.0-20220829175752-36a9c930ecbf/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk=
+google.golang.org/genproto v0.0.0-20220913154956-18f8339a66a5/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo=
+google.golang.org/genproto v0.0.0-20220914142337-ca0e39ece12f/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo=
+google.golang.org/genproto v0.0.0-20220915135415-7fd63a7952de/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo=
+google.golang.org/genproto v0.0.0-20220916172020-2692e8806bfa/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo=
+google.golang.org/genproto v0.0.0-20220919141832-68c03719ef51/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo=
+google.golang.org/genproto v0.0.0-20220920201722-2b89144ce006/go.mod h1:ht8XFiar2npT/g4vkk7O0WYS1sHOHbdujxbEp7CJWbw=
+google.golang.org/genproto v0.0.0-20220926165614-551eb538f295/go.mod h1:woMGP53BroOrRY3xTxlbr8Y3eB/nzAvvFM83q7kG2OI=
+google.golang.org/genproto v0.0.0-20220926220553-6981cbe3cfce/go.mod h1:woMGP53BroOrRY3xTxlbr8Y3eB/nzAvvFM83q7kG2OI=
+google.golang.org/genproto v0.0.0-20221010155953-15ba04fc1c0e/go.mod h1:3526vdqwhZAwq4wsRUaVG555sVgsNmIjRtO7t/JH29U=
+google.golang.org/genproto v0.0.0-20221014173430-6e2ab493f96b/go.mod h1:1vXfmgAz9N9Jx0QA82PqRVauvCz1SGSz739p0f183jM=
+google.golang.org/genproto v0.0.0-20221014213838-99cd37c6964a/go.mod h1:1vXfmgAz9N9Jx0QA82PqRVauvCz1SGSz739p0f183jM=
+google.golang.org/genproto v0.0.0-20221025140454-527a21cfbd71/go.mod h1:9qHF0xnpdSfF6knlcsnpzUu5y+rpwgbvsyGAZPBMg4s=
+google.golang.org/genproto v0.0.0-20241118233622-e639e219e697 h1:ToEetK57OidYuqD4Q5w+vfEnPvPpuTwedCNVohYJfNk=
+google.golang.org/genproto v0.0.0-20241118233622-e639e219e697/go.mod h1:JJrvXBWRZaFMxBufik1a4RpFw4HhgVtBBWQeQgUj2cc=
+google.golang.org/genproto/googleapis/api v0.0.0-20250528174236-200df99c418a h1:SGktgSolFCo75dnHJF2yMvnns6jCmHFJ0vE4Vn2JKvQ=
+google.golang.org/genproto/googleapis/api v0.0.0-20250528174236-200df99c418a/go.mod h1:a77HrdMjoeKbnd2jmgcWdaS++ZLZAEq3orIOAEIKiVw=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20250528174236-200df99c418a h1:v2PbRU4K3llS09c7zodFpNePeamkAwG3mPrAery9VeE=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20250528174236-200df99c418a/go.mod h1:qQ0YXyHHx3XkvlzUtpXDkS29lDSafHMZBAZDc03LQ3A=
+google.golang.org/grpc v1.17.0/go.mod h1:6QZJwpn2B+Zp71q/5VxRsJ6NXXVCE5NRUHRo+f3cWCs=
+google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
+google.golang.org/grpc v1.20.0/go.mod h1:chYK+tFQF0nDUGJgXMSgLCQk3phJEuONr2DCgLDdAQM=
+google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
+google.golang.org/grpc v1.21.0/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
+google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
+google.golang.org/grpc v1.22.1/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
+google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
+google.golang.org/grpc v1.23.1/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
+google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
+google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60=
+google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk=
+google.golang.org/grpc v1.30.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
+google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
+google.golang.org/grpc v1.31.1/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
+google.golang.org/grpc v1.32.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
+google.golang.org/grpc v1.33.1/go.mod h1:fr5YgcSWrqhRRxogOsw7RzIpsmvOZ6IcH4kBYTpR3n0=
+google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc=
+google.golang.org/grpc v1.34.0/go.mod h1:WotjhfgOW/POjDeRt8vscBtXq+2VjORFy659qA51WJ8=
+google.golang.org/grpc v1.35.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU=
+google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU=
+google.golang.org/grpc v1.36.1/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU=
+google.golang.org/grpc v1.37.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM=
+google.golang.org/grpc v1.37.1/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM=
+google.golang.org/grpc v1.38.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM=
+google.golang.org/grpc v1.39.0/go.mod h1:PImNr+rS9TWYb2O4/emRugxiyHZ5JyHW5F+RPnDzfrE=
+google.golang.org/grpc v1.39.1/go.mod h1:PImNr+rS9TWYb2O4/emRugxiyHZ5JyHW5F+RPnDzfrE=
+google.golang.org/grpc v1.40.0/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34=
+google.golang.org/grpc v1.40.1/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34=
+google.golang.org/grpc v1.44.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU=
+google.golang.org/grpc v1.45.0/go.mod h1:lN7owxKUQEqMfSyQikvvk5tf/6zMPsrK+ONuO11+0rQ=
+google.golang.org/grpc v1.46.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk=
+google.golang.org/grpc v1.46.2/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk=
+google.golang.org/grpc v1.47.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk=
+google.golang.org/grpc v1.48.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk=
+google.golang.org/grpc v1.49.0/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI=
+google.golang.org/grpc v1.50.0/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI=
+google.golang.org/grpc v1.50.1/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI=
+google.golang.org/grpc v1.72.2 h1:TdbGzwb82ty4OusHWepvFWGLgIbNo1/SUynEN0ssqv8=
+google.golang.org/grpc v1.72.2/go.mod h1:wH5Aktxcg25y1I3w7H69nHfXdOG3UiadoBtjh3izSDM=
+google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.1.0/go.mod h1:6Kw0yEErY5E/yWrBtf03jp27GLLJujG4z/JK95pnjjw=
+google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
+google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
+google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
+google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
+google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
+google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4=
+google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
+google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
+google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
+google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
+google.golang.org/protobuf v1.28.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
+google.golang.org/protobuf v1.28.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
+google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY=
+google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=
+gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+gopkg.in/cheggaaa/pb.v1 v1.0.25/go.mod h1:V/YB90LKu/1FcN3WVnfiiE5oMCibMjukxqG/qStrOgw=
+gopkg.in/cheggaaa/pb.v1 v1.0.27/go.mod h1:V/YB90LKu/1FcN3WVnfiiE5oMCibMjukxqG/qStrOgw=
+gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
+gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
+gopkg.in/gcfg.v1 v1.2.3/go.mod h1:yesOnuUOFQAhST5vPY4nbZsb/huCgGGXlipJsBn0b3o=
+gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
+gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI=
+gopkg.in/yaml.v2 v2.0.0-20170812160011-eb3733d160e7/go.mod h1:JAlM8MvJe8wmxCU4Bli9HhUf9+ttbYbLASfIpnQbh74=
+gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
+gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gotest.tools/v3 v3.5.2 h1:7koQfIKdy+I8UTetycgUqXWSDwpgv193Ka+qRsmBY8Q=
+gotest.tools/v3 v3.5.2/go.mod h1:LtdLGcnqToBH83WByAAi/wiwSFCArdFIUV/xxN4pcjA=
+honnef.co/go/tools v0.0.0-20180728063816-88497007e858/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
+honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
+honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
+modernc.org/cc/v4 v4.26.2 h1:991HMkLjJzYBIfha6ECZdjrIYz2/1ayr+FL8GN+CNzM=
+modernc.org/cc/v4 v4.26.2/go.mod h1:uVtb5OGqUKpoLWhqwNQo/8LwvoiEBLvZXIQ/SmO6mL0=
+modernc.org/ccgo/v4 v4.28.0 h1:rjznn6WWehKq7dG4JtLRKxb52Ecv8OUGah8+Z/SfpNU=
+modernc.org/ccgo/v4 v4.28.0/go.mod h1:JygV3+9AV6SmPhDasu4JgquwU81XAKLd3OKTUDNOiKE=
+modernc.org/fileutil v1.3.8 h1:qtzNm7ED75pd1C7WgAGcK4edm4fvhtBsEiI/0NQ54YM=
+modernc.org/fileutil v1.3.8/go.mod h1:HxmghZSZVAz/LXcMNwZPA/DRrQZEVP9VX0V4LQGQFOc=
+modernc.org/gc/v2 v2.6.5 h1:nyqdV8q46KvTpZlsw66kWqwXRHdjIlJOhG6kxiV/9xI=
+modernc.org/gc/v2 v2.6.5/go.mod h1:YgIahr1ypgfe7chRuJi2gD7DBQiKSLMPgBQe9oIiito=
+modernc.org/goabi0 v0.2.0 h1:HvEowk7LxcPd0eq6mVOAEMai46V+i7Jrj13t4AzuNks=
+modernc.org/goabi0 v0.2.0/go.mod h1:CEFRnnJhKvWT1c1JTI3Avm+tgOWbkOu5oPA8eH8LnMI=
+modernc.org/libc v1.66.3 h1:cfCbjTUcdsKyyZZfEUKfoHcP3S0Wkvz3jgSzByEWVCQ=
+modernc.org/libc v1.66.3/go.mod h1:XD9zO8kt59cANKvHPXpx7yS2ELPheAey0vjIuZOhOU8=
+modernc.org/mathutil v1.7.1 h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU=
+modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg=
+modernc.org/memory v1.11.0 h1:o4QC8aMQzmcwCK3t3Ux/ZHmwFPzE6hf2Y5LbkRs+hbI=
+modernc.org/memory v1.11.0/go.mod h1:/JP4VbVC+K5sU2wZi9bHoq2MAkCnrt2r98UGeSK7Mjw=
+modernc.org/opt v0.1.4 h1:2kNGMRiUjrp4LcaPuLY2PzUfqM/w9N23quVwhKt5Qm8=
+modernc.org/opt v0.1.4/go.mod h1:03fq9lsNfvkYSfxrfUhZCWPk1lm4cq4N+Bh//bEtgns=
+modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w=
+modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMjDzETGsSMqJE=
+modernc.org/sqlite v1.39.0 h1:6bwu9Ooim0yVYA7IZn9demiQk/Ejp0BtTjBWFLymSeY=
+modernc.org/sqlite v1.39.0/go.mod h1:cPTJYSlgg3Sfg046yBShXENNtPrWrDX8bsbAQBzgQ5E=
+modernc.org/strutil v1.2.1 h1:UneZBkQA+DX2Rp35KcM69cSsNES9ly8mQWD71HKlOA0=
+modernc.org/strutil v1.2.1/go.mod h1:EHkiggD70koQxjVdSBM3JKM7k6L0FbGE5eymy9i3B9A=
+modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y=
+modernc.org/token v1.1.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM=
+nhooyr.io/websocket v1.8.6 h1:s+C3xAMLwGmlI31Nyn/eAehUlZPwfYZu2JXM621Q5/k=
+nhooyr.io/websocket v1.8.6/go.mod h1:B70DZP8IakI65RVQ51MsWP/8jndNma26DVA/nFSCgW0=
+pgregory.net/rapid v1.2.0 h1:keKAYRcjm+e1F0oAuU5F5+YPAWcyxNNRK2wud503Gnk=
+pgregory.net/rapid v1.2.0/go.mod h1:PY5XlDGj0+V1FCq0o192FdRhpKHGTRIWBgqjDBTrq04=
+rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=
+rsc.io/qr v0.2.0 h1:6vBLea5/NRMVTz8V66gipeLycZMl/+UlFmk8DvqQ6WY=
+rsc.io/qr v0.2.0/go.mod h1:IF+uZjkb9fqyeF/4tlBoynqmQxUoPfWEKh921coOuXs=
+rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0=
+rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=
+sigs.k8s.io/yaml v1.1.0/go.mod h1:UJmg0vDUVViEyp3mgSv9WPwZCDxu4rQW1olrI1uml+o=
+sigs.k8s.io/yaml v1.4.0 h1:Mk1wCc2gy/F0THH0TAp1QYyJNzRm2KCLy3o5ASXVI5E=
+sigs.k8s.io/yaml v1.4.0/go.mod h1:Ejl7/uTz7PSA4eKMyQCUTnhZYNmLIl+5c2lQPGR2BPY=
+sourcegraph.com/sourcegraph/appdash v0.0.0-20190731080439-ebfcffb1b5c0/go.mod h1:hI742Nqp5OhwiqlzhgfbWU4mW4yO10fP+LoT9WOswdU=
diff --git a/decentralized-api/internal/bandwidth_limiter.go b/decentralized-api/internal/bandwidth_limiter.go
new file mode 100644
index 000000000..913b400c0
--- /dev/null
+++ b/decentralized-api/internal/bandwidth_limiter.go
@@ -0,0 +1,315 @@
+package internal
+
+import (
+ "decentralized-api/apiconfig"
+ "decentralized-api/chainphase"
+ "decentralized-api/cosmosclient"
+ "decentralized-api/logging"
+ "sync"
+ "time"
+
+ "github.com/productscience/inference/x/inference/types"
+)
+
+// BandwidthLimiter provides a simple mechanism to enforce bandwidth limits.
+// Minimalistic approach: use cached epoch data, refresh only when epoch changes.
+type BandwidthLimiter struct {
+ mu sync.RWMutex
+ limitsPerBlockKB uint64
+ usagePerBlock map[int64]float64
+ cleanupInterval time.Duration
+ requestLifespanBlocks int64
+
+ // Configurable coefficients from chain parameters
+ kbPerInputToken float64
+ kbPerOutputToken float64
+
+ recorder cosmosclient.CosmosMessageClient
+ defaultLimit uint64
+ epochCache *EpochGroupDataCache
+ phaseTracker ChainPhaseTracker
+ configManager ConfigManager
+ cachedLimitEpochIndex uint64
+ cachedWeightLimit uint64
+}
+
+func (bl *BandwidthLimiter) CanAcceptRequest(blockHeight int64, promptTokens, maxTokens int) (bool, float64) {
+ bl.maybeUpdateLimits()
+
+ bl.mu.RLock()
+ defer bl.mu.RUnlock()
+
+ estimatedKB := float64(promptTokens)*bl.kbPerInputToken + float64(maxTokens)*bl.kbPerOutputToken
+
+ totalUsage := 0.0
+ windowSize := bl.requestLifespanBlocks + 1
+ for i := blockHeight; i <= blockHeight+bl.requestLifespanBlocks; i++ {
+ totalUsage += bl.usagePerBlock[i]
+ }
+
+ avgUsage := totalUsage / float64(windowSize)
+ estimatedKBPerBlock := estimatedKB / float64(windowSize)
+ canAccept := avgUsage+estimatedKBPerBlock <= float64(bl.limitsPerBlockKB)
+
+ logging.Debug("CanAcceptRequest", types.Config,
+ "avgUsage", avgUsage,
+ "estimatedKB", estimatedKBPerBlock,
+ "limitsPerBlockKB", bl.limitsPerBlockKB,
+ "requestLifespanBlocks", bl.requestLifespanBlocks,
+ "totalUsage", totalUsage)
+
+ if !canAccept {
+ logging.Info("Bandwidth limit exceeded", types.Config,
+ "avgUsage", avgUsage, "estimatedKB", estimatedKBPerBlock, "limit", bl.limitsPerBlockKB)
+ }
+
+ return canAccept, estimatedKB
+}
+
+func (bl *BandwidthLimiter) maybeUpdateLimits() {
+ if bl.phaseTracker == nil {
+ return
+ }
+
+ epochState := bl.phaseTracker.GetCurrentEpochState()
+ if epochState == nil {
+ return
+ }
+
+ currentEpochIndex := epochState.LatestEpoch.EpochIndex
+ if bl.cachedLimitEpochIndex == currentEpochIndex {
+ return
+ }
+
+ if bl.configManager != nil {
+ bl.updateParametersFromConfig()
+ }
+
+ bl.updateWeightBasedLimit(currentEpochIndex)
+}
+
+func (bl *BandwidthLimiter) updateParametersFromConfig() {
+ validationParams := bl.configManager.GetValidationParams()
+ bandwidthParams := bl.configManager.GetBandwidthParams()
+
+ bl.mu.Lock()
+ defer bl.mu.Unlock()
+
+ updated := false
+
+ if validationParams.ExpirationBlocks > 0 && bl.requestLifespanBlocks != validationParams.ExpirationBlocks {
+ bl.requestLifespanBlocks = validationParams.ExpirationBlocks
+ updated = true
+ }
+
+ if bandwidthParams.KbPerInputToken > 0 && bl.kbPerInputToken != bandwidthParams.KbPerInputToken {
+ bl.kbPerInputToken = bandwidthParams.KbPerInputToken
+ updated = true
+ }
+
+ if bandwidthParams.KbPerOutputToken > 0 && bl.kbPerOutputToken != bandwidthParams.KbPerOutputToken {
+ bl.kbPerOutputToken = bandwidthParams.KbPerOutputToken
+ updated = true
+ }
+
+ if bandwidthParams.EstimatedLimitsPerBlockKb > 0 && bl.defaultLimit != bandwidthParams.EstimatedLimitsPerBlockKb {
+ bl.defaultLimit = bandwidthParams.EstimatedLimitsPerBlockKb
+ updated = true
+ }
+
+ if updated {
+ logging.Info("Updated bandwidth parameters from config", types.Config,
+ "lifespanBlocks", bl.requestLifespanBlocks,
+ "kbPerInputToken", bl.kbPerInputToken,
+ "kbPerOutputToken", bl.kbPerOutputToken,
+ "defaultLimit", bl.defaultLimit)
+ }
+}
+
+func (bl *BandwidthLimiter) updateWeightBasedLimit(currentEpochIndex uint64) {
+ if bl.epochCache == nil || bl.recorder == nil {
+ logging.Warn("Epoch cache or recorder is nil, skipping weight-based limit update", types.Config)
+ return
+ }
+
+ if bl.cachedLimitEpochIndex == currentEpochIndex && bl.cachedWeightLimit > 0 {
+ return
+ }
+
+ newLimit := bl.calculateUniformLimit(currentEpochIndex)
+
+ bl.mu.Lock()
+ defer bl.mu.Unlock()
+
+ if bl.limitsPerBlockKB != newLimit {
+ bl.limitsPerBlockKB = newLimit
+ logging.Info("Updated bandwidth limit", types.Config,
+ "newLimit", newLimit, "epoch", currentEpochIndex)
+ }
+}
+
+func (bl *BandwidthLimiter) calculateUniformLimit(currentEpochIndex uint64) uint64 {
+ epochGroupData, err := bl.epochCache.GetCurrentEpochGroupData(currentEpochIndex)
+ if err != nil {
+ logging.Warn("Failed to get epoch data, using default limit", types.Config, "error", err)
+ return bl.defaultLimit
+ }
+
+ return bl.defaultLimit / uint64(len(epochGroupData.ValidationWeights))
+}
+
+// Weigh based limits. We ignore it for now
+func (bl *BandwidthLimiter) calculateWeightBasedLimit(currentEpochIndex uint64) uint64 {
+ epochGroupData, err := bl.epochCache.GetCurrentEpochGroupData(currentEpochIndex)
+ if err != nil {
+ logging.Warn("Failed to get epoch data, using default limit", types.Config, "error", err)
+ return bl.defaultLimit
+ }
+
+ if len(epochGroupData.ValidationWeights) == 0 {
+ return bl.defaultLimit
+ }
+
+ nodeAddress := bl.recorder.GetAccountAddress()
+ nodeWeight, totalWeight := bl.calculateWeights(epochGroupData.ValidationWeights, nodeAddress)
+
+ if totalWeight <= 0 || nodeWeight <= 0 {
+ logging.Warn("Invalid weights, using default limit", types.Config,
+ "nodeWeight", nodeWeight, "totalWeight", totalWeight)
+ return bl.defaultLimit
+ }
+
+ adjustedLimit := uint64(float64(bl.defaultLimit) * float64(nodeWeight) / float64(totalWeight))
+
+ bl.cachedLimitEpochIndex = currentEpochIndex
+ bl.cachedWeightLimit = adjustedLimit
+
+ logging.Info("Calculated weight-based limit", types.Config,
+ "nodeWeight", nodeWeight, "totalWeight", totalWeight,
+ "adjustedLimit", adjustedLimit, "participants", len(epochGroupData.ValidationWeights))
+
+ return adjustedLimit
+}
+
+func (bl *BandwidthLimiter) calculateWeights(weights []*types.ValidationWeight, nodeAddress string) (int64, int64) {
+ var nodeWeight, totalWeight int64
+
+ for _, weight := range weights {
+ totalWeight += weight.Weight
+ if weight.MemberAddress == nodeAddress {
+ nodeWeight = weight.Weight
+ }
+ }
+
+ return nodeWeight, totalWeight
+}
+
+func (bl *BandwidthLimiter) RecordRequest(startBlockHeight int64, estimatedKB float64) {
+ bl.mu.Lock()
+ defer bl.mu.Unlock()
+
+ completionBlock := startBlockHeight + bl.requestLifespanBlocks
+ bl.usagePerBlock[completionBlock] += estimatedKB
+}
+
+func (bl *BandwidthLimiter) ReleaseRequest(startBlockHeight int64, estimatedKB float64) {
+ bl.mu.Lock()
+ defer bl.mu.Unlock()
+
+ completionBlock := startBlockHeight + bl.requestLifespanBlocks
+ bl.usagePerBlock[completionBlock] -= estimatedKB
+
+ if bl.usagePerBlock[completionBlock] <= 0 {
+ delete(bl.usagePerBlock, completionBlock)
+ }
+}
+
+func (bl *BandwidthLimiter) startCleanupRoutine() {
+ ticker := time.NewTicker(bl.cleanupInterval)
+ defer ticker.Stop()
+
+ for range ticker.C {
+ bl.cleanupOldEntries()
+ }
+}
+
+func (bl *BandwidthLimiter) cleanupOldEntries() {
+ bl.mu.Lock()
+ defer bl.mu.Unlock()
+
+ if len(bl.usagePerBlock) == 0 {
+ return
+ }
+
+ var newestBlock int64
+ for block := range bl.usagePerBlock {
+ if block > newestBlock {
+ newestBlock = block
+ }
+ }
+
+ cutoffBlock := newestBlock - bl.requestLifespanBlocks*2 // Keep some buffer
+ for block := range bl.usagePerBlock {
+ if block < cutoffBlock {
+ delete(bl.usagePerBlock, block)
+ }
+ }
+}
+
+func NewBandwidthLimiterFromConfig(configManager ConfigManager, recorder cosmosclient.CosmosMessageClient, phaseTracker ChainPhaseTracker) *BandwidthLimiter {
+ validationParams := configManager.GetValidationParams()
+ bandwidthParams := configManager.GetBandwidthParams()
+
+ requestLifespanBlocks := validationParams.ExpirationBlocks
+ if requestLifespanBlocks == 0 {
+ requestLifespanBlocks = 10
+ }
+
+ limitsPerBlockKB := bandwidthParams.EstimatedLimitsPerBlockKb
+ if limitsPerBlockKB == 0 {
+ limitsPerBlockKB = 21 * 1024 // 21MB default
+ }
+
+ kbPerInputToken := bandwidthParams.KbPerInputToken
+ if kbPerInputToken == 0 {
+ kbPerInputToken = 0.0023
+ }
+
+ kbPerOutputToken := bandwidthParams.KbPerOutputToken
+ if kbPerOutputToken == 0 {
+ kbPerOutputToken = 0.64
+ }
+
+ bl := &BandwidthLimiter{
+ limitsPerBlockKB: limitsPerBlockKB,
+ usagePerBlock: make(map[int64]float64),
+ cleanupInterval: 30 * time.Second,
+ requestLifespanBlocks: requestLifespanBlocks,
+ kbPerInputToken: kbPerInputToken,
+ kbPerOutputToken: kbPerOutputToken,
+ recorder: recorder,
+ defaultLimit: limitsPerBlockKB,
+ phaseTracker: phaseTracker,
+ configManager: configManager,
+ }
+
+ if recorder != nil && phaseTracker != nil {
+ bl.epochCache = NewEpochGroupDataCache(recorder)
+ }
+
+ logging.Info("Bandwidth limiter initialized", types.Config,
+ "limit", limitsPerBlockKB, "lifespan", requestLifespanBlocks,
+ "weightBased", recorder != nil && phaseTracker != nil)
+
+ go bl.startCleanupRoutine()
+ return bl
+}
+
+type ConfigManager interface {
+ GetValidationParams() apiconfig.ValidationParamsCache
+ GetBandwidthParams() apiconfig.BandwidthParamsCache
+}
+
+type ChainPhaseTracker interface {
+ GetCurrentEpochState() *chainphase.EpochState
+}
diff --git a/decentralized-api/internal/bandwidth_limiter_test.go b/decentralized-api/internal/bandwidth_limiter_test.go
new file mode 100644
index 000000000..f1a328695
--- /dev/null
+++ b/decentralized-api/internal/bandwidth_limiter_test.go
@@ -0,0 +1,264 @@
+package internal
+
+import (
+ "decentralized-api/apiconfig"
+ "math"
+ "sync"
+ "testing"
+ "time"
+
+ "github.com/productscience/inference/x/inference/types"
+ "github.com/stretchr/testify/require"
+)
+
+// Mock implementations for testing
+type mockConfigManager struct {
+ validationParams apiconfig.ValidationParamsCache
+ bandwidthParams apiconfig.BandwidthParamsCache
+}
+
+func (m *mockConfigManager) GetValidationParams() apiconfig.ValidationParamsCache {
+ return m.validationParams
+}
+
+func (m *mockConfigManager) GetBandwidthParams() apiconfig.BandwidthParamsCache {
+ return m.bandwidthParams
+}
+
+// newTestBandwidthLimiter creates a bandwidth limiter for testing without weight-based allocation
+func newTestBandwidthLimiter(limitsPerBlockKB uint64, requestLifespanBlocks int64, kbPerInputToken, kbPerOutputToken float64) *BandwidthLimiter {
+ configManager := &mockConfigManager{
+ validationParams: apiconfig.ValidationParamsCache{
+ ExpirationBlocks: requestLifespanBlocks,
+ },
+ bandwidthParams: apiconfig.BandwidthParamsCache{
+ EstimatedLimitsPerBlockKb: limitsPerBlockKB,
+ KbPerInputToken: kbPerInputToken,
+ KbPerOutputToken: kbPerOutputToken,
+ },
+ }
+
+ // Create without recorder and phase tracker for simple testing
+ return NewBandwidthLimiterFromConfig(configManager, nil, nil)
+}
+
+func TestBandwidthLimiter_CanAcceptRequest(t *testing.T) {
+ limiter := newTestBandwidthLimiter(100, 10, 0.0023, 0.64) // 100 KB limit, default coefficients
+
+ // Test case 1: Request well under the limit
+ can, _ := limiter.CanAcceptRequest(1, 1000, 100)
+ require.True(t, can, "Should accept request under the limit")
+
+ // Test case 2: Create scenario that exceeds the limit
+ // Fill up most of the bandwidth at overlapping blocks
+ limiter.RecordRequest(1, 800) // Records 800 KB at block 11
+ limiter.RecordRequest(5, 800) // Records 800 KB at block 15
+
+ // Try to accept a request starting at block 6 (checks range [6:16])
+ // Range [6:16] contains blocks 11 and 15 with 800 KB each
+ // Average usage = (800 + 800) / 10 = 160 KB per block (already over 100 KB limit)
+ can, _ = limiter.CanAcceptRequest(6, 100, 10) // Small request, should still be rejected
+ require.False(t, can, "Should not accept request when average usage already exceeds limit")
+}
+
+func TestBandwidthLimiter_RecordAndRelease(t *testing.T) {
+ limiter := newTestBandwidthLimiter(100, 10, 0.0023, 0.64)
+
+ // Record a large request that will create conflict
+ limiter.RecordRequest(1, 950) // Records 950 KB at block 11
+
+ // Check that a new request starting at block 5 is now rejected
+ // This checks range [5:15] which includes block 11 with 950 KB
+ // Range [5:15] = 11 blocks, so average existing = 950/11 = 86.36 KB per block
+ // New request ~67 KB = 6.1 KB per block, total = 86.36 + 6.1 = 92.46 KB per block (under 100 KB limit)
+ // So we need a larger request to exceed the limit
+ can, _ := limiter.CanAcceptRequest(5, 2000, 200) // ~130 KB request = 11.8 KB per block, total = 98.16 KB (still under)
+ // Let's try an even bigger request
+ can, _ = limiter.CanAcceptRequest(5, 5000, 500) // ~332 KB request = 30.2 KB per block, total = 116.56 KB (over 100 KB limit)
+ require.False(t, can, "Should not accept a new request that would exceed average limit")
+
+ // Release the first request
+ limiter.ReleaseRequest(1, 950)
+
+ // Check that the same large request is now accepted
+ can, _ = limiter.CanAcceptRequest(5, 5000, 500)
+ require.True(t, can, "Should accept a new request after releasing the conflicting one")
+}
+
+func TestBandwidthLimiter_Concurrency(t *testing.T) {
+ limiter := newTestBandwidthLimiter(100, 10, 0.0023, 0.64) // Lower limit for clearer test
+ var wg sync.WaitGroup
+ numRoutines := 50
+
+ // Use larger requests to make limits more visible
+ promptTokens := 1000
+ maxTokens := 30 // 1000×0.0023 + 30×0.64 = ~21.5KB total
+ _, estimatedKB := limiter.CanAcceptRequest(1, promptTokens, maxTokens)
+
+ acceptedCount := 0
+ var mu sync.Mutex
+
+ for i := 0; i < numRoutines; i++ {
+ wg.Add(1)
+ go func() {
+ defer wg.Done()
+ can, kb := limiter.CanAcceptRequest(1, promptTokens, maxTokens)
+ if can {
+ limiter.RecordRequest(1, kb)
+ mu.Lock()
+ acceptedCount++
+ mu.Unlock()
+ }
+ }()
+ }
+
+ wg.Wait()
+
+ // All requests record at block 11, so effective limit is 100KB * 10 blocks = 1000KB total
+ // With each request ~21.5KB, we expect ~46 requests maximum
+ // But due to concurrency races, we might get a few more
+ expectedMax := int(math.Floor(1000/estimatedKB)) + 5 // Allow some race condition tolerance
+ require.LessOrEqual(t, acceptedCount, expectedMax, "Should not accept significantly more requests than capacity allows")
+ require.Greater(t, acceptedCount, 20, "Should accept a reasonable number of requests")
+}
+
+func TestBandwidthLimiter_Cleanup(t *testing.T) {
+ limiter := newTestBandwidthLimiter(100, 5, 0.0023, 0.64)
+ limiter.cleanupInterval = 10 * time.Millisecond // Speed up cleanup for test
+
+ // Record usage - these will be recorded at completion blocks (start + 5)
+ limiter.RecordRequest(1, 50) // Records at block 6
+ limiter.RecordRequest(2, 50) // Records at block 7
+
+ // Record usage on a much later block
+ limiter.RecordRequest(20, 50) // Records at block 25
+
+ // Wait for cleanup to run multiple times
+ time.Sleep(50 * time.Millisecond)
+
+ // Manually trigger cleanup to ensure it runs
+ limiter.cleanupOldEntries()
+
+ limiter.mu.RLock()
+ defer limiter.mu.RUnlock()
+
+ _, exists6 := limiter.usagePerBlock[6] // From RecordRequest(1, 50)
+ _, exists7 := limiter.usagePerBlock[7] // From RecordRequest(2, 50)
+ _, exists25 := limiter.usagePerBlock[25] // From RecordRequest(20, 50)
+
+ require.False(t, exists6, "Usage for block 6 should have been cleaned up")
+ require.False(t, exists7, "Usage for block 7 should have been cleaned up")
+ require.True(t, exists25, "Usage for block 25 should not have been cleaned up")
+}
+
+func TestBandwidthParameterLoading(t *testing.T) {
+ // Test that bandwidth parameters are correctly loaded from proto Decimal types
+
+ // Create test Decimal values that simulate chain parameters
+ kbPerInputDecimal := &types.Decimal{
+ Value: 23, // 0.0023 = 23 * 10^-4
+ Exponent: -4,
+ }
+
+ kbPerOutputDecimal := &types.Decimal{
+ Value: 64, // 0.64 = 64 * 10^-2
+ Exponent: -2,
+ }
+
+ // Create mock BandwidthLimitsParams
+ bandwidthParams := &types.BandwidthLimitsParams{
+ EstimatedLimitsPerBlockKb: 1024,
+ KbPerInputToken: kbPerInputDecimal,
+ KbPerOutputToken: kbPerOutputDecimal,
+ }
+
+ // Create mock ValidationParams
+ validationParams := &types.ValidationParams{
+ TimestampExpiration: 300,
+ TimestampAdvance: 60,
+ ExpirationBlocks: 10,
+ }
+
+ // Create mock Params
+ params := &types.Params{
+ ValidationParams: validationParams,
+ BandwidthLimitsParams: bandwidthParams,
+ }
+
+ // Simulate parameter loading logic from new_block_dispatcher.go
+ validationConfig := apiconfig.ValidationParamsCache{
+ TimestampExpiration: params.ValidationParams.TimestampExpiration,
+ TimestampAdvance: params.ValidationParams.TimestampAdvance,
+ ExpirationBlocks: params.ValidationParams.ExpirationBlocks,
+ }
+
+ // Load bandwidth parameters separately (like in new_block_dispatcher.go)
+ var bandwidthConfig apiconfig.BandwidthParamsCache
+ if params.BandwidthLimitsParams != nil {
+ bandwidthConfig = apiconfig.BandwidthParamsCache{
+ EstimatedLimitsPerBlockKb: params.BandwidthLimitsParams.EstimatedLimitsPerBlockKb,
+ KbPerInputToken: params.BandwidthLimitsParams.KbPerInputToken.ToFloat(),
+ KbPerOutputToken: params.BandwidthLimitsParams.KbPerOutputToken.ToFloat(),
+ }
+ }
+
+ // Verify the parameters were loaded correctly
+ require.Equal(t, uint64(1024), bandwidthConfig.EstimatedLimitsPerBlockKb, "EstimatedLimitsPerBlockKb should be loaded from bandwidth params")
+ require.InDelta(t, 0.0023, bandwidthConfig.KbPerInputToken, 0.00001, "KbPerInputToken should be converted correctly from Decimal")
+ require.InDelta(t, 0.64, bandwidthConfig.KbPerOutputToken, 0.00001, "KbPerOutputToken should be converted correctly from Decimal")
+
+ // Verify validation params are separate and preserved
+ require.Equal(t, int64(300), validationConfig.TimestampExpiration, "TimestampExpiration should be preserved")
+ require.Equal(t, int64(60), validationConfig.TimestampAdvance, "TimestampAdvance should be preserved")
+ require.Equal(t, int64(10), validationConfig.ExpirationBlocks, "ExpirationBlocks should be preserved")
+
+ // Test that BandwidthLimiter can be created with these parameters
+ limiter := newTestBandwidthLimiter(bandwidthConfig.EstimatedLimitsPerBlockKb, validationConfig.ExpirationBlocks, bandwidthConfig.KbPerInputToken, bandwidthConfig.KbPerOutputToken)
+ require.NotNil(t, limiter, "BandwidthLimiter should be created successfully")
+
+ // Test a calculation with the loaded parameters
+ can, estimatedKB := limiter.CanAcceptRequest(1, 1000, 100)
+ expectedKB := 1000*bandwidthConfig.KbPerInputToken + 100*bandwidthConfig.KbPerOutputToken // 1000*0.0023 + 100*0.64 = 66.3
+ require.True(t, can, "Should accept request under limit")
+ require.InDelta(t, expectedKB, estimatedKB, 0.01, "Estimated KB should match calculation with loaded parameters")
+}
+
+func TestConfigManagerInterface(t *testing.T) {
+ // Test that our ConfigManager interface is satisfied by the actual config manager
+ // This ensures the factory function will work correctly in the server
+
+ // Create mock config manager
+ mockConfig := &MockConfigManager{
+ validationParams: apiconfig.ValidationParamsCache{
+ ExpirationBlocks: 15,
+ },
+ bandwidthParams: apiconfig.BandwidthParamsCache{
+ EstimatedLimitsPerBlockKb: 2048,
+ KbPerInputToken: 0.005,
+ KbPerOutputToken: 0.8,
+ },
+ }
+
+ // Test that our interface methods work
+ validationParams := mockConfig.GetValidationParams()
+ bandwidthParams := mockConfig.GetBandwidthParams()
+
+ require.Equal(t, int64(15), validationParams.ExpirationBlocks, "Should return validation params")
+ require.Equal(t, uint64(2048), bandwidthParams.EstimatedLimitsPerBlockKb, "Should return bandwidth params")
+ require.Equal(t, 0.005, bandwidthParams.KbPerInputToken, "Should return input token coefficient")
+ require.Equal(t, 0.8, bandwidthParams.KbPerOutputToken, "Should return output token coefficient")
+}
+
+// Mock implementations for testing
+type MockConfigManager struct {
+ validationParams apiconfig.ValidationParamsCache
+ bandwidthParams apiconfig.BandwidthParamsCache
+}
+
+func (m *MockConfigManager) GetValidationParams() apiconfig.ValidationParamsCache {
+ return m.validationParams
+}
+
+func (m *MockConfigManager) GetBandwidthParams() apiconfig.BandwidthParamsCache {
+ return m.bandwidthParams
+}
diff --git a/decentralized-api/internal/bls/dealer.go b/decentralized-api/internal/bls/dealer.go
new file mode 100644
index 000000000..904e1b56e
--- /dev/null
+++ b/decentralized-api/internal/bls/dealer.go
@@ -0,0 +1,429 @@
+// Package bls_dkg implements Distributed Key Generation (DKG) for BLS signatures
+//
+// Using github.com/consensys/gnark-crypto for Ethereum-compatible BLS12-381 implementation
+// - Production-ready with audit reports
+// - Excellent performance and active maintenance
+// - Full compliance with IETF BLS standards
+//
+// Example integration:
+// import (
+// "github.com/Consensys/gnark-crypto/ecc/bls12-381"
+// "github.com/Consensys/gnark-crypto/ecc/bls12-381/fr"
+// )
+
+package bls
+
+import (
+ "crypto/rand"
+ "decentralized-api/internal/event_listener/chainevents"
+ "decentralized-api/internal/utils"
+ "decentralized-api/logging"
+ "encoding/base64"
+ "encoding/json"
+ "fmt"
+ "math/big"
+ "strconv"
+
+ "github.com/productscience/inference/x/bls/types"
+ inferenceTypes "github.com/productscience/inference/x/inference/types"
+
+ bls12381 "github.com/consensys/gnark-crypto/ecc/bls12-381"
+ "github.com/consensys/gnark-crypto/ecc/bls12-381/fr"
+ "github.com/cosmos/cosmos-sdk/crypto/ecies"
+ "github.com/decred/dcrd/dcrec/secp256k1/v4"
+)
+
+// DEALER METHODS - All methods operate on BlsManager
+
+// ProcessKeyGenerationInitiated handles the EventKeyGenerationInitiated event
+func (bm *BlsManager) ProcessKeyGenerationInitiated(event *chainevents.JSONRPCResponse) error {
+ // Extract event data from chain event (typed event from EmitTypedEvent)
+ epochIDs, ok := event.Result.Events["inference.bls.EventKeyGenerationInitiated.epoch_id"]
+ if !ok || len(epochIDs) == 0 {
+ return fmt.Errorf("epoch_id not found in key generation initiated event")
+ }
+
+ // Unquote the epoch_id value (handles JSON-encoded strings like "\"1\"")
+ unquotedEpochID, err := utils.UnquoteEventValue(epochIDs[0])
+ if err != nil {
+ return fmt.Errorf("failed to unquote epoch_id: %w", err)
+ }
+
+ epochID, err := strconv.ParseUint(unquotedEpochID, 10, 64)
+ if err != nil {
+ return fmt.Errorf("failed to parse epoch_id: %w", err)
+ }
+
+ totalSlotsStrs, ok := event.Result.Events["inference.bls.EventKeyGenerationInitiated.i_total_slots"]
+ if !ok || len(totalSlotsStrs) == 0 {
+ return fmt.Errorf("i_total_slots not found in event")
+ }
+
+ // Unquote the total_slots value
+ unquotedTotalSlots, err := utils.UnquoteEventValue(totalSlotsStrs[0])
+ if err != nil {
+ return fmt.Errorf("failed to unquote i_total_slots: %w", err)
+ }
+
+ totalSlots, err := strconv.ParseUint(unquotedTotalSlots, 10, 32)
+ if err != nil {
+ return fmt.Errorf("failed to parse i_total_slots: %w", err)
+ }
+
+ tDegreesStrs, ok := event.Result.Events["inference.bls.EventKeyGenerationInitiated.t_slots_degree"]
+ if !ok || len(tDegreesStrs) == 0 {
+ return fmt.Errorf("t_slots_degree not found in event")
+ }
+
+ // Unquote the t_slots_degree value
+ unquotedTDegree, err := utils.UnquoteEventValue(tDegreesStrs[0])
+ if err != nil {
+ return fmt.Errorf("failed to unquote t_slots_degree: %w", err)
+ }
+
+ tDegree, err := strconv.ParseUint(unquotedTDegree, 10, 32)
+ if err != nil {
+ return fmt.Errorf("failed to parse t_slots_degree: %w", err)
+ }
+
+ logging.Debug("Processing DKG key generation initiated", inferenceTypes.BLS,
+ "epochID", epochID, "totalSlots", totalSlots, "tDegree", tDegree, "dealer", bm.cosmosClient.GetAddress())
+
+ // Parse participants from event
+ participants, err := bm.parseParticipantsFromEvent(event)
+ if err != nil {
+ return fmt.Errorf("failed to parse participants: %w", err)
+ }
+
+ // Check if this node is a participant
+ isParticipant := false
+ for _, participant := range participants {
+ if participant.Address == bm.cosmosClient.GetAddress() {
+ isParticipant = true
+ break
+ }
+ }
+
+ if !isParticipant {
+ logging.Debug("Not a participant in this DKG round", inferenceTypes.BLS,
+ "epochID", epochID, "address", bm.cosmosClient.GetAddress())
+ return nil
+ }
+
+ logging.Debug("This node is a participant in DKG", inferenceTypes.BLS,
+ "epochID", epochID, "participantCount", len(participants))
+
+ // Generate dealer part
+ dealerPart, err := bm.generateDealerPart(epochID, uint32(totalSlots), uint32(tDegree), participants)
+ if err != nil {
+ return fmt.Errorf("failed to generate dealer part: %w", err)
+ }
+
+ // Submit dealer part to chain
+ err = bm.cosmosClient.SubmitDealerPart(dealerPart)
+ if err != nil {
+ return fmt.Errorf("failed to submit dealer part: %w", err)
+ }
+
+ logging.Info("Successfully submitted dealer part", inferenceTypes.BLS,
+ "epochID", epochID, "dealer", bm.cosmosClient.GetAddress())
+
+ return nil
+}
+
+// parseParticipantsFromEvent extracts participant information from the event
+func (bm *BlsManager) parseParticipantsFromEvent(event *chainevents.JSONRPCResponse) ([]ParticipantInfo, error) {
+ // Get the participants field - this should be a JSON-encoded array
+ participantStrs, ok := event.Result.Events["inference.bls.EventKeyGenerationInitiated.participants"]
+ if !ok || len(participantStrs) == 0 {
+ return nil, fmt.Errorf("participants not found in event")
+ }
+
+ // The participants field should be a JSON-encoded array of BLSParticipantInfo objects
+ // First, unquote the JSON string if it's quoted
+ unquotedParticipants, err := utils.UnquoteEventValue(participantStrs[0])
+ if err != nil {
+ return nil, fmt.Errorf("failed to unquote participants: %w", err)
+ }
+
+ // Parse the JSON array into BLSParticipantInfo objects
+ var blsParticipants []types.BLSParticipantInfo
+ err = json.Unmarshal([]byte(unquotedParticipants), &blsParticipants)
+ if err != nil {
+ return nil, fmt.Errorf("failed to unmarshal participants JSON: %w", err)
+ }
+
+ if len(blsParticipants) == 0 {
+ return nil, fmt.Errorf("no participants found in event")
+ }
+
+ // Convert BLSParticipantInfo to ParticipantInfo
+ participants := make([]ParticipantInfo, len(blsParticipants))
+ for i, blsParticipant := range blsParticipants {
+ participants[i] = ParticipantInfo{
+ Address: blsParticipant.Address,
+ Secp256K1PublicKey: blsParticipant.Secp256K1PublicKey,
+ SlotStartIndex: blsParticipant.SlotStartIndex,
+ SlotEndIndex: blsParticipant.SlotEndIndex,
+ }
+
+ logging.Debug("Parsed participant from event", inferenceTypes.BLS,
+ "index", i, "address", blsParticipant.Address,
+ "slotStart", blsParticipant.SlotStartIndex,
+ "slotEnd", blsParticipant.SlotEndIndex)
+ }
+
+ logging.Info("Successfully parsed participants from event", inferenceTypes.BLS,
+ "participantCount", len(participants))
+
+ return participants, nil
+}
+
+// generateDealerPart generates the dealer's contribution to the DKG
+func (bm *BlsManager) generateDealerPart(epochID uint64, totalSlots, tDegree uint32, participants []ParticipantInfo) (*types.MsgSubmitDealerPart, error) {
+ logging.Debug("Generating dealer part", inferenceTypes.BLS,
+ "epochID", epochID, "totalSlots", totalSlots, "tDegree", tDegree, "participantCount", len(participants))
+
+ // Generate secret BLS polynomial Poly_k(x) of degree tDegree
+ polynomial, err := generateRandomPolynomial(tDegree)
+ if err != nil {
+ return nil, fmt.Errorf("failed to generate random polynomial: %w", err)
+ }
+
+ // Compute public commitments to coefficients (C_kj = g * a_kj, G2 points)
+ commitments := computeG2Commitments(polynomial)
+
+ // Create encrypted shares for participants using deterministic array indexing
+ encryptedSharesForParticipants := make([]types.EncryptedSharesForParticipant, len(participants))
+ for i, participant := range participants {
+ // Get all allowed public keys for this participant (including warm keys)
+ allowedPubKeys, err := bm.getAllowedPubKeysForParticipant(participant.Address)
+ if err != nil {
+ return nil, fmt.Errorf("failed to get allowed public keys for participant %s: %w",
+ participant.Address, err)
+ }
+
+ // Calculate number of slots for this participant
+ numSlots := participant.SlotEndIndex - participant.SlotStartIndex + 1
+
+ // For warm keys: store multiple encryptions per slot consecutively
+ // Total ciphertexts = numSlots * numKeys
+ totalCiphertexts := numSlots * uint32(len(allowedPubKeys))
+ encryptedShares := make([][]byte, totalCiphertexts)
+ ciphertextIndex := 0
+
+ for slotOffset := uint32(0); slotOffset < numSlots; slotOffset++ {
+ slotIndex := participant.SlotStartIndex + slotOffset
+
+ // Compute scalar share share_ki = Poly_k(slotIndex+1) to match chain's x-domain
+ share := evaluatePolynomial(polynomial, slotIndex+1)
+ shareBytes := share.Marshal()
+
+ // Encrypt the same share for all allowed public keys
+ for keyIndex, pubKeyBase64 := range allowedPubKeys {
+ // Convert base64 public key to secp256k1 bytes
+ pubKeyBytes, err := bm.convertPubKeyToSecp256k1Bytes(pubKeyBase64)
+ if err != nil {
+ logging.Debug("Failed to convert public key, skipping", inferenceTypes.BLS,
+ "participant", participant.Address, "keyIndex", keyIndex,
+ "pubKeyBase64", pubKeyBase64, "error", err)
+ continue
+ }
+
+ // Encrypt share using this public key
+ encryptedShare, err := encryptForParticipant(shareBytes, pubKeyBytes)
+ if err != nil {
+ logging.Warn("Failed to encrypt share for public key, skipping", inferenceTypes.BLS,
+ "participant", participant.Address, "slotIndex", slotIndex,
+ "keyIndex", keyIndex, "pubKeyBase64", pubKeyBase64, "error", err)
+ continue
+ }
+
+ encryptedShares[ciphertextIndex] = encryptedShare
+ ciphertextIndex++
+ }
+ }
+
+ // Trim to actual successful encryptions
+ encryptedShares = encryptedShares[:ciphertextIndex]
+
+ encryptedSharesForParticipants[i] = types.EncryptedSharesForParticipant{
+ EncryptedShares: encryptedShares,
+ }
+
+ logging.Debug("Generated encrypted shares for participant with warm keys", inferenceTypes.BLS,
+ "participantIndex", i, "participant", participant.Address,
+ "slotStart", participant.SlotStartIndex, "slotEnd", participant.SlotEndIndex,
+ "numSlots", numSlots, "allowedKeys", len(allowedPubKeys),
+ "totalCiphertexts", len(encryptedShares))
+ }
+
+ dealerPart := &types.MsgSubmitDealerPart{
+ Creator: bm.cosmosClient.GetAddress(),
+ EpochId: epochID,
+ Commitments: commitments,
+ EncryptedSharesForParticipants: encryptedSharesForParticipants,
+ }
+
+ logging.Info("Generated dealer part with actual cryptography", inferenceTypes.BLS,
+ "epochID", epochID, "commitmentsCount", len(commitments),
+ "participantsCount", len(encryptedSharesForParticipants),
+ "note", "Using gnark-crypto for BLS12-381 cryptography")
+
+ return dealerPart, nil
+}
+
+// BLS CRYPTOGRAPHY FUNCTIONS using gnark-crypto
+
+// generateRandomPolynomial generates random polynomial coefficients for BLS DKG
+func generateRandomPolynomial(degree uint32) ([]*fr.Element, error) {
+ coefficients := make([]*fr.Element, degree+1)
+ for i := uint32(0); i <= degree; i++ {
+ coeff := new(fr.Element)
+ _, err := coeff.SetRandom()
+ if err != nil {
+ return nil, fmt.Errorf("failed to generate random coefficient %d: %w", i, err)
+ }
+ coefficients[i] = coeff
+ }
+ return coefficients, nil
+}
+
+// computeG2Commitments computes G2 commitments for polynomial coefficients
+func computeG2Commitments(coefficients []*fr.Element) [][]byte {
+ commitments := make([][]byte, len(coefficients))
+
+ // Get the BLS12-381 G2 generator (4th return value is G2Affine)
+ _, _, _, g2Gen := bls12381.Generators()
+
+ for i, coeff := range coefficients {
+ var commitment bls12381.G2Affine
+ // Convert fr.Element to big.Int for scalar multiplication
+ coeffBigInt := new(big.Int)
+ coeff.BigInt(coeffBigInt)
+ commitment.ScalarMultiplication(&g2Gen, coeffBigInt)
+ // Use compressed format (96 bytes) instead of uncompressed (192 bytes)
+ // This is more efficient for blockchain storage and network transmission
+ compressedBytes := commitment.Bytes() // Returns [96]byte
+ commitments[i] = compressedBytes[:] // Convert to []byte slice
+ }
+ return commitments
+}
+
+// evaluatePolynomial evaluates polynomial at given x using Horner's method
+func evaluatePolynomial(polynomial []*fr.Element, x uint32) *fr.Element {
+ if len(polynomial) == 0 {
+ return new(fr.Element).SetZero()
+ }
+
+ // Convert x to fr.Element
+ xFr := new(fr.Element).SetUint64(uint64(x))
+
+ // Start with highest degree coefficient
+ result := new(fr.Element).Set(polynomial[len(polynomial)-1])
+
+ // Apply Horner's method: result = result * x + coeff[i]
+ for i := len(polynomial) - 2; i >= 0; i-- {
+ result.Mul(result, xFr)
+ result.Add(result, polynomial[i])
+ }
+
+ return result
+}
+
+// encryptForParticipant encrypts data for a specific participant using Cosmos-compatible ECIES
+// This uses the same go-ethereum ECIES implementation that the modified Cosmos keyring uses
+func encryptForParticipant(data []byte, secp256k1PubKeyBytes []byte) ([]byte, error) {
+ // Validate the compressed secp256k1 public key format
+ // (33 bytes: 0x02 or 0x03 + 32 bytes X)
+ if len(secp256k1PubKeyBytes) != 33 {
+ return nil, fmt.Errorf("invalid compressed secp256k1 public key format, expected 33 bytes, got %d bytes", len(secp256k1PubKeyBytes))
+ }
+ // Check for valid prefix (0x02 or 0x03)
+ if secp256k1PubKeyBytes[0] != 0x02 && secp256k1PubKeyBytes[0] != 0x03 {
+ return nil, fmt.Errorf("invalid compressed secp256k1 public key prefix, expected 0x02 or 0x03, got 0x%x", secp256k1PubKeyBytes[0])
+ }
+
+ // Use Decred secp256k1 to parse the compressed key bytes into a secp256k1.PublicKey
+ pubKey, err := secp256k1.ParsePubKey(secp256k1PubKeyBytes)
+ if err != nil {
+ return nil, fmt.Errorf("failed to parse secp256k1 public key: %w", err)
+ }
+
+ // Convert secp256k1.PublicKey to *ecdsa.PublicKey
+ ecdsaPubKey := pubKey.ToECDSA()
+
+ // Convert *ecdsa.PublicKey to *ecies.PublicKey using the same method as Cosmos keyring
+ eciesPubKey := ecies.ImportECDSAPublic(ecdsaPubKey)
+
+ // Encrypt the data using the same method as the modified Cosmos keyring
+ // This ensures compatibility: dealer encryption → keyring decryption
+ ciphertext, err := ecies.Encrypt(rand.Reader, eciesPubKey, data, nil, nil)
+ if err != nil {
+ return nil, fmt.Errorf("ECIES encryption failed: %w", err)
+ }
+
+ return ciphertext, nil
+}
+
+// getAllowedPubKeysForParticipant gets all allowed public keys for a participant (including warm keys via Authz)
+func (bm *BlsManager) getAllowedPubKeysForParticipant(participantAddress string) ([]string, error) {
+ queryClient := bm.cosmosClient.NewInferenceQueryClient()
+
+ // Get all grantees (warm keys) allowed to act on behalf of this participant
+ grantees, err := queryClient.GranteesByMessageType(bm.ctx, &inferenceTypes.QueryGranteesByMessageTypeRequest{
+ GranterAddress: participantAddress,
+ MessageTypeUrl: "/inference.bls.MsgSubmitDealerPart", // BLS operations
+ })
+ if err != nil {
+ // If querying grantees fails, log warning but continue with just the participant's own key
+ logging.Warn("Failed to get grantees for participant, using only participant's own key", inferenceTypes.BLS,
+ "participant", participantAddress, "error", err)
+ grantees = &inferenceTypes.QueryGranteesByMessageTypeResponse{Grantees: []*inferenceTypes.Grantee{}}
+ }
+
+ // Get the participant's own public key
+ participant, err := queryClient.InferenceParticipant(bm.ctx, &inferenceTypes.QueryInferenceParticipantRequest{
+ Address: participantAddress,
+ })
+ if err != nil {
+ return nil, fmt.Errorf("failed to get participant's own public key: %w", err)
+ }
+
+ // Collect all allowed public keys (participant's own + warm keys)
+ allowedPubKeys := make([]string, 0, len(grantees.Grantees)+1)
+
+ // Add participant's own public key first
+ allowedPubKeys = append(allowedPubKeys, participant.Pubkey)
+
+ // Add all warm key public keys
+ for _, grantee := range grantees.Grantees {
+ allowedPubKeys = append(allowedPubKeys, grantee.PubKey)
+ }
+
+ logging.Debug("Retrieved allowed public keys for participant", inferenceTypes.BLS,
+ "participant", participantAddress,
+ "ownKey", participant.Pubkey,
+ "warmKeysCount", len(grantees.Grantees),
+ "totalKeys", len(allowedPubKeys))
+
+ return allowedPubKeys, nil
+}
+
+// convertPubKeyToSecp256k1Bytes converts a base64-encoded public key string to secp256k1 bytes
+func (bm *BlsManager) convertPubKeyToSecp256k1Bytes(pubKeyBase64 string) ([]byte, error) {
+ // Decode base64-encoded public key
+ pubKeyBytes, err := base64.StdEncoding.DecodeString(pubKeyBase64)
+ if err != nil {
+ return nil, fmt.Errorf("failed to decode base64 public key: %w", err)
+ }
+
+ // Validate secp256k1 compressed format (33 bytes)
+ if len(pubKeyBytes) != 33 {
+ return nil, fmt.Errorf("invalid secp256k1 public key length: expected 33 bytes, got %d", len(pubKeyBytes))
+ }
+
+ return pubKeyBytes, nil
+}
+
+// All BLS cryptographic functions have been implemented above using gnark-crypto
diff --git a/decentralized-api/internal/bls/dealer_test.go b/decentralized-api/internal/bls/dealer_test.go
new file mode 100644
index 000000000..b88e9a4c7
--- /dev/null
+++ b/decentralized-api/internal/bls/dealer_test.go
@@ -0,0 +1,228 @@
+package bls
+
+import (
+ "encoding/hex"
+ "testing"
+)
+
+// TestBLSCryptographicFunctions tests the basic functionality of our BLS functions
+func TestBLSCryptographicFunctions(t *testing.T) {
+ // Test polynomial generation
+ degree := uint32(3)
+ polynomial, err := generateRandomPolynomial(degree)
+ if err != nil {
+ t.Fatalf("Failed to generate polynomial: %v", err)
+ }
+
+ if len(polynomial) != int(degree+1) {
+ t.Fatalf("Expected polynomial length %d, got %d", degree+1, len(polynomial))
+ }
+
+ // Test G2 commitments
+ commitments := computeG2Commitments(polynomial)
+ if len(commitments) != len(polynomial) {
+ t.Fatalf("Expected %d commitments, got %d", len(polynomial), len(commitments))
+ }
+
+ // Test polynomial evaluation
+ x := uint32(5)
+ result := evaluatePolynomial(polynomial, x)
+ if result == nil {
+ t.Fatal("Polynomial evaluation returned nil")
+ }
+
+ // Test ECIES encryption with a valid compressed secp256k1 public key
+ // This is a valid compressed secp256k1 public key for testing (33 bytes)
+ testPubKey := make([]byte, 33)
+ testPubKey[0] = 0x02 // Compressed key prefix (even Y coordinate)
+ // Fill with some test data that forms a valid secp256k1 point
+ // Using a known valid compressed public key for testing
+ validCompressedKey := []byte{
+ 0x02, 0x79, 0xbe, 0x66, 0x7e, 0xf9, 0xdc, 0xbb, 0xac, 0x55, 0xa0, 0x62, 0x95, 0xce, 0x87, 0x0b,
+ 0x07, 0x02, 0x9b, 0xfc, 0xdb, 0x2d, 0xce, 0x28, 0xd9, 0x59, 0xf2, 0x81, 0x5b, 0x16, 0xf8, 0x17, 0x98,
+ }
+ copy(testPubKey, validCompressedKey)
+
+ testData := []byte("test data for encryption")
+ encrypted, err := encryptForParticipant(testData, testPubKey)
+ if err != nil {
+ t.Fatalf("ECIES encryption failed: %v", err)
+ }
+
+ if len(encrypted) == 0 {
+ t.Fatal("ECIES encryption returned empty result")
+ }
+
+ t.Logf("Successfully tested all BLS cryptographic functions:")
+ t.Logf("- Generated polynomial with %d coefficients", len(polynomial))
+ t.Logf("- Generated %d G2 commitments", len(commitments))
+ t.Logf("- Evaluated polynomial at x=%d", x)
+ t.Logf("- Encrypted %d bytes to %d bytes", len(testData), len(encrypted))
+}
+
+// TestPolynomialGeneration tests polynomial generation with different degrees
+func TestPolynomialGeneration(t *testing.T) {
+ testCases := []struct {
+ name string
+ degree uint32
+ }{
+ {"Small degree", 1},
+ {"Medium degree", 10},
+ {"Large degree", 100},
+ }
+
+ for _, tc := range testCases {
+ t.Run(tc.name, func(t *testing.T) {
+ polynomial, err := generateRandomPolynomial(tc.degree)
+ if err != nil {
+ t.Fatalf("Failed to generate polynomial: %v", err)
+ }
+
+ expectedLength := int(tc.degree + 1)
+ if len(polynomial) != expectedLength {
+ t.Fatalf("Expected polynomial length %d, got %d", expectedLength, len(polynomial))
+ }
+
+ // Verify all coefficients are non-nil
+ for i, coeff := range polynomial {
+ if coeff == nil {
+ t.Fatalf("Coefficient at index %d is nil", i)
+ }
+ }
+ })
+ }
+}
+
+// TestCommitmentCalculation tests G2 commitment computation
+func TestCommitmentCalculation(t *testing.T) {
+ // Generate a test polynomial
+ degree := uint32(5)
+ polynomial, err := generateRandomPolynomial(degree)
+ if err != nil {
+ t.Fatalf("Failed to generate polynomial: %v", err)
+ }
+
+ // Compute commitments
+ commitments := computeG2Commitments(polynomial)
+
+ // Verify commitment count matches polynomial length
+ if len(commitments) != len(polynomial) {
+ t.Fatalf("Expected %d commitments, got %d", len(polynomial), len(commitments))
+ }
+
+ // Verify commitments are valid G2 points (basic check)
+ for i, commitment := range commitments {
+ if len(commitment) == 0 {
+ t.Fatalf("Commitment at index %d is empty", i)
+ }
+ // G2 points in compressed form are 96 bytes (48 bytes each for x and y coordinates)
+ if len(commitment) != 96 {
+ t.Fatalf("Expected commitment length 96 bytes (compressed), got %d at index %d", len(commitment), i)
+ }
+ }
+}
+
+// TestShareEncryption tests ECIES encryption of shares
+func TestShareEncryption(t *testing.T) {
+ // Test data
+ testShares := [][]byte{
+ []byte("share_data_1"),
+ []byte("share_data_2"),
+ []byte("longer_share_data_for_testing"),
+ }
+
+ // Valid compressed secp256k1 public key
+ validPubKey := []byte{
+ 0x02, 0x79, 0xbe, 0x66, 0x7e, 0xf9, 0xdc, 0xbb, 0xac, 0x55, 0xa0, 0x62, 0x95, 0xce, 0x87, 0x0b,
+ 0x07, 0x02, 0x9b, 0xfc, 0xdb, 0x2d, 0xce, 0x28, 0xd9, 0x59, 0xf2, 0x81, 0x5b, 0x16, 0xf8, 0x17, 0x98,
+ }
+
+ for i, share := range testShares {
+ t.Run(hex.EncodeToString(share)[:16], func(t *testing.T) {
+ encrypted, err := encryptForParticipant(share, validPubKey)
+ if err != nil {
+ t.Fatalf("Failed to encrypt share %d: %v", i, err)
+ }
+
+ if len(encrypted) == 0 {
+ t.Fatalf("Encrypted share %d is empty", i)
+ }
+
+ // Encrypted data should be longer than original due to ECIES overhead
+ if len(encrypted) <= len(share) {
+ t.Fatalf("Encrypted data should be longer than original. Original: %d, Encrypted: %d", len(share), len(encrypted))
+ }
+ })
+ }
+}
+
+// TestInvalidPublicKeyEncryption tests encryption with invalid public keys
+func TestInvalidPublicKeyEncryption(t *testing.T) {
+ testData := []byte("test data")
+
+ invalidKeys := []struct {
+ name string
+ key []byte
+ }{
+ {"Empty key", []byte{}},
+ {"Too short", []byte{0x02, 0x79}},
+ {"Too long", make([]byte, 65)}, // Uncompressed format
+ {"Invalid prefix", append([]byte{0x05}, make([]byte, 32)...)},
+ }
+
+ for _, tc := range invalidKeys {
+ t.Run(tc.name, func(t *testing.T) {
+ _, err := encryptForParticipant(testData, tc.key)
+ if err == nil {
+ t.Fatalf("Expected encryption to fail with invalid key: %s", tc.name)
+ }
+ })
+ }
+}
+
+// TestPolynomialEvaluation tests polynomial evaluation at different points
+func TestPolynomialEvaluation(t *testing.T) {
+ // Generate a test polynomial
+ degree := uint32(3)
+ polynomial, err := generateRandomPolynomial(degree)
+ if err != nil {
+ t.Fatalf("Failed to generate polynomial: %v", err)
+ }
+
+ // Test evaluation at different points
+ testPoints := []uint32{0, 1, 5, 10, 100}
+
+ for _, x := range testPoints {
+ t.Run(hex.EncodeToString([]byte{byte(x)}), func(t *testing.T) {
+ result := evaluatePolynomial(polynomial, x)
+ if result == nil {
+ t.Fatalf("Polynomial evaluation returned nil for x=%d", x)
+ }
+ })
+ }
+}
+
+// TestDeterministicPolynomialEvaluation tests that polynomial evaluation is deterministic
+func TestDeterministicPolynomialEvaluation(t *testing.T) {
+ // Generate a test polynomial
+ degree := uint32(2)
+ polynomial, err := generateRandomPolynomial(degree)
+ if err != nil {
+ t.Fatalf("Failed to generate polynomial: %v", err)
+ }
+
+ x := uint32(42)
+
+ // Evaluate multiple times
+ result1 := evaluatePolynomial(polynomial, x)
+ result2 := evaluatePolynomial(polynomial, x)
+
+ if result1 == nil || result2 == nil {
+ t.Fatal("Polynomial evaluation returned nil")
+ }
+
+ // Results should be identical (deterministic)
+ if !result1.Equal(result2) {
+ t.Fatal("Polynomial evaluation is not deterministic")
+ }
+}
diff --git a/decentralized-api/internal/bls/group_validation.go b/decentralized-api/internal/bls/group_validation.go
new file mode 100644
index 000000000..f4706bb4b
--- /dev/null
+++ b/decentralized-api/internal/bls/group_validation.go
@@ -0,0 +1,246 @@
+package bls
+
+import (
+ "decentralized-api/internal/event_listener/chainevents"
+ "decentralized-api/internal/utils"
+ "decentralized-api/logging"
+ "encoding/binary"
+ "fmt"
+ "math/big"
+ "strconv"
+
+ "crypto/sha256"
+
+ bls12381 "github.com/consensys/gnark-crypto/ecc/bls12-381"
+ "github.com/consensys/gnark-crypto/ecc/bls12-381/fp"
+ "github.com/consensys/gnark-crypto/ecc/bls12-381/fr"
+ "github.com/consensys/gnark-crypto/ecc/bls12-381/hash_to_curve"
+ blstypes "github.com/productscience/inference/x/bls/types"
+ inferenceTypes "github.com/productscience/inference/x/inference/types"
+ "golang.org/x/crypto/sha3"
+)
+
+const (
+ validatorLogTag = "BLS Group Key Validator: "
+)
+
+// GROUP KEY VALIDATION METHODS - All methods operate on BlsManager
+
+// ProcessGroupPublicKeyGenerated handles validation signing when a new group public key is generated
+func (bm *BlsManager) ProcessGroupPublicKeyGeneratedToSign(event *chainevents.JSONRPCResponse) error {
+ // Extract epochID from event
+ epochIDs, ok := event.Result.Events["inference.bls.EventGroupPublicKeyGenerated.epoch_id"]
+ if !ok || len(epochIDs) == 0 {
+ return fmt.Errorf("epoch_id not found in group public key generated event")
+ }
+
+ // Unquote the epoch_id value
+ unquotedEpochID, err := utils.UnquoteEventValue(epochIDs[0])
+ if err != nil {
+ return fmt.Errorf("failed to unquote epoch_id: %w", err)
+ }
+
+ newEpochID, err := strconv.ParseUint(unquotedEpochID, 10, 64)
+ if err != nil {
+ return fmt.Errorf("failed to parse epoch_id: %w", err)
+ }
+
+ logging.Debug(validatorLogTag+"Processing group key validation", inferenceTypes.BLS, "newEpochID", newEpochID)
+
+ // Genesis case: Epoch 1 doesn't need validation (no previous epoch)
+ if newEpochID == 1 {
+ logging.Info(validatorLogTag+"Skipping validation for genesis epoch", inferenceTypes.BLS, "epochID", newEpochID)
+ return nil
+ }
+
+ previousEpochID := newEpochID - 1
+
+ // Check if we participated in the previous epoch
+ previousEpochResult := bm.GetVerificationResult(previousEpochID)
+ if previousEpochResult == nil || !previousEpochResult.IsParticipant {
+ logging.Debug(validatorLogTag+"Not a participant in previous epoch, skipping validation", inferenceTypes.BLS,
+ "newEpochID", newEpochID,
+ "previousEpochID", previousEpochID)
+ return nil
+ }
+
+ // Extract new group public key from event
+ groupPublicKeyStrs, ok := event.Result.Events["inference.bls.EventGroupPublicKeyGenerated.group_public_key"]
+ if !ok || len(groupPublicKeyStrs) == 0 {
+ return fmt.Errorf("group_public_key not found in event")
+ }
+
+ // Unquote and decode the group public key
+ unquotedGroupPublicKey, err := utils.UnquoteEventValue(groupPublicKeyStrs[0])
+ if err != nil {
+ return fmt.Errorf("failed to unquote group_public_key: %w", err)
+ }
+
+ // The group public key should be base64 encoded
+ groupPublicKeyBytes, err := utils.DecodeBase64IfPossible(unquotedGroupPublicKey)
+ if err != nil {
+ return fmt.Errorf("failed to decode group public key: %w", err)
+ }
+
+ if len(groupPublicKeyBytes) != 96 {
+ return fmt.Errorf("invalid group public key length: expected 96 bytes, got %d", len(groupPublicKeyBytes))
+ }
+
+ // Extract chain ID from event
+ chainIDs, ok := event.Result.Events["inference.bls.EventGroupPublicKeyGenerated.chain_id"]
+ if !ok || len(chainIDs) == 0 {
+ return fmt.Errorf("chain_id not found in group public key generated event")
+ }
+ chainID, err := utils.UnquoteEventValue(chainIDs[0])
+ if err != nil {
+ return fmt.Errorf("failed to unquote chain_id: %w", err)
+ }
+
+ // Compute the validation message hash
+ messageHash, err := bm.computeValidationMessageHash(groupPublicKeyBytes, previousEpochID, newEpochID, chainID)
+ if err != nil {
+ return fmt.Errorf("failed to compute validation message hash: %w", err)
+ }
+
+ // Create partial signature using previous epoch slot shares
+ partialSignature, slotIndices, err := bm.createPartialSignature(messageHash, previousEpochResult)
+ if err != nil {
+ return fmt.Errorf("failed to create partial signature: %w", err)
+ }
+
+ // Submit the group key validation signature
+ msg := &blstypes.MsgSubmitGroupKeyValidationSignature{
+ Creator: bm.cosmosClient.GetAddress(),
+ NewEpochId: newEpochID,
+ SlotIndices: slotIndices,
+ PartialSignature: partialSignature,
+ }
+
+ err = bm.cosmosClient.SubmitGroupKeyValidationSignature(msg)
+ if err != nil {
+ return fmt.Errorf("failed to submit group key validation signature: %w", err)
+ }
+
+ logging.Info(validatorLogTag+"Successfully submitted group key validation signature", inferenceTypes.BLS,
+ "newEpochID", newEpochID,
+ "previousEpochID", previousEpochID,
+ "slotIndices", slotIndices)
+
+ return nil
+}
+
+// computeValidationMessageHash computes the validation message hash using the same format as the chain
+// Format: abi.encodePacked(previous_epoch_id (8 BE), sha256(chain_id) (32), new_group_key_uncompressed_256 (X.c0||X.c1||Y.c0||Y.c1; each 64-byte BE limb))
+func (bm *BlsManager) computeValidationMessageHash(groupPublicKey []byte, previousEpochID, newEpochID uint64, chainID string) ([]byte, error) {
+ if len(groupPublicKey) != 96 {
+ return nil, fmt.Errorf("invalid group public key length: expected 96 bytes, got %d", len(groupPublicKey))
+ }
+
+ // Decompress 96-byte compressed G2 key
+ var g2 bls12381.G2Affine
+ if err := g2.Unmarshal(groupPublicKey); err != nil {
+ return nil, fmt.Errorf("failed to unmarshal compressed G2 key: %w", err)
+ }
+
+ // Use sha256(chainID) to form 32-byte chain id (matches keeper)
+ gonkaIdHash := sha256.Sum256([]byte(chainID))
+ chainIdBytes := gonkaIdHash[:]
+
+ // Implement Ethereum-compatible abi.encodePacked
+ var encodedData []byte
+
+ // Add previous_epoch_id (uint64 -> 8 bytes big endian)
+ previousEpochBytes := make([]byte, 8)
+ binary.BigEndian.PutUint64(previousEpochBytes, previousEpochID)
+ encodedData = append(encodedData, previousEpochBytes...)
+
+ // Add chain_id (32 bytes)
+ encodedData = append(encodedData, chainIdBytes...)
+
+ // Append uncompressed G2 (256 bytes): X.c0||X.c1||Y.c0||Y.c1, each 64-byte big-endian (48-byte left-padded)
+ appendFp64 := func(e fp.Element) {
+ be48 := e.Bytes()
+ var limb [64]byte
+ copy(limb[64-48:], be48[:])
+ encodedData = append(encodedData, limb[:]...)
+ }
+ appendFp64(g2.X.A0) // c0
+ appendFp64(g2.X.A1) // c1
+ appendFp64(g2.Y.A0) // c0
+ appendFp64(g2.Y.A1) // c1
+
+ // Compute keccak256 hash (Ethereum-compatible)
+ hash := sha3.NewLegacyKeccak256()
+ hash.Write(encodedData)
+ return hash.Sum(nil), nil
+}
+
+// createPartialSignature creates per-slot BLS partial signatures for the validation message.
+// Returns a concatenation of 48-byte compressed G1 signatures (one per slot, in SlotIndices order),
+// and the corresponding absolute SlotIndices.
+func (bm *BlsManager) createPartialSignature(messageHash []byte, previousEpochResult *VerificationResult) ([]byte, []uint32, error) {
+ if len(previousEpochResult.AggregatedShares) == 0 {
+ return nil, nil, fmt.Errorf("no aggregated shares available for previous epoch")
+ }
+
+ // Hash message to G1 point
+ messageG1, err := bm.hashToG1(messageHash)
+ if err != nil {
+ return nil, nil, fmt.Errorf("failed to hash message to G1: %w", err)
+ }
+
+ // Create slot indices array for our assigned slots (absolute slot IDs)
+ slotIndices := make([]uint32, 0, int(previousEpochResult.SlotRange[1]-previousEpochResult.SlotRange[0]+1))
+ for abs := previousEpochResult.SlotRange[0]; abs <= previousEpochResult.SlotRange[1]; abs++ {
+ slotIndices = append(slotIndices, abs)
+ }
+
+ // For each relative slot offset in our range, compute signing key using consensus ValidDealers,
+ // then compute per-slot partial signature: sig_rel = (sum_dealers share[rel]) * H
+ var concatenated []byte
+ for rel := 0; rel < len(slotIndices); rel++ {
+ // Sum shares across dealers using consensus ValidDealers mask, falling back to DealerValidity if consensus not present
+ var signingKey fr.Element
+ signingKey.SetZero()
+ for dealerIdx := 0; dealerIdx < len(previousEpochResult.DealerShares); dealerIdx++ {
+ // Check consensus valid dealers if available, otherwise skip if dealer shares missing
+ isValidDealer := true
+ if len(previousEpochResult.ValidDealers) == len(previousEpochResult.DealerShares) {
+ isValidDealer = previousEpochResult.ValidDealers[dealerIdx]
+ }
+ if !isValidDealer {
+ continue
+ }
+ shares := previousEpochResult.DealerShares[dealerIdx]
+ if len(shares) == 0 || rel >= len(shares) {
+ continue
+ }
+ signingKey.Add(&signingKey, &shares[rel])
+ }
+ // Compute partial signature for this slot offset: signature = signingKey * H
+ var partialSignature bls12381.G1Affine
+ partialSignature.ScalarMultiplication(&messageG1, signingKey.BigInt(new(big.Int)))
+ // Append compressed 48-byte signature
+ sigBytes := partialSignature.Bytes()
+ concatenated = append(concatenated, sigBytes[:]...)
+ }
+
+ return concatenated, slotIndices, nil
+}
+
+// hashToG1 converts a 32-byte hash to a G1 point using the same method as the chain:
+// Left-pad to 48-byte fp.Element, SWU map, isogeny, and clear cofactor.
+func (bm *BlsManager) hashToG1(hash []byte) (bls12381.G1Affine, error) {
+ var out bls12381.G1Affine
+ if len(hash) != 32 {
+ return out, fmt.Errorf("message hash must be 32 bytes, got %d", len(hash))
+ }
+ var be [48]byte
+ copy(be[48-32:], hash)
+ var u fp.Element
+ u.SetBytes(be[:])
+ p := bls12381.MapToCurve1(&u)
+ hash_to_curve.G1Isogeny(&p.X, &p.Y)
+ out.ClearCofactor(&p)
+ return out, nil
+}
diff --git a/decentralized-api/internal/bls/keyring_encrypt_decrypt_test.go b/decentralized-api/internal/bls/keyring_encrypt_decrypt_test.go
new file mode 100644
index 000000000..aaa7d677d
--- /dev/null
+++ b/decentralized-api/internal/bls/keyring_encrypt_decrypt_test.go
@@ -0,0 +1,406 @@
+package bls
+
+import (
+ "bytes"
+ "crypto/rand"
+ "encoding/hex"
+ "testing"
+
+ "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/stretchr/testify/require"
+)
+
+// setupTestCodec creates a properly configured codec for keyring operations
+func setupTestCodec() codec.Codec {
+ registry := codectypes.NewInterfaceRegistry()
+
+ // Register the crypto interfaces needed by keyring
+ registry.RegisterInterface("cosmos.crypto.PubKey", (*cryptotypes.PubKey)(nil))
+ registry.RegisterInterface("cosmos.crypto.PrivKey", (*cryptotypes.PrivKey)(nil))
+
+ // Register secp256k1 implementations
+ registry.RegisterImplementations((*cryptotypes.PubKey)(nil), &secp256k1.PubKey{})
+ registry.RegisterImplementations((*cryptotypes.PrivKey)(nil), &secp256k1.PrivKey{})
+
+ return codec.NewProtoCodec(registry)
+}
+
+func TestKeyringEncryptDecryptBasic(t *testing.T) {
+ // Setup properly configured codec for keyring
+ cdc := setupTestCodec()
+
+ // Create real in-memory keyring
+ kr := keyring.NewInMemory(cdc)
+
+ // Add a key to the keyring
+ keyName := "encryption-test-key"
+ record, _, err := kr.NewMnemonic(
+ keyName,
+ keyring.English,
+ sdk.FullFundraiserPath,
+ "",
+ hd.Secp256k1,
+ )
+ require.NoError(t, err)
+ require.NotNil(t, record)
+
+ // Test data to encrypt
+ testData := []byte("Hello, Cosmos Keyring encryption!")
+
+ // Encrypt the data
+ encryptedData, err := kr.Encrypt(rand.Reader, keyName, testData, nil, nil)
+ require.NoError(t, err)
+ require.NotEmpty(t, encryptedData)
+ require.NotEqual(t, testData, encryptedData, "Encrypted data should be different from original")
+
+ // Decrypt the data
+ decryptedData, err := kr.Decrypt(keyName, encryptedData, nil, nil)
+ require.NoError(t, err)
+ require.Equal(t, testData, decryptedData, "Decrypted data should match original")
+
+ t.Logf("✅ Basic Encrypt/Decrypt Test Passed")
+ t.Logf(" Original: %s", string(testData))
+ t.Logf(" Encrypted: %s", hex.EncodeToString(encryptedData))
+ t.Logf(" Decrypted: %s", string(decryptedData))
+}
+
+func TestKeyringMultipleParticipants(t *testing.T) {
+ // Setup codec
+ cdc := setupTestCodec()
+
+ // Create keyring
+ kr := keyring.NewInMemory(cdc)
+
+ // Create multiple participants (like in DKG)
+ participants := []string{"alice", "bob", "charlie"}
+ testMessages := map[string][]byte{
+ "alice": []byte("Alice's secret BLS share"),
+ "bob": []byte("Bob's secret BLS share"),
+ "charlie": []byte("Charlie's secret BLS share"),
+ }
+
+ // Add keys for each participant
+ for _, participant := range participants {
+ _, _, err := kr.NewMnemonic(
+ participant,
+ keyring.English,
+ sdk.FullFundraiserPath,
+ "",
+ hd.Secp256k1,
+ )
+ require.NoError(t, err)
+ }
+
+ // Each participant encrypts their own data
+ encryptedData := make(map[string][]byte)
+ for participant, message := range testMessages {
+ encrypted, err := kr.Encrypt(rand.Reader, participant, message, nil, nil)
+ require.NoError(t, err)
+ encryptedData[participant] = encrypted
+
+ t.Logf("✅ %s encrypted %d bytes -> %d bytes", participant, len(message), len(encrypted))
+ }
+
+ // Each participant can decrypt their own data
+ for participant, originalMessage := range testMessages {
+ decrypted, err := kr.Decrypt(participant, encryptedData[participant], nil, nil)
+ require.NoError(t, err)
+ require.Equal(t, originalMessage, decrypted)
+
+ t.Logf("✅ %s successfully decrypted their data", participant)
+ }
+
+ // Verify participants cannot decrypt each other's data
+ for _, participant := range participants {
+ for _, otherParticipant := range participants {
+ if participant != otherParticipant {
+ _, err := kr.Decrypt(participant, encryptedData[otherParticipant], nil, nil)
+ require.Error(t, err, "Participant %s should not be able to decrypt %s's data", participant, otherParticipant)
+
+ t.Logf("✅ %s cannot decrypt %s's data (as expected)", participant, otherParticipant)
+ }
+ }
+ }
+}
+
+func TestKeyringFromPrivateKey(t *testing.T) {
+ // Setup codec
+ cdc := setupTestCodec()
+
+ // Create keyring
+ kr := keyring.NewInMemory(cdc)
+
+ // Generate a private key (like what happens in real DKG)
+ privKey := secp256k1.GenPrivKey()
+ keyName := "imported-key"
+
+ // Convert private key to hex for import
+ privKeyHex := hex.EncodeToString(privKey.Bytes())
+
+ // Import the private key
+ err := kr.ImportPrivKeyHex(keyName, privKeyHex, "secp256k1")
+ require.NoError(t, err)
+
+ // Get the record back and verify
+ record, err := kr.Key(keyName)
+ require.NoError(t, err)
+ require.NotNil(t, record)
+
+ // Test encryption/decryption with imported key
+ testData := []byte("Testing with imported private key")
+
+ encrypted, err := kr.Encrypt(rand.Reader, keyName, testData, nil, nil)
+ require.NoError(t, err)
+
+ decrypted, err := kr.Decrypt(keyName, encrypted, nil, nil)
+ require.NoError(t, err)
+ require.Equal(t, testData, decrypted)
+
+ t.Logf("✅ Successfully imported private key and performed encrypt/decrypt")
+ t.Logf(" Private Key: %s", privKeyHex[:32]+"...")
+ t.Logf(" Encrypted %d bytes", len(encrypted))
+}
+
+func TestKeyringLargeData(t *testing.T) {
+ // Setup codec
+ cdc := setupTestCodec()
+
+ // Create keyring
+ kr := keyring.NewInMemory(cdc)
+
+ // Add a key
+ keyName := "large-data-key"
+ _, _, err := kr.NewMnemonic(
+ keyName,
+ keyring.English,
+ sdk.FullFundraiserPath,
+ "",
+ hd.Secp256k1,
+ )
+ require.NoError(t, err)
+
+ // Test with larger data (like BLS polynomial coefficients)
+ largeData := make([]byte, 1024) // 1KB of data
+ for i := range largeData {
+ largeData[i] = byte(i % 256)
+ }
+
+ // Encrypt large data
+ encrypted, err := kr.Encrypt(rand.Reader, keyName, largeData, nil, nil)
+ require.NoError(t, err)
+ require.Greater(t, len(encrypted), len(largeData), "Encrypted data should be larger due to encryption overhead")
+
+ // Decrypt large data
+ decrypted, err := kr.Decrypt(keyName, encrypted, nil, nil)
+ require.NoError(t, err)
+ require.Equal(t, largeData, decrypted)
+
+ t.Logf("✅ Large Data Test Passed")
+ t.Logf(" Original: %d bytes", len(largeData))
+ t.Logf(" Encrypted: %d bytes", len(encrypted))
+ t.Logf(" Overhead: %d bytes", len(encrypted)-len(largeData))
+}
+
+func TestKeyringErrorHandling(t *testing.T) {
+ // Setup codec
+ cdc := setupTestCodec()
+
+ // Create keyring
+ kr := keyring.NewInMemory(cdc)
+
+ // Test encrypting with non-existent key
+ _, err := kr.Encrypt(rand.Reader, "non-existent-key", []byte("test"), nil, nil)
+ require.Error(t, err, "Should fail when encrypting with non-existent key")
+
+ // Test decrypting with non-existent key
+ _, err = kr.Decrypt("non-existent-key", []byte("test"), nil, nil)
+ require.Error(t, err, "Should fail when decrypting with non-existent key")
+
+ // Add a key for valid operations
+ keyName := "error-test-key"
+ _, _, err = kr.NewMnemonic(
+ keyName,
+ keyring.English,
+ sdk.FullFundraiserPath,
+ "",
+ hd.Secp256k1,
+ )
+ require.NoError(t, err)
+
+ // Test decrypting invalid data
+ invalidData := []byte("invalid-encrypted-data-that-is-too-short")
+ _, err = kr.Decrypt(keyName, invalidData, nil, nil)
+ require.Error(t, err, "Should fail when decrypting invalid data")
+ // The error can be either ECIES decryption failure or other crypto errors
+ t.Logf("Got expected decryption error: %v", err)
+
+ // Test encrypting empty data
+ encrypted, err := kr.Encrypt(rand.Reader, keyName, []byte{}, nil, nil)
+ if err != nil {
+ // Some keyring implementations don't support empty data encryption
+ t.Logf("Empty data encryption not supported: %v", err)
+ require.Contains(t, err.Error(), "ECIES", "Should get ECIES related error for empty data")
+ } else {
+ // If encryption succeeds, decryption should also succeed
+ decrypted, err := kr.Decrypt(keyName, encrypted, nil, nil)
+ if err != nil {
+ t.Logf("Empty data decryption failed (this may be expected): %v", err)
+ // This is acceptable behavior for some keyring implementations
+ } else {
+ require.Empty(t, decrypted)
+ t.Logf("✅ Empty data encryption/decryption succeeded")
+ }
+ }
+
+ t.Logf("✅ Error Handling Tests Passed")
+}
+
+func TestKeyringRoundTripConsistency(t *testing.T) {
+ // Setup codec
+ cdc := setupTestCodec()
+
+ // Create keyring
+ kr := keyring.NewInMemory(cdc)
+
+ // Add a key
+ keyName := "consistency-key"
+ _, _, err := kr.NewMnemonic(
+ keyName,
+ keyring.English,
+ sdk.FullFundraiserPath,
+ "",
+ hd.Secp256k1,
+ )
+ require.NoError(t, err)
+
+ // Test multiple round trips with same data
+ testData := []byte("Consistency test data for multiple round trips")
+
+ for i := 0; i < 5; i++ {
+ // Encrypt
+ encrypted, err := kr.Encrypt(rand.Reader, keyName, testData, nil, nil)
+ require.NoError(t, err)
+
+ // Decrypt
+ decrypted, err := kr.Decrypt(keyName, encrypted, nil, nil)
+ require.NoError(t, err)
+ require.Equal(t, testData, decrypted)
+
+ // Note: Each encryption should produce different ciphertext due to randomness
+ // but all should decrypt to the same plaintext
+ t.Logf("Round %d: %d bytes -> %d bytes -> %d bytes", i+1, len(testData), len(encrypted), len(decrypted))
+ }
+
+ // Test that multiple encryptions of same data produce different ciphertexts
+ encrypted1, err := kr.Encrypt(rand.Reader, keyName, testData, nil, nil)
+ require.NoError(t, err)
+
+ encrypted2, err := kr.Encrypt(rand.Reader, keyName, testData, nil, nil)
+ require.NoError(t, err)
+
+ require.NotEqual(t, encrypted1, encrypted2, "Multiple encryptions should produce different ciphertexts")
+
+ // But both should decrypt to same plaintext
+ decrypted1, err := kr.Decrypt(keyName, encrypted1, nil, nil)
+ require.NoError(t, err)
+
+ decrypted2, err := kr.Decrypt(keyName, encrypted2, nil, nil)
+ require.NoError(t, err)
+
+ require.Equal(t, testData, decrypted1)
+ require.Equal(t, testData, decrypted2)
+ require.True(t, bytes.Equal(decrypted1, decrypted2))
+
+ t.Logf("✅ Round Trip Consistency Tests Passed")
+ t.Logf(" Same plaintext encrypted to different ciphertexts (secure)")
+ t.Logf(" Both ciphertexts decrypt to same plaintext")
+}
+
+func TestKeyringVsDealerEncryption(t *testing.T) {
+ // Setup codec
+ cdc := setupTestCodec()
+
+ // Create keyring
+ kr := keyring.NewInMemory(cdc)
+
+ // Add a key
+ keyName := "comparison-key"
+ record, _, err := kr.NewMnemonic(
+ keyName,
+ keyring.English,
+ sdk.FullFundraiserPath,
+ "",
+ hd.Secp256k1,
+ )
+ require.NoError(t, err)
+
+ // Get the public key from the keyring record
+ pubKey, err := record.GetPubKey()
+ require.NoError(t, err)
+
+ // Convert to the correct format for dealer encryption
+ // The keyring might return uncompressed format, but dealer expects compressed
+ secp256k1PubKey, ok := pubKey.(*secp256k1.PubKey)
+ require.True(t, ok, "Should be secp256k1 public key")
+
+ // Get compressed public key bytes (33 bytes: 0x02/0x03 + 32 bytes)
+ pubKeyBytes := secp256k1PubKey.Key
+ require.Len(t, pubKeyBytes, 33, "Should be compressed secp256k1 public key")
+ require.True(t, pubKeyBytes[0] == 0x02 || pubKeyBytes[0] == 0x03, "Should have valid compressed key prefix")
+
+ // Test data
+ testData := []byte("Testing dealer vs keyring encryption compatibility")
+
+ t.Logf("🔄 Comparing Cosmos Keyring vs Dealer ECIES Encryption")
+ t.Logf(" Test data: %s", string(testData))
+ t.Logf(" Public key: %x", pubKeyBytes)
+
+ // Encrypt using Cosmos keyring
+ keyringEncrypted, err := kr.Encrypt(rand.Reader, keyName, testData, nil, nil)
+ require.NoError(t, err)
+ t.Logf(" Keyring encrypted: %d bytes", len(keyringEncrypted))
+
+ // Encrypt using dealer's encryptForParticipant method
+ dealerEncrypted, err := encryptForParticipant(testData, pubKeyBytes)
+ require.NoError(t, err)
+ t.Logf(" Dealer encrypted: %d bytes", len(dealerEncrypted))
+
+ // The encrypted data should be different (due to randomness) but similar length
+ require.NotEqual(t, keyringEncrypted, dealerEncrypted, "Different encryptions should produce different ciphertexts due to randomness")
+
+ // Both should have similar overhead (within reasonable range)
+ keyringOverhead := len(keyringEncrypted) - len(testData)
+ dealerOverhead := len(dealerEncrypted) - len(testData)
+ t.Logf(" Keyring overhead: %d bytes", keyringOverhead)
+ t.Logf(" Dealer overhead: %d bytes", dealerOverhead)
+
+ // ECIES overhead should be similar (both use same algorithm)
+ require.InDelta(t, keyringOverhead, dealerOverhead, 20, "ECIES overhead should be similar")
+
+ // Test self-consistency: Each method should decrypt its own encryption
+ keyringDecrypted, err := kr.Decrypt(keyName, keyringEncrypted, nil, nil)
+ require.NoError(t, err)
+ require.Equal(t, testData, keyringDecrypted, "Keyring round-trip should work")
+
+ // Test cross-compatibility: Can keyring decrypt dealer-encrypted data?
+ _, err = kr.Decrypt(keyName, dealerEncrypted, nil, nil)
+ if err != nil {
+ t.Logf(" ⚠️ Keyring cannot decrypt dealer encryption: %v", err)
+ t.Logf(" 📝 Different ECIES implementations may not be cross-compatible")
+ } else {
+ t.Logf(" ✅ Keyring successfully decrypted dealer encryption!")
+ t.Logf(" 🎉 Perfect compatibility achieved!")
+ }
+
+ t.Logf("✅ Encryption Analysis Complete")
+ t.Logf(" ✓ Both methods produce valid ECIES encryptions")
+ t.Logf(" ✓ Both have similar overhead (%d vs %d bytes)", keyringOverhead, dealerOverhead)
+ t.Logf(" ✓ Both use same public key format (33-byte compressed secp256k1)")
+ t.Logf(" ✓ Keyring self-consistency verified")
+}
diff --git a/decentralized-api/internal/bls/manager.go b/decentralized-api/internal/bls/manager.go
new file mode 100644
index 000000000..b9a915a55
--- /dev/null
+++ b/decentralized-api/internal/bls/manager.go
@@ -0,0 +1,179 @@
+package bls
+
+import (
+ "context"
+ "decentralized-api/cosmosclient"
+ "decentralized-api/internal/event_listener/chainevents"
+ "decentralized-api/logging"
+
+ "github.com/consensys/gnark-crypto/ecc/bls12-381/fr"
+ "github.com/productscience/inference/x/bls/types"
+ inferenceTypes "github.com/productscience/inference/x/inference/types"
+)
+
+const (
+ blsLogTag = "BLS Manager: "
+)
+
+// BlsManager handles all BLS operations including DKG dealing, verification, and group key validation
+type BlsManager struct {
+ cosmosClient cosmosclient.InferenceCosmosClient
+ ctx context.Context // Context for chain queries
+
+ // Verification state management
+ cache *VerificationCache // Cache for multiple epochs
+
+ // Configuration
+ maxCacheSize uint64
+}
+
+// VerificationResult holds the results of DKG verification for an epoch
+type VerificationResult struct {
+ EpochID uint64
+ DkgPhase types.DKGPhase // The DKG phase when verification was performed
+ IsParticipant bool
+ SlotRange [2]uint32 // [start_index, end_index]
+ DealerShares [][]fr.Element // dealer_index -> [slot_shares...]
+ DealerValidity []bool // dealer_index -> validity
+ AggregatedShares []fr.Element // slot_offset -> aggregated_share
+ ValidDealers []bool // final consensus validity of each dealer (after majority voting)
+ GroupPublicKey []byte // the final group public key (when DKG is completed)
+}
+
+// VerificationCache manages verification results for multiple epochs
+type VerificationCache struct {
+ results map[uint64]*VerificationResult // epochID -> VerificationResult
+}
+
+// NewVerificationCache creates a new verification cache
+func NewVerificationCache() *VerificationCache {
+ return &VerificationCache{
+ results: make(map[uint64]*VerificationResult),
+ }
+}
+
+// Store adds a verification result to the cache and cleans up old entries
+func (vc *VerificationCache) Store(result *VerificationResult) {
+ if result == nil {
+ return
+ }
+
+ // Store the new result
+ vc.results[result.EpochID] = result
+
+ // Clean up old entries (keep only current and previous epoch)
+ if result.EpochID >= 2 {
+ epochToRemove := result.EpochID - 2
+ if _, exists := vc.results[epochToRemove]; exists {
+ delete(vc.results, epochToRemove)
+ logging.Debug(verifierLogTag+"Removed old verification result from cache", inferenceTypes.BLS,
+ "removedEpochID", epochToRemove,
+ "currentEpochID", result.EpochID)
+ }
+ }
+
+ logging.Debug(verifierLogTag+"Stored verification result in cache", inferenceTypes.BLS,
+ "epochID", result.EpochID,
+ "cachedEpochs", len(vc.results))
+}
+
+// Get retrieves a verification result for a specific epoch
+func (vc *VerificationCache) Get(epochID uint64) *VerificationResult {
+ return vc.results[epochID]
+}
+
+// GetCurrent returns the verification result for the highest epoch ID
+func (vc *VerificationCache) GetCurrent() *VerificationResult {
+ var current *VerificationResult
+ var maxEpochID uint64 = 0
+
+ for epochID, result := range vc.results {
+ if epochID > maxEpochID {
+ maxEpochID = epochID
+ current = result
+ }
+ }
+
+ return current
+}
+
+// GetCachedEpochs returns a list of all cached epoch IDs
+func (vc *VerificationCache) GetCachedEpochs() []uint64 {
+ epochs := make([]uint64, 0, len(vc.results))
+ for epochID := range vc.results {
+ epochs = append(epochs, epochID)
+ }
+ return epochs
+}
+
+// ParticipantInfo represents participant information for DKG
+type ParticipantInfo struct {
+ Address string
+ Secp256K1PublicKey []byte
+ SlotStartIndex uint32
+ SlotEndIndex uint32
+}
+
+// SlotAssignment represents the slot assignment for a participant
+type SlotAssignment struct {
+ StartSlot uint32
+ EndSlot uint32
+}
+
+// NewBlsManager creates a new unified BLS manager
+func NewBlsManager(cosmosClient cosmosclient.InferenceCosmosClient) *BlsManager {
+ return &BlsManager{
+ cosmosClient: cosmosClient,
+ ctx: context.Background(), // Use background context for chain queries
+ cache: NewVerificationCache(),
+ }
+}
+
+// GetVerificationResult returns the verification result for a specific epoch
+func (v *BlsManager) GetVerificationResult(epochID uint64) *VerificationResult {
+ return v.cache.Get(epochID)
+}
+
+// GetCurrentVerificationResult returns the current verification result (highest epoch)
+func (v *BlsManager) GetCurrentVerificationResult() *VerificationResult {
+ return v.cache.GetCurrent()
+}
+
+// GetCachedEpochs returns all cached epoch IDs
+func (v *BlsManager) GetCachedEpochs() []uint64 {
+ return v.cache.GetCachedEpochs()
+}
+
+// storeVerificationResult stores a verification result in the cache
+// This method can be extended in the future for additional validation or processing
+func (bm *BlsManager) storeVerificationResult(result *VerificationResult) {
+ if result == nil {
+ logging.Warn(verifierLogTag+"Attempted to store nil verification result", inferenceTypes.BLS)
+ return
+ }
+
+ bm.cache.Store(result)
+
+ logging.Debug(verifierLogTag+"Stored verification result", inferenceTypes.BLS,
+ "epochID", result.EpochID,
+ "isParticipant", result.IsParticipant,
+ "slotRange", result.SlotRange,
+ "totalCachedEpochs", len(bm.cache.GetCachedEpochs()))
+}
+
+// ProcessGroupPublicKeyGenerated handles the DKG completion event
+func (bm *BlsManager) ProcessGroupPublicKeyGenerated(event *chainevents.JSONRPCResponse) error {
+ // Process for verification (updating cache with completed result)
+ err := bm.ProcessGroupPublicKeyGeneratedToVerify(event)
+ if err != nil {
+ logging.Warn(blsLogTag+"Failed to process group public key generated for verification", inferenceTypes.BLS, "error", err)
+ }
+
+ // Process for group key validation signing
+ err = bm.ProcessGroupPublicKeyGeneratedToSign(event)
+ if err != nil {
+ logging.Warn(blsLogTag+"Failed to process group public key generated for signing", inferenceTypes.BLS, "error", err)
+ }
+
+ return nil
+}
diff --git a/decentralized-api/internal/bls/threshold_signing.go b/decentralized-api/internal/bls/threshold_signing.go
new file mode 100644
index 000000000..df606ac45
--- /dev/null
+++ b/decentralized-api/internal/bls/threshold_signing.go
@@ -0,0 +1,182 @@
+package bls
+
+import (
+ "decentralized-api/internal/event_listener/chainevents"
+ "decentralized-api/internal/utils"
+ "decentralized-api/logging"
+ "fmt"
+ "math/big"
+ "strconv"
+
+ bls12381 "github.com/consensys/gnark-crypto/ecc/bls12-381"
+ inferenceTypes "github.com/productscience/inference/x/inference/types"
+)
+
+const (
+ thresholdSigningLogTag = "Threshold Signing: "
+)
+
+// ProcessThresholdSigningRequested handles EventThresholdSigningRequested events
+func (bm *BlsManager) ProcessThresholdSigningRequested(event *chainevents.JSONRPCResponse) error {
+ logging.Debug(thresholdSigningLogTag+"Processing threshold signing requested event", inferenceTypes.BLS)
+
+ // Extract event data
+ requestIdBytes, err := bm.extractEventData(event, "inference.bls.EventThresholdSigningRequested.request_id")
+ if err != nil {
+ return fmt.Errorf("failed to extract request_id: %w", err)
+ }
+
+ epochIdStr, err := bm.extractEventString(event, "inference.bls.EventThresholdSigningRequested.current_epoch_id")
+ if err != nil {
+ return fmt.Errorf("failed to extract current_epoch_id: %w", err)
+ }
+
+ messageHashBytes, err := bm.extractEventData(event, "inference.bls.EventThresholdSigningRequested.message_hash")
+ if err != nil {
+ return fmt.Errorf("failed to extract message_hash: %w", err)
+ }
+
+ deadlineStr, err := bm.extractEventString(event, "inference.bls.EventThresholdSigningRequested.deadline_block_height")
+ if err != nil {
+ return fmt.Errorf("failed to extract deadline_block_height: %w", err)
+ }
+
+ // Parse epoch ID
+ epochId, err := strconv.ParseUint(epochIdStr, 10, 64)
+ if err != nil {
+ return fmt.Errorf("failed to parse epoch_id: %w", err)
+ }
+
+ // Parse deadline
+ deadline, err := strconv.ParseInt(deadlineStr, 10, 64)
+ if err != nil {
+ return fmt.Errorf("failed to parse deadline: %w", err)
+ }
+
+ logging.Info(thresholdSigningLogTag+"Received threshold signing request", inferenceTypes.BLS,
+ "request_id", fmt.Sprintf("%x", requestIdBytes),
+ "epoch_id", epochId,
+ "deadline", deadline)
+
+ // Get verification result for this epoch from cache
+ result := bm.cache.Get(epochId)
+ if result == nil {
+ logging.Warn(thresholdSigningLogTag+"No verification result found for epoch", inferenceTypes.BLS, "epoch_id", epochId)
+ return fmt.Errorf("no verification result found for epoch %d", epochId)
+ }
+
+ // Check if we are a participant in this epoch
+ if !result.IsParticipant {
+ logging.Debug(thresholdSigningLogTag+"Not a participant in this epoch, skipping", inferenceTypes.BLS, "epoch_id", epochId)
+ return nil
+ }
+
+ // Validate message hash length
+ if len(messageHashBytes) != 32 {
+ return fmt.Errorf("invalid message hash length: expected 32 bytes, got %d", len(messageHashBytes))
+ }
+
+ // Compute partial signatures for our slot range
+ err = bm.submitPartialSignatures(epochId, requestIdBytes, messageHashBytes, result)
+ if err != nil {
+ return fmt.Errorf("failed to submit partial signatures: %w", err)
+ }
+
+ logging.Info(thresholdSigningLogTag+"Successfully submitted partial signatures", inferenceTypes.BLS,
+ "request_id", fmt.Sprintf("%x", requestIdBytes),
+ "epoch_id", epochId,
+ "slot_range", result.SlotRange)
+
+ return nil
+}
+
+// submitPartialSignatures computes and submits partial signatures for our slot range
+func (bm *BlsManager) submitPartialSignatures(epochId uint64, requestId []byte, messageHash []byte, result *VerificationResult) error {
+ // Generate slot indices for our range
+ var slotIndices []uint32
+ for slot := result.SlotRange[0]; slot <= result.SlotRange[1]; slot++ {
+ slotIndices = append(slotIndices, slot)
+ }
+
+ // Compute partial signature for our slots
+ partialSignature, err := bm.computePartialSignature(messageHash, result)
+ if err != nil {
+ return fmt.Errorf("failed to compute partial signature: %w", err)
+ }
+
+ // Submit the partial signature via transaction
+ err = bm.cosmosClient.SubmitPartialSignature(requestId, slotIndices, partialSignature)
+ if err != nil {
+ return fmt.Errorf("failed to submit partial signature transaction: %w", err)
+ }
+
+ logging.Debug(thresholdSigningLogTag+"Partial signature submitted", inferenceTypes.BLS,
+ "epoch_id", epochId,
+ "slot_count", len(slotIndices),
+ "signature_length", len(partialSignature))
+
+ return nil
+}
+
+// computePartialSignature computes per-slot BLS partial signatures for the given message hash.
+// Returns a concatenation of 48-byte compressed G1 signatures (one per slot in our assigned range).
+func (bm *BlsManager) computePartialSignature(messageHash []byte, result *VerificationResult) ([]byte, error) {
+ if len(result.AggregatedShares) == 0 {
+ return nil, fmt.Errorf("no aggregated shares available for signing")
+ }
+
+ // Hash the message to a G1 point for signing
+ messageG1, err := bm.hashToG1(messageHash)
+ if err != nil {
+ return nil, fmt.Errorf("failed to hash message to G1: %w", err)
+ }
+
+ // For each relative slot offset, compute per-slot signature and append 48 bytes
+ var concatenated []byte
+ for rel := 0; rel < len(result.AggregatedShares); rel++ {
+ sk := result.AggregatedShares[rel]
+ var sig bls12381.G1Affine
+ sig.ScalarMultiplication(&messageG1, sk.BigInt(new(big.Int)))
+ sb := sig.Bytes()
+ concatenated = append(concatenated, sb[:]...)
+ }
+ return concatenated, nil
+}
+
+// extractEventData extracts byte data from event (base64, hex, or raw string)
+func (bm *BlsManager) extractEventData(event *chainevents.JSONRPCResponse, key string) ([]byte, error) {
+ values := event.Result.Events[key]
+ if len(values) == 0 {
+ return nil, fmt.Errorf("key %s not found in event", key)
+ }
+
+ // Tendermint may wrap values in quotes. Remove them first.
+ unquoted, _ := utils.UnquoteEventValue(values[0])
+
+ // 1) Try base-64
+ if data, err := utils.DecodeBase64IfPossible(unquoted); err == nil {
+ return data, nil
+ }
+
+ // 2) Try hex
+ if data, err := utils.DecodeHex(unquoted); err == nil {
+ return data, nil
+ }
+
+ // 3) Fallback to raw bytes of the string
+ return []byte(unquoted), nil
+}
+
+// extractEventString extracts string data from event and removes extra JSON quotes if present
+func (bm *BlsManager) extractEventString(event *chainevents.JSONRPCResponse, key string) (string, error) {
+ values := event.Result.Events[key]
+ if len(values) == 0 {
+ return "", fmt.Errorf("key %s not found in event", key)
+ }
+
+ // Tendermint sometimes stores values as quoted JSON strings (e.g. "\"2\"").
+ if unquoted, err := utils.UnquoteEventValue(values[0]); err == nil {
+ return unquoted, nil
+ }
+ return values[0], nil
+}
diff --git a/decentralized-api/internal/bls/verifier.go b/decentralized-api/internal/bls/verifier.go
new file mode 100644
index 000000000..73a1b21da
--- /dev/null
+++ b/decentralized-api/internal/bls/verifier.go
@@ -0,0 +1,717 @@
+package bls
+
+import (
+ "decentralized-api/internal/event_listener/chainevents"
+ "decentralized-api/internal/utils"
+ "decentralized-api/logging"
+ "encoding/json"
+ "fmt"
+ "math/big"
+ "strconv"
+
+ bls12381 "github.com/consensys/gnark-crypto/ecc/bls12-381"
+ "github.com/consensys/gnark-crypto/ecc/bls12-381/fr"
+ "github.com/productscience/inference/x/bls/types"
+ inferenceTypes "github.com/productscience/inference/x/inference/types"
+)
+
+const verifierLogTag = "[bls-verifier] "
+
+// ProcessVerifyingPhaseStarted handles the EventVerifyingPhaseStarted event
+func (bm *BlsManager) ProcessVerifyingPhaseStarted(event *chainevents.JSONRPCResponse) error {
+ // Extract event data from chain event (typed event from EmitTypedEvent)
+ epochIDs, ok := event.Result.Events["inference.bls.EventVerifyingPhaseStarted.epoch_id"]
+ if !ok || len(epochIDs) == 0 {
+ return fmt.Errorf("epoch_id not found in verifying phase started event")
+ }
+
+ // Unquote the epoch_id value (handles JSON-encoded strings like "\"1\"")
+ unquotedEpochID, err := utils.UnquoteEventValue(epochIDs[0])
+ if err != nil {
+ return fmt.Errorf("failed to unquote epoch_id: %w", err)
+ }
+
+ epochID, err := strconv.ParseUint(unquotedEpochID, 10, 64)
+ if err != nil {
+ return fmt.Errorf("failed to parse epoch_id: %w", err)
+ }
+
+ existingResult := bm.GetVerificationResult(epochID)
+ if existingResult != nil &&
+ (existingResult.DkgPhase == types.DKGPhase_DKG_PHASE_VERIFYING ||
+ existingResult.DkgPhase == types.DKGPhase_DKG_PHASE_COMPLETED ||
+ existingResult.DkgPhase == types.DKGPhase_DKG_PHASE_SIGNED) {
+ logging.Info(verifierLogTag+"Verification already completed for this epoch", inferenceTypes.BLS,
+ "epochID", epochID,
+ "existingPhase", existingResult.DkgPhase,
+ "isParticipant", existingResult.IsParticipant)
+ return nil
+ }
+
+ // Now access the rest of the event fields as before
+ deadlineStrs, ok := event.Result.Events["inference.bls.EventVerifyingPhaseStarted.verifying_phase_deadline_block"]
+ if !ok || len(deadlineStrs) == 0 {
+ return fmt.Errorf("verifying_phase_deadline_block not found in event")
+ }
+
+ // Unquote the deadline value
+ unquotedDeadline, err := utils.UnquoteEventValue(deadlineStrs[0])
+ if err != nil {
+ return fmt.Errorf("failed to unquote verifying_phase_deadline_block: %w", err)
+ }
+
+ deadlineBlock, err := strconv.ParseUint(unquotedDeadline, 10, 64)
+ if err != nil {
+ return fmt.Errorf("failed to parse verifying_phase_deadline_block: %w", err)
+ }
+
+ logging.Info(verifierLogTag+"Processing DKG verifying phase started", inferenceTypes.BLS,
+ "epochID", epochID, "deadlineBlock", deadlineBlock, "verifier", bm.cosmosClient.GetAccountAddress())
+
+ // Extract epoch data from event instead of querying chain
+ epochData, err := bm.extractEpochDataFromVerifyingEvent(event)
+ if err != nil {
+ return fmt.Errorf("failed to extract epoch data from event: %w", err)
+ }
+
+ // Setup, perform verification, and store result for this epoch using event data
+ completed, err := bm.setupAndPerformVerification(epochID, epochData)
+ if err != nil {
+ return fmt.Errorf("failed to setup and perform verification for epoch %d: %w", epochID, err)
+ }
+
+ // If we're not a participant, return early
+ if !completed {
+ return nil
+ }
+
+ // Submit verification vector
+ err = bm.submitVerificationVectorSimplified(epochID)
+ if err != nil {
+ return fmt.Errorf("failed to submit verification vector: %w", err)
+ }
+
+ return nil
+}
+
+// setupAndPerformVerification handles epoch data validation, participant setup, verification, and storage
+// Returns true if verification was completed and stored, false if we're not a participant or not in correct phase
+func (bm *BlsManager) setupAndPerformVerification(epochID uint64, epochData *types.EpochBLSData) (bool, error) {
+ // Create new verification result for this epoch
+ verificationResult := &VerificationResult{
+ EpochID: epochID,
+ }
+
+ // Set the DKG phase from epoch data
+ verificationResult.DkgPhase = epochData.DkgPhase
+
+ // Validate we're in the correct phase
+ if epochData.DkgPhase != types.DKGPhase_DKG_PHASE_VERIFYING {
+ logging.Debug(verifierLogTag+"DKG not in verifying phase", inferenceTypes.BLS,
+ "epochID", epochID,
+ "currentPhase", epochData.DkgPhase)
+ return false, nil // Return false to indicate we should skip verification
+ }
+
+ // Find our participant info
+ myAddress := bm.cosmosClient.GetAccountAddress()
+ var myParticipantIndex int = -1
+ var myParticipant *types.BLSParticipantInfo
+
+ for i, participant := range epochData.Participants {
+ if participant.Address == myAddress {
+ myParticipantIndex = i
+ myParticipant = &participant
+ break
+ }
+ }
+
+ if myParticipantIndex == -1 {
+ logging.Debug(verifierLogTag+"Not a participant in this DKG round", inferenceTypes.BLS,
+ "epochID", epochID,
+ "myAddress", myAddress,
+ "participantCount", len(epochData.Participants))
+ return false, nil // Return false to indicate we should skip verification
+ }
+
+ // Set participant info in verification result
+ verificationResult.IsParticipant = true
+ verificationResult.SlotRange = [2]uint32{myParticipant.SlotStartIndex, myParticipant.SlotEndIndex}
+
+ logging.Debug(verifierLogTag+"Found participant info from epoch data", inferenceTypes.BLS,
+ "epochID", epochID,
+ "participantIndex", myParticipantIndex,
+ "slotRange", verificationResult.SlotRange,
+ "dealerPartsCount", len(epochData.DealerParts),
+ "totalSlots", epochData.ITotalSlots,
+ "tDegree", epochData.TSlotsDegree)
+
+ // Perform verification and reconstruction
+ err := bm.performVerificationAndReconstruction(verificationResult, epochData.DealerParts, myParticipantIndex)
+ if err != nil {
+ return false, fmt.Errorf("failed to perform verification and reconstruction: %w", err)
+ }
+
+ // Store the completed verification result in cache
+ bm.storeVerificationResult(verificationResult)
+
+ return true, nil
+}
+
+// performVerificationAndReconstruction performs the core verification and share reconstruction logic
+func (bm *BlsManager) performVerificationAndReconstruction(verificationResult *VerificationResult, dealerParts []*types.DealerPartStorage, myParticipantIndex int) error {
+ logging.Debug(verifierLogTag+"Starting share verification and reconstruction", inferenceTypes.BLS,
+ "epochID", verificationResult.EpochID,
+ "slotRange", verificationResult.SlotRange,
+ "dealerPartsCount", len(dealerParts),
+ "myParticipantIndex", myParticipantIndex)
+
+ // Initialize arrays
+ numSlots := int(verificationResult.SlotRange[1] - verificationResult.SlotRange[0] + 1)
+ verificationResult.DealerShares = make([][]fr.Element, len(dealerParts))
+ verificationResult.DealerValidity = make([]bool, len(dealerParts))
+ verificationResult.AggregatedShares = make([]fr.Element, numSlots)
+
+ // First iterate over dealers
+ for dealerIndex, dealerPart := range dealerParts {
+ logging.Debug(verifierLogTag+"Processing dealer", inferenceTypes.BLS, "dealerIndex", dealerIndex)
+
+ // Check if dealer part exists
+ if dealerPart == nil {
+ logging.Debug(verifierLogTag+"Skipping empty dealer part", inferenceTypes.BLS, "dealerIndex", dealerIndex)
+ verificationResult.DealerShares[dealerIndex] = make([]fr.Element, 0) // Empty array
+ verificationResult.DealerValidity[dealerIndex] = false
+ continue
+ }
+
+ // Check if we have shares for our participant index
+ if myParticipantIndex >= len(dealerPart.ParticipantShares) {
+ logging.Warn(verifierLogTag+"No shares for our participant index", inferenceTypes.BLS,
+ "dealerIndex", dealerIndex,
+ "myParticipantIndex", myParticipantIndex)
+ verificationResult.DealerShares[dealerIndex] = make([]fr.Element, 0) // Empty array
+ verificationResult.DealerValidity[dealerIndex] = false
+ continue
+ }
+
+ participantShares := dealerPart.ParticipantShares[myParticipantIndex]
+ if participantShares == nil {
+ logging.Debug(verifierLogTag+"No shares from dealer", inferenceTypes.BLS,
+ "dealerIndex", dealerIndex)
+ verificationResult.DealerShares[dealerIndex] = make([]fr.Element, 0) // Empty array
+ verificationResult.DealerValidity[dealerIndex] = false
+ continue
+ }
+
+ // Initialize dealer shares array
+ dealerSlotShares := make([]fr.Element, numSlots)
+ allSlotsValid := true
+ dealerKeyIndex := -1 // Track which key index works for this dealer
+
+ // Iterate over all slots for this dealer
+ for slotOffset := 0; slotOffset < numSlots; slotOffset++ {
+ slotIndex := verificationResult.SlotRange[0] + uint32(slotOffset)
+
+ // Try to decrypt share for this slot (may have multiple ciphertexts due to warm keys)
+ decryptedShare, keyIndex, err := bm.decryptShareForSlot(participantShares.EncryptedShares, slotOffset, numSlots, dealerIndex, slotIndex, dealerKeyIndex)
+ if err != nil {
+ logging.Warn(verifierLogTag+"Failed to decrypt any ciphertext for slot", inferenceTypes.BLS,
+ "dealerIndex", dealerIndex,
+ "slotIndex", slotIndex,
+ "error", err)
+ allSlotsValid = false
+ break
+ }
+
+ // Remember the key index that worked for this dealer
+ dealerKeyIndex = keyIndex
+
+ // Verify the share against dealer's commitments
+ isValid, err := bm.verifyShareAgainstCommitments(decryptedShare, slotIndex, dealerPart.Commitments)
+ if err != nil {
+ logging.Warn(verifierLogTag+"Failed to verify share", inferenceTypes.BLS,
+ "dealerIndex", dealerIndex,
+ "slotIndex", slotIndex,
+ "error", err)
+ allSlotsValid = false
+ break
+ }
+
+ if !isValid {
+ logging.Warn(verifierLogTag+"Share verification failed", inferenceTypes.BLS,
+ "dealerIndex", dealerIndex,
+ "slotIndex", slotIndex)
+ allSlotsValid = false
+ break
+ }
+
+ // Store valid decrypted share
+ dealerSlotShares[slotOffset] = *decryptedShare
+
+ logging.Debug(verifierLogTag+"Successfully processed share", inferenceTypes.BLS,
+ "dealerIndex", dealerIndex,
+ "slotIndex", slotIndex)
+ }
+
+ // Store dealer results
+ if allSlotsValid {
+ verificationResult.DealerShares[dealerIndex] = dealerSlotShares
+ verificationResult.DealerValidity[dealerIndex] = true
+ logging.Debug(verifierLogTag+"Dealer validation successful", inferenceTypes.BLS,
+ "dealerIndex", dealerIndex,
+ "processedSlots", len(dealerSlotShares))
+ } else {
+ verificationResult.DealerShares[dealerIndex] = make([]fr.Element, 0) // Empty array
+ verificationResult.DealerValidity[dealerIndex] = false
+ logging.Debug(verifierLogTag+"Dealer validation failed", inferenceTypes.BLS,
+ "dealerIndex", dealerIndex)
+ }
+ }
+
+ // Now aggregate shares per slot
+ for slotOffset := 0; slotOffset < numSlots; slotOffset++ {
+ slotIndex := verificationResult.SlotRange[0] + uint32(slotOffset)
+ aggregatedShare := &fr.Element{}
+ aggregatedShare.SetZero()
+
+ // Sum up shares from all valid dealers for this slot
+ for dealerIndex := 0; dealerIndex < len(dealerParts); dealerIndex++ {
+ if verificationResult.DealerValidity[dealerIndex] && len(verificationResult.DealerShares[dealerIndex]) > slotOffset {
+ aggregatedShare.Add(aggregatedShare, &verificationResult.DealerShares[dealerIndex][slotOffset])
+ }
+ }
+
+ // Store aggregated share
+ verificationResult.AggregatedShares[slotOffset] = *aggregatedShare
+
+ logging.Debug(verifierLogTag+"Completed slot share reconstruction", inferenceTypes.BLS,
+ "slotIndex", slotIndex,
+ "slotOffset", slotOffset,
+ "finalShare", aggregatedShare.String())
+ }
+
+ logging.Info(verifierLogTag+"Completed verification and reconstruction", inferenceTypes.BLS,
+ "epochID", verificationResult.EpochID,
+ "validDealers", countTrueValues(verificationResult.DealerValidity),
+ "totalDealers", len(dealerParts),
+ "processedSlots", len(verificationResult.AggregatedShares))
+
+ return nil
+}
+
+// decryptShareForSlot tries to decrypt a share for a specific slot, handling warm keys
+// For warm keys, multiple ciphertexts per slot are stored consecutively in the encrypted_shares array
+// Returns the decrypted share and the key index that worked (for reuse in subsequent slots)
+// dealerKeyIndex: -1 means try all keys, >= 0 means try this key index first
+func (bm *BlsManager) decryptShareForSlot(encryptedShares [][]byte, slotOffset, numSlots, dealerIndex int, slotIndex uint32, dealerKeyIndex int) (*fr.Element, int, error) {
+ totalCiphertexts := len(encryptedShares)
+ if totalCiphertexts == 0 {
+ return nil, -1, fmt.Errorf("no encrypted shares available")
+ }
+
+ // Get our current public key for logging
+ ourPubKey := bm.cosmosClient.GetAccountPubKey()
+
+ // Calculate keys per slot: totalCiphertexts = numSlots * keysPerSlot
+ if totalCiphertexts%numSlots != 0 {
+ return nil, -1, fmt.Errorf("invalid encrypted shares array length: %d ciphertexts for %d slots (not evenly divisible)", totalCiphertexts, numSlots)
+ }
+
+ keysPerSlot := totalCiphertexts / numSlots
+
+ // Calculate the range of ciphertexts for this specific slot
+ startIndex := slotOffset * keysPerSlot
+ endIndex := startIndex + keysPerSlot
+
+ if endIndex > totalCiphertexts {
+ return nil, -1, fmt.Errorf("calculated ciphertext range [%d:%d] exceeds array bounds %d", startIndex, endIndex, totalCiphertexts)
+ }
+
+ // If we already know which key index works, use it exclusively
+ if dealerKeyIndex >= 0 && dealerKeyIndex < keysPerSlot {
+ targetCipherIndex := startIndex + dealerKeyIndex
+ if len(encryptedShares[targetCipherIndex]) > 0 {
+ decryptedShare, err := bm.decryptShare(encryptedShares[targetCipherIndex])
+ if err == nil {
+ // Same key index worked again
+ return decryptedShare, dealerKeyIndex, nil
+ } else {
+ // Known key index failed - this is an error since all slots should use same key
+ return nil, -1, fmt.Errorf("failed to decrypt with known key index %d for slot %d: %w", dealerKeyIndex, slotIndex, err)
+ }
+ } else {
+ return nil, -1, fmt.Errorf("invalid ciphertext at known key index %d for slot %d", dealerKeyIndex, slotIndex)
+ }
+ }
+
+ // First slot: try each ciphertext until one decrypts successfully
+ for keyIndex := 0; keyIndex < keysPerSlot; keyIndex++ {
+ cipherIndex := startIndex + keyIndex
+ encryptedShare := encryptedShares[cipherIndex]
+ if len(encryptedShare) == 0 {
+ continue // Skip empty ciphertexts
+ }
+
+ // Try to decrypt this ciphertext
+ decryptedShare, err := bm.decryptShare(encryptedShare)
+ if err != nil {
+ // This ciphertext didn't decrypt with our key, try the next one
+ continue
+ }
+
+ // Successfully decrypted! Return both the share and the key index
+ return decryptedShare, keyIndex, nil
+ }
+
+ // If we get here, none of the ciphertexts for this slot could be decrypted
+ return nil, -1, fmt.Errorf("failed to decrypt any of %d ciphertexts for slot %d with our key %s", keysPerSlot, slotIndex, ourPubKey)
+}
+
+// decryptShare decrypts an encrypted share using the cosmos-sdk keyring Decrypt API
+func (bm *BlsManager) decryptShare(encryptedShare []byte) (*fr.Element, error) {
+ // Use the cosmos-sdk keyring Decrypt method through the clean interface
+ decryptedBytes, err := bm.cosmosClient.DecryptBytes(encryptedShare)
+ if err != nil {
+ return nil, fmt.Errorf("keyring decryption failed: %w", err)
+ }
+
+ // Convert decrypted bytes back to fr.Element
+ if len(decryptedBytes) != 32 {
+ return nil, fmt.Errorf("unexpected decrypted share length: %d, expected 32", len(decryptedBytes))
+ }
+
+ share := &fr.Element{}
+ share.SetBytes(decryptedBytes)
+
+ return share, nil
+}
+
+// verifyShareAgainstCommitments verifies a decrypted share against the dealer's polynomial commitments
+func (bm *BlsManager) verifyShareAgainstCommitments(share *fr.Element, slotIndex uint32, commitments [][]byte) (bool, error) {
+ if len(commitments) == 0 {
+ return false, fmt.Errorf("no commitments provided")
+ }
+
+ // Convert slot index to fr.Element for polynomial evaluation (x = slotIndex+1, to avoid x=0 and match chain)
+ slotIndexFr := &fr.Element{}
+ slotIndexFr.SetUint64(uint64(slotIndex + 1))
+
+ // Evaluate the polynomial at slotIndex using the commitments
+ // This computes: sum(commitments[j] * slotIndex^j) for j = 0 to degree
+ var expectedCommitment bls12381.G2Affine
+ // Start with identity (zero point) - G2 zero point
+ expectedCommitment = bls12381.G2Affine{}
+
+ // slotIndexPower starts at 1 (slotIndex^0)
+ slotIndexPower := &fr.Element{}
+ slotIndexPower.SetOne()
+
+ for j, commitmentBytes := range commitments {
+ // Parse commitment as compressed G2 point (96 bytes)
+ if len(commitmentBytes) != 96 {
+ return false, fmt.Errorf("invalid commitment length at index %d: %d, expected 96", j, len(commitmentBytes))
+ }
+
+ var commitment bls12381.G2Affine
+ err := commitment.Unmarshal(commitmentBytes)
+ if err != nil {
+ return false, fmt.Errorf("failed to unmarshal commitment at index %d: %w", j, err)
+ }
+
+ // Multiply commitment by slotIndex^j
+ var scaledCommitment bls12381.G2Affine
+ scaledCommitment.ScalarMultiplication(&commitment, slotIndexPower.BigInt(new(big.Int)))
+
+ // Add to running total
+ expectedCommitment.Add(&expectedCommitment, &scaledCommitment)
+
+ // Update slotIndexPower for next iteration: slotIndexPower *= (slotIndex+1)
+ slotIndexPower.Mul(slotIndexPower, slotIndexFr)
+ }
+
+ // Compute g * share (where g is the G2 generator)
+ var actualCommitment bls12381.G2Affine
+ _, _, _, g2Gen := bls12381.Generators()
+ actualCommitment.ScalarMultiplication(&g2Gen, share.BigInt(new(big.Int)))
+
+ // Verify: actualCommitment == expectedCommitment
+ return actualCommitment.Equal(&expectedCommitment), nil
+}
+
+// submitVerificationVectorSimplified constructs and submits the verification vector to the chain
+func (bm *BlsManager) submitVerificationVectorSimplified(epochID uint64) error {
+ // Get verification result from cache
+ verificationResult := bm.cache.Get(epochID)
+ if verificationResult == nil {
+ return fmt.Errorf("verification result not found in cache for epoch %d", epochID)
+ }
+
+ logging.Debug(verifierLogTag+"Submitting verification vector", inferenceTypes.BLS, "epochID", epochID)
+
+ // Submit the verification vector using the dealer validity we already determined
+ msg := &types.MsgSubmitVerificationVector{
+ Creator: bm.cosmosClient.GetAccountAddress(),
+ EpochId: epochID,
+ DealerValidity: verificationResult.DealerValidity,
+ }
+
+ _, err := bm.cosmosClient.SubmitVerificationVector(msg)
+ if err != nil {
+ return fmt.Errorf("failed to submit verification vector: %w", err)
+ }
+
+ logging.Debug(verifierLogTag+"Successfully submitted verification vector", inferenceTypes.BLS,
+ "epochID", epochID,
+ "validDealers", countTrueValues(verificationResult.DealerValidity),
+ "totalDealers", len(verificationResult.DealerValidity))
+
+ return nil
+}
+
+// countTrueValues counts the number of true values in a boolean slice
+func countTrueValues(values []bool) int {
+ count := 0
+ for _, v := range values {
+ if v {
+ count++
+ }
+ }
+ return count
+}
+
+// ProcessGroupPublicKeyGenerated handles the DKG completion event
+func (bm *BlsManager) ProcessGroupPublicKeyGeneratedToVerify(event *chainevents.JSONRPCResponse) error {
+ // Extract epochID from event
+ epochIDs, ok := event.Result.Events["inference.bls.EventGroupPublicKeyGenerated.epoch_id"]
+ if !ok || len(epochIDs) == 0 {
+ return fmt.Errorf("epoch_id not found in group public key generated event")
+ }
+
+ // Unquote the epoch_id value (handles JSON-encoded strings like "\"1\"")
+ unquotedEpochID, err := utils.UnquoteEventValue(epochIDs[0])
+ if err != nil {
+ return fmt.Errorf("failed to unquote epoch_id: %w", err)
+ }
+
+ epochID, err := strconv.ParseUint(unquotedEpochID, 10, 64)
+ if err != nil {
+ return fmt.Errorf("failed to parse epoch_id: %w", err)
+ }
+
+ logging.Debug(verifierLogTag+"Processing group public key generated", inferenceTypes.BLS, "epochID", epochID)
+
+ // Check if we already have a COMPLETED or SIGNED result for this epoch
+ existingResult := bm.GetVerificationResult(epochID)
+ if existingResult != nil && (existingResult.DkgPhase == types.DKGPhase_DKG_PHASE_COMPLETED || existingResult.DkgPhase == types.DKGPhase_DKG_PHASE_SIGNED) {
+ logging.Warn(verifierLogTag+"DKG already completed for this epoch", inferenceTypes.BLS,
+ "epochID", epochID,
+ "isParticipant", existingResult.IsParticipant)
+ return nil
+ }
+
+ // Extract epoch data from event instead of querying chain
+ epochData, err := bm.extractEpochDataFromGroupPublicKeyEvent(event)
+ if err != nil {
+ return fmt.Errorf("failed to extract epoch data from event: %w", err)
+ }
+
+ // Validate we're in the correct phase
+ if epochData.DkgPhase != types.DKGPhase_DKG_PHASE_COMPLETED && epochData.DkgPhase != types.DKGPhase_DKG_PHASE_SIGNED {
+ logging.Warn(verifierLogTag+"DKG not in completed phase", inferenceTypes.BLS,
+ "epochID", epochID,
+ "currentPhase", epochData.DkgPhase)
+ return fmt.Errorf("epoch %d is not in COMPLETED or SIGNED phase, current phase: %s", epochID, epochData.DkgPhase)
+ }
+
+ // If we don't have a VERIFYING result, we need to perform verification first
+ if existingResult == nil || existingResult.DkgPhase != types.DKGPhase_DKG_PHASE_VERIFYING {
+ logging.Debug(verifierLogTag+"No verification result found, performing verification", inferenceTypes.BLS,
+ "epochID", epochID,
+ "existingPhase", func() string {
+ if existingResult != nil {
+ return existingResult.DkgPhase.String()
+ }
+ return "none"
+ }())
+
+ // Setup and perform verification to get our slot shares using event data
+ completed, err := bm.setupAndPerformVerification(epochID, epochData)
+ if err != nil {
+ return fmt.Errorf("failed to setup and perform verification for epoch %d: %w", epochID, err)
+ }
+
+ if !completed {
+ logging.Warn(verifierLogTag+"Not a participant in this DKG round", inferenceTypes.BLS, "epochID", epochID)
+ return nil
+ }
+
+ // Get the updated verification result
+ existingResult = bm.GetVerificationResult(epochID)
+ if existingResult == nil {
+ return fmt.Errorf("verification result not found after performing verification for epoch %d", epochID)
+ }
+ }
+
+ // Update the verification result to COMPLETED phase and store group public key
+ // Validate group public key format before storing (should be 96 bytes for compressed G2)
+ if len(epochData.GroupPublicKey) != 96 {
+ logging.Warn(verifierLogTag+"Invalid group public key length from epoch data", inferenceTypes.BLS,
+ "epochID", epochID,
+ "expectedBytes", 96,
+ "actualBytes", len(epochData.GroupPublicKey))
+ return fmt.Errorf("invalid group public key length: expected 96 bytes, got %d", len(epochData.GroupPublicKey))
+ }
+
+ logging.Debug(verifierLogTag+"Group public key validated from epoch data", inferenceTypes.BLS,
+ "epochID", epochID,
+ "groupPubKeyBytes", len(epochData.GroupPublicKey))
+
+ completedResult := &VerificationResult{
+ EpochID: epochID,
+ DkgPhase: types.DKGPhase_DKG_PHASE_COMPLETED,
+ IsParticipant: existingResult.IsParticipant,
+ SlotRange: existingResult.SlotRange,
+ DealerShares: existingResult.DealerShares,
+ DealerValidity: existingResult.DealerValidity,
+ AggregatedShares: existingResult.AggregatedShares,
+ ValidDealers: epochData.ValidDealers, // Store consensus valid dealers from event
+ GroupPublicKey: epochData.GroupPublicKey, // Store validated group public key from epoch data
+ }
+
+ // Store the completed verification result
+ bm.storeVerificationResult(completedResult)
+
+ logging.Info(verifierLogTag+"Successfully processed DKG completion", inferenceTypes.BLS,
+ "epochID", epochID,
+ "isParticipant", completedResult.IsParticipant,
+ "slotRange", completedResult.SlotRange,
+ "aggregatedSharesCount", len(completedResult.AggregatedShares),
+ "phase", completedResult.DkgPhase)
+
+ return nil
+}
+
+// extractEpochDataFromGroupPublicKeyEvent extracts epoch data from a group public key generated event
+func (bm *BlsManager) extractEpochDataFromGroupPublicKeyEvent(event *chainevents.JSONRPCResponse) (*types.EpochBLSData, error) {
+ // Extract epoch data from event - this should be a JSON-encoded object
+ epochDataStrs, ok := event.Result.Events["inference.bls.EventGroupPublicKeyGenerated.epoch_data"]
+ if !ok || len(epochDataStrs) == 0 {
+ return nil, fmt.Errorf("epoch_data not found in group public key generated event")
+ }
+
+ // The epoch_data field should be a JSON-encoded EpochBLSData object
+ // First, unquote the JSON string if it's quoted
+ unquotedEpochData, err := utils.UnquoteEventValue(epochDataStrs[0])
+ if err != nil {
+ return nil, fmt.Errorf("failed to unquote epoch_data: %w", err)
+ }
+
+ // Parse the epoch data using the helper function that handles type conversions
+ epochData, err := bm.parseEpochDataFromJSON(unquotedEpochData)
+ if err != nil {
+ return nil, fmt.Errorf("failed to parse epoch_data: %w", err)
+ }
+
+ return epochData, nil
+}
+
+// parseEpochDataFromJSON parses epoch data from JSON with explicit type conversion for protobuf fields
+func (bm *BlsManager) parseEpochDataFromJSON(jsonStr string) (*types.EpochBLSData, error) {
+ // Parse the JSON into a map first to handle type conversions
+ var epochDataMap map[string]interface{}
+ err := json.Unmarshal([]byte(jsonStr), &epochDataMap)
+ if err != nil {
+ return nil, fmt.Errorf("failed to unmarshal JSON to map: %w", err)
+ }
+
+ // Manually convert string numbers to proper types for protobuf fields
+ if epochIDStr, ok := epochDataMap["epoch_id"].(string); ok {
+ if epochID, err := strconv.ParseUint(epochIDStr, 10, 64); err == nil {
+ epochDataMap["epoch_id"] = epochID
+ }
+ }
+
+ if iTotalSlotsStr, ok := epochDataMap["i_total_slots"].(string); ok {
+ if iTotalSlots, err := strconv.ParseUint(iTotalSlotsStr, 10, 32); err == nil {
+ epochDataMap["i_total_slots"] = uint32(iTotalSlots)
+ }
+ }
+
+ if tSlotsDegreeStr, ok := epochDataMap["t_slots_degree"].(string); ok {
+ if tSlotsDegree, err := strconv.ParseUint(tSlotsDegreeStr, 10, 32); err == nil {
+ epochDataMap["t_slots_degree"] = uint32(tSlotsDegree)
+ }
+ }
+
+ // Handle DKGPhase enum conversion
+ if dkgPhaseStr, ok := epochDataMap["dkg_phase"].(string); ok {
+ switch dkgPhaseStr {
+ case "DKG_PHASE_UNDEFINED":
+ epochDataMap["dkg_phase"] = int32(0)
+ case "DKG_PHASE_DEALING":
+ epochDataMap["dkg_phase"] = int32(1)
+ case "DKG_PHASE_VERIFYING":
+ epochDataMap["dkg_phase"] = int32(2)
+ case "DKG_PHASE_COMPLETED":
+ epochDataMap["dkg_phase"] = int32(3)
+ case "DKG_PHASE_FAILED":
+ epochDataMap["dkg_phase"] = int32(4)
+ default:
+ // Try to parse as number if it's a numeric string
+ if dkgPhaseNum, err := strconv.ParseUint(dkgPhaseStr, 10, 32); err == nil {
+ epochDataMap["dkg_phase"] = int32(dkgPhaseNum)
+ }
+ }
+ }
+
+ if dealingDeadlineStr, ok := epochDataMap["dealing_phase_deadline_block"].(string); ok {
+ if dealingDeadline, err := strconv.ParseInt(dealingDeadlineStr, 10, 64); err == nil {
+ epochDataMap["dealing_phase_deadline_block"] = dealingDeadline
+ }
+ }
+
+ if verifyingDeadlineStr, ok := epochDataMap["verifying_phase_deadline_block"].(string); ok {
+ if verifyingDeadline, err := strconv.ParseInt(verifyingDeadlineStr, 10, 64); err == nil {
+ epochDataMap["verifying_phase_deadline_block"] = verifyingDeadline
+ }
+ }
+
+ // Convert the map back to JSON with proper type handling
+ convertedJSON, err := json.Marshal(epochDataMap)
+ if err != nil {
+ return nil, fmt.Errorf("failed to marshal converted epoch_data: %w", err)
+ }
+
+ // Now parse into the actual EpochBLSData struct
+ var epochData types.EpochBLSData
+ err = json.Unmarshal(convertedJSON, &epochData)
+ if err != nil {
+ return nil, fmt.Errorf("failed to unmarshal epoch_data JSON to struct: %w", err)
+ }
+
+ return &epochData, nil
+}
+
+// extractEpochDataFromVerifyingEvent extracts epoch data from a verifying event
+func (bm *BlsManager) extractEpochDataFromVerifyingEvent(event *chainevents.JSONRPCResponse) (*types.EpochBLSData, error) {
+ // Extract epoch data from event - this should be a JSON-encoded object
+ epochDataStrs, ok := event.Result.Events["inference.bls.EventVerifyingPhaseStarted.epoch_data"]
+ if !ok || len(epochDataStrs) == 0 {
+ return nil, fmt.Errorf("epoch_data not found in verifying phase started event")
+ }
+
+ // The epoch_data field should be a JSON-encoded EpochBLSData object
+ // First, unquote the JSON string if it's quoted
+ unquotedEpochData, err := utils.UnquoteEventValue(epochDataStrs[0])
+ if err != nil {
+ return nil, fmt.Errorf("failed to unquote epoch_data: %w", err)
+ }
+
+ // Parse the epoch data using the helper function that handles type conversions
+ epochData, err := bm.parseEpochDataFromJSON(unquotedEpochData)
+ if err != nil {
+ return nil, fmt.Errorf("failed to parse epoch_data: %w", err)
+ }
+
+ return epochData, nil
+}
diff --git a/decentralized-api/internal/bls/verifier_test.go b/decentralized-api/internal/bls/verifier_test.go
new file mode 100644
index 000000000..3b8ee88a2
--- /dev/null
+++ b/decentralized-api/internal/bls/verifier_test.go
@@ -0,0 +1,375 @@
+package bls
+
+import (
+ "strings"
+ "testing"
+
+ "decentralized-api/cosmosclient"
+ "decentralized-api/internal/event_listener/chainevents"
+
+ "github.com/consensys/gnark-crypto/ecc/bls12-381/fr"
+ "github.com/productscience/inference/x/bls/types"
+ "github.com/stretchr/testify/assert"
+)
+
+// createMockCosmosClient creates a minimal mock cosmos client for testing
+func createMockCosmosClient() cosmosclient.InferenceCosmosClient {
+ return cosmosclient.InferenceCosmosClient{
+ Address: "cosmos1testaddress",
+ }
+}
+
+func TestNewBlsManager(t *testing.T) {
+ // Test with mock client for basic construction
+ blsManager := NewBlsManager(createMockCosmosClient())
+
+ assert.NotNil(t, blsManager)
+ assert.NotNil(t, blsManager.cache) // Should have cache initialized
+ assert.Nil(t, blsManager.GetCurrentVerificationResult()) // Should be nil until verification starts
+}
+
+func TestVerificationResult(t *testing.T) {
+ // Test VerificationResult structure
+ result := &VerificationResult{
+ EpochID: 1,
+ DkgPhase: types.DKGPhase_DKG_PHASE_VERIFYING,
+ IsParticipant: true,
+ SlotRange: [2]uint32{0, 1}, // Slots 0 and 1
+ }
+
+ // Add some test aggregated shares
+ share1 := fr.Element{}
+ share1.SetUint64(123)
+ share2 := fr.Element{}
+ share2.SetUint64(456)
+
+ result.AggregatedShares = []fr.Element{share1, share2}
+
+ assert.Equal(t, uint64(1), result.EpochID)
+ assert.Equal(t, types.DKGPhase_DKG_PHASE_VERIFYING, result.DkgPhase)
+ assert.True(t, result.IsParticipant)
+ assert.Equal(t, [2]uint32{0, 1}, result.SlotRange)
+ assert.Len(t, result.AggregatedShares, 2)
+ assert.Equal(t, share1.String(), result.AggregatedShares[0].String())
+ assert.Equal(t, share2.String(), result.AggregatedShares[1].String())
+}
+
+func TestCountTrueValues(t *testing.T) {
+ tests := []struct {
+ name string
+ input []bool
+ expected int
+ }{
+ {"empty slice", []bool{}, 0},
+ {"all false", []bool{false, false, false}, 0},
+ {"all true", []bool{true, true, true}, 3},
+ {"mixed", []bool{true, false, true, false, true}, 3},
+ {"single true", []bool{true}, 1},
+ {"single false", []bool{false}, 0},
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ result := countTrueValues(tt.input)
+ assert.Equal(t, tt.expected, result)
+ })
+ }
+}
+
+func TestVerificationCache(t *testing.T) {
+ cache := NewVerificationCache()
+
+ // Test empty cache
+ assert.Nil(t, cache.Get(1))
+ assert.Nil(t, cache.GetCurrent())
+ assert.Empty(t, cache.GetCachedEpochs())
+
+ // Create test verification results
+ result1 := &VerificationResult{
+ EpochID: 1,
+ DkgPhase: types.DKGPhase_DKG_PHASE_VERIFYING,
+ IsParticipant: true,
+ SlotRange: [2]uint32{0, 1},
+ }
+
+ result2 := &VerificationResult{
+ EpochID: 2,
+ DkgPhase: types.DKGPhase_DKG_PHASE_COMPLETED,
+ IsParticipant: true,
+ SlotRange: [2]uint32{2, 3},
+ }
+
+ result3 := &VerificationResult{
+ EpochID: 3,
+ DkgPhase: types.DKGPhase_DKG_PHASE_VERIFYING,
+ IsParticipant: true,
+ SlotRange: [2]uint32{4, 5},
+ }
+
+ // Store first result
+ cache.Store(result1)
+ assert.Equal(t, result1, cache.Get(1))
+ assert.Equal(t, result1, cache.GetCurrent())
+ assert.Len(t, cache.GetCachedEpochs(), 1)
+
+ // Store second result
+ cache.Store(result2)
+ assert.Equal(t, result1, cache.Get(1))
+ assert.Equal(t, result2, cache.Get(2))
+ assert.Equal(t, result2, cache.GetCurrent()) // Should return highest epoch
+ assert.Len(t, cache.GetCachedEpochs(), 2)
+
+ // Store third result - should remove epoch 1
+ cache.Store(result3)
+ assert.Nil(t, cache.Get(1)) // Should be removed
+ assert.Equal(t, result2, cache.Get(2)) // Should still exist
+ assert.Equal(t, result3, cache.Get(3)) // Should exist
+ assert.Equal(t, result3, cache.GetCurrent()) // Should return highest epoch
+ assert.Len(t, cache.GetCachedEpochs(), 2)
+
+ // Verify cached epochs
+ epochs := cache.GetCachedEpochs()
+ assert.Contains(t, epochs, uint64(2))
+ assert.Contains(t, epochs, uint64(3))
+ assert.NotContains(t, epochs, uint64(1))
+}
+
+func TestVerificationCacheEdgeCases(t *testing.T) {
+ cache := NewVerificationCache()
+
+ // Test storing nil result
+ cache.Store(nil)
+ assert.Empty(t, cache.GetCachedEpochs())
+
+ // Test epoch 0
+ result0 := &VerificationResult{
+ EpochID: 0,
+ DkgPhase: types.DKGPhase_DKG_PHASE_DEALING,
+ }
+ cache.Store(result0)
+ assert.Equal(t, result0, cache.Get(0))
+
+ // Test epoch 1
+ result1 := &VerificationResult{
+ EpochID: 1,
+ DkgPhase: types.DKGPhase_DKG_PHASE_VERIFYING,
+ }
+ cache.Store(result1)
+ assert.Equal(t, result0, cache.Get(0)) // Should still exist
+ assert.Equal(t, result1, cache.Get(1)) // Should exist
+ assert.Len(t, cache.GetCachedEpochs(), 2)
+
+ // Both should still exist (no cleanup until epoch >= 2)
+ assert.NotNil(t, cache.Get(0))
+ assert.NotNil(t, cache.Get(1))
+}
+
+func TestVerifierCacheIntegration(t *testing.T) {
+ blsManager := NewBlsManager(createMockCosmosClient())
+
+ // Test initial state
+ assert.NotNil(t, blsManager.cache)
+ assert.Nil(t, blsManager.GetCurrentVerificationResult())
+ assert.Empty(t, blsManager.GetCachedEpochs())
+
+ // Manually create and store verification results
+ result1 := &VerificationResult{
+ EpochID: 1,
+ DkgPhase: types.DKGPhase_DKG_PHASE_VERIFYING,
+ IsParticipant: true,
+ SlotRange: [2]uint32{0, 1},
+ }
+
+ result2 := &VerificationResult{
+ EpochID: 2,
+ DkgPhase: types.DKGPhase_DKG_PHASE_COMPLETED,
+ IsParticipant: true,
+ SlotRange: [2]uint32{2, 3},
+ }
+
+ blsManager.cache.Store(result1)
+ blsManager.cache.Store(result2)
+
+ // Test convenience methods
+ assert.Equal(t, result1, blsManager.GetVerificationResult(1))
+ assert.Equal(t, result2, blsManager.GetVerificationResult(2))
+ assert.Equal(t, result2, blsManager.GetCurrentVerificationResult())
+
+ epochs := blsManager.GetCachedEpochs()
+ assert.Len(t, epochs, 2)
+ assert.Contains(t, epochs, uint64(1))
+ assert.Contains(t, epochs, uint64(2))
+}
+
+func TestStoreVerificationResult(t *testing.T) {
+ blsManager := NewBlsManager(createMockCosmosClient())
+
+ // Test storing a valid result
+ result1 := &VerificationResult{
+ EpochID: 1,
+ DkgPhase: types.DKGPhase_DKG_PHASE_VERIFYING,
+ IsParticipant: true,
+ SlotRange: [2]uint32{0, 1},
+ }
+
+ blsManager.storeVerificationResult(result1)
+
+ // Verify it was stored
+ stored := blsManager.GetVerificationResult(1)
+ assert.NotNil(t, stored)
+ assert.Equal(t, uint64(1), stored.EpochID)
+ assert.Equal(t, types.DKGPhase_DKG_PHASE_VERIFYING, stored.DkgPhase)
+ assert.True(t, stored.IsParticipant)
+ assert.Equal(t, [2]uint32{0, 1}, stored.SlotRange)
+
+ // Test storing nil result - should not panic
+ blsManager.storeVerificationResult(nil)
+
+ // Cache should still only have one result
+ assert.Len(t, blsManager.GetCachedEpochs(), 1)
+
+ // Test storing another result
+ result2 := &VerificationResult{
+ EpochID: 2,
+ DkgPhase: types.DKGPhase_DKG_PHASE_COMPLETED,
+ IsParticipant: false,
+ SlotRange: [2]uint32{2, 3},
+ }
+
+ blsManager.storeVerificationResult(result2)
+
+ // Should have both results now
+ assert.Len(t, blsManager.GetCachedEpochs(), 2)
+ assert.NotNil(t, blsManager.GetVerificationResult(1))
+ assert.NotNil(t, blsManager.GetVerificationResult(2))
+
+ // Current should be the latest (highest epoch ID)
+ current := blsManager.GetCurrentVerificationResult()
+ assert.Equal(t, uint64(2), current.EpochID)
+ assert.Equal(t, types.DKGPhase_DKG_PHASE_COMPLETED, current.DkgPhase)
+}
+
+func TestProcessVerifyingPhaseStartedWithExistingResult(t *testing.T) {
+ blsManager := NewBlsManager(createMockCosmosClient())
+
+ // Mock event for epoch 5 with complete and proper mock data
+ completeEpochData := `{
+ "epoch_id": "5",
+ "i_total_slots": "100",
+ "t_slots_degree": "50",
+ "dkg_phase": "DKG_PHASE_VERIFYING",
+ "dealing_phase_deadline_block": "950",
+ "verifying_phase_deadline_block": "1000",
+ "participants": [
+ {
+ "address": "cosmos1test",
+ "percentage_weight": "0.5",
+ "secp256k1_public_key": "AqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
+ "slot_start_index": "0",
+ "slot_end_index": "49"
+ }
+ ],
+ "dealer_parts": [],
+ "verification_submissions": [],
+ "group_public_key": "",
+ "valid_dealers": []
+ }`
+
+ event := &chainevents.JSONRPCResponse{
+ Result: chainevents.Result{
+ Events: map[string][]string{
+ "inference.bls.EventVerifyingPhaseStarted.epoch_id": {"5"},
+ "inference.bls.EventVerifyingPhaseStarted.verifying_phase_deadline_block": {"1000"},
+ "inference.bls.EventVerifyingPhaseStarted.epoch_data": {completeEpochData},
+ },
+ },
+ }
+
+ // Manually store a verification result for epoch 5 with VERIFYING phase
+ result := &VerificationResult{
+ EpochID: 5,
+ DkgPhase: types.DKGPhase_DKG_PHASE_VERIFYING,
+ IsParticipant: true,
+ SlotRange: [2]uint32{0, 1},
+ }
+ blsManager.cache.Store(result)
+
+ // Test: Call should skip verification because we already have a VERIFYING result
+ err := blsManager.ProcessVerifyingPhaseStarted(event)
+ assert.NoError(t, err) // Should succeed without trying to verify again
+
+ // Update the result to COMPLETED phase
+ resultCompleted := &VerificationResult{
+ EpochID: 5,
+ DkgPhase: types.DKGPhase_DKG_PHASE_COMPLETED,
+ IsParticipant: true,
+ SlotRange: [2]uint32{0, 1},
+ }
+ blsManager.cache.Store(resultCompleted)
+
+ // Test: Call should also skip verification because we have a COMPLETED result
+ err = blsManager.ProcessVerifyingPhaseStarted(event)
+ assert.NoError(t, err) // Should succeed without trying to verify again
+}
+
+func TestProcessGroupPublicKeyGeneratedWithExistingResult(t *testing.T) {
+ blsManager := NewBlsManager(createMockCosmosClient())
+
+ // Mock event for epoch 10
+ event := &chainevents.JSONRPCResponse{
+ Result: chainevents.Result{
+ Events: map[string][]string{
+ "inference.bls.EventGroupPublicKeyGenerated.epoch_id": {"10"},
+ "inference.bls.EventGroupPublicKeyGenerated.group_public_key": {"0123456789abcdef" + strings.Repeat("00", 88)}, // 96 bytes hex
+ },
+ },
+ }
+
+ // Store a COMPLETED result and verify it skips processing
+ completedResult := &VerificationResult{
+ EpochID: 10,
+ DkgPhase: types.DKGPhase_DKG_PHASE_COMPLETED,
+ IsParticipant: true,
+ SlotRange: [2]uint32{0, 1},
+ }
+ blsManager.cache.Store(completedResult)
+
+ // This should skip processing and return successfully
+ err := blsManager.ProcessGroupPublicKeyGeneratedToVerify(event)
+ assert.NoError(t, err) // Should succeed without trying to query chain
+
+ // Verify the result is still COMPLETED and unchanged
+ stored := blsManager.GetVerificationResult(10)
+ assert.NotNil(t, stored)
+ assert.Equal(t, types.DKGPhase_DKG_PHASE_COMPLETED, stored.DkgPhase)
+}
+
+func TestProcessGroupPublicKeyGeneratedEventParsing(t *testing.T) {
+ blsManager := NewBlsManager(createMockCosmosClient())
+
+ // Test invalid event - missing epoch_id
+ invalidEvent := &chainevents.JSONRPCResponse{
+ Result: chainevents.Result{
+ Events: map[string][]string{
+ "inference.bls.EventGroupPublicKeyGenerated.group_public_key": {"test"},
+ },
+ },
+ }
+
+ err := blsManager.ProcessGroupPublicKeyGeneratedToVerify(invalidEvent)
+ assert.Error(t, err)
+ assert.Contains(t, err.Error(), "epoch_id not found")
+
+ // Test invalid epoch_id format
+ invalidEpochEvent := &chainevents.JSONRPCResponse{
+ Result: chainevents.Result{
+ Events: map[string][]string{
+ "inference.bls.EventGroupPublicKeyGenerated.epoch_id": {"invalid"},
+ },
+ },
+ }
+
+ err = blsManager.ProcessGroupPublicKeyGeneratedToVerify(invalidEpochEvent)
+ assert.Error(t, err)
+ assert.Contains(t, err.Error(), "failed to parse epoch_id")
+}
diff --git a/decentralized-api/internal/epoch_group_cache.go b/decentralized-api/internal/epoch_group_cache.go
new file mode 100644
index 000000000..8f2cf8f8e
--- /dev/null
+++ b/decentralized-api/internal/epoch_group_cache.go
@@ -0,0 +1,61 @@
+package internal
+
+import (
+ "context"
+ "decentralized-api/cosmosclient"
+ "decentralized-api/logging"
+ "sync"
+
+ "github.com/productscience/inference/x/inference/types"
+)
+
+type EpochGroupDataCache struct {
+ mu sync.RWMutex
+
+ cachedEpochIndex uint64
+ cachedGroupData *types.EpochGroupData
+
+ recorder cosmosclient.CosmosMessageClient
+}
+
+func NewEpochGroupDataCache(recorder cosmosclient.CosmosMessageClient) *EpochGroupDataCache {
+ return &EpochGroupDataCache{
+ recorder: recorder,
+ }
+}
+
+func (c *EpochGroupDataCache) GetCurrentEpochGroupData(currentEpochIndex uint64) (*types.EpochGroupData, error) {
+ c.mu.RLock()
+ if c.cachedGroupData != nil && c.cachedEpochIndex == currentEpochIndex {
+ defer c.mu.RUnlock()
+ return c.cachedGroupData, nil
+ }
+ c.mu.RUnlock()
+
+ c.mu.Lock()
+ defer c.mu.Unlock()
+
+ if c.cachedGroupData != nil && c.cachedEpochIndex == currentEpochIndex {
+ return c.cachedGroupData, nil
+ }
+
+ logging.Info("Fetching new epoch group data", types.Config,
+ "cachedEpochIndex", c.cachedEpochIndex, "currentEpochIndex", currentEpochIndex)
+
+ queryClient := c.recorder.NewInferenceQueryClient()
+ req := &types.QueryCurrentEpochGroupDataRequest{}
+ resp, err := queryClient.CurrentEpochGroupData(context.Background(), req)
+ if err != nil {
+ logging.Warn("Failed to query current epoch group data", types.Config, "error", err)
+ return nil, err
+ }
+
+ c.cachedEpochIndex = currentEpochIndex
+ c.cachedGroupData = &resp.EpochGroupData
+
+ logging.Info("Updated epoch group data cache", types.Config,
+ "epochIndex", currentEpochIndex,
+ "validationWeights", len(resp.EpochGroupData.ValidationWeights))
+
+ return c.cachedGroupData, nil
+}
diff --git a/decentralized-api/internal/event_listener/README.md b/decentralized-api/internal/event_listener/README.md
new file mode 100644
index 000000000..80d5add37
--- /dev/null
+++ b/decentralized-api/internal/event_listener/README.md
@@ -0,0 +1,128 @@
+# OnNewBlockDispatcher Architecture
+
+## Overview
+
+The OnNewBlockDispatcher provides a more testable and maintainable approach to processing blockchain events. It separates concerns and makes the system more robust by eliminating the need for time-based reconciliation in favor of block-driven reconciliation.
+
+## Key Components
+
+### 1. Data Structures
+
+- **NewBlockInfo**: Parsed block information (height, hash, timestamp)
+- **PhaseInfo**: Complete phase state (epoch, phase, block info, PoC parameters, sync status)
+- **ReconciliationConfig**: Configures when reconciliation should trigger (block interval + time fallback)
+
+### 2. OnNewBlockDispatcher
+
+The main orchestrator that:
+1. Queries network state (sync status, epoch params)
+2. Updates phase tracker with pure functions
+3. Handles phase transitions and stage events
+4. Triggers reconciliation based on block count and time
+5. Manages seed generation and money claiming
+
+### 3. Benefits Over Previous Architecture
+
+#### Better Testability
+- **Unit Tests**: Can test reconciliation logic without running blockchain
+- **Mock Data**: Easy to create fake NewBlockInfo structs for testing
+- **Phase Simulation**: Test different phase transitions independently
+
+#### Better Separation of Concerns
+- **EventListener**: Only parses events and delegates to dispatcher
+- **Dispatcher**: Handles business logic and orchestration
+- **PhaseTracker**: Pure functions for phase management
+- **Broker**: Receives commands with all necessary data
+
+#### More Robust Reconciliation
+- **Block-Driven**: Reconciliation triggered by actual blockchain progress
+- **Self-Contained Commands**: Commands include all phase data at creation time
+- **Configurable**: Hybrid approach with block interval + time fallback
+
+## Command Pattern Improvements
+
+All commands now include phase data at creation time instead of accessing shared state:
+
+```go
+// Before: Commands accessed phase tracker during execution
+StartPocCommand{} // Had to query phase tracker internally
+
+// After: Commands are self-contained
+StartPocCommand{
+ CurrentEpoch: 5,
+ CurrentPhase: chainphase.PhasePoC,
+ // ... other fields
+}
+```
+
+This makes commands:
+- **Thread-safe**: No shared state access during execution
+- **Testable**: Easy to create with known phase data
+- **Predictable**: All data available at command creation time
+
+## Reconciliation Strategy
+
+### Hybrid Approach
+- **Primary**: Every N blocks (configurable, default 5)
+- **Fallback**: Every N seconds (configurable, default 30s)
+
+### Benefits
+- **Responsive**: Reacts immediately to blockchain events
+- **Reliable**: Time fallback ensures reconciliation even if blocks are slow
+- **Efficient**: No constant polling, only when needed
+
+## Testing Examples
+
+```go
+// Test reconciliation logic with fake data
+func TestShouldTriggerReconciliation(t *testing.T) {
+ dispatcher := &OnNewBlockDispatcher{
+ reconciliationConfig: ReconciliationConfig{
+ BlockInterval: 5,
+ LastBlockHeight: 10,
+ },
+ }
+
+ phaseInfo := &PhaseInfo{BlockHeight: 16} // 6 blocks later
+ assert.True(t, dispatcher.shouldTriggerReconciliation(phaseInfo))
+}
+
+// Test phase transitions without blockchain
+func TestPhaseTransitions(t *testing.T) {
+ phaseInfo := &PhaseInfo{
+ CurrentPhase: chainphase.PhasePoC,
+ PoCParameters: &PoCParams{StartBlockHeight: 1000},
+ }
+ // Test phase-specific logic...
+}
+```
+
+## Migration Notes
+
+### EventListener Changes
+- Added `OnNewBlockDispatcher` field
+- Updated `processEvent` to use dispatcher for new blocks
+- Removed direct calls to `poc.ProcessNewBlockEvent`
+
+### Broker Changes
+- Disabled time-based `nodeReconciliationWorker`
+- Commands now include phase data
+- Reconciliation triggered by dispatcher
+
+### PhaseTracker Changes
+- Sync status updates moved to dispatcher
+- Network queries moved to dispatcher
+- Focused on pure state management functions
+
+## Configuration
+
+The reconciliation behavior can be configured:
+
+```go
+reconciliationConfig: ReconciliationConfig{
+ BlockInterval: 5, // Every 5 blocks
+ TimeInterval: 30 * time.Second, // OR every 30 seconds
+}
+```
+
+This allows tuning based on network conditions and requirements.
\ No newline at end of file
diff --git a/decentralized-api/internal/event_listener/block_observer.go b/decentralized-api/internal/event_listener/block_observer.go
new file mode 100644
index 000000000..9726c05e1
--- /dev/null
+++ b/decentralized-api/internal/event_listener/block_observer.go
@@ -0,0 +1,254 @@
+package event_listener
+
+import (
+ "decentralized-api/apiconfig"
+ "decentralized-api/internal/event_listener/chainevents"
+ "decentralized-api/logging"
+ "strconv"
+
+ "context"
+ "decentralized-api/cosmosclient"
+
+ "sync/atomic"
+
+ coretypes "github.com/cometbft/cometbft/rpc/core/types"
+ "github.com/productscience/inference/x/inference/types"
+)
+
+type BlockObserver struct {
+ lastProcessedBlockHeight atomic.Int64
+ lastQueriedBlockHeight atomic.Int64
+ currentBlockHeight atomic.Int64
+ ConfigManager *apiconfig.ConfigManager
+ Queue *UnboundedQueue[*chainevents.JSONRPCResponse]
+ caughtUp atomic.Bool
+ tmClient TmHTTPClient
+ notify chan struct{}
+}
+
+// TmHTTPClient abstracts the subset of RPC methods we need
+type TmHTTPClient interface {
+ BlockResults(ctx context.Context, height *int64) (*coretypes.ResultBlockResults, error)
+ Status(ctx context.Context) (*coretypes.ResultStatus, error)
+}
+
+func NewBlockObserver(manager *apiconfig.ConfigManager) *BlockObserver {
+ queue := NewUnboundedQueue[*chainevents.JSONRPCResponse]()
+ // Initialize Tendermint RPC client
+ httpClient, err := cosmosclient.NewRpcClient(manager.GetChainNodeConfig().Url)
+ if err != nil {
+ logging.Error("Failed to create Tendermint RPC client for BlockObserver", types.EventProcessing, "error", err)
+ }
+
+ bo := &BlockObserver{
+ ConfigManager: manager,
+ Queue: queue,
+ tmClient: httpClient,
+ notify: make(chan struct{}, 1),
+ }
+
+ bo.lastProcessedBlockHeight.Store(manager.GetLastProcessedHeight())
+ // Start querying from last processed height
+ bo.lastQueriedBlockHeight.Store(bo.lastProcessedBlockHeight.Load())
+ bo.currentBlockHeight.Store(manager.GetHeight())
+ bo.caughtUp.Store(false)
+
+ // If first run and we have a current height but no last processed, start from current-1
+ if bo.lastProcessedBlockHeight.Load() == 0 && bo.currentBlockHeight.Load() > 0 {
+ bo.lastProcessedBlockHeight.Store(bo.currentBlockHeight.Load() - 1)
+ bo.lastQueriedBlockHeight.Store(bo.lastProcessedBlockHeight.Load())
+ }
+
+ return bo
+}
+
+// NewBlockObserverWithClient allows injecting a custom Tendermint RPC client (used in tests)
+func NewBlockObserverWithClient(manager *apiconfig.ConfigManager, client TmHTTPClient) *BlockObserver {
+ queue := NewUnboundedQueue[*chainevents.JSONRPCResponse]()
+
+ bo := &BlockObserver{
+ ConfigManager: manager,
+ Queue: queue,
+ tmClient: client,
+ notify: make(chan struct{}, 1),
+ }
+
+ bo.lastProcessedBlockHeight.Store(manager.GetLastProcessedHeight())
+ bo.currentBlockHeight.Store(manager.GetHeight())
+ bo.caughtUp.Store(false)
+
+ if bo.lastProcessedBlockHeight.Load() == 0 && bo.currentBlockHeight.Load() > 0 {
+ bo.lastProcessedBlockHeight.Store(bo.currentBlockHeight.Load() - 1)
+ }
+ return bo
+}
+
+// UpdateStatus sets both height and caughtUp atomically and signals processing only if changed
+func (bo *BlockObserver) updateStatus(newHeight int64, caughtUp bool) {
+ prevHeight := bo.currentBlockHeight.Load()
+ prevCaught := bo.caughtUp.Load()
+ changed := (newHeight != prevHeight) || (caughtUp != prevCaught)
+ if !changed {
+ return
+ }
+ bo.currentBlockHeight.Store(newHeight)
+ bo.caughtUp.Store(caughtUp)
+ select {
+ case bo.notify <- struct{}{}:
+ default:
+ // already notified; coalesce
+ }
+}
+
+// getStartProcessingBlock determines the correct starting block height for processing
+// Returns max(currentBlock - 500, firstAvailableBlock) to handle snapshot nodes
+func (bo *BlockObserver) getStartProcessingBlock(ctx context.Context, currentBlock int64) int64 {
+ if bo.tmClient == nil {
+ logging.Warn("tmClient is nil, starting from recent block to avoid unavailable blocks", types.EventProcessing)
+ return currentBlock - 1
+ }
+
+ status, err := bo.tmClient.Status(ctx)
+ if err != nil || status == nil {
+ logging.Warn("Failed to fetch chain status, starting from recent block to avoid unavailable blocks", types.EventProcessing, "error", err)
+ return currentBlock - 1
+ }
+
+ firstAvailable := status.SyncInfo.EarliestBlockHeight
+ targetStart := currentBlock - 500
+
+ if targetStart < firstAvailable {
+ logging.Info("Adjusting start block for snapshot node", types.EventProcessing,
+ "targetStart", targetStart,
+ "firstAvailable", firstAvailable,
+ "usingBlock", firstAvailable)
+ return firstAvailable
+ }
+
+ logging.Debug("Using target start block", types.EventProcessing,
+ "startBlock", targetStart,
+ "firstAvailable", firstAvailable)
+ return targetStart
+}
+
+func (bo *BlockObserver) Process(ctx context.Context) {
+ for {
+ select {
+ case <-ctx.Done():
+ return
+ case <-bo.notify:
+ // Drain extra signals to coalesce bursts
+ drain:
+ for {
+ select {
+ case <-bo.notify:
+ continue
+ default:
+ break drain
+ }
+ }
+ if !bo.caughtUp.Load() {
+ continue
+ }
+
+ currentHeight := bo.currentBlockHeight.Load()
+ lastQueried := bo.lastQueriedBlockHeight.Load()
+
+ // Check if lastQueried is too far behind (more than 500 blocks) or invalid
+ // This handles snapshot nodes where old blocks are unavailable
+ if lastQueried < (currentHeight-500) || lastQueried <= 0 {
+ startBlock := bo.getStartProcessingBlock(ctx, currentHeight)
+ logging.Info("Resetting lastQueriedBlockHeight for block availability", types.EventProcessing,
+ "oldLastQueried", lastQueried,
+ "currentHeight", currentHeight,
+ "newStartBlock", startBlock)
+ bo.lastQueriedBlockHeight.Store(startBlock - 1)
+ }
+
+ // Process as many contiguous blocks as available (based on lastQueried)
+ for {
+ nextHeight := bo.lastQueriedBlockHeight.Load() + 1
+ if nextHeight > bo.currentBlockHeight.Load() || nextHeight <= 0 {
+ break
+ }
+ if !bo.processBlock(ctx, nextHeight) {
+ // stop on fetch error; next status change will retry
+ break
+ }
+ // Successfully enqueued events for nextHeight; advance lastQueried
+ bo.lastQueriedBlockHeight.Store(nextHeight)
+ }
+ }
+ }
+}
+
+func (bo *BlockObserver) processBlock(ctx context.Context, height int64) bool {
+ if bo.tmClient == nil {
+ logging.Warn("BlockObserver tmClient is nil, skipping", types.EventProcessing)
+ return false
+ }
+ res, err := bo.tmClient.BlockResults(ctx, &height)
+ if err != nil || res == nil {
+ logging.Warn("Failed to fetch BlockResults", types.EventProcessing, "height", height, "error", err)
+ return false
+ }
+
+ // For each tx in the block, flatten events and enqueue as synthetic Tx events
+ for txIdx, txRes := range res.TxsResults {
+ events := make(map[string][]string)
+ // Include tx.height to satisfy waitForEventHeight
+ events["tx.height"] = []string{strconv.FormatInt(height, 10)}
+
+ for _, ev := range txRes.Events {
+ evType := ev.Type
+ for _, attr := range ev.Attributes {
+ key := evType + "." + attr.Key
+ val := attr.Value
+ events[key] = append(events[key], val)
+ }
+ }
+
+ msg := &chainevents.JSONRPCResponse{
+ JSONRPC: "2.0",
+ ID: "block-" + strconv.FormatInt(height, 10) + "-tx-" + strconv.Itoa(txIdx),
+ Result: chainevents.Result{
+ Query: "block_monitor/Tx",
+ Data: chainevents.Data{Type: "tendermint/event/Tx", Value: map[string]interface{}{}},
+ Events: events,
+ },
+ }
+ // Enqueue for processing
+ bo.Queue.In <- msg
+ }
+ // Enqueue a barrier event to signal block completion when consumed
+ barrier := &chainevents.JSONRPCResponse{
+ JSONRPC: "2.0",
+ ID: "block-" + strconv.FormatInt(height, 10) + "-barrier",
+ Result: chainevents.Result{
+ Query: "block_monitor/Barrier",
+ Data: chainevents.Data{Type: systemBarrierEventType, Value: map[string]interface{}{}},
+ Events: map[string][]string{"barrier.height": {strconv.FormatInt(height, 10)}},
+ },
+ }
+ bo.Queue.In <- barrier
+ return true
+}
+
+// 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.
+func (bo *BlockObserver) signalAllEventsRead(height int64) {
+ // Future improvement: check contiguity here
+ // and roll back the lastQueried if some timeout/block difference is exceeded
+ if height < bo.lastProcessedBlockHeight.Load() {
+ logging.Warn("BlockObserver: signalAllEventsRead called for out-of-order block", types.EventProcessing, "height", height)
+ } else if height == bo.lastProcessedBlockHeight.Load() {
+ // Already processed
+ logging.Warn("BlockObserver: signalAllEventsRead called for already processed block", types.EventProcessing, "height", height)
+ } else {
+ bo.lastProcessedBlockHeight.Store(height)
+ if err := bo.ConfigManager.SetLastProcessedHeight(height); err != nil {
+ logging.Warn("BlockObserver: Failed to persist last processed height", types.Config, "error", err)
+ }
+ }
+}
diff --git a/decentralized-api/internal/event_listener/block_observer_test.go b/decentralized-api/internal/event_listener/block_observer_test.go
new file mode 100644
index 000000000..058eb4169
--- /dev/null
+++ b/decentralized-api/internal/event_listener/block_observer_test.go
@@ -0,0 +1,330 @@
+package event_listener
+
+import (
+ "context"
+ "os"
+ "sort"
+ "strconv"
+ "strings"
+ "sync"
+ "testing"
+ "time"
+
+ "decentralized-api/apiconfig"
+ "decentralized-api/cosmosclient"
+
+ abcitypes "github.com/cometbft/cometbft/abci/types"
+ coretypes "github.com/cometbft/cometbft/rpc/core/types"
+)
+
+// mockTmHTTPClient implements TmHTTPClient for tests.
+type mockTmHTTPClient struct {
+ mu sync.Mutex
+ calls []int64
+ txsPerBlock int
+}
+
+func newMockTmHTTPClient(txsPerBlock int) *mockTmHTTPClient {
+ return &mockTmHTTPClient{txsPerBlock: txsPerBlock}
+}
+
+func (m *mockTmHTTPClient) BlockResults(ctx context.Context, height *int64) (*coretypes.ResultBlockResults, error) {
+ m.mu.Lock()
+ m.calls = append(m.calls, *height)
+ m.mu.Unlock()
+
+ // Build deterministic tx results for the requested height
+ txs := make([]*abcitypes.ExecTxResult, m.txsPerBlock)
+ for i := 0; i < m.txsPerBlock; i++ {
+ txs[i] = &abcitypes.ExecTxResult{
+ Events: []abcitypes.Event{
+ {
+ Type: "inference_finished",
+ Attributes: []abcitypes.EventAttribute{
+ {Key: "inference_id", Value: "id-", Index: true},
+ },
+ },
+ },
+ }
+ }
+ return &coretypes.ResultBlockResults{TxsResults: txs}, nil
+}
+
+func (m *mockTmHTTPClient) Status(ctx context.Context) (*coretypes.ResultStatus, error) {
+ // Return a mock status with earliest block at 1 (full history available)
+ return &coretypes.ResultStatus{
+ SyncInfo: coretypes.SyncInfo{
+ EarliestBlockHeight: 1,
+ },
+ }, nil
+}
+
+// Test that BlockObserver handles a large backlog without deadlocking when the consumer is slow.
+func TestBlockObserver_StressBackpressure(t *testing.T) {
+ // Arrange
+ manager := &apiconfig.ConfigManager{}
+ bo := NewBlockObserverWithClient(manager, newMockTmHTTPClient(10))
+ // Inject mock RPC client
+ const (
+ totalBlocks = 200
+ txsPerBlock = 10
+ )
+ bo.tmClient = newMockTmHTTPClient(txsPerBlock)
+
+ ctx, cancel := context.WithCancel(context.Background())
+ defer cancel()
+ go bo.Process(ctx)
+
+ // Act: set caughtUp and jump height forward to create a backlog
+ bo.updateStatus(totalBlocks, true)
+
+ // Simulate slow consumer: delay before starting reads
+ time.Sleep(100 * time.Millisecond)
+
+ // Consume events slowly but ensure we eventually read them all (including barrier per block)
+ expectedTotal := totalBlocks * (txsPerBlock + 1)
+ received := 0
+ deadline := time.After(5 * time.Second)
+ for received < expectedTotal {
+ select {
+ case <-deadline:
+ t.Fatalf("timed out waiting for events: got %d, want %d", received, expectedTotal)
+ case ev, ok := <-bo.Queue.Out:
+ if !ok {
+ t.Fatalf("queue closed prematurely after %d events", received)
+ }
+ if ev == nil {
+ t.Fatalf("nil event received at count=%d", received)
+ }
+ received++
+ // Slow down the consumer a bit to exercise backpressure
+ if received%200 == 0 {
+ time.Sleep(5 * time.Millisecond)
+ }
+ }
+ }
+
+ // Assert: queried up to the target height
+ if got := bo.lastQueriedBlockHeight.Load(); got != totalBlocks {
+ t.Fatalf("lastQueriedBlockHeight=%d, want %d", got, totalBlocks)
+ }
+}
+
+// Test that repeated status updates without changes do not re-trigger processing.
+func TestBlockObserver_NoSpuriousWakeups(t *testing.T) {
+ manager := &apiconfig.ConfigManager{}
+ bo := NewBlockObserverWithClient(manager, newMockTmHTTPClient(1))
+
+ ctx, cancel := context.WithCancel(context.Background())
+ defer cancel()
+ go bo.Process(ctx)
+
+ // First update triggers processing of height 1 (1 tx + 1 barrier)
+ bo.updateStatus(1, true)
+
+ // Drain until barrier for height 1 is received; count tx events
+ txCount := 0
+ barrierSeen := false
+ drainDeadline := time.After(2 * time.Second)
+ for !barrierSeen {
+ select {
+ case <-drainDeadline:
+ t.Fatalf("timeout waiting for barrier for height 1")
+ case ev := <-bo.Queue.Out:
+ if ev == nil {
+ t.Fatalf("nil event while draining")
+ }
+ if ev.Result.Data.Type == systemBarrierEventType {
+ heights := ev.Result.Events["barrier.height"]
+ if len(heights) > 0 && heights[0] == "1" {
+ barrierSeen = true
+ }
+ continue
+ }
+ if ev.Result.Data.Type == "tendermint/event/Tx" {
+ txCount++
+ }
+ }
+ }
+ if txCount != 1 {
+ t.Fatalf("expected 1 tx event before barrier, got %d", txCount)
+ }
+
+ // Extra duplicate updates should not produce more events
+ for i := 0; i < 5; i++ {
+ bo.updateStatus(1, true)
+ }
+
+ select {
+ case <-time.After(200 * time.Millisecond):
+ // ok, no new events
+ case <-bo.Queue.Out:
+ t.Fatalf("received unexpected extra event after duplicate updates")
+ }
+}
+
+// TestProcessBlock_ParsesEvents validates that processBlock enqueues one message per tx
+// and includes flattened keys with "tx.height".
+func TestProcessBlock_ParsesEvents(t *testing.T) {
+ manager := &apiconfig.ConfigManager{}
+ mock := newMockTmHTTPClient(3)
+ bo := NewBlockObserverWithClient(manager, mock)
+
+ ctx, cancel := context.WithCancel(context.Background())
+ defer cancel()
+
+ height := int64(42)
+ if ok := bo.processBlock(ctx, height); !ok {
+ t.Fatalf("processBlock returned false")
+ }
+
+ // Expect 3 messages (one per tx)
+ eventTypeToAttrCount := make(map[string]int)
+ eventTypeToAttrNames := make(map[string]map[string]int)
+ for i := 0; i < 3; i++ {
+ select {
+ case <-time.After(1 * time.Second):
+ t.Fatalf("timeout waiting for event %d", i)
+ case ev := <-bo.Queue.Out:
+ if ev == nil {
+ t.Fatalf("nil event")
+ }
+ if ev.Result.Data.Type != "tendermint/event/Tx" {
+ t.Fatalf("unexpected type: %s", ev.Result.Data.Type)
+ }
+ if ev.Result.Events["tx.height"][0] != strconv.FormatInt(height, 10) {
+ t.Fatalf("tx.height mismatch: %v", ev.Result.Events["tx.height"])
+ }
+ // Our mock emits inference_finished.inference_id
+ if len(ev.Result.Events["inference_finished.inference_id"]) == 0 {
+ t.Fatalf("expected inference_finished.inference_id in events")
+ }
+
+ // accumulate stats by event type
+ for k, vals := range ev.Result.Events {
+ parts := strings.SplitN(k, ".", 2)
+ etype := parts[0]
+ eventTypeToAttrCount[etype] += len(vals)
+ if _, ok := eventTypeToAttrNames[etype]; !ok {
+ eventTypeToAttrNames[etype] = make(map[string]int)
+ }
+ aname := ""
+ if len(parts) > 1 {
+ aname = parts[1]
+ }
+ eventTypeToAttrNames[etype][aname] += len(vals)
+ }
+ }
+ }
+
+ // Log stats for mock
+ types := make([]string, 0, len(eventTypeToAttrCount))
+ for k := range eventTypeToAttrCount {
+ types = append(types, k)
+ }
+ sort.Strings(types)
+ for _, et := range types {
+ attrMap := eventTypeToAttrNames[et]
+ attrNames := make([]string, 0, len(attrMap))
+ for n := range attrMap {
+ attrNames = append(attrNames, n)
+ }
+ sort.Strings(attrNames)
+ // print top-level count and a compact attribute list
+ t.Logf("mock stats: type=%s total_attrs=%d distinct_attrs=%d", et, eventTypeToAttrCount[et], len(attrNames))
+ }
+}
+
+// TestProcessBlock_RealNodeParse hits a real node if env vars are set.
+// Env: DAPI_TEST_RPC_URL, DAPI_TEST_BLOCK_HEIGHT
+func TestProcessBlock_RealNodeParse(t *testing.T) {
+ url := os.Getenv("DAPI_TEST_RPC_URL")
+ heightStr := os.Getenv("DAPI_TEST_BLOCK_HEIGHT")
+ if url == "" || heightStr == "" {
+ t.Skip("set DAPI_TEST_RPC_URL and DAPI_TEST_BLOCK_HEIGHT to run this test")
+ }
+
+ h, err := strconv.ParseInt(heightStr, 10, 64)
+ if err != nil {
+ t.Fatalf("invalid DAPI_TEST_BLOCK_HEIGHT: %v", err)
+ }
+
+ client, err := cosmosclient.NewRpcClient(url)
+ if err != nil {
+ t.Fatalf("failed to create rpc client: %v", err)
+ }
+
+ // Probe expected tx count first
+ ctx := context.Background()
+ res, err := client.BlockResults(ctx, &h)
+ if err != nil || res == nil {
+ t.Fatalf("failed BlockResults probe: %v", err)
+ }
+ expected := len(res.TxsResults)
+
+ manager := &apiconfig.ConfigManager{}
+ bo := NewBlockObserverWithClient(manager, client)
+
+ if ok := bo.processBlock(ctx, h); !ok {
+ t.Fatalf("processBlock returned false")
+ }
+
+ received := 0
+ eventTypeToAttrCount := make(map[string]int)
+ eventTypeToAttrNames := make(map[string]map[string]int)
+ deadline := time.After(5 * time.Second)
+ for received < expected {
+ select {
+ case <-deadline:
+ t.Fatalf("timeout waiting events: got %d, want %d", received, expected)
+ case ev := <-bo.Queue.Out:
+ if ev == nil {
+ t.Fatalf("nil event")
+ }
+ received++
+ // Log parsed event keys for manual inspection
+ t.Logf("event %d: id=%s keys=%d", received, ev.ID, len(ev.Result.Events))
+
+ // accumulate stats by event type
+ for k, vals := range ev.Result.Events {
+ parts := strings.SplitN(k, ".", 2)
+ etype := parts[0]
+ eventTypeToAttrCount[etype] += len(vals)
+ if _, ok := eventTypeToAttrNames[etype]; !ok {
+ eventTypeToAttrNames[etype] = make(map[string]int)
+ }
+ aname := ""
+ if len(parts) > 1 {
+ aname = parts[1]
+ }
+ eventTypeToAttrNames[etype][aname] += len(vals)
+ }
+ }
+ }
+
+ // Print statistics by event type
+ types := make([]string, 0, len(eventTypeToAttrCount))
+ for k := range eventTypeToAttrCount {
+ types = append(types, k)
+ }
+ sort.Strings(types)
+ for _, et := range types {
+ attrMap := eventTypeToAttrNames[et]
+ attrNames := make([]string, 0, len(attrMap))
+ for n := range attrMap {
+ attrNames = append(attrNames, n)
+ }
+ sort.Strings(attrNames)
+ t.Logf("stats: type=%s total_attrs=%d distinct_attrs=%d", et, eventTypeToAttrCount[et], len(attrNames))
+ // Optionally list a few attributes
+ for i, n := range attrNames {
+ if i >= 10 {
+ break
+ }
+ t.Logf(" attr=%s count=%d", n, attrMap[n])
+ }
+ }
+}
+
+// Note: we rely on zero-value apiconfig.ConfigManager methods that read/write
+// in-memory fields and no-op writes when WriterProvider is nil.
diff --git a/decentralized-api/internal/event_listener/chainevents/event_message.go b/decentralized-api/internal/event_listener/chainevents/event_message.go
new file mode 100644
index 000000000..99bbb8911
--- /dev/null
+++ b/decentralized-api/internal/event_listener/chainevents/event_message.go
@@ -0,0 +1,41 @@
+package chainevents
+
+type JSONRPCResponse struct {
+ JSONRPC string `json:"jsonrpc"`
+ ID string `json:"id"`
+ Result Result `json:"result"`
+}
+
+type Result struct {
+ Query string `json:"query"`
+ Data Data `json:"data"`
+ Events map[string][]string `json:"events"`
+}
+
+type Data struct {
+ Type string `json:"type"`
+ Value map[string]interface{} `json:"value"`
+}
+
+type Attribute struct {
+ Key string `json:"key"`
+ Value string `json:"value"`
+ Index bool `json:"index"`
+}
+
+type Event struct {
+ Type string `json:"type"`
+ Attributes []Attribute `json:"attributes"`
+}
+
+type TxResult struct {
+ Height string `json:"height"`
+ Tx string `json:"tx"`
+ Result struct {
+ Events []Event `json:"events"`
+ } `json:"result"`
+}
+
+type Value struct {
+ TxResult TxResult `json:"TxResult"`
+}
diff --git a/decentralized-api/internal/event_listener/event_listener.go b/decentralized-api/internal/event_listener/event_listener.go
new file mode 100644
index 000000000..ebcbe6908
--- /dev/null
+++ b/decentralized-api/internal/event_listener/event_listener.go
@@ -0,0 +1,510 @@
+package event_listener
+
+import (
+ "context"
+ "decentralized-api/apiconfig"
+ "decentralized-api/broker"
+ "decentralized-api/chainphase"
+ "decentralized-api/cosmosclient"
+ "decentralized-api/internal/bls"
+ "decentralized-api/internal/event_listener/chainevents"
+ "decentralized-api/internal/poc"
+ "decentralized-api/internal/startup"
+ "decentralized-api/internal/validation"
+ "decentralized-api/logging"
+ "decentralized-api/training"
+ "decentralized-api/upgrade"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "log"
+ "strconv"
+ "sync/atomic"
+ "time"
+
+ "github.com/gorilla/websocket"
+ "github.com/productscience/inference/x/inference/types"
+)
+
+const (
+ // BLS Typed Event Types (from EmitTypedEvent)
+ blsKeyGenerationInitiatedEvent = "inference.bls.EventKeyGenerationInitiated"
+ blsVerifyingPhaseStartedEvent = "inference.bls.EventVerifyingPhaseStarted"
+ blsGroupPublicKeyGeneratedEvent = "inference.bls.EventGroupPublicKeyGenerated"
+ blsThresholdSigningRequestedEvent = "inference.bls.EventThresholdSigningRequested"
+
+ newBlockEventType = "tendermint/event/NewBlock"
+ txEventType = "tendermint/event/Tx"
+ systemBarrierEventType = "decentralized-api/event/Barrier"
+)
+
+// TODO: write tests properly
+type EventListener struct {
+ nodeBroker *broker.Broker
+ configManager *apiconfig.ConfigManager
+ validator *validation.InferenceValidator
+ transactionRecorder cosmosclient.InferenceCosmosClient
+ trainingExecutor *training.Executor
+ blsManager *bls.BlsManager
+ nodeCaughtUp atomic.Bool
+ phaseTracker *chainphase.ChainPhaseTracker
+ dispatcher *OnNewBlockDispatcher
+ cancelFunc context.CancelFunc
+ rewardRecoveryChecker *startup.RewardRecoveryChecker
+
+ eventHandlers []EventHandler
+
+ ws *websocket.Conn
+ blockObserver *BlockObserver
+}
+
+func NewEventListener(
+ configManager *apiconfig.ConfigManager,
+ nodePocOrchestrator poc.NodePoCOrchestrator,
+ nodeBroker *broker.Broker,
+ validator *validation.InferenceValidator,
+ transactionRecorder cosmosclient.InferenceCosmosClient,
+ trainingExecutor *training.Executor,
+ phaseTracker *chainphase.ChainPhaseTracker,
+ cancelFunc context.CancelFunc,
+ blsManager *bls.BlsManager,
+) *EventListener {
+ // Create the new block dispatcher
+ dispatcher := NewOnNewBlockDispatcherFromCosmosClient(
+ nodeBroker,
+ configManager,
+ nodePocOrchestrator,
+ &transactionRecorder,
+ phaseTracker,
+ DefaultReconciliationConfig,
+ validator,
+ )
+
+ eventHandlers := []EventHandler{
+ &BlsTransactionEventHandler{},
+ &InferenceFinishedEventHandler{},
+ &InferenceValidationEventHandler{},
+ &SubmitProposalEventHandler{},
+ &TrainingTaskAssignedEventHandler{},
+ }
+
+ bo := NewBlockObserver(configManager)
+
+ return &EventListener{
+ nodeBroker: nodeBroker,
+ transactionRecorder: transactionRecorder,
+ configManager: configManager,
+ validator: validator,
+ trainingExecutor: trainingExecutor,
+ phaseTracker: phaseTracker,
+ dispatcher: dispatcher,
+ cancelFunc: cancelFunc,
+ blsManager: blsManager,
+ eventHandlers: eventHandlers,
+ blockObserver: bo,
+ rewardRecoveryChecker: startup.NewRewardRecoveryChecker(phaseTracker, &transactionRecorder, validator, configManager),
+ }
+}
+
+func (el *EventListener) openWsConnAndSubscribe() {
+ websocketUrl := getWebsocketUrl(el.configManager.GetChainNodeConfig().Url)
+ logging.Info("Connecting to websocket at", types.EventProcessing, "url", websocketUrl)
+
+ ws, _, err := websocket.DefaultDialer.Dial(websocketUrl, nil)
+ if err != nil {
+ logging.Error("Failed to connect to websocket", types.EventProcessing, "error", err)
+ log.Fatal("dial:", err)
+ }
+ el.ws = ws
+
+ // Subscribe only to NewBlock events; all Tx events will be polled via BlockObserver
+ subscribeToEvents(el.ws, 1, "tm.event='NewBlock'")
+
+ logging.Info("Subscribed to NewBlock only; Tx will be polled by BlockObserver.", types.EventProcessing)
+}
+
+func (el *EventListener) Start(ctx context.Context) {
+ el.openWsConnAndSubscribe()
+ defer el.ws.Close()
+
+ go el.startSyncStatusChecker()
+
+ // Start processing of Tx events sourced by BlockObserver
+ el.processEvents(ctx, el.blockObserver.Queue)
+
+ blockEventQueue := NewUnboundedQueue[*chainevents.JSONRPCResponse]()
+ defer blockEventQueue.Close()
+ el.processBlockEvents(ctx, blockEventQueue)
+
+ // Start BlockObserver
+ go el.blockObserver.Process(ctx)
+
+ el.listen(ctx, blockEventQueue, el.blockObserver.Queue)
+}
+
+func worker(
+ ctx context.Context,
+ eventQueue *UnboundedQueue[*chainevents.JSONRPCResponse],
+ processEvent func(event *chainevents.JSONRPCResponse, workerName string),
+ workerName string) {
+ go func() {
+ for {
+ select {
+ case <-ctx.Done():
+ return
+ case event, ok := <-eventQueue.Out:
+ if !ok {
+ logging.Warn(workerName+": event channel is closed", types.System)
+ return
+ }
+ if event == nil {
+ logging.Error(workerName+": received nil chain event", types.System)
+ } else {
+ processEvent(event, workerName)
+ }
+ }
+ }
+ }()
+}
+
+func (el *EventListener) processEvents(ctx context.Context, mainQueue *UnboundedQueue[*chainevents.JSONRPCResponse]) {
+ const numWorkers = 10
+ for i := 0; i < numWorkers; i++ {
+ worker(ctx, mainQueue, el.processEvent, "process_events_"+strconv.Itoa(i))
+ }
+}
+
+func (el *EventListener) processBlockEvents(ctx context.Context, blockQueue *UnboundedQueue[*chainevents.JSONRPCResponse]) {
+ const numWorkers = 2
+ for i := 0; i < numWorkers; i++ {
+ worker(ctx, blockQueue, el.processEvent, "process_block_events")
+ }
+}
+
+func (el *EventListener) listen(ctx context.Context, blockQueue, mainQueue *UnboundedQueue[*chainevents.JSONRPCResponse]) {
+ for {
+ select {
+ case <-ctx.Done():
+ logging.Info("Close ws connection", types.EventProcessing)
+ return
+ default:
+ _, message, err := el.ws.ReadMessage()
+ if err != nil {
+ logging.Warn("Failed to read a websocket message", types.EventProcessing, "errorType", fmt.Sprintf("%T", err), "error", err)
+
+ if websocket.IsCloseError(err, websocket.CloseNormalClosure, websocket.CloseGoingAway, websocket.CloseAbnormalClosure) {
+ logging.Warn("Websocket connection closed", types.EventProcessing, "errorType", fmt.Sprintf("%T", err), "error", err)
+
+ if upgrade.CheckForUpgrade(el.configManager) {
+ logging.Error("Upgrade required! Shutting down the entire system...", types.Upgrades)
+ el.cancelFunc()
+ return
+ }
+
+ }
+
+ logging.Warn("Close websocket connection", types.EventProcessing)
+ el.ws.Close()
+
+ logging.Warn("Reopen websocket", types.EventProcessing)
+ time.Sleep(10 * time.Second)
+
+ el.openWsConnAndSubscribe()
+ continue
+ }
+
+ // logging.Debug("Raw websocket message received", types.EventProcessing, "raw_message_bytes", string(message))
+
+ var event chainevents.JSONRPCResponse
+ if err = json.Unmarshal(message, &event); err != nil {
+ logging.Error("Error unmarshalling message to JSONRPCResponse", types.EventProcessing, "error", err, "raw_message_bytes", string(message))
+ continue
+ }
+
+ // Detailed logging for event type evaluation
+ isNewBlockTypeComparison := event.Result.Data.Type == newBlockEventType
+ logging.Info("Event unmarshalled. Evaluating type...", types.EventProcessing,
+ "event_id", event.ID,
+ "subscription_query", event.Result.Query,
+ "result_data_type", event.Result.Data.Type,
+ "comparing_against_type", newBlockEventType,
+ "is_new_block_event_type_result", isNewBlockTypeComparison)
+
+ if isNewBlockTypeComparison {
+ logging.Info("Event classified as NewBlock", types.EventProcessing, "ID", event.ID, "subscription_query", event.Result.Query, "result_data_type", event.Result.Data.Type)
+ blockQueue.In <- &event
+ continue
+ }
+
+ // We no longer subscribe to Tx over WS; ignore other event types
+ logging.Debug("Ignoring non-NewBlock WS event", types.EventProcessing, "type", event.Result.Data.Type)
+ }
+ }
+}
+
+func (el *EventListener) startSyncStatusChecker() {
+ chainNodeUrl := el.configManager.GetChainNodeConfig().Url
+ hasTriedVersionSync := false
+
+ ticker := time.NewTicker(5 * time.Second)
+ defer ticker.Stop()
+
+ for range ticker.C {
+ status, err := getStatus(chainNodeUrl)
+ if err != nil {
+ logging.Error("Error getting node status", types.EventProcessing, "error", err)
+ continue
+ }
+ // The node is "synced" if it's NOT catching up.
+ isSynced := !status.SyncInfo.CatchingUp
+ wasAlreadySynced := el.isNodeSynced()
+ el.updateNodeSyncStatus(isSynced)
+
+ if isSynced && !wasAlreadySynced && !hasTriedVersionSync {
+ hasTriedVersionSync = true
+ go func() {
+ queryClient := el.transactionRecorder.NewInferenceQueryClient()
+ if err := el.configManager.SyncVersionFromChain(queryClient); err != nil {
+ logging.Debug("MLNode version sync failed after blockchain ready", types.Config, "error", err)
+ } else {
+ logging.Info("MLNode version synced successfully after blockchain ready", types.Config)
+ }
+ }()
+ }
+
+ // Note: Sync status is now handled by the dispatcher during block processing
+ logging.Debug("Updated sync status", types.EventProcessing, "caughtUp", isSynced, "height", status.SyncInfo.LatestBlockHeight)
+ }
+}
+
+func (el *EventListener) isNodeSynced() bool {
+ return el.nodeCaughtUp.Load()
+}
+
+func (el *EventListener) updateNodeSyncStatus(status bool) {
+ el.nodeCaughtUp.Store(status)
+}
+
+// processEvent is the worker function that processes a JSONRPCResponse event.
+func (el *EventListener) processEvent(event *chainevents.JSONRPCResponse, workerName string) {
+ switch event.Result.Data.Type {
+ case newBlockEventType:
+ logging.Debug("New block event received", types.EventProcessing, "type", event.Result.Data.Type, "worker", workerName)
+
+ if el.isNodeSynced() {
+ // Check for BLS events in NewBlock events (emitted from EndBlocker)
+ el.handleBLSEvents(event, workerName)
+ }
+
+ // Parse the event into NewBlockInfo
+ blockInfo, err := parseNewBlockInfo(event)
+ if err != nil {
+ logging.Error("Failed to parse new block info", types.EventProcessing, "error", err, "worker", workerName)
+ return
+ }
+
+ // Update BlockObserver with latest height and sync status
+ el.blockObserver.updateStatus(blockInfo.Height, el.isNodeSynced())
+
+ // Process using the new dispatcher
+ ctx := context.Background() // We could pass this from caller if needed
+ err = el.dispatcher.ProcessNewBlock(ctx, *blockInfo)
+ if err != nil {
+ logging.Error("Failed to process new block", types.EventProcessing, "error", err, "worker", workerName)
+ }
+
+ // Still handle upgrade processing separately
+ upgrade.ProcessNewBlockEvent(event, el.transactionRecorder, el.configManager)
+ if el.isNodeSynced() {
+ el.rewardRecoveryChecker.RecoverIfNeeded(blockInfo.Height)
+ }
+
+ case txEventType:
+ if el.hasHandler(event) {
+ el.handleMessage(event, workerName)
+ }
+ case systemBarrierEventType:
+ heights := event.Result.Events["barrier.height"]
+ if len(heights) > 0 {
+ height, err := strconv.ParseInt(heights[0], 10, 64)
+ if err == nil {
+ el.blockObserver.signalAllEventsRead(height)
+ } else {
+ logging.Warn("Invalid barrier height", types.EventProcessing, "value", heights[0], "error", err)
+ }
+ }
+ default:
+ logging.Warn("Unexpected event type received", types.EventProcessing, "type", event.Result.Data.Type)
+ }
+}
+
+func (el *EventListener) hasHandler(event *chainevents.JSONRPCResponse) bool {
+ for _, handler := range el.eventHandlers {
+ if handler.CanHandle(event) {
+ return true
+ }
+ }
+ return false
+}
+
+func (el *EventListener) handleBLSEvents(event *chainevents.JSONRPCResponse, workerName string) {
+ // Check for BLS events in NewBlock events (emitted from EndBlocker)
+ // Note: Threshold signing events are handled separately in handleBLSTransactionEvents
+
+ if epochIdValues := event.Result.Events[blsKeyGenerationInitiatedEvent+".epoch_id"]; len(epochIdValues) > 0 {
+ logging.Info("Key generation initiated event received", types.EventProcessing, "worker", workerName)
+ err := el.blsManager.ProcessKeyGenerationInitiated(event)
+ if err != nil {
+ logging.Error("Failed to process key generation initiated event", types.EventProcessing, "error", err, "worker", workerName)
+ }
+ }
+
+ if epochIdValues := event.Result.Events[blsVerifyingPhaseStartedEvent+".epoch_id"]; len(epochIdValues) > 0 {
+ logging.Info("Verifying phase started event received", types.EventProcessing, "worker", workerName)
+ err := el.blsManager.ProcessVerifyingPhaseStarted(event)
+ if err != nil {
+ logging.Error("Failed to process verifying phase started event", types.EventProcessing, "error", err, "worker", workerName)
+ }
+ }
+
+ if epochIdValues := event.Result.Events[blsGroupPublicKeyGeneratedEvent+".epoch_id"]; len(epochIdValues) > 0 {
+ logging.Info("Group public key generated event received", types.EventProcessing, "worker", workerName)
+ err := el.blsManager.ProcessGroupPublicKeyGenerated(event)
+ if err != nil {
+ logging.Error("Failed to process group public key generated event", types.EventProcessing, "error", err, "worker", workerName)
+ }
+ }
+}
+
+func (el *EventListener) handleMessage(event *chainevents.JSONRPCResponse, name string) {
+ if waitForEventHeight(event, el.configManager, name) {
+ logging.Warn("Event height not reached yet, skipping", types.EventProcessing, "event", event)
+ return
+ }
+
+ for _, handler := range el.eventHandlers {
+ if handler.CanHandle(event) {
+ logging.Info("Handling event", types.EventProcessing, "event", event, "handler", handler.GetName(), "worker", name)
+ err := handler.Handle(event, el)
+ if err != nil {
+ logging.Error("Failed to handle event", types.EventProcessing, "error", err, "event", event)
+ }
+ }
+ }
+}
+
+type EventHandler interface {
+ GetName() string
+ CanHandle(event *chainevents.JSONRPCResponse) bool
+ Handle(event *chainevents.JSONRPCResponse, el *EventListener) error
+}
+type BlsTransactionEventHandler struct{}
+
+func (e *BlsTransactionEventHandler) GetName() string {
+ return "bls_transaction"
+}
+
+func (e *BlsTransactionEventHandler) CanHandle(event *chainevents.JSONRPCResponse) bool {
+ return len(event.Result.Events[blsThresholdSigningRequestedEvent+".request_id"]) > 0
+}
+
+func (e *BlsTransactionEventHandler) Handle(event *chainevents.JSONRPCResponse, el *EventListener) error {
+ if el.isNodeSynced() {
+ return el.blsManager.ProcessThresholdSigningRequested(event)
+ }
+ return nil
+}
+
+type InferenceFinishedEventHandler struct {
+}
+
+func (e *InferenceFinishedEventHandler) GetName() string {
+ return "inference_finished"
+}
+
+func (e *InferenceFinishedEventHandler) CanHandle(event *chainevents.JSONRPCResponse) bool {
+ return len(event.Result.Events["inference_finished.inference_id"]) > 0
+}
+
+func (e *InferenceFinishedEventHandler) Handle(event *chainevents.JSONRPCResponse, el *EventListener) error {
+ if el.isNodeSynced() {
+ el.validator.SampleInferenceToValidate(event.Result.Events["inference_finished.inference_id"], el.transactionRecorder)
+ }
+ return nil
+}
+
+type InferenceValidationEventHandler struct {
+}
+
+func (e *InferenceValidationEventHandler) GetName() string {
+ return "inference_validation"
+}
+
+func (e *InferenceValidationEventHandler) CanHandle(event *chainevents.JSONRPCResponse) bool {
+ needsRevalidation := event.Result.Events["inference_validation.needs_revalidation"]
+ return len(needsRevalidation) > 0 && needsRevalidation[0] == "true"
+}
+
+func (e *InferenceValidationEventHandler) Handle(event *chainevents.JSONRPCResponse, el *EventListener) error {
+ if el.isNodeSynced() {
+ el.validator.VerifyInvalidation(event.Result.Events, el.transactionRecorder)
+ }
+ return nil
+}
+
+type SubmitProposalEventHandler struct{}
+
+func (e *SubmitProposalEventHandler) GetName() string {
+ return "submit_proposal"
+}
+
+func (e *SubmitProposalEventHandler) CanHandle(event *chainevents.JSONRPCResponse) bool {
+ return len(event.Result.Events["submit_proposal.proposal_id"]) > 0
+}
+
+func (e *SubmitProposalEventHandler) Handle(event *chainevents.JSONRPCResponse, el *EventListener) error {
+ proposalIds := event.Result.Events["submit_proposal.proposal_id"]
+ if len(proposalIds) == 0 {
+ return errors.New("proposal_id not found in event")
+ }
+ logging.Debug("Handling `submit_proposal` event", types.EventProcessing, "proposalId", proposalIds[0])
+ return nil
+}
+
+type TrainingTaskAssignedEventHandler struct{}
+
+func (e *TrainingTaskAssignedEventHandler) GetName() string {
+ return "training_task_assigned"
+}
+
+func (e *TrainingTaskAssignedEventHandler) CanHandle(event *chainevents.JSONRPCResponse) bool {
+ return len(event.Result.Events["training_task_assigned.task_id"]) > 0
+}
+
+func (e *TrainingTaskAssignedEventHandler) Handle(event *chainevents.JSONRPCResponse, el *EventListener) error {
+ if el.isNodeSynced() {
+ for _, taskId := range event.Result.Events["training_task_assigned.task_id"] {
+ taskIdUint, err := strconv.ParseUint(taskId, 10, 64)
+ if err != nil {
+ logging.Error("Failed to parse task ID", types.Training, "error", err)
+ continue // Continue to the next task ID
+ }
+ el.trainingExecutor.ProcessTaskAssignedEvent(taskIdUint)
+ }
+ }
+ return nil
+}
+
+func waitForEventHeight(event *chainevents.JSONRPCResponse, currentConfig *apiconfig.ConfigManager, name string) bool {
+ heightString := event.Result.Events["tx.height"][0]
+ expectedHeight, err := strconv.ParseInt(heightString, 10, 64)
+ if err != nil {
+ logging.Error("Failed to parse height", types.EventProcessing, "error", err)
+ return true
+ }
+ for currentConfig.GetHeight() < expectedHeight {
+ logging.Info("Height race condition! Waiting for height to catch up", types.EventProcessing, "currentHeight", currentConfig.GetHeight(), "expectedHeight", expectedHeight, "worker", name)
+ time.Sleep(100 * time.Millisecond)
+ }
+ return false
+}
diff --git a/decentralized-api/internal/event_listener/event_listener_test.go b/decentralized-api/internal/event_listener/event_listener_test.go
new file mode 100644
index 000000000..b2a96239c
--- /dev/null
+++ b/decentralized-api/internal/event_listener/event_listener_test.go
@@ -0,0 +1,167 @@
+package event_listener
+
+import (
+ "decentralized-api/internal/event_listener/chainevents"
+ "encoding/json"
+ "log"
+ "testing"
+)
+
+const (
+ e3 = `
+{
+ "jsonrpc": "2.0",
+ "id": "1",
+ "result": {
+ "query": "tm.event='Tx' AND message.action='/inference.inference.MsgFinishInference'",
+ "data": {
+ "type": "tendermint/event/Tx",
+ "value": {
+ "TxResult": {
+ "height": "20483",
+ "tx": "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",
+ "result": {
+ "data": "EjEKLy9pbmZlcmVuY2UuaW5mZXJlbmNlLk1zZ0ZpbmlzaEluZmVyZW5jZVJlc3BvbnNl",
+ "gas_wanted": "300000",
+ "gas_used": "175479",
+ "events": [
+ {
+ "type": "tx",
+ "attributes": [
+ {
+ "key": "fee",
+ "value": "",
+ "index": true
+ },
+ {
+ "key": "fee_payer",
+ "value": "cosmos1pd94n6dp8et2grepmanh9qsajccn7mt76dh0s7",
+ "index": true
+ }
+ ]
+ },
+ {
+ "type": "tx",
+ "attributes": [
+ {
+ "key": "acc_seq",
+ "value": "cosmos1pd94n6dp8et2grepmanh9qsajccn7mt76dh0s7/18",
+ "index": true
+ }
+ ]
+ },
+ {
+ "type": "tx",
+ "attributes": [
+ {
+ "key": "signature",
+ "value": "Oyvk7oVBhKWMFmuxweFzxp0bw7HUWlL5Cl56fi136JpUi0xUKhGuXik6rqjpOTI2XChGNJgIpdANbc72y/XhZA==",
+ "index": true
+ }
+ ]
+ },
+ {
+ "type": "message",
+ "attributes": [
+ {
+ "key": "action",
+ "value": "/inference.inference.MsgFinishInference",
+ "index": true
+ },
+ {
+ "key": "sender",
+ "value": "cosmos1pd94n6dp8et2grepmanh9qsajccn7mt76dh0s7",
+ "index": true
+ },
+ {
+ "key": "module",
+ "value": "inference",
+ "index": true
+ },
+ {
+ "key": "msg_index",
+ "value": "0",
+ "index": true
+ }
+ ]
+ },
+ {
+ "type": "inference_finished",
+ "attributes": [
+ {
+ "key": "inference_id",
+ "value": "3cdfa7b3-ec1d-45d4-99b2-1fe708a9dda7",
+ "index": true
+ },
+ {
+ "key": "msg_index",
+ "value": "0",
+ "index": true
+ }
+ ]
+ }
+ ]
+ }
+ }
+ }
+ },
+ "events": {
+ "tm.event": [
+ "Tx"
+ ],
+ "tx.height": [
+ "20483"
+ ],
+ "tx.fee": [
+ ""
+ ],
+ "tx.acc_seq": [
+ "cosmos1pd94n6dp8et2grepmanh9qsajccn7mt76dh0s7/18"
+ ],
+ "tx.signature": [
+ "Oyvk7oVBhKWMFmuxweFzxp0bw7HUWlL5Cl56fi136JpUi0xUKhGuXik6rqjpOTI2XChGNJgIpdANbc72y/XhZA=="
+ ],
+ "message.sender": [
+ "cosmos1pd94n6dp8et2grepmanh9qsajccn7mt76dh0s7"
+ ],
+ "message.module": [
+ "inference"
+ ],
+ "inference_finished.msg_index": [
+ "0"
+ ],
+ "tx.fee_payer": [
+ "cosmos1pd94n6dp8et2grepmanh9qsajccn7mt76dh0s7"
+ ],
+ "message.action": [
+ "/inference.inference.MsgFinishInference"
+ ],
+ "message.msg_index": [
+ "0"
+ ],
+ "inference_finished.inference_id": [
+ "3cdfa7b3-ec1d-45d4-99b2-1fe708a9dda7"
+ ],
+ "tx.hash": [
+ "21090B3646B234ADA4A27B9D81B999158FAEE87085CADDC74988CAE8D8CF28BE"
+ ]
+ }
+ }
+}
+`
+)
+
+func Test(t *testing.T) {
+ var res chainevents.JSONRPCResponse
+ err := json.Unmarshal([]byte(e3), &res)
+ if err != nil {
+ t.Fatalf("error unmarshalling: %v", err)
+ }
+
+ log.Printf("res = %v", res)
+
+ ids := res.Result.Events["inference_finished.inference_id"]
+ if len(ids) == 0 {
+ t.Fatalf("no inference ids found")
+ }
+}
diff --git a/decentralized-api/internal/event_listener/integration_test.go b/decentralized-api/internal/event_listener/integration_test.go
new file mode 100644
index 000000000..14c75c23a
--- /dev/null
+++ b/decentralized-api/internal/event_listener/integration_test.go
@@ -0,0 +1,1083 @@
+package event_listener
+
+import (
+ "context"
+ "decentralized-api/internal/poc"
+ "decentralized-api/internal/validation"
+ "decentralized-api/mlnodeclient"
+ "decentralized-api/participant"
+ "errors"
+ "fmt"
+ "strconv"
+ "testing"
+ "time"
+
+ "github.com/productscience/inference/testutil/keeper"
+
+ "decentralized-api/apiconfig"
+ "decentralized-api/broker"
+ "decentralized-api/chainphase"
+
+ coretypes "github.com/cometbft/cometbft/rpc/core/types"
+ "github.com/productscience/inference/x/inference/types"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/mock"
+ "github.com/stretchr/testify/require"
+ "google.golang.org/grpc"
+)
+
+var defaultEpochParams = types.EpochParams{
+ EpochLength: 100,
+ EpochShift: 0,
+ EpochMultiplier: 1,
+ PocStageDuration: 20,
+ PocExchangeDuration: 2,
+ PocValidationDelay: 2,
+ PocValidationDuration: 10,
+}
+
+var defaultReconciliationConfig = MlNodeReconciliationConfig{
+ Inference: &MlNodeStageReconciliationConfig{
+ BlockInterval: 50,
+ TimeInterval: 60 * time.Hour,
+ },
+ PoC: &MlNodeStageReconciliationConfig{
+ BlockInterval: 1,
+ TimeInterval: 60 * time.Hour,
+ },
+ LastTime: time.Now(),
+}
+
+// Mock implementations using minimal interfaces
+type MockOrchestratorChainBridge struct {
+}
+
+func (m MockOrchestratorChainBridge) PoCBatchesForStage(startPoCBlockHeight int64) (*types.QueryPocBatchesForStageResponse, error) {
+ return &types.QueryPocBatchesForStageResponse{
+ PocBatch: []types.PoCBatchesWithParticipants{
+ {
+ Participant: "participant-1",
+ PubKey: "pubkey-1",
+ HexPubKey: "hex-pubkey-1",
+ PocBatch: []types.PoCBatch{
+ {
+ ParticipantAddress: "participant-1",
+ PocStageStartBlockHeight: startPoCBlockHeight,
+ ReceivedAtBlockHeight: startPoCBlockHeight + 1,
+ Nonces: []int64{1, 2, 3},
+ Dist: []float64{0, 0, 0},
+ BatchId: "batch-1",
+ },
+ },
+ },
+ },
+ }, nil
+}
+
+func (m MockOrchestratorChainBridge) GetBlockHash(height int64) (string, error) {
+ return fmt.Sprintf("block-hash-%d", height), nil
+}
+
+func (m MockOrchestratorChainBridge) GetPocParams() (*types.PocParams, error) {
+ return &types.PocParams{
+ ValidationSampleSize: 200,
+ }, nil
+}
+
+type MockBrokerChainBridge struct {
+ mock.Mock
+}
+
+func (m *MockBrokerChainBridge) GetParticipantAddress() string {
+ args := m.Called()
+ return args.String(0)
+}
+
+func (m *MockBrokerChainBridge) GetHardwareNodes() (*types.QueryHardwareNodesResponse, error) {
+ args := m.Called()
+ if args.Get(0) == nil {
+ return nil, args.Error(1)
+ }
+ return args.Get(0).(*types.QueryHardwareNodesResponse), nil
+}
+
+func (m *MockBrokerChainBridge) SubmitHardwareDiff(diff *types.MsgSubmitHardwareDiff) error {
+ args := m.Called(diff)
+ return args.Error(0)
+}
+
+func (m *MockBrokerChainBridge) GetBlockHash(height int64) (string, error) {
+ return "block-hash-" + strconv.FormatInt(height, 10), nil
+}
+
+func (m *MockBrokerChainBridge) GetGovernanceModels() (*types.QueryModelsAllResponse, error) {
+ args := m.Called()
+ if args.Get(0) == nil {
+ return nil, args.Error(1)
+ }
+ return args.Get(0).(*types.QueryModelsAllResponse), args.Error(1)
+}
+
+func (m *MockBrokerChainBridge) GetCurrentEpochGroupData() (*types.QueryCurrentEpochGroupDataResponse, error) {
+ args := m.Called()
+ if args.Get(0) == nil {
+ return nil, args.Error(1)
+ }
+ return args.Get(0).(*types.QueryCurrentEpochGroupDataResponse), args.Error(1)
+}
+
+func (m *MockBrokerChainBridge) GetEpochGroupDataByModelId(pocHeight uint64, modelId string) (*types.QueryGetEpochGroupDataResponse, error) {
+ args := m.Called(pocHeight, modelId)
+ if args.Get(0) == nil {
+ return nil, args.Error(1)
+ }
+ return args.Get(0).(*types.QueryGetEpochGroupDataResponse), args.Error(1)
+}
+
+type MockRandomSeedManager struct {
+ mock.Mock
+}
+
+func (m *MockRandomSeedManager) ChangeCurrentSeed() {
+ m.Called()
+}
+
+func (m *MockRandomSeedManager) GetSeedForEpoch(epochIndex uint64) apiconfig.SeedInfo {
+ m.Called()
+ return apiconfig.SeedInfo{}
+}
+
+func (m *MockRandomSeedManager) RequestMoney(epochIndex uint64) {
+ m.Called()
+}
+
+func (m *MockRandomSeedManager) CreateNewSeed(epochIndex uint64) (*apiconfig.SeedInfo, error) {
+ m.Called()
+ return nil, nil
+}
+
+func (m *MockRandomSeedManager) GenerateSeedInfo(epochIndex uint64) {
+ m.Called(epochIndex)
+}
+
+type MockQueryClient struct {
+ mock.Mock
+}
+
+func (m *MockQueryClient) EpochInfo(ctx context.Context, req *types.QueryEpochInfoRequest, opts ...grpc.CallOption) (*types.QueryEpochInfoResponse, error) {
+ args := m.Called(ctx, req)
+ return args.Get(0).(*types.QueryEpochInfoResponse), args.Error(1)
+}
+
+func (m *MockQueryClient) Params(ctx context.Context, req *types.QueryParamsRequest, opts ...grpc.CallOption) (*types.QueryParamsResponse, error) {
+ args := m.Called(ctx, req)
+ if args.Get(0) == nil {
+ return nil, args.Error(1)
+ }
+ return args.Get(0).(*types.QueryParamsResponse), args.Error(1)
+}
+
+// Test setup helpers
+
+type IntegrationTestSetup struct {
+ Dispatcher *OnNewBlockDispatcher
+ NodeBroker *broker.Broker
+ PoCOrchestrator poc.NodePoCOrchestrator
+ PhaseTracker *chainphase.ChainPhaseTracker
+ MockClientFactory *mlnodeclient.MockClientFactory
+ MockChainBridge *MockBrokerChainBridge
+ MockQueryClient *MockQueryClient
+ MockSeedManager *MockRandomSeedManager
+ EpochParams *types.EpochParams
+}
+
+func createIntegrationTestSetup(reconcilialtionConfig *MlNodeReconciliationConfig, params *types.EpochParams) *IntegrationTestSetup {
+ mockQueryClient := &MockQueryClient{}
+ mockSeedManager := &MockRandomSeedManager{}
+
+ phaseTracker := chainphase.NewChainPhaseTracker()
+
+ // Create mock client factory that tracks calls
+ mockClientFactory := mlnodeclient.NewMockClientFactory()
+
+ // Create real broker with mocked chain bridge
+ mockChainBridge := &MockBrokerChainBridge{}
+ participantInfo := participant.CosmosInfo{
+ Address: "some-address",
+ PubKey: "some-pub-key",
+ }
+ mockConfigManager := &apiconfig.ConfigManager{}
+ nodeBroker := broker.NewBroker(mockChainBridge, phaseTracker, &participantInfo, "http://localhost:8080/poc", mockClientFactory, mockConfigManager)
+
+ // Create real PoC orchestrator (not mocked - we want to test the real flow)
+ pocOrchestrator := poc.NewNodePoCOrchestrator(
+ "some-pub-key",
+ nodeBroker,
+ "http://localhost:8080/poc",
+ &MockOrchestratorChainBridge{},
+ phaseTracker,
+ )
+
+ // Mock status function
+ mockStatusFunc := func() (*coretypes.ResultStatus, error) {
+ return &coretypes.ResultStatus{
+ SyncInfo: coretypes.SyncInfo{CatchingUp: false},
+ }, nil
+ }
+
+ mockSetHeightFunc := func(height int64) error {
+ return nil
+ }
+
+ var paramsToReturn *types.EpochParams = &defaultEpochParams
+ if params != nil {
+ paramsToReturn = params
+ }
+
+ // Setup default mock behaviors
+ mockChainBridge.On("GetHardwareNodes").Return(&types.QueryHardwareNodesResponse{Nodes: &types.HardwareNodes{HardwareNodes: []*types.HardwareNode{}}}, nil)
+ mockChainBridge.On("GetParticipantAddress").Return("some-address")
+ mockChainBridge.On("SubmitHardwareDiff", mock.Anything).Return(nil)
+ mockChainBridge.On("GetGovernanceModels").Return(&types.QueryModelsAllResponse{
+ Model: keeper.GenesisModelsTestList(),
+ }, nil)
+ mockChainBridge.On("GetCurrentEpochGroupData").Return(&types.QueryCurrentEpochGroupDataResponse{
+ EpochGroupData: types.EpochGroupData{
+ PocStartBlockHeight: 100,
+ SubGroupModels: []string{"test-model"},
+ },
+ }, nil)
+ mockChainBridge.On("GetEpochGroupDataByModelId", mock.AnythingOfType("uint64"), "").Return(&types.QueryGetEpochGroupDataResponse{
+ EpochGroupData: types.EpochGroupData{
+ PocStartBlockHeight: 100,
+ SubGroupModels: []string{"test-model"},
+ },
+ }, nil)
+ mockChainBridge.On("GetEpochGroupDataByModelId", mock.AnythingOfType("uint64"), "test-model").Return(&types.QueryGetEpochGroupDataResponse{
+ EpochGroupData: types.EpochGroupData{
+ ModelSnapshot: &types.Model{Id: "test-model"},
+ ValidationWeights: []*types.ValidationWeight{
+ {
+ MemberAddress: "some-address",
+ MlNodes: []*types.MLNodeInfo{
+ {NodeId: "node-1"},
+ {NodeId: "node-2"},
+ },
+ },
+ },
+ },
+ }, nil)
+
+ mockQueryClient.On("EpochInfo", mock.Anything, mock.Anything).Return(&types.QueryEpochInfoResponse{
+ Params: types.Params{
+ EpochParams: paramsToReturn,
+ },
+ // Empty epoch for now
+ LatestEpoch: types.Epoch{},
+ }, nil)
+
+ // Setup mock for Params method
+ validationParams := &types.ValidationParams{
+ TimestampExpiration: 10,
+ TimestampAdvance: 10,
+ }
+ mockQueryClient.On("Params", mock.MatchedBy(func(ctx context.Context) bool {
+ return true // Match any context
+ }), mock.AnythingOfType("*types.QueryParamsRequest")).Return(&types.QueryParamsResponse{
+ Params: types.Params{
+ ValidationParams: validationParams,
+ },
+ }, nil)
+
+ // Setup mock expectations for RandomSeedManager
+ mockSeedManager.On("ChangeCurrentSeed").Return()
+ mockSeedManager.On("RequestMoney").Return()
+ mockSeedManager.On("GenerateSeedInfo", mock.AnythingOfType("uint64")).Return()
+ mockSeedManager.On("CreateNewSeed", mock.AnythingOfType("uint64")).Return()
+ mockSeedManager.On("GetSeedForEpoch").Return(apiconfig.SeedInfo{})
+
+ var finalReconciliationConfig MlNodeReconciliationConfig
+ if reconcilialtionConfig == nil {
+ finalReconciliationConfig = defaultReconciliationConfig
+ } else {
+ finalReconciliationConfig = *reconcilialtionConfig
+ }
+ // Create dispatcher with mocked dependencies
+ mockValidator := &validation.InferenceValidator{}
+ dispatcher := NewOnNewBlockDispatcher(
+ nodeBroker,
+ pocOrchestrator,
+ mockQueryClient,
+ phaseTracker,
+ mockStatusFunc,
+ mockSetHeightFunc,
+ mockSeedManager,
+ finalReconciliationConfig,
+ mockConfigManager,
+ mockValidator,
+ )
+
+ return &IntegrationTestSetup{
+ Dispatcher: dispatcher,
+ NodeBroker: nodeBroker,
+ PoCOrchestrator: pocOrchestrator,
+ PhaseTracker: phaseTracker,
+ MockClientFactory: mockClientFactory,
+ MockChainBridge: mockChainBridge,
+ MockQueryClient: mockQueryClient,
+ MockSeedManager: mockSeedManager,
+ EpochParams: paramsToReturn,
+ }
+}
+
+func (setup *IntegrationTestSetup) addTestNode(nodeId string, port int) {
+ node := apiconfig.InferenceNodeConfig{
+ Id: nodeId,
+ Host: "localhost",
+ InferenceSegment: "/inference",
+ InferencePort: port - 1, // Use different ports to distinguish nodes
+ PoCSegment: "/poc",
+ PoCPort: port,
+ MaxConcurrent: 1,
+ Models: map[string]apiconfig.ModelConfig{
+ keeper.GenesisModelsTest_QWQ: {Args: []string{}},
+ },
+ Hardware: []apiconfig.Hardware{
+ {Type: "GPU", Count: 1},
+ },
+ }
+
+ responseChan := setup.NodeBroker.LoadNodeToBroker(&node)
+
+ // Wait for the node to be loaded
+ response := <-responseChan
+ if response.Error != nil || response.Node == nil {
+ panic(fmt.Sprintf("failed to register node %s: %v", nodeId, response.Error))
+ }
+}
+
+func (setup *IntegrationTestSetup) advanceBlockHeight(blockHeight int64) {
+ resp, err := setup.MockQueryClient.EpochInfo(context.Background(), &types.QueryEpochInfoRequest{})
+ if err != nil {
+ panic(err)
+ }
+
+ setup.setLatestEpoch(blockHeight, resp.LatestEpoch)
+}
+
+func (setup *IntegrationTestSetup) setLatestEpoch(blockHeight int64, epoch types.Epoch) {
+ setup.MockQueryClient.ExpectedCalls = nil
+ setup.MockQueryClient.On("EpochInfo", mock.Anything, mock.Anything).Return(&types.QueryEpochInfoResponse{
+ BlockHeight: blockHeight,
+ Params: types.Params{
+ EpochParams: setup.EpochParams,
+ },
+ LatestEpoch: epoch,
+ }, nil)
+}
+
+func (setup *IntegrationTestSetup) transitionChainStateToNextEpoch(blockHeight int64) {
+ epochInfo, err := setup.MockQueryClient.EpochInfo(context.Background(), &types.QueryEpochInfoRequest{})
+ if err != nil || epochInfo == nil {
+ panic(fmt.Sprintf("Failed to get epoch info: %v", err))
+ }
+
+ newEpoch := types.Epoch{
+ Index: epochInfo.LatestEpoch.Index + 1,
+ PocStartBlockHeight: blockHeight,
+ }
+
+ setup.setLatestEpoch(blockHeight, newEpoch)
+}
+
+func (setup *IntegrationTestSetup) setNodeAdminState(nodeId string, enabled bool) error {
+ response := make(chan error, 1)
+ err := setup.NodeBroker.QueueMessage(broker.SetNodeAdminStateCommand{
+ NodeId: nodeId,
+ Enabled: enabled,
+ Response: response,
+ })
+ if err != nil {
+ return err
+ }
+ return <-response
+}
+
+func (setup *IntegrationTestSetup) simulateBlock(height int64) error {
+ // Now call to chain mock will return new blockHeight
+ setup.advanceBlockHeight(height)
+
+ blockInfo := chainphase.BlockInfo{
+ Height: height,
+ Hash: fmt.Sprintf("hash-%d", height),
+ }
+ return setup.Dispatcher.ProcessNewBlock(context.Background(), blockInfo)
+}
+
+func (setup *IntegrationTestSetup) getNodeClient(nodeId string, port int) *mlnodeclient.MockClient {
+ // Construct URLs the same way the broker does
+ pocUrl := fmt.Sprintf("http://localhost:%d/poc", port)
+ inferenceUrl := fmt.Sprintf("http://localhost:8080/inference")
+
+ client := setup.MockClientFactory.GetClientForNode(pocUrl)
+ if client == nil {
+ // Create the client if it doesn't exist (should have been created by node registration)
+ setup.MockClientFactory.CreateClient(pocUrl, inferenceUrl)
+ client = setup.MockClientFactory.GetClientForNode(pocUrl)
+ if client == nil {
+ panic(fmt.Sprintf("Mock client is still nil after creation for pocUrl: %s", pocUrl))
+ }
+ }
+
+ return client
+}
+
+func (setup *IntegrationTestSetup) assertNode(nodeId string, assertion func(n broker.NodeResponse)) {
+ nodes, err := setup.NodeBroker.GetNodes()
+ if err != nil {
+ panic(err)
+ }
+
+ for _, node := range nodes {
+ if node.Node.Id == nodeId {
+ assertion(node)
+ return
+ }
+ }
+}
+
+func (setup *IntegrationTestSetup) getNode(nodeId string) (*broker.Node, *broker.NodeState) {
+ nodes, err := setup.NodeBroker.GetNodes()
+ if err != nil {
+ panic(err)
+ }
+
+ for _, node := range nodes {
+ if node.Node.Id == nodeId {
+ return &node.Node, &node.State
+ }
+ }
+
+ panic("node not found")
+}
+
+func waitForAsync(duration time.Duration) {
+ time.Sleep(duration)
+}
+
+func waitForNodeStatus(t *testing.T, setup *IntegrationTestSetup, nodeId string, expectedStatus types.HardwareNodeStatus, timeout time.Duration) {
+ deadline := time.Now().Add(timeout)
+ for time.Now().Before(deadline) {
+ _, state := setup.getNode(nodeId)
+ if state.CurrentStatus == expectedStatus {
+ return // Success
+ }
+ time.Sleep(50 * time.Millisecond) // Poll interval
+ }
+ // If the loop finishes, the condition was not met in time.
+ _, state := setup.getNode(nodeId)
+ require.Equal(t, expectedStatus, state.CurrentStatus, "timed out waiting for node status")
+}
+
+func testreconcilialtionConfig(blockInterval int) MlNodeReconciliationConfig {
+ return MlNodeReconciliationConfig{
+ Inference: &MlNodeStageReconciliationConfig{
+ BlockInterval: blockInterval,
+ TimeInterval: 60 * time.Minute,
+ },
+ PoC: &MlNodeStageReconciliationConfig{
+ BlockInterval: 1,
+ TimeInterval: 60 * time.Minute,
+ },
+ LastTime: time.Now(),
+ LastBlockHeight: 0,
+ }
+}
+
+func TestInferenceReconciliation(t *testing.T) {
+ epochParams := defaultEpochParams
+ reconciliationConfig := testreconcilialtionConfig(5)
+ setup := createIntegrationTestSetup(&reconciliationConfig, &epochParams)
+
+ setup.addTestNode("node-1", 8081)
+ waitForNodeStatus(t, setup, "node-1", types.HardwareNodeStatus_STOPPED, 2*time.Second)
+
+ setup.addTestNode("node-2", 8082)
+ waitForNodeStatus(t, setup, "node-2", types.HardwareNodeStatus_STOPPED, 2*time.Second)
+
+ setup.assertNode("node-1", func(n broker.NodeResponse) {
+ require.Equal(t, types.HardwareNodeStatus_STOPPED, n.State.CurrentStatus)
+ require.Equal(t, types.HardwareNodeStatus_UNKNOWN, n.State.IntendedStatus)
+ })
+ setup.assertNode("node-2", func(n broker.NodeResponse) {
+ require.Equal(t, types.HardwareNodeStatus_STOPPED, n.State.CurrentStatus)
+ require.Equal(t, types.HardwareNodeStatus_UNKNOWN, n.State.IntendedStatus)
+ })
+
+ node1Client := setup.getNodeClient("node-1", 8081)
+ node2Client := setup.getNodeClient("node-2", 8082)
+ assertNodeClient(t, NodeClientAssertion{0, 0, 0, 0}, node1Client)
+ assertNodeClient(t, NodeClientAssertion{0, 0, 0, 0}, node2Client)
+
+ var i = int64(1)
+ for i <= int64(reconciliationConfig.Inference.BlockInterval) {
+ err := setup.simulateBlock(i)
+ require.NoError(t, err)
+
+ i++
+ }
+
+ waitForAsync(500 * time.Millisecond)
+
+ setup.assertNode("node-1", func(n broker.NodeResponse) {
+ require.Equal(t, types.HardwareNodeStatus_INFERENCE, n.State.CurrentStatus)
+ require.Equal(t, types.HardwareNodeStatus_INFERENCE, n.State.IntendedStatus)
+ })
+ setup.assertNode("node-2", func(n broker.NodeResponse) {
+ require.Equal(t, types.HardwareNodeStatus_INFERENCE, n.State.CurrentStatus)
+ require.Equal(t, types.HardwareNodeStatus_INFERENCE, n.State.IntendedStatus)
+ })
+
+ expected := NodeClientAssertion{1, 0, 0, 1}
+ assertNodeClient(t, expected, node1Client)
+ assertNodeClient(t, expected, node2Client)
+
+ for i < setup.EpochParams.EpochLength {
+ i++
+ }
+
+ assertNodeClient(t, expected, node1Client)
+ assertNodeClient(t, expected, node2Client)
+}
+
+func TestRegularPocScenario(t *testing.T) {
+ epochParams := defaultEpochParams
+ setup := createIntegrationTestSetup(nil, &epochParams)
+
+ // Add two nodes - both initially enabled
+ setup.addTestNode("node-1", 8081)
+ setup.addTestNode("node-2", 8082)
+
+ node1Client := setup.getNodeClient("node-1", 8081)
+ node2Client := setup.getNodeClient("node-2", 8082)
+ assertNodeClient(t, NodeClientAssertion{0, 0, 0, 0}, node1Client)
+ assertNodeClient(t, NodeClientAssertion{0, 0, 0, 0}, node2Client)
+
+ var i int64 = 1
+ for i <= setup.EpochParams.EpochLength {
+ require.Equal(t, 0, node1Client.InitGenerateCalled, "InitGenerate was called. n = %d. i = %d", node1Client.InitGenerateCalled, i)
+ require.Equal(t, 0, node2Client.InitGenerateCalled, "InitGenerate was called. n = %d. i = %d", node2Client.InitGenerateCalled, i)
+ if i == setup.EpochParams.EpochLength {
+ setup.transitionChainStateToNextEpoch(i)
+ }
+ err := setup.simulateBlock(i)
+ require.NoError(t, err)
+
+ i++
+ }
+
+ time.Sleep(100 * time.Millisecond)
+
+ setup.assertNode("node-1", func(n broker.NodeResponse) {
+ require.Equal(t, types.HardwareNodeStatus_POC, n.State.CurrentStatus)
+ require.Equal(t, broker.PocStatusGenerating, n.State.PocCurrentStatus)
+ require.Equal(t, types.HardwareNodeStatus_POC, n.State.IntendedStatus)
+ })
+ setup.assertNode("node-2", func(n broker.NodeResponse) {
+ require.Equal(t, types.HardwareNodeStatus_POC, n.State.CurrentStatus)
+ require.Equal(t, broker.PocStatusGenerating, n.State.PocCurrentStatus)
+ require.Equal(t, types.HardwareNodeStatus_POC, n.State.IntendedStatus)
+ })
+
+ // +1 stop call for inference reconciliation
+ expected := NodeClientAssertion{StopCalled: 2, InitGenerateCalled: 1, InitValidateCalled: 0, InferenceUpCalled: 1}
+ assertNodeClient(t, expected, node1Client)
+ assertNodeClient(t, expected, node2Client)
+
+ pocGenEnd := setup.EpochParams.EpochLength + setup.EpochParams.GetEndOfPoCStage()
+ for i < pocGenEnd {
+ err := setup.simulateBlock(i)
+ require.NoError(t, err)
+
+ // Expect no new calls to ml node client
+ expected := NodeClientAssertion{StopCalled: 2, InitGenerateCalled: 1, InitValidateCalled: 0, InferenceUpCalled: 1}
+ assertNodeClient(t, expected, node1Client)
+ assertNodeClient(t, expected, node2Client)
+ i++
+ }
+
+ pocValStart := i
+ pocValEnd := pocValStart + setup.EpochParams.PocValidationDelay + setup.EpochParams.PocValidationDuration
+ for i < pocValEnd {
+ err := setup.simulateBlock(i)
+ require.NoError(t, err)
+
+ if i == pocValStart {
+ waitForAsync(300 * time.Millisecond)
+ }
+
+ expected := NodeClientAssertion{StopCalled: 2, InitGenerateCalled: 1, InitValidateCalled: 1, InferenceUpCalled: 1}
+ assertNodeClient(t, expected, node1Client)
+ assertNodeClient(t, expected, node2Client)
+
+ i++
+ }
+ require.Equal(t, pocValEnd, i)
+
+ require.Equal(t, node1Client.LastInitDto.BlockHeight, node1Client.LastInitValidateDto.BlockHeight)
+ require.Equal(t, node1Client.LastInitDto.BlockHash, node1Client.LastInitValidateDto.BlockHash)
+ require.Equal(t, node2Client.LastInitDto.BlockHeight, node2Client.LastInitValidateDto.BlockHeight)
+ require.Equal(t, node2Client.LastInitDto.BlockHash, node2Client.LastInitValidateDto.BlockHash)
+
+ require.Equal(t, node1Client.LastInitValidateDto.BlockHeight, node2Client.LastInitValidateDto.BlockHeight)
+ require.Equal(t, node1Client.LastInitValidateDto.BlockHash, node2Client.LastInitValidateDto.BlockHash)
+
+ err := setup.simulateBlock(i)
+ require.NoError(t, err)
+ waitForAsync(100 * time.Millisecond)
+
+ expected = NodeClientAssertion{StopCalled: 3, InitGenerateCalled: 1, InitValidateCalled: 1, InferenceUpCalled: 2}
+ assertNodeClient(t, expected, node1Client)
+ assertNodeClient(t, expected, node2Client)
+ setup.assertNode("node-1", func(n broker.NodeResponse) {
+ assert.Equal(t, types.HardwareNodeStatus_INFERENCE, n.State.IntendedStatus)
+ assert.Equal(t, types.HardwareNodeStatus_INFERENCE, n.State.CurrentStatus)
+ })
+ setup.assertNode("node-2", func(n broker.NodeResponse) {
+ assert.Equal(t, types.HardwareNodeStatus_INFERENCE, n.State.IntendedStatus)
+ assert.Equal(t, types.HardwareNodeStatus_INFERENCE, n.State.CurrentStatus)
+ })
+}
+
+func TestNodeUpdateSwitchesPocAddresses(t *testing.T) {
+ reconciliationConfig := testreconcilialtionConfig(4)
+ epochParams := defaultEpochParams
+ setup := createIntegrationTestSetup(&reconciliationConfig, &epochParams)
+
+ const (
+ nodeID = "node-1"
+ initialPort = 8091
+ )
+
+ setup.addTestNode(nodeID, initialPort)
+ waitForNodeStatus(t, setup, nodeID, types.HardwareNodeStatus_STOPPED, 2*time.Second)
+
+ nodeClient := setup.getNodeClient(nodeID, initialPort)
+
+ var height int64 = 1
+ for height <= int64(reconciliationConfig.Inference.BlockInterval) {
+ require.NoError(t, setup.simulateBlock(height))
+ height++
+ }
+ waitForAsync(200 * time.Millisecond)
+ waitForNodeStatus(t, setup, nodeID, types.HardwareNodeStatus_INFERENCE, 2*time.Second)
+
+ assertNodeClient(t, NodeClientAssertion{StopCalled: 1, InitGenerateCalled: 0, InitValidateCalled: 0, InferenceUpCalled: 1}, nodeClient)
+
+ nodes, err := setup.NodeBroker.GetNodes()
+ require.NoError(t, err)
+ require.Equal(t, 1, len(nodes))
+ originalNode := nodes[0].Node
+
+ oldPocURL := fmt.Sprintf("http://%s:%d%s", originalNode.Host, originalNode.PoCPort, originalNode.PoCSegment)
+ oldClient := setup.MockClientFactory.GetClientForNode(oldPocURL)
+ require.NotNil(t, oldClient, "expected ML client for original address")
+
+ updatedHost := "node1-updated-host"
+ updatedInferencePort := 18081
+ updatedPocPort := 18082
+ updatedConfig := apiconfig.InferenceNodeConfig{
+ Id: nodeID,
+ Host: updatedHost,
+ InferenceSegment: originalNode.InferenceSegment,
+ InferencePort: updatedInferencePort,
+ PoCSegment: originalNode.PoCSegment,
+ PoCPort: updatedPocPort,
+ MaxConcurrent: originalNode.MaxConcurrent,
+ Models: make(map[string]apiconfig.ModelConfig),
+ Hardware: originalNode.Hardware,
+ }
+ for modelID, args := range originalNode.Models {
+ updatedConfig.Models[modelID] = apiconfig.ModelConfig{Args: args.Args}
+ }
+
+ updateCmd := broker.NewUpdateNodeCommand(updatedConfig)
+ require.NoError(t, setup.NodeBroker.QueueMessage(updateCmd))
+ updateResp := <-updateCmd.Response
+ require.NotNil(t, updateResp)
+ require.Nil(t, updateResp.Error)
+
+ for height <= int64(setup.EpochParams.EpochLength) {
+ if height == int64(setup.EpochParams.EpochLength) {
+ setup.transitionChainStateToNextEpoch(height)
+ }
+ require.NoError(t, setup.simulateBlock(height))
+ height++
+ }
+
+ waitForAsync(500 * time.Millisecond)
+
+ newPocURL := fmt.Sprintf("http://%s:%d%s", updatedHost, updatedPocPort, originalNode.PoCSegment)
+ newClient := setup.MockClientFactory.GetClientForNode(newPocURL)
+ require.NotNil(t, newClient, "expected ML client to be recreated for updated address")
+
+ newClient.WithTryLock(t, func() {
+ assert.Greater(t, newClient.InitGenerateCalled, 0, "PoC should use updated address")
+ })
+ oldClient.WithTryLock(t, func() {
+ assert.Equal(t, 0, oldClient.InitGenerateCalled, "PoC should not use stale address")
+ })
+}
+
+type NodeClientAssertion struct {
+ StopCalled int
+ InitGenerateCalled int
+ InitValidateCalled int
+ InferenceUpCalled int
+}
+
+func assertNodeClient(t *testing.T, expected NodeClientAssertion, nodeClient *mlnodeclient.MockClient) {
+ lock := nodeClient.Mu.TryLock()
+ if !lock {
+ t.Fatal("Failed to acquire lock on nodeClient")
+ } else {
+ defer nodeClient.Mu.Unlock()
+ }
+
+ require.Equal(t, expected.InitGenerateCalled, nodeClient.InitGenerateCalled, "InitGenerate was called. n = %d", nodeClient.InitGenerateCalled)
+ require.Equal(t, expected.InitValidateCalled, nodeClient.InitValidateCalled, "InitValidate was called. n = %d", nodeClient.InitValidateCalled)
+ require.Equal(t, expected.InferenceUpCalled, nodeClient.InferenceUpCalled, "InferenceUp was called. n = %d", nodeClient.InferenceUpCalled)
+ require.Equal(t, expected.StopCalled, nodeClient.StopCalled, "Stop was called. n = %d", nodeClient.StopCalled)
+}
+
+// Test Scenario 1: Node disable scenario - node should skip PoC when disabled
+func TestNodeDisableScenario_Integration(t *testing.T) {
+ reconciliationConfig := testreconcilialtionConfig(5)
+ epochParams := &types.EpochParams{
+ EpochLength: 100,
+ EpochShift: 0,
+ EpochMultiplier: 1,
+ PocStageDuration: 20,
+ PocExchangeDuration: 2,
+ PocValidationDelay: 2,
+ PocValidationDuration: 10,
+ }
+ setup := createIntegrationTestSetup(&reconciliationConfig, epochParams)
+
+ // Add two nodes - both initially enabled
+ setup.addTestNode("node-1", 8081)
+ setup.addTestNode("node-2", 8082)
+
+ node1Client := setup.getNodeClient("node-1", 8081)
+ node2Client := setup.getNodeClient("node-2", 8082)
+
+ // Disable node-1 before the PoC starts
+ err := setup.setNodeAdminState("node-1", false)
+ require.NoError(t, err)
+ waitForAsync(100 * time.Millisecond)
+
+ setup.assertNode("node-1", func(n broker.NodeResponse) {
+ require.Equal(t, false, n.State.AdminState.Enabled)
+ require.Equal(t, uint64(0), n.State.AdminState.Epoch)
+ })
+ setup.assertNode("node-2", func(n broker.NodeResponse) {
+ require.Equal(t, true, n.State.AdminState.Enabled)
+ require.Equal(t, uint64(0), n.State.AdminState.Epoch)
+ })
+
+ // Simulate epoch PoC phase (block 100) to avoid same-epoch restrictions
+ // Only node-2 should participate since node-1 is disabled
+ latestEpoch := types.Epoch{
+ Index: 1,
+ PocStartBlockHeight: epochParams.EpochLength,
+ }
+
+ var i = setup.EpochParams.EpochLength
+ setup.setLatestEpoch(i, latestEpoch)
+ ec := types.NewEpochContext(latestEpoch, *setup.EpochParams)
+
+ for i < 2*setup.EpochParams.EpochLength {
+ err = setup.simulateBlock(i)
+ require.NoError(t, err)
+
+ // TODO: overall feels like a hack, should we just unconditionally wait after each block?
+ // or maybe add some explicit sync mechanism that would notify subscribers when all commands are processed?
+ if ec.IsStartOfPocStage(i) ||
+ ec.IsEndOfPoCStage(i) ||
+ ec.IsStartOfPoCValidationStage(i) ||
+ ec.IsEndOfPoCValidationStage(i) {
+ println("Simulating block:", i, "ec.IsStartOfPocStage == ", ec.IsStartOfPocStage(i), "ec.IsEndOfPoCValidationStage == ", ec.IsEndOfPoCValidationStage(i))
+ // Wait for all commands to finish so we don't cancel them too soon
+ waitForAsync(500 * time.Millisecond)
+ }
+
+ i++
+ }
+
+ waitForAsync(300 * time.Millisecond)
+
+ // Verify only node-2 received PoC start command, node-1 should be excluded
+ node1Client.WithTryLock(t, func() {
+ assert.Equal(t, 0, node1Client.InitGenerateCalled, "Disabled node-1 should NOT receive InitGenerate call")
+ assert.Equal(t, 0, node1Client.InitValidateCalled, "Disabled node-1 should NOT receive InitGenerate call")
+ })
+ node2Client.WithTryLock(t, func() {
+ assert.Equal(t, 1, node2Client.InitGenerateCalled, "Enabled node-2 should receive InitGenerate call")
+ assert.Equal(t, 1, node2Client.InitValidateCalled, "Enabled node-2 should receive InitGenerate call")
+ })
+
+ node1Expected := NodeClientAssertion{StopCalled: 1, InitGenerateCalled: 0, InitValidateCalled: 0, InferenceUpCalled: 1}
+ assertNodeClient(t, node1Expected, node1Client)
+ setup.assertNode("node-1", func(n broker.NodeResponse) {
+ // Default state is inference
+ require.Equal(t, types.HardwareNodeStatus_INFERENCE, n.State.CurrentStatus)
+ })
+
+ node2Expected := NodeClientAssertion{StopCalled: 1, InitGenerateCalled: 1, InitValidateCalled: 1, InferenceUpCalled: 1}
+ assertNodeClient(t, node2Expected, node2Client)
+ setup.assertNode("node-2", func(n broker.NodeResponse) {
+ require.Equal(t, types.HardwareNodeStatus_INFERENCE, n.State.CurrentStatus)
+ })
+}
+
+// Test Scenario 2: Node enable scenario - node should participate in PoC after being enabled
+func TestNodeEnableScenario_Integration(t *testing.T) {
+ reconciliationConfig := testreconcilialtionConfig(4)
+ setup := createIntegrationTestSetup(&reconciliationConfig, nil)
+
+ // Add two nodes - node-1 initially disabled, node-2 enabled
+ setup.addTestNode("node-1", 8081)
+ setup.addTestNode("node-2", 8082)
+
+ node1Client := setup.getNodeClient("node-1", 8081)
+ node2Client := setup.getNodeClient("node-2", 8082)
+
+ // Disable node-1 initially
+ err := setup.setNodeAdminState("node-1", false)
+ require.NoError(t, err)
+ waitForAsync(100 * time.Millisecond)
+
+ setup.assertNode("node-1", func(n broker.NodeResponse) {
+ require.Equal(t, false, n.State.AdminState.Enabled)
+ require.Equal(t, uint64(0), n.State.AdminState.Epoch)
+ })
+ setup.assertNode("node-2", func(n broker.NodeResponse) {
+ require.Equal(t, true, n.State.AdminState.Enabled)
+ require.Equal(t, uint64(0), n.State.AdminState.Epoch)
+ })
+
+ // Simulate first PoC (block 100) - only node-2 should participate
+ setup.transitionChainStateToNextEpoch(100)
+ err = setup.simulateBlock(100)
+ require.NoError(t, err)
+
+ // Give time for processing
+ waitForAsync(500 * time.Millisecond)
+
+ // Verify only node-2 received PoC start command
+ require.Equal(t, 0, node1Client.InitGenerateCalled, "Disabled node-1 should NOT receive InitGenerate call")
+ require.Equal(t, 1, node2Client.InitGenerateCalled, "Enabled node-2 should receive InitGenerate call")
+ setup.assertNode("node-1", func(n broker.NodeResponse) {
+ require.Equal(t, types.HardwareNodeStatus_INFERENCE, n.State.CurrentStatus)
+ })
+ setup.assertNode("node-2", func(n broker.NodeResponse) {
+ require.Equal(t, types.HardwareNodeStatus_POC, n.State.CurrentStatus)
+ require.Equal(t, broker.PocStatusGenerating, n.State.PocCurrentStatus)
+ })
+
+ // Enable node-1 during inference phase
+ err = setup.setNodeAdminState("node-1", true)
+ require.NoError(t, err)
+ waitForAsync(300 * time.Millisecond)
+
+ var i = int64(150)
+ for i < int64(150+reconciliationConfig.Inference.BlockInterval) {
+ err = setup.simulateBlock(i)
+ require.NoError(t, err)
+ i++
+ }
+ waitForAsync(300 * time.Millisecond)
+
+ setup.assertNode("node-1", func(n broker.NodeResponse) {
+ require.Equal(t, types.HardwareNodeStatus_INFERENCE, n.State.CurrentStatus)
+ })
+ setup.assertNode("node-2", func(n broker.NodeResponse) {
+ require.Equal(t, types.HardwareNodeStatus_INFERENCE, n.State.CurrentStatus)
+ })
+
+ // Simulate next epoch PoC (block 200) - both nodes should participate
+ setup.transitionChainStateToNextEpoch(200)
+ err = setup.simulateBlock(200)
+ require.NoError(t, err)
+
+ // Give time for processing
+ waitForAsync(500 * time.Millisecond)
+
+ setup.assertNode("node-1", func(n broker.NodeResponse) {
+ require.Equal(t, types.HardwareNodeStatus_POC, n.State.CurrentStatus)
+ require.Equal(t, broker.PocStatusGenerating, n.State.PocCurrentStatus)
+ })
+ setup.assertNode("node-2", func(n broker.NodeResponse) {
+ require.Equal(t, types.HardwareNodeStatus_POC, n.State.CurrentStatus)
+ require.Equal(t, broker.PocStatusGenerating, n.State.PocCurrentStatus)
+ })
+
+ // Verify both nodes received PoC start command
+ require.Equal(t, 1, node1Client.InitGenerateCalled, "Node-1 should receive InitGenerate call after being enabled")
+ require.Equal(t, 2, node2Client.InitGenerateCalled, "Node-2 should continue to receive InitGenerate call")
+}
+
+// Test Scenario 4: Full epoch transition with PoC commands
+func TestFullEpochTransitionWithPocCommands_Integration(t *testing.T) {
+ setup := createIntegrationTestSetup(nil, nil)
+
+ // Add two nodes
+ setup.addTestNode("node-1", 8081)
+ setup.addTestNode("node-2", 8082)
+
+ node1Client := setup.getNodeClient("node-1", 8081)
+ node2Client := setup.getNodeClient("node-2", 8082)
+
+ assertNodeClient(t, NodeClientAssertion{0, 0, 0, 0}, node1Client)
+ assertNodeClient(t, NodeClientAssertion{0, 0, 0, 0}, node2Client)
+
+ // Simulate PoC start (block 0)
+ setup.transitionChainStateToNextEpoch(100)
+ err := setup.simulateBlock(100)
+ require.NoError(t, err)
+ waitForAsync(100 * time.Millisecond)
+
+ // Both nodes should start PoC
+ assert.Greater(t, node1Client.InitGenerateCalled, 0, "Node-1 should start PoC")
+ assert.Greater(t, node2Client.InitGenerateCalled, 0, "Node-2 should start PoC")
+
+ // Simulate end of PoC stage (block 20)
+ err = setup.simulateBlock(120)
+ require.NoError(t, err)
+ waitForAsync(100 * time.Millisecond)
+
+ assert.Equal(t, node1Client.InitValidateCalled, 1, "Node-1 should receive validation command")
+ assert.Equal(t, node2Client.InitValidateCalled, 1, "Node-2 should receive validation command")
+
+ // Simulate PoC validation start (block 22)
+ err = setup.simulateBlock(122)
+ require.NoError(t, err)
+ waitForAsync(100 * time.Millisecond)
+
+ // Nodes should receive validation commands
+
+ // Simulate end of validation (block 32)
+ err = setup.simulateBlock(132)
+ require.NoError(t, err)
+ waitForAsync(100 * time.Millisecond)
+
+ // Nodes should receive inference up commands
+ assert.Greater(t, node1Client.InferenceUpCalled, 0, "Node-1 should receive InferenceUp command")
+ assert.Greater(t, node2Client.InferenceUpCalled, 0, "Node-2 should receive InferenceUp command")
+
+ t.Logf("✅ Test 4 passed: Full epoch transition with proper PoC and validation commands")
+}
+
+func TestBasicSetup(t *testing.T) {
+ reconcilialtionConfig := testreconcilialtionConfig(5)
+ setup := createIntegrationTestSetup(&reconcilialtionConfig, nil)
+ require.NotNil(t, setup)
+ require.NotNil(t, setup.Dispatcher)
+ require.NotNil(t, setup.NodeBroker)
+ require.NotNil(t, setup.MockClientFactory)
+
+ // Add a node and verify client creation
+ setup.addTestNode("test-node", 8081)
+ client := setup.getNodeClient("test-node", 8081)
+ require.NotNil(t, client)
+}
+
+func TestPoCRetry(t *testing.T) {
+ params := types.EpochParams{
+ EpochLength: 100,
+ EpochShift: 0,
+ EpochMultiplier: 1,
+ PocStageDuration: 20,
+ PocExchangeDuration: 2,
+ PocValidationDelay: 2,
+ PocValidationDuration: 10,
+ }
+ reconciliationConfig := testreconcilialtionConfig(2)
+ setup := createIntegrationTestSetup(&reconciliationConfig, ¶ms)
+
+ // Add two nodes
+ setup.addTestNode("node-1", 8081)
+ setup.addTestNode("node-2", 8082)
+
+ node1Client := setup.getNodeClient("node-1", 8081)
+ node2Client := setup.getNodeClient("node-2", 8082)
+
+ node1Client.WithTryLock(t, func() {
+ node1Client.InitGenerateError = errors.New("test error")
+ })
+
+ var i = params.EpochLength
+ setup.transitionChainStateToNextEpoch(i)
+ err := setup.simulateBlock(i)
+ i++
+ require.NoError(t, err)
+
+ waitForAsync(100 * time.Millisecond)
+
+ assertNodeClient(t, NodeClientAssertion{0, 1, 0, 0}, node1Client)
+ assertNodeClient(t, NodeClientAssertion{0, 1, 0, 0}, node2Client)
+ setup.assertNode("node-1", func(n broker.NodeResponse) {
+ require.Equal(t, types.HardwareNodeStatus_FAILED, n.State.CurrentStatus)
+ })
+ setup.assertNode("node-2", func(n broker.NodeResponse) {
+ require.Equal(t, types.HardwareNodeStatus_POC, n.State.CurrentStatus)
+ require.Equal(t, broker.PocStatusGenerating, n.State.PocCurrentStatus)
+ })
+
+ for i <= params.EpochLength+int64(reconciliationConfig.PoC.BlockInterval) {
+ err = setup.simulateBlock(i)
+ require.NoError(t, err)
+
+ i++
+ }
+
+ waitForAsync(100 * time.Millisecond)
+
+ // check PoC init generate was retried
+ assertNodeClient(t, NodeClientAssertion{0, 2, 0, 0}, node1Client)
+ assertNodeClient(t, NodeClientAssertion{0, 1, 0, 0}, node2Client)
+ setup.assertNode("node-1", func(n broker.NodeResponse) {
+ require.Equal(t, types.HardwareNodeStatus_FAILED, n.State.CurrentStatus)
+ })
+ setup.assertNode("node-2", func(n broker.NodeResponse) {
+ require.Equal(t, types.HardwareNodeStatus_POC, n.State.CurrentStatus)
+ require.Equal(t, broker.PocStatusGenerating, n.State.PocCurrentStatus)
+ })
+
+ node1Client.WithTryLock(t, func() {
+ node1Client.InitGenerateError = nil
+ })
+
+ for i < params.EpochLength+params.GetEndOfPoCStage() {
+ err = setup.simulateBlock(i)
+ require.NoError(t, err)
+
+ waitForAsync(100 * time.Millisecond)
+
+ i++
+ }
+
+ // waitForAsync(100 * time.Millisecond)
+
+ // check only 1 retry happened and then it stopped once we removed the error
+ assertNodeClient(t, NodeClientAssertion{0, 3, 0, 0}, node1Client)
+ assertNodeClient(t, NodeClientAssertion{0, 1, 0, 0}, node2Client)
+ setup.assertNode("node-1", func(n broker.NodeResponse) {
+ require.Equal(t, types.HardwareNodeStatus_POC, n.State.CurrentStatus)
+ require.Equal(t, broker.PocStatusGenerating, n.State.PocCurrentStatus)
+ })
+ setup.assertNode("node-2", func(n broker.NodeResponse) {
+ require.Equal(t, types.HardwareNodeStatus_POC, n.State.CurrentStatus)
+ require.Equal(t, broker.PocStatusGenerating, n.State.PocCurrentStatus)
+ })
+}
diff --git a/decentralized-api/internal/event_listener/new_block_dispatcher.go b/decentralized-api/internal/event_listener/new_block_dispatcher.go
new file mode 100644
index 000000000..333662bd3
--- /dev/null
+++ b/decentralized-api/internal/event_listener/new_block_dispatcher.go
@@ -0,0 +1,667 @@
+package event_listener
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "strconv"
+ "strings"
+ "time"
+
+ "decentralized-api/apiconfig"
+ "decentralized-api/broker"
+ "decentralized-api/chainphase"
+ "decentralized-api/cosmosclient"
+ "decentralized-api/internal/event_listener/chainevents"
+ "decentralized-api/internal/poc"
+ "decentralized-api/internal/validation"
+ "decentralized-api/logging"
+
+ coretypes "github.com/cometbft/cometbft/rpc/core/types"
+ "github.com/productscience/inference/x/inference/types"
+ "google.golang.org/grpc"
+)
+
+// Minimal interface for query operations needed by the dispatcher
+type ChainStateClient interface {
+ EpochInfo(ctx context.Context, req *types.QueryEpochInfoRequest, opts ...grpc.CallOption) (*types.QueryEpochInfoResponse, error)
+ Params(ctx context.Context, req *types.QueryParamsRequest, opts ...grpc.CallOption) (*types.QueryParamsResponse, error)
+}
+
+// StatusFunc defines the function signature for getting node sync status
+type StatusFunc func() (*coretypes.ResultStatus, error)
+
+type SetHeightFunc func(blockHeight int64) error
+
+// PoCParams contains Proof of Compute parameters
+type PoCParams struct {
+ StartBlockHeight int64
+ StartBlockHash string
+}
+
+// MlNodeStageReconciliationConfig defines when reconciliation should be triggered
+type MlNodeStageReconciliationConfig struct {
+ BlockInterval int // Trigger every N blocks
+ TimeInterval time.Duration // OR every N time duration
+}
+
+type MlNodeReconciliationConfig struct {
+ Inference *MlNodeStageReconciliationConfig
+ PoC *MlNodeStageReconciliationConfig
+ LastBlockHeight int64 // Track last reconciliation block
+ LastTime time.Time // Track last reconciliation time
+}
+
+// OnNewBlockDispatcher orchestrates processing of new block events
+type OnNewBlockDispatcher struct {
+ nodeBroker *broker.Broker
+ nodePocOrchestrator poc.NodePoCOrchestrator
+ queryClient ChainStateClient
+ phaseTracker *chainphase.ChainPhaseTracker
+ reconciliationConfig MlNodeReconciliationConfig
+ getStatusFunc StatusFunc
+ setHeightFunc SetHeightFunc
+ randomSeedManager poc.RandomSeedManager
+ configManager *apiconfig.ConfigManager
+ validator *validation.InferenceValidator
+}
+
+// StatusResponse matches the structure expected by getStatus function
+type StatusResponse struct {
+ SyncInfo SyncInfo `json:"sync_info"`
+}
+
+type SyncInfo struct {
+ CatchingUp bool `json:"catching_up"`
+}
+
+var DefaultReconciliationConfig = MlNodeReconciliationConfig{
+ Inference: &MlNodeStageReconciliationConfig{
+ BlockInterval: 5,
+ TimeInterval: 30 * time.Second,
+ },
+ PoC: &MlNodeStageReconciliationConfig{
+ BlockInterval: 1,
+ TimeInterval: 30 * time.Second,
+ },
+ LastTime: time.Now(),
+ LastBlockHeight: 0,
+}
+
+// NewOnNewBlockDispatcher creates a new dispatcher with default configuration
+func NewOnNewBlockDispatcher(
+ nodeBroker *broker.Broker,
+ nodePocOrchestrator poc.NodePoCOrchestrator,
+ queryClient ChainStateClient,
+ phaseTracker *chainphase.ChainPhaseTracker,
+ getStatusFunc StatusFunc,
+ setHeightFunc SetHeightFunc,
+ randomSeedManager poc.RandomSeedManager,
+ reconciliationConfig MlNodeReconciliationConfig,
+ configManager *apiconfig.ConfigManager,
+ validator *validation.InferenceValidator,
+) *OnNewBlockDispatcher {
+ return &OnNewBlockDispatcher{
+ nodeBroker: nodeBroker,
+ nodePocOrchestrator: nodePocOrchestrator,
+ queryClient: queryClient,
+ phaseTracker: phaseTracker,
+ reconciliationConfig: reconciliationConfig,
+ getStatusFunc: getStatusFunc,
+ setHeightFunc: setHeightFunc,
+ randomSeedManager: randomSeedManager,
+ configManager: configManager,
+ validator: validator,
+ }
+}
+
+// NewOnNewBlockDispatcherFromCosmosClient creates a dispatcher using a full cosmos client
+// This is a convenience constructor for existing code
+func NewOnNewBlockDispatcherFromCosmosClient(
+ nodeBroker *broker.Broker,
+ configManager *apiconfig.ConfigManager,
+ nodePocOrchestrator poc.NodePoCOrchestrator,
+ cosmosClient cosmosclient.CosmosMessageClient,
+ phaseTracker *chainphase.ChainPhaseTracker,
+ reconciliationConfig MlNodeReconciliationConfig,
+ validator *validation.InferenceValidator,
+) *OnNewBlockDispatcher {
+ // Adapt the cosmos client to our minimal interfaces
+ queryClient := cosmosClient.NewInferenceQueryClient()
+ setHeightFunc := func(blockHeight int64) error {
+ return configManager.SetHeight(blockHeight)
+ }
+ getStatusFunc := func() (*coretypes.ResultStatus, error) {
+ url := configManager.GetChainNodeConfig().Url
+ return getStatus(url)
+ }
+
+ randomSeedManager := poc.NewRandomSeedManager(cosmosClient, configManager)
+
+ return NewOnNewBlockDispatcher(
+ nodeBroker,
+ nodePocOrchestrator,
+ queryClient,
+ phaseTracker,
+ getStatusFunc,
+ setHeightFunc,
+ randomSeedManager,
+ reconciliationConfig,
+ configManager,
+ validator,
+ )
+}
+
+// ProcessNewBlock is the main entry point for processing new block events
+func (d *OnNewBlockDispatcher) ProcessNewBlock(ctx context.Context, blockInfo chainphase.BlockInfo) error {
+ logging.Debug("Processing new block", types.Stages,
+ "height", blockInfo.Height,
+ "hash", blockInfo.Hash)
+
+ // 1. Query network for current state (sync status, epoch params)
+ networkInfo, err := d.queryNetworkInfo(ctx)
+ if err != nil {
+ logging.Error("Failed to query network info, skipping block processing", types.Stages,
+ "error", err, "height", blockInfo.Height)
+ return err // Skip processing this block
+ }
+
+ // Fetch validation parameters - skip in tests
+ if d.configManager != nil && !strings.HasPrefix(blockInfo.Hash, "hash-") { // Skip in tests where hash has format "hash-N"
+ params, err := d.queryClient.Params(ctx, &types.QueryParamsRequest{})
+ if err != nil {
+ logging.Error("Failed to get params", types.Validation, "error", err)
+ } else {
+ // Update validation parameters in config
+ validationParams := apiconfig.ValidationParamsCache{
+ TimestampExpiration: params.Params.ValidationParams.TimestampExpiration,
+ TimestampAdvance: params.Params.ValidationParams.TimestampAdvance,
+ ExpirationBlocks: params.Params.ValidationParams.ExpirationBlocks,
+ }
+
+ logging.Debug("Updating validation parameters", types.Validation,
+ "timestampExpiration", validationParams.TimestampExpiration,
+ "timestampAdvance", validationParams.TimestampAdvance,
+ "expirationBlocks", validationParams.ExpirationBlocks)
+
+ err = d.configManager.SetValidationParams(validationParams)
+ if err != nil {
+ logging.Warn("Failed to update validation parameters", types.Config, "error", err)
+ }
+
+ if params.Params.BandwidthLimitsParams != nil {
+ bandwidthParams := apiconfig.BandwidthParamsCache{
+ EstimatedLimitsPerBlockKb: params.Params.BandwidthLimitsParams.EstimatedLimitsPerBlockKb,
+ KbPerInputToken: params.Params.BandwidthLimitsParams.KbPerInputToken.ToFloat(),
+ KbPerOutputToken: params.Params.BandwidthLimitsParams.KbPerOutputToken.ToFloat(),
+ }
+
+ logging.Debug("Updated bandwidth parameters from chain", types.Config,
+ "estimatedLimitsPerBlockKb", bandwidthParams.EstimatedLimitsPerBlockKb,
+ "kbPerInputToken", bandwidthParams.KbPerInputToken,
+ "kbPerOutputToken", bandwidthParams.KbPerOutputToken)
+
+ err = d.configManager.SetBandwidthParams(bandwidthParams)
+ if err != nil {
+ logging.Warn("Failed to update bandwidth parameters", types.Config, "error", err)
+ }
+ }
+ }
+ }
+
+ // Let's check in prod how often this happens
+ if networkInfo.BlockHeight != blockInfo.Height {
+ logging.Warn("Block height mismatch between event and network query", types.Stages,
+ "event_height", blockInfo.Height,
+ "network_height", networkInfo.BlockHeight)
+ }
+
+ // 2. Update phase tracker and get phase info
+ // FIXME: It looks like a problem that queries are separate inside networkInfo, and blockInfo
+ // comes from a totally different source?
+ // TODO: log block that came from event vs block returned by query
+ // TODO: can we add the state to the block event? As a future optimization?
+ d.phaseTracker.Update(blockInfo, &networkInfo.LatestEpoch, &networkInfo.EpochParams, networkInfo.IsSynced, networkInfo.ActiveConfirmationPoCEvent)
+ epochState := d.phaseTracker.GetCurrentEpochState()
+ if epochState == nil {
+ logging.Error("[ILLEGAL_STATE]: Epoch state is nil right after an update call to phase tracker. "+
+ "Skip block processing", types.Stages,
+ "blockHeight", blockInfo.Height, "isSynced", networkInfo.IsSynced)
+ return nil
+ }
+
+ logging.Info("[new-block-dispatcher] Current epoch state.", types.Stages,
+ "blockHeight", epochState.CurrentBlock.Height,
+ "epoch", epochState.LatestEpoch.EpochIndex,
+ "epoch.PocStartBlockHeight", epochState.LatestEpoch.PocStartBlockHeight,
+ "currentPhase", epochState.CurrentPhase,
+ "isSynced", epochState.IsSynced,
+ "blockHash", epochState.CurrentBlock.Hash)
+ logging.Debug("[new-block-dispatcher]", types.Stages, "blockHeight", epochState.CurrentBlock.Height, "blochHash", epochState.CurrentBlock.Hash)
+ if !epochState.IsSynced {
+ logging.Info("The blockchain node is still catching up, skipping on new block phase transitions", types.Stages)
+ return nil
+ }
+
+ // 3. Check for phase transitions and stage events
+ d.handlePhaseTransitions(*epochState)
+
+ // 4. Check if reconciliation should be triggered
+ if d.shouldTriggerReconciliation(*epochState) {
+ d.triggerReconciliation(*epochState)
+ }
+
+ // 5. Update config manager height
+ err = d.setHeightFunc(blockInfo.Height)
+ if err != nil {
+ logging.Warn("Failed to write config", types.Config, "error", err)
+ }
+
+ return nil
+}
+
+// NetworkInfo contains information queried from the network
+type NetworkInfo struct {
+ EpochParams types.EpochParams
+ IsSynced bool
+ LatestEpoch types.Epoch
+ BlockHeight int64
+ ActiveConfirmationPoCEvent *types.ConfirmationPoCEvent
+}
+
+// queryNetworkInfo queries the network for sync status and epoch parameters
+func (d *OnNewBlockDispatcher) queryNetworkInfo(ctx context.Context) (NetworkInfo, error) {
+ // Query sync status
+ status, err := d.getStatusFunc()
+ if err != nil {
+ return NetworkInfo{}, err
+ }
+ isSynced := !status.SyncInfo.CatchingUp
+
+ epochInfo, err := d.queryClient.EpochInfo(ctx, &types.QueryEpochInfoRequest{})
+ if err != nil || epochInfo == nil {
+ logging.Error("Failed to query epoch info", types.Stages, "error", err)
+ return NetworkInfo{}, err
+ }
+
+ // Extract confirmation PoC event if active
+ var confirmationEvent *types.ConfirmationPoCEvent
+ if epochInfo.IsConfirmationPocActive && epochInfo.ActiveConfirmationPocEvent != nil {
+ confirmationEvent = epochInfo.ActiveConfirmationPocEvent
+ }
+
+ return NetworkInfo{
+ EpochParams: *epochInfo.Params.EpochParams,
+ IsSynced: isSynced,
+ LatestEpoch: epochInfo.LatestEpoch,
+ BlockHeight: epochInfo.BlockHeight,
+ ActiveConfirmationPoCEvent: confirmationEvent,
+ }, nil
+}
+
+// handlePhaseTransitions checks for and handles phase transitions and stage events
+func (d *OnNewBlockDispatcher) handlePhaseTransitions(epochState chainphase.EpochState) {
+ epochContext := epochState.LatestEpoch
+ blockHeight := epochState.CurrentBlock.Height
+ blockHash := epochState.CurrentBlock.Hash
+
+ // Sync broker node state with the latest epoch data at the start of a transition check
+ if err := d.nodeBroker.UpdateNodeWithEpochData(&epochState); err != nil {
+ logging.Error("Failed to update node with epoch data, skipping phase transitions.", types.Stages, "error", err)
+ return
+ }
+
+ // Check for PoC start for the next epoch. This is the most important transition.
+ if epochContext.IsStartOfPocStage(blockHeight) {
+
+ logging.Info("DapiStage:IsStartOfPocStage: sending StartPoCEvent to the PoC orchestrator", types.Stages, "blockHeight", blockHeight, "blockHash", blockHash)
+ d.randomSeedManager.GenerateSeedInfo(epochContext.EpochIndex)
+ return
+ }
+
+ // Check for PoC validation stage transitions
+ if epochContext.IsEndOfPoCStage(blockHeight) {
+ logging.Info("DapiStage:IsEndOfPoCStage. Calling MoveToValidationStage", types.Stages,
+ "blockHeigh", blockHeight, "blockHash", blockHash)
+ command := broker.NewInitValidateCommand()
+ err := d.nodeBroker.QueueMessage(command)
+ if err != nil {
+ logging.Error("Failed to send init validate command", types.PoC, "error", err)
+ return
+ }
+ }
+
+ if epochContext.IsStartOfPoCValidationStage(blockHeight) {
+ logging.Info("DapiStage:IsStartOfPoCValidationStage", types.Stages, "blockHeight", blockHeight, "blockHash", blockHash, "pocStartBlockHeight", epochContext.PocStartBlockHeight)
+ go func() {
+ d.nodePocOrchestrator.ValidateReceivedBatches(epochContext.PocStartBlockHeight)
+ }()
+ }
+
+ if epochContext.IsEndOfPoCValidationStage(blockHeight) {
+ logging.Info("DapiStage:IsEndOfPoCValidationStage", types.Stages, "blockHeight", blockHeight, "blockHash", blockHash)
+ command := broker.NewInferenceUpAllCommand()
+ err := d.nodeBroker.QueueMessage(command)
+ if err != nil {
+ logging.Error("Failed to send inference up command", types.PoC, "error", err)
+ return
+ }
+ return
+ }
+
+ // Check for other stage transitions
+ if epochContext.IsSetNewValidatorsStage(blockHeight) {
+ logging.Info("DapiStage:IsSetNewValidatorsStage", types.Stages, "blockHeight", blockHeight, "blockHash", blockHash)
+ go func() {
+ d.randomSeedManager.ChangeCurrentSeed()
+ }()
+ }
+
+ if epochContext.IsClaimMoneyStage(blockHeight) {
+ logging.Info("DapiStage:IsClaimMoneyStage", types.Stages, "blockHeight", blockHeight, "blockHash", blockHash)
+
+ // Calculate previous epoch index
+ expectedPreviousEpochIndex := epochContext.EpochIndex - 1
+ // Get the previous epoch seed for validation recovery
+ previousSeed := d.randomSeedManager.GetSeedForEpoch(expectedPreviousEpochIndex)
+
+ // Verify the seed is from the correct epoch
+ if previousSeed.EpochIndex != expectedPreviousEpochIndex {
+ logging.Warn("Previous seed epoch mismatch for recovery", types.Validation,
+ "previousSeedEpoch", previousSeed.EpochIndex,
+ "expectedPreviousEpoch", expectedPreviousEpochIndex,
+ "currentEpoch", epochContext.EpochIndex)
+ }
+
+ // Execute missed validation recovery BEFORE claiming rewards
+ go func() {
+ // First, recover any missed validations from the previous epoch
+ d.executeMissedValidationRecoveryWithSeed(expectedPreviousEpochIndex, previousSeed)
+
+ // Then, claim rewards (this ensures we've validated everything before claiming)
+ d.randomSeedManager.RequestMoney(expectedPreviousEpochIndex)
+
+ // Mark the seed as claimed to prevent duplicate claims
+ err := d.configManager.MarkPreviousSeedClaimed()
+ if err != nil {
+ logging.Error("Failed to mark seed as claimed", types.Claims, "epochIndex", expectedPreviousEpochIndex, "error", err)
+ }
+ }()
+ }
+
+ // Confirmation PoC transitions (during inference phase)
+ if epochState.CurrentPhase == types.InferencePhase && epochState.ActiveConfirmationPoCEvent != nil {
+ event := epochState.ActiveConfirmationPoCEvent
+ epochParams := &epochState.LatestEpoch.EpochParams
+
+ // Start generation
+ if event.ShouldStartGeneration(blockHeight) {
+ logging.Info("Confirmation PoC generation starting", types.PoC,
+ "trigger_height", event.TriggerHeight,
+ "block_hash", event.PocSeedBlockHash)
+
+ command := broker.NewStartPocCommand()
+ if err := d.nodeBroker.QueueMessage(command); err != nil {
+ logging.Error("Failed to send confirmation PoC start command", types.PoC, "error", err)
+ }
+ }
+
+ // End of exchange period - initiate validation transition
+ if event.ShouldInitValidation(blockHeight, epochParams) {
+ logging.Info("Confirmation PoC: initiating validation transition", types.PoC,
+ "trigger_height", event.TriggerHeight,
+ "exchange_end", event.GetExchangeEnd(epochParams),
+ "validation_starts_at", event.GetValidationStart(epochParams))
+
+ command := broker.NewInitValidateCommand()
+ if err := d.nodeBroker.QueueMessage(command); err != nil {
+ logging.Error("Failed to send confirmation PoC validate command", types.PoC, "error", err)
+ }
+ }
+
+ // Start validation (now has proper gap from InitValidateCommand)
+ if event.ShouldStartValidation(blockHeight, epochParams) {
+ logging.Info("Confirmation PoC validation starting", types.PoC,
+ "trigger_height", event.TriggerHeight)
+
+ go func() {
+ d.nodePocOrchestrator.ValidateReceivedBatches(event.TriggerHeight)
+ }()
+ }
+
+ // End of event - return to inference
+ if event.ShouldReturnToInference(blockHeight, epochParams) {
+ logging.Info("Confirmation PoC completed", types.PoC,
+ "trigger_height", event.TriggerHeight)
+
+ command := broker.NewInferenceUpAllCommand()
+ if err := d.nodeBroker.QueueMessage(command); err != nil {
+ logging.Error("Failed to send inference up command", types.PoC, "error", err)
+ }
+ }
+ }
+}
+
+// shouldTriggerReconciliation determines if reconciliation should be triggered
+func (d *OnNewBlockDispatcher) shouldTriggerReconciliation(epochState chainphase.EpochState) bool {
+ switch epochState.CurrentPhase {
+ case types.PoCGeneratePhase, types.PoCValidatePhase:
+ return shouldTriggerReconciliation(epochState.CurrentBlock.Height, &d.reconciliationConfig, d.reconciliationConfig.PoC)
+ case types.InferencePhase:
+ return shouldTriggerReconciliation(epochState.CurrentBlock.Height, &d.reconciliationConfig, d.reconciliationConfig.Inference)
+ case types.PoCGenerateWindDownPhase, types.PoCValidateWindDownPhase:
+ return false
+ }
+ return false
+}
+
+func shouldTriggerReconciliation(blockHeight int64, config *MlNodeReconciliationConfig, stageConfig *MlNodeStageReconciliationConfig) bool {
+ // Check block interval
+ blocksSinceLastReconciliation := blockHeight - config.LastBlockHeight
+ if blocksSinceLastReconciliation >= int64(stageConfig.BlockInterval) {
+ return true
+ }
+
+ // Check time interval
+ timeSinceLastReconciliation := time.Since(config.LastTime)
+ if timeSinceLastReconciliation >= stageConfig.TimeInterval {
+ return true
+ }
+
+ return false
+}
+
+// triggerReconciliation starts node reconciliation with current phase info
+func (d *OnNewBlockDispatcher) triggerReconciliation(epochState chainphase.EpochState) {
+ cmd, response := getCommandForPhase(epochState)
+ if cmd == nil || response == nil {
+ logging.Info("[triggerReconciliation] No command required for phase", types.Nodes,
+ "phase", epochState.CurrentPhase, "height", epochState.CurrentBlock.Height)
+ return
+ }
+
+ logging.Info("[triggerReconciliation] Created command for reconciliation", types.Nodes,
+ "command_type", fmt.Sprintf("%T", cmd),
+ "height", epochState.CurrentBlock.Height,
+ "epoch", epochState.LatestEpoch.EpochIndex,
+ "phase", epochState.CurrentPhase)
+
+ err := d.nodeBroker.QueueMessage(cmd)
+ if err != nil {
+ logging.Error("[triggerReconciliation] Failed to queue reconciliation command", types.Nodes, "error", err)
+ return
+ }
+
+ // Update reconciliation tracking
+ d.reconciliationConfig.LastBlockHeight = epochState.CurrentBlock.Height
+ d.reconciliationConfig.LastTime = time.Now()
+
+ // Wait for a response or not?
+}
+
+func getCommandForPhase(phaseInfo chainphase.EpochState) (broker.Command, *chan bool) {
+ // Handle confirmation PoC during inference phase
+ if phaseInfo.CurrentPhase == types.InferencePhase && phaseInfo.ActiveConfirmationPoCEvent != nil {
+ event := phaseInfo.ActiveConfirmationPoCEvent
+
+ switch event.Phase {
+ case types.ConfirmationPoCPhase_CONFIRMATION_POC_GENERATION:
+ cmd := broker.NewStartPocCommand()
+ return cmd, &cmd.Response
+ case types.ConfirmationPoCPhase_CONFIRMATION_POC_VALIDATION:
+ cmd := broker.NewInitValidateCommand()
+ return cmd, &cmd.Response
+ }
+ // GRACE_PERIOD or COMPLETED - return to inference
+ cmd := broker.NewInferenceUpAllCommand()
+ return cmd, &cmd.Response
+ }
+
+ // Regular phase commands
+ switch phaseInfo.CurrentPhase {
+ case types.PoCGeneratePhase, types.PoCGenerateWindDownPhase:
+ cmd := broker.NewStartPocCommand()
+ return cmd, &cmd.Response
+ case types.PoCValidatePhase, types.PoCValidateWindDownPhase:
+ cmd := broker.NewInitValidateCommand()
+ return cmd, &cmd.Response
+ case types.InferencePhase:
+ cmd := broker.NewInferenceUpAllCommand()
+ return cmd, &cmd.Response
+ }
+ return nil, nil
+}
+
+// executeMissedValidationRecoveryWithSeed performs missed validation recovery for the previous epoch
+// This function runs during the Set New Validators stage to recover any missed validations
+// It accepts the seed as a parameter to avoid race conditions with ChangeCurrentSeed()
+func (d *OnNewBlockDispatcher) executeMissedValidationRecoveryWithSeed(previousEpochIndex uint64, previousSeed apiconfig.SeedInfo) {
+ if d.validator == nil {
+ logging.Warn("Missed validation recovery skipped: validator not available", types.ValidationRecovery)
+ return
+ }
+
+ // Check for genesis epoch
+ if previousEpochIndex == 0 && previousSeed.EpochIndex == 0 {
+ logging.Info("Missed validation recovery skipped: genesis epoch", types.ValidationRecovery, "previousEpochIndex", previousEpochIndex)
+ return
+ }
+
+ // Check if seed is valid
+ if previousSeed.Seed == 0 {
+ logging.Warn("Empty seed, try to reproduce", types.ValidationRecovery,
+ "previousEpochIndex", previousEpochIndex,
+ "seedEpochIndex", previousSeed.EpochIndex)
+ regeneratedSeed, err := d.randomSeedManager.CreateNewSeed(previousSeed.EpochIndex)
+ if err != nil {
+ logging.Error("Error regenerating seed", types.ValidationRecovery,
+ "err", err,
+ "previousEpochIndex", previousEpochIndex,
+ "seedEpochIndex", previousSeed.EpochIndex)
+ return
+ }
+ previousSeed.Seed = regeneratedSeed.Seed
+ }
+
+ // Verify seed epoch matches (this should always be true now, but good to verify)
+ if previousSeed.EpochIndex != previousEpochIndex {
+ logging.Warn("Missed validation recovery skipped: seed epoch mismatch", types.ValidationRecovery,
+ "previousEpochIndex", previousEpochIndex,
+ "seedEpochIndex", previousSeed.EpochIndex)
+ return
+ }
+
+ logging.Info("Starting missed validation recovery", types.ValidationRecovery,
+ "previousEpochIndex", previousEpochIndex,
+ "seed", previousSeed.Seed)
+
+ // Detect missed validations for the previous epoch
+ missedInferences, err := d.validator.DetectMissedValidations(previousEpochIndex, previousSeed.Seed)
+ if err != nil {
+ logging.Error("Failed to detect missed validations", types.ValidationRecovery,
+ "previousEpochIndex", previousEpochIndex,
+ "error", err)
+ return
+ }
+
+ if len(missedInferences) == 0 {
+ logging.Info("No missed validations found for recovery", types.ValidationRecovery, "previousEpochIndex", previousEpochIndex)
+ return
+ }
+
+ logging.Info("Found missed validations, executing recovery", types.ValidationRecovery,
+ "previousEpochIndex", previousEpochIndex,
+ "missedCount", len(missedInferences))
+
+ // Execute recovery validations
+ recoveredCount, err := d.validator.ExecuteRecoveryValidations(missedInferences)
+ if err != nil {
+ logging.Warn("Failed to execute recovery validations", types.ValidationRecovery, "error", err)
+ }
+
+ if recoveredCount > 0 {
+ logging.Info("Recovered validations", types.ValidationRecovery, "recoveredCount", recoveredCount)
+ d.validator.WaitForValidationsToBeRecorded()
+ }
+
+ logging.Info("Missed validation recovery completed", types.ValidationRecovery,
+ "previousEpochIndex", previousEpochIndex,
+ "recoveredCount", len(missedInferences))
+}
+
+// parseNewBlockInfo extracts NewBlockInfo from a JSONRPCResponse event
+func parseNewBlockInfo(event *chainevents.JSONRPCResponse) (*chainphase.BlockInfo, error) {
+ blockHeight, err := getBlockHeight(event.Result.Data.Value)
+ if err != nil {
+ return nil, err
+ }
+
+ blockHash, err := getBlockHash(event.Result.Data.Value)
+ if err != nil {
+ return nil, err
+ }
+
+ return &chainphase.BlockInfo{
+ Height: blockHeight,
+ Hash: blockHash,
+ }, nil
+}
+
+// Helper functions moved from event_listener.go for parsing block data
+func getBlockHeight(data map[string]interface{}) (int64, error) {
+ block, ok := data["block"].(map[string]interface{})
+ if !ok {
+ return 0, errors.New("failed to access 'block' key")
+ }
+
+ header, ok := block["header"].(map[string]interface{})
+ if !ok {
+ return 0, errors.New("failed to access 'header' key")
+ }
+
+ heightString, ok := header["height"].(string)
+ if !ok {
+ return 0, errors.New("failed to access 'height' key or it's not a string")
+ }
+
+ height, err := strconv.ParseInt(heightString, 10, 64)
+ if err != nil {
+ return 0, errors.New("Failed to convert retrieved height value to int64")
+ }
+
+ return height, nil
+}
+
+func getBlockHash(data map[string]interface{}) (string, error) {
+ blockID, ok := data["block_id"].(map[string]interface{})
+ if !ok {
+ return "", errors.New("failed to access 'block_id' key")
+ }
+
+ hash, ok := blockID["hash"].(string)
+ if !ok {
+ return "", errors.New("failed to access 'hash' key or it's not a string")
+ }
+
+ return hash, nil
+}
diff --git a/decentralized-api/internal/event_listener/new_block_dispatcher_test.go b/decentralized-api/internal/event_listener/new_block_dispatcher_test.go
new file mode 100644
index 000000000..fbe7ff49d
--- /dev/null
+++ b/decentralized-api/internal/event_listener/new_block_dispatcher_test.go
@@ -0,0 +1,128 @@
+package event_listener
+
+import (
+ "decentralized-api/chainphase"
+ "github.com/productscience/inference/x/inference/types"
+ "testing"
+ "time"
+
+ "decentralized-api/internal/event_listener/chainevents"
+
+ "github.com/stretchr/testify/assert"
+)
+
+func TestOnNewBlockDispatcher_ShouldTriggerReconciliation(t *testing.T) {
+ testCases := []struct {
+ name string
+ blockInterval int
+ timeInterval time.Duration
+ lastBlockHeight int64
+ lastTime time.Time
+ epochState *chainphase.EpochState
+ expectedResult bool
+ description string
+ }{
+ {
+ name: "should trigger due to block interval",
+ blockInterval: 5,
+ timeInterval: 30 * time.Second,
+ lastBlockHeight: 10,
+ lastTime: time.Now().Add(-10 * time.Second), // Recent time
+ epochState: &chainphase.EpochState{
+ CurrentPhase: types.InferencePhase,
+ CurrentBlock: chainphase.BlockInfo{
+ Height: 16, // 16 - 10 = 6 blocks, >= 5
+ },
+ },
+ expectedResult: true,
+ description: "6 blocks since last reconciliation, should trigger",
+ },
+ {
+ name: "should not trigger - too few blocks and recent time",
+ blockInterval: 5,
+ timeInterval: 30 * time.Second,
+ lastBlockHeight: 10,
+ lastTime: time.Now().Add(-10 * time.Second), // Recent time
+ epochState: &chainphase.EpochState{
+ CurrentBlock: chainphase.BlockInfo{
+ Height: 13, // 13 - 10 = 3 blocks, < 5
+ },
+ },
+ expectedResult: false,
+ description: "Only 3 blocks since last reconciliation and time is recent",
+ },
+ {
+ name: "should trigger due to time interval",
+ blockInterval: 5,
+ timeInterval: 30 * time.Second,
+ lastBlockHeight: 10,
+ lastTime: time.Now().Add(-40 * time.Second), // Old time
+ epochState: &chainphase.EpochState{
+ CurrentPhase: types.InferencePhase,
+ CurrentBlock: chainphase.BlockInfo{
+ Height: 12, // Only 2 blocks
+ },
+ },
+ expectedResult: true,
+ description: "Time interval exceeded (40s > 30s)",
+ },
+ }
+
+ for _, tc := range testCases {
+ t.Run(tc.name, func(t *testing.T) {
+ // Create a fresh dispatcher for each test case
+ dispatcher := &OnNewBlockDispatcher{
+ reconciliationConfig: MlNodeReconciliationConfig{
+ Inference: &MlNodeStageReconciliationConfig{
+ BlockInterval: tc.blockInterval,
+ TimeInterval: tc.timeInterval,
+ },
+ PoC: &MlNodeStageReconciliationConfig{
+ BlockInterval: tc.blockInterval,
+ TimeInterval: tc.timeInterval,
+ },
+ LastBlockHeight: tc.lastBlockHeight,
+ LastTime: tc.lastTime,
+ },
+ }
+
+ result := dispatcher.shouldTriggerReconciliation(*tc.epochState)
+ assert.Equal(t, tc.expectedResult, result, tc.description)
+ })
+ }
+}
+
+func TestParseNewBlockInfo(t *testing.T) {
+ // This test shows how we can test the parsing logic independently
+ // without needing a real blockchain event
+
+ testData := map[string]interface{}{
+ "block": map[string]interface{}{
+ "header": map[string]interface{}{
+ "height": "12345",
+ },
+ },
+ "block_id": map[string]interface{}{
+ "hash": "ABCDEF123456",
+ },
+ }
+
+ mockEvent := &chainevents.JSONRPCResponse{
+ JSONRPC: "2.0",
+ ID: "test",
+ Result: chainevents.Result{
+ Query: "tm.event='NewBlock'",
+ Data: chainevents.Data{
+ Type: "tendermint/event/NewBlock",
+ Value: testData,
+ },
+ Events: make(map[string][]string),
+ },
+ }
+
+ blockInfo, err := parseNewBlockInfo(mockEvent)
+
+ assert.NoError(t, err)
+ assert.Equal(t, int64(12345), blockInfo.Height)
+ assert.Equal(t, "ABCDEF123456", blockInfo.Hash)
+}
diff --git a/decentralized-api/internal/event_listener/unbounded_queue.go b/decentralized-api/internal/event_listener/unbounded_queue.go
new file mode 100644
index 000000000..584041e95
--- /dev/null
+++ b/decentralized-api/internal/event_listener/unbounded_queue.go
@@ -0,0 +1,93 @@
+package event_listener
+
+import (
+ "sync"
+)
+
+// UnboundedQueue[T] represents an unbounded thread-safe FIFO queue
+// that exposes channels for enqueuing and dequeuing elements of type T
+type UnboundedQueue[T any] struct {
+ // Public channels for interacting with the queue
+ In chan<- T // Send-only channel for producers
+ Out <-chan T // Receive-only channel for consumers
+
+ // Private implementation details
+ input chan T
+ output chan T
+ done chan struct{}
+ wg sync.WaitGroup
+ closeOnce sync.Once // Ensures Close is only executed once
+}
+
+// NewUnboundedQueue creates a new unbounded queue that exposes channels
+func NewUnboundedQueue[T any]() *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,
+ }
+
+ q.wg.Add(1)
+ go q.manage() // Start the queue manager goroutine
+
+ return q
+}
+
+// manage handles the internal queue operation
+func (q *UnboundedQueue[T]) manage() {
+ defer q.wg.Done()
+ defer close(q.output) // Close output channel when done
+
+ // This slice acts as our unbounded queue storage
+ items := make([]T, 0)
+
+ for {
+ // If we have items, try to send the first one to output
+ // If we don't have items, only wait for input or done
+ var out chan T
+ var first T
+
+ if len(items) > 0 {
+ out = q.output
+ first = items[0]
+ }
+
+ select {
+ case item := <-q.input:
+ // Store new item from producer
+ items = append(items, item)
+
+ case out <- first:
+ // First item was consumed, remove it
+ items = items[1:]
+
+ case <-q.done:
+ // Shutdown signal received, exit manager
+ return
+ }
+ }
+}
+
+// Size returns the approximate number of elements in the queue
+// Note: This is approximate since the queue state might change
+// immediately after the count is returned
+func (q *UnboundedQueue[T]) Size() int {
+ // This is just an approximation based on channel buffer lengths
+ return len(q.input) + len(q.output)
+}
+
+// Close shuts down the queue and waits for the manager to exit
+// This method is idempotent and can be safely called multiple times
+func (q *UnboundedQueue[T]) Close() {
+ q.closeOnce.Do(func() {
+ close(q.done)
+ close(q.input) // Stop accepting new items
+ q.wg.Wait() // Wait for the manager to finish
+ })
+}
diff --git a/decentralized-api/internal/event_listener/unbounded_queue_test.go b/decentralized-api/internal/event_listener/unbounded_queue_test.go
new file mode 100644
index 000000000..d46304ab7
--- /dev/null
+++ b/decentralized-api/internal/event_listener/unbounded_queue_test.go
@@ -0,0 +1,739 @@
+package event_listener
+
+import (
+ "context"
+ "decentralized-api/logging"
+ "fmt"
+ "github.com/productscience/inference/x/inference/types"
+ "github.com/stretchr/testify/require"
+ "math/rand"
+ "runtime"
+ "sync"
+ "sync/atomic"
+ "testing"
+ "time"
+)
+
+// TestBasicQueueOperations verifies basic enqueue/dequeue functionality
+func TestBasicQueueOperations(t *testing.T) {
+ q := NewUnboundedQueue[int]()
+ defer q.Close()
+
+ // Test sending and receiving a single item
+ q.In <- 42
+ result := <-q.Out
+ if result != 42 {
+ t.Errorf("Expected 42, got %d", result)
+ }
+
+ // Test sending and receiving multiple items in order
+ values := []int{1, 2, 3, 4, 5}
+ for _, v := range values {
+ q.In <- v
+ }
+
+ for i, expected := range values {
+ result := <-q.Out
+ if result != expected {
+ t.Errorf("Item %d: Expected %d, got %d", i, expected, result)
+ }
+ }
+}
+
+// TestQueueClosing verifies that the queue closes properly
+func TestQueueClosing(t *testing.T) {
+ q := NewUnboundedQueue[int]()
+
+ // Add some items
+ for i := 0; i < 10; i++ {
+ q.In <- i
+ }
+
+ // Give the queue time to process the inputs
+ time.Sleep(50 * time.Millisecond)
+
+ // Close the queue
+ q.Close()
+
+ // Collect all the items we receive
+ received := make([]int, 0)
+ for value := range q.Out {
+ received = append(received, value)
+ }
+
+ // Verify we received all items
+ if len(received) != 10 {
+ t.Errorf("Expected to receive 10 items, got %d", len(received))
+ }
+
+ // Verify they're in the right order
+ for i := 0; i < len(received); i++ {
+ if received[i] != i {
+ t.Errorf("At position %d: Expected %d, got %d", i, i, received[i])
+ }
+ }
+
+ // Verify the channel is now closed (already checked by exiting the range loop)
+}
+
+// TestConcurrentAccess tests that the queue works correctly with multiple producers and consumers
+func TestConcurrentAccess(t *testing.T) {
+ q := NewUnboundedQueue[int]()
+ defer q.Close()
+
+ const (
+ producerCount = 5
+ itemsPerProducer = 100
+ totalItems = producerCount * itemsPerProducer
+ )
+
+ // Setup tracking for received items
+ var received sync.Map
+ var receivedCount atomic.Int64
+ var wgConsumers sync.WaitGroup
+
+ // Create a channel to signal consumers when all items are received
+ allItemsReceived := make(chan struct{})
+
+ // Start consumers
+ wgConsumers.Add(3)
+ for i := 0; i < 3; i++ {
+ go func() {
+ defer wgConsumers.Done()
+ for {
+ select {
+ case item, ok := <-q.Out:
+ if !ok {
+ // Queue output was closed
+ return
+ }
+
+ received.Store(item, true)
+ count := receivedCount.Add(1)
+
+ // If we've received all items, signal it
+ if count >= totalItems {
+ close(allItemsReceived)
+ return
+ }
+ case <-allItemsReceived:
+ // Another consumer got the last item
+ return
+ }
+ }
+ }()
+ }
+
+ // Start producers
+ var wgProducers sync.WaitGroup
+ wgProducers.Add(producerCount)
+ for p := 0; p < producerCount; p++ {
+ go func(producerID int) {
+ defer wgProducers.Done()
+ baseValue := producerID * itemsPerProducer
+
+ for i := 0; i < itemsPerProducer; i++ {
+ q.In <- baseValue + i
+
+ // Add some randomness to test concurrency
+ if rand.Intn(10) > 7 {
+ time.Sleep(time.Millisecond)
+ }
+ }
+ }(p)
+ }
+
+ // Wait for producers to finish
+ wgProducers.Wait()
+
+ // Wait for consumers to process all items or timeout
+ select {
+ case <-allItemsReceived:
+ // Success, all items consumed
+ case <-time.After(5 * time.Second):
+ t.Fatalf("Timeout waiting for consumers, received %d/%d items", receivedCount.Load(), totalItems)
+ }
+
+ // Now wait for all consumer goroutines to exit
+ waitCh := make(chan struct{})
+ go func() {
+ wgConsumers.Wait()
+ close(waitCh)
+ }()
+
+ select {
+ case <-waitCh:
+ // All consumers have exited properly
+ case <-time.After(1 * time.Second):
+ t.Log("Warning: Timeout waiting for consumer goroutines to exit")
+ }
+
+ // Verify all items were received exactly once
+ if count := receivedCount.Load(); count != totalItems {
+ t.Errorf("Expected %d items, got %d", totalItems, count)
+ }
+
+ // Verify each individual item was received
+ for p := 0; p < producerCount; p++ {
+ baseValue := p * itemsPerProducer
+ for i := 0; i < itemsPerProducer; i++ {
+ value := baseValue + i
+ if _, ok := received.Load(value); !ok {
+ t.Errorf("Item %d was not received", value)
+ }
+ }
+ }
+}
+
+// TestQueueSizeApproximation verifies that Size() gives a reasonable approximation
+func TestQueueSizeApproximation(t *testing.T) {
+ q := NewUnboundedQueue[int]()
+ defer q.Close()
+
+ // Queue should start empty
+ if size := q.Size(); size != 0 {
+ t.Errorf("Expected empty queue, got size %d", size)
+ }
+
+ // Add some items
+ const itemCount = 50
+ for i := 0; i < itemCount; i++ {
+ q.In <- i
+ }
+
+ // Allow time for items to be processed by the manager goroutine
+ time.Sleep(100 * time.Millisecond)
+
+ // Size should reflect *approximately* the number of items
+ // We can't test for exact equality due to the concurrent nature
+ size := q.Size()
+ if size == 0 {
+ t.Error("Queue size is 0 after adding items")
+ }
+
+ // Take items out
+ for i := 0; i < itemCount; i++ {
+ <-q.Out
+ }
+
+ // Allow time for processing
+ time.Sleep(100 * time.Millisecond)
+
+ // Size should be approximately 0 again
+ if size := q.Size(); size > 0 {
+ t.Errorf("Expected empty queue after removing all items, got size %d", size)
+ }
+}
+
+// TestQueueOrdering verifies that items are dequeued in the same order they were enqueued
+func TestQueueOrdering(t *testing.T) {
+ q := NewUnboundedQueue[string]()
+ defer q.Close()
+
+ // Insert items with distinct values
+ items := []string{"first", "second", "third", "fourth", "fifth"}
+ for _, item := range items {
+ q.In <- item
+ }
+
+ // Verify they come out in the same order
+ for i, expected := range items {
+ result := <-q.Out
+ if result != expected {
+ t.Errorf("Item %d: Expected '%s', got '%s'", i, expected, result)
+ }
+ }
+}
+
+// TestLargeItemCount verifies the queue can handle a large number of items
+func TestLargeItemCount(t *testing.T) {
+ q := NewUnboundedQueue[int]()
+ defer q.Close()
+
+ const itemCount = 10000
+
+ // Send large batch of items
+ go func() {
+ for i := 0; i < itemCount; i++ {
+ q.In <- i
+ }
+ }()
+
+ // Receive and verify items
+ for i := 0; i < itemCount; i++ {
+ value := <-q.Out
+ if value != i {
+ t.Errorf("Item %d: Expected %d, got %d", i, i, value)
+ break
+ }
+ }
+}
+
+// TestTypeVariance verifies the queue works with different data types
+func TestTypeVariance(t *testing.T) {
+ // Test with string type
+ t.Run("StringQueue", func(t *testing.T) {
+ q := NewUnboundedQueue[string]()
+ defer q.Close()
+
+ q.In <- "hello"
+ q.In <- "world"
+
+ if result := <-q.Out; result != "hello" {
+ t.Errorf("Expected 'hello', got '%s'", result)
+ }
+ if result := <-q.Out; result != "world" {
+ t.Errorf("Expected 'world', got '%s'", result)
+ }
+ })
+
+ // Test with custom struct type
+ t.Run("StructQueue", func(t *testing.T) {
+ type Person struct {
+ Name string
+ Age int
+ }
+
+ q := NewUnboundedQueue[Person]()
+ defer q.Close()
+
+ alice := Person{Name: "Alice", Age: 30}
+ bob := Person{Name: "Bob", Age: 25}
+
+ q.In <- alice
+ q.In <- bob
+
+ if result := <-q.Out; result.Name != "Alice" || result.Age != 30 {
+ t.Errorf("Expected Alice(30), got %v", result)
+ }
+ if result := <-q.Out; result.Name != "Bob" || result.Age != 25 {
+ t.Errorf("Expected Bob(25), got %v", result)
+ }
+ })
+}
+
+// TestEmptyQueueBehavior verifies that trying to receive from an empty queue blocks
+func TestEmptyQueueBehavior(t *testing.T) {
+ q := NewUnboundedQueue[int]()
+ defer q.Close()
+
+ // Try to receive with timeout
+ received := false
+ go func() {
+ <-q.Out
+ received = true
+ }()
+
+ // Should time out without receiving
+ time.Sleep(100 * time.Millisecond)
+ if received {
+ t.Error("Received value from empty queue, expected to block")
+ }
+
+ // Now send a value
+ q.In <- 42
+
+ // Allow time for processing
+ time.Sleep(100 * time.Millisecond)
+
+ if !received {
+ t.Error("Did not receive value after it was sent")
+ }
+}
+
+func TestCloseQueueTwice(t *testing.T) {
+ q := NewUnboundedQueue[int]()
+
+ // Close the queue twice
+ q.Close()
+ q.Close()
+
+ // No panic should occur
+}
+
+func TestQueueMemoryManagement(t *testing.T) {
+ q := NewUnboundedQueue[int]()
+
+ const (
+ producerCount = 4
+ itemsPerProducer = 1_000_000 // 1M items per producer
+ totalItems = producerCount * itemsPerProducer
+ )
+
+ // Log initial memory state
+ runtime.GC()
+ logMemoryStats("initial")
+
+ // Start consumers first (they don't store items)
+ var wg sync.WaitGroup
+ consumeDone := make(chan struct{})
+ itemsProcessed := atomic.Int64{}
+
+ wg.Add(2)
+ for i := 0; i < 2; i++ {
+ go func() {
+ defer wg.Done()
+ for {
+ select {
+ case _, ok := <-q.Out:
+ if !ok {
+ return
+ }
+ if itemsProcessed.Add(1) == int64(totalItems) {
+ close(consumeDone)
+ return
+ }
+ case <-consumeDone:
+ return
+ }
+ }
+ }()
+ }
+
+ // Log memory before producing
+ logMemoryStats("before producing")
+
+ beforeMemory := getAllocatedMemory()
+ // Produce items
+ for p := 0; p < producerCount; p++ {
+ go func(producerID int) {
+ base := producerID * itemsPerProducer
+ for i := 0; i < itemsPerProducer; i++ {
+ q.In <- base + i
+ }
+ }(p)
+ }
+
+ // Wait for all items to be consumed
+ select {
+ case <-consumeDone:
+ // Success
+ case <-time.After(30 * time.Second):
+ t.Fatal("Timeout waiting for items to be consumed")
+ }
+
+ // Log memory during peak
+ logMemoryStats("during peak")
+
+ // Force GC and check memory again
+ runtime.GC()
+ logMemoryStats("after GC")
+
+ // Close queue and wait for consumers
+ q.Close()
+ wg.Wait()
+
+ // Final memory check after everything is done
+ runtime.GC()
+ logMemoryStats("final")
+
+ finalMemory := getAllocatedMemory()
+ const maxMemoryIncrease = 104_857 // 0.1MB in bytes (ish)
+ println("Memory increase " + formatSize(finalMemory-beforeMemory))
+ require.Less(t, finalMemory, beforeMemory+maxMemoryIncrease, "Memory usage increased by more than 0.1MB")
+
+ if processed := itemsProcessed.Load(); processed != int64(totalItems) {
+ t.Errorf("Expected to process %d items, but processed %d", totalItems, processed)
+ }
+}
+
+// TestQueueStress runs a stress test with multiple producers and consumers
+func TestQueueStress(t *testing.T) {
+ if testing.Short() {
+ t.Skip("Skipping stress test in short mode")
+ }
+
+ q := NewUnboundedQueue[int]()
+ defer q.Close()
+
+ const (
+ producerCount = 10
+ consumerCount = 5
+ itemsPerProducer = 1000
+ totalItems = producerCount * itemsPerProducer
+ )
+
+ var (
+ wgConsumers sync.WaitGroup
+ wgProducers sync.WaitGroup
+ receivedItems sync.Map
+ itemCount atomic.Int64
+ )
+
+ // Create a channel to signal all consumers when we've received everything
+ allItemsReceived := make(chan struct{})
+
+ // Start consumers
+ wgConsumers.Add(consumerCount)
+ for i := 0; i < consumerCount; i++ {
+ go func(id int) {
+ defer wgConsumers.Done()
+ for {
+ select {
+ case item, ok := <-q.Out:
+ if !ok {
+ // Queue output was closed
+ return
+ }
+
+ receivedItems.Store(item, true)
+ count := itemCount.Add(1)
+
+ // If we've received all items, signal it
+ if count >= totalItems {
+ close(allItemsReceived)
+ return
+ }
+ case <-allItemsReceived:
+ // Another consumer got the last item
+ return
+ }
+ }
+ }(i)
+ }
+
+ // Start producers
+ wgProducers.Add(producerCount)
+ for p := 0; p < producerCount; p++ {
+ go func(producerID int) {
+ defer wgProducers.Done()
+ base := producerID * itemsPerProducer
+
+ for i := 0; i < itemsPerProducer; i++ {
+ q.In <- base + i
+
+ // Add some randomness to test concurrency patterns
+ if rand.Intn(100) > 95 {
+ time.Sleep(time.Millisecond)
+ }
+ }
+ }(p)
+ }
+ // Wait for producers to finish
+ wgProducers.Wait()
+
+ // Wait for consumers to process all items or timeout
+ select {
+ case <-allItemsReceived:
+ // Success, all items consumed
+ case <-time.After(10 * time.Second):
+ t.Fatalf("Timeout waiting for consumers, received %d/%d items", itemCount.Load(), totalItems)
+ }
+
+ // Now wait for all consumer goroutines to exit
+ waitCh := make(chan struct{})
+ go func() {
+ wgConsumers.Wait()
+ close(waitCh)
+ }()
+
+ select {
+ case <-waitCh:
+ // All consumers have exited properly
+ case <-time.After(1 * time.Second):
+ t.Log("Warning: Timeout waiting for consumer goroutines to exit")
+ }
+
+ // Verify all items were received exactly once
+ if count := itemCount.Load(); count != totalItems {
+ t.Errorf("Expected %d items, got %d", totalItems, count)
+ }
+
+ // Verify each individual item was received
+ missingItems := 0
+ for p := 0; p < producerCount; p++ {
+ base := p * itemsPerProducer
+ for i := 0; i < itemsPerProducer; i++ {
+ item := base + i
+ if _, ok := receivedItems.Load(item); !ok {
+ if missingItems < 10 {
+ t.Errorf("Item %d was not received", item)
+ }
+ missingItems++
+ }
+ }
+ }
+
+ if missingItems > 0 {
+ t.Errorf("Total of %d items were not received", missingItems)
+ }
+}
+
+// TestQueueWithDelayedConsumers tests that items are properly queued when consumers are slow
+func TestQueueWithDelayedConsumers(t *testing.T) {
+ q := NewUnboundedQueue[int]()
+ defer q.Close()
+
+ const itemCount = 100
+
+ // Send items rapidly
+ for i := 0; i < itemCount; i++ {
+ q.In <- i
+ }
+
+ // Consume items slowly
+ for i := 0; i < itemCount; i++ {
+ value := <-q.Out
+ if value != i {
+ t.Errorf("Expected %d, got %d", i, value)
+ }
+
+ // Simulate slow consumer
+ if i%10 == 0 {
+ time.Sleep(10 * time.Millisecond)
+ }
+ }
+}
+
+func TestQueueWithDelayedProducers(t *testing.T) {
+ q := NewUnboundedQueue[int]()
+ defer q.Close()
+
+ const itemCount = 50
+
+ // Start a consumer
+ var wg sync.WaitGroup
+ wg.Add(1)
+ go func() {
+ defer wg.Done()
+ for i := 0; i < itemCount; i++ {
+ value := <-q.Out
+ if value != i {
+ t.Errorf("Expected %d, got %d", i, value)
+ }
+ }
+ }()
+
+ // Send items with delays
+ for i := 0; i < itemCount; i++ {
+ q.In <- i
+
+ // Simulate slow producer
+ if i%5 == 0 {
+ time.Sleep(20 * time.Millisecond)
+ }
+ }
+
+ // Wait for consumer to finish
+ wg.Wait()
+}
+
+// TestQueueInterface verifies the exported interface works as expected
+func TestQueueInterface(t *testing.T) {
+ // This test validates that we can use the In/Out channels as documented
+ q := NewUnboundedQueue[string]()
+ defer q.Close()
+
+ // Producer
+ in := q.In
+ in <- "message1"
+ in <- "message2"
+
+ // Consumer
+ out := q.Out
+ if msg := <-out; msg != "message1" {
+ t.Errorf("Expected 'message1', got '%s'", msg)
+ }
+ if msg := <-out; msg != "message2" {
+ t.Errorf("Expected 'message2', got '%s'", msg)
+ }
+}
+
+// TestQueueWithTimeout tests behavior with context timeouts
+func TestQueueWithTimeout(t *testing.T) {
+ q := NewUnboundedQueue[int]()
+ defer q.Close()
+
+ // Receive with timeout
+ ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
+ defer cancel()
+
+ select {
+ case <-q.Out:
+ t.Error("Received unexpected value from empty queue")
+ case <-ctx.Done():
+ // Expected behavior
+ }
+
+ // Now send and receive with timeout
+ q.In <- 42
+
+ ctx, cancel = context.WithTimeout(context.Background(), 100*time.Millisecond)
+ defer cancel()
+
+ select {
+ case val := <-q.Out:
+ if val != 42 {
+ t.Errorf("Expected 42, got %d", val)
+ }
+ case <-ctx.Done():
+ t.Error("Timeout while waiting for value")
+ }
+}
+
+// benchmarkQueueThroughput measures the throughput of the queue
+func BenchmarkQueueThroughput(b *testing.B) {
+ q := NewUnboundedQueue[int]()
+ defer q.Close()
+
+ b.ResetTimer()
+
+ // Start consumer
+ go func() {
+ for i := 0; i < b.N; i++ {
+ <-q.Out
+ }
+ }()
+
+ // Producer
+ for i := 0; i < b.N; i++ {
+ q.In <- i
+ }
+}
+
+// BenchmarkQueueLatency measures the latency of the queue
+func BenchmarkQueueLatency(b *testing.B) {
+ q := NewUnboundedQueue[int]()
+ defer q.Close()
+
+ b.ResetTimer()
+
+ for i := 0; i < b.N; i++ {
+ q.In <- i
+ <-q.Out
+ }
+}
+func getAllocatedMemory() uint64 {
+ var m runtime.MemStats
+ runtime.ReadMemStats(&m)
+ return m.Alloc
+}
+func logMemoryStats(tag string) {
+ var m runtime.MemStats
+ runtime.ReadMemStats(&m)
+
+ logging.Info("Memory stats",
+ types.EventProcessing,
+ "tag", tag,
+ "alloc", formatSize(m.Alloc),
+ "totalAlloc", formatSize(m.TotalAlloc),
+ "sys", formatSize(m.Sys),
+ "heapAlloc", formatSize(m.HeapAlloc),
+ "heapSys", formatSize(m.HeapSys),
+ "heapIdle", formatSize(m.HeapIdle),
+ "heapReleased", formatSize(m.HeapReleased))
+}
+
+// Helper to format byte sizes in human-readable form
+func formatSize(bytes uint64) string {
+ const unit = 1024
+ if bytes < unit {
+ return fmt.Sprintf("%d B", bytes)
+ }
+ div, exp := uint64(unit), 0
+ for n := bytes / unit; n >= unit; n /= unit {
+ div *= unit
+ exp++
+ }
+ return fmt.Sprintf("%.2f %cB", float64(bytes)/float64(div), "KMGTPE"[exp])
+}
diff --git a/decentralized-api/internal/event_listener/utils.go b/decentralized-api/internal/event_listener/utils.go
new file mode 100644
index 000000000..2b6d3b206
--- /dev/null
+++ b/decentralized-api/internal/event_listener/utils.go
@@ -0,0 +1,43 @@
+package event_listener
+
+import (
+ "context"
+ "decentralized-api/cosmosclient"
+ "decentralized-api/logging"
+ "fmt"
+ coretypes "github.com/cometbft/cometbft/rpc/core/types"
+ "github.com/gorilla/websocket"
+ "github.com/productscience/inference/x/inference/types"
+ "log"
+ "net/url"
+)
+
+func subscribeToEvents(ws *websocket.Conn, id uint32, query string) {
+ subscribeMsg := fmt.Sprintf(`{"jsonrpc": "2.0", "method": "subscribe", "id": "%d", "params": ["%s"]}`, id, query)
+ if err := ws.WriteMessage(websocket.TextMessage, []byte(subscribeMsg)); err != nil {
+ logging.Error("Failed to subscribe to a websocket", types.EventProcessing, "error", err)
+ log.Fatalf("Failed to subscribe to a websocket. %v", err)
+ }
+}
+
+func getWebsocketUrl(chainNodeUrl string) string {
+ u, err := url.Parse(chainNodeUrl)
+ if err != nil {
+ logging.Error("Error parsing URL", types.EventProcessing, "error", err)
+ return ""
+ }
+
+ u.Scheme = "ws"
+ u.Path = "/websocket"
+
+ return u.String()
+}
+
+func getStatus(chainNodeUrl string) (*coretypes.ResultStatus, error) {
+ client, err := cosmosclient.NewRpcClient(chainNodeUrl)
+ if err != nil {
+ return nil, err
+ }
+
+ return client.Status(context.Background())
+}
diff --git a/decentralized-api/internal/modelmanager/mlnode_background_manager.go b/decentralized-api/internal/modelmanager/mlnode_background_manager.go
new file mode 100644
index 000000000..688faed1f
--- /dev/null
+++ b/decentralized-api/internal/modelmanager/mlnode_background_manager.go
@@ -0,0 +1,336 @@
+package modelmanager
+
+import (
+ "context"
+ "decentralized-api/apiconfig"
+ "decentralized-api/broker"
+ "decentralized-api/chainphase"
+ "decentralized-api/logging"
+ "decentralized-api/mlnodeclient"
+ "errors"
+ "fmt"
+ "sort"
+ "time"
+
+ "github.com/productscience/inference/x/inference/types"
+)
+
+// NodesConfigManagerInterface defines the minimal interface needed from ConfigManager
+type NodesConfigManagerInterface interface {
+ GetNodes() []apiconfig.InferenceNodeConfig
+ GetCurrentNodeVersion() string
+ SetNodes(nodes []apiconfig.InferenceNodeConfig) error
+}
+
+// PhaseTrackerInterface defines the minimal interface needed from PhaseTracker
+type PhaseTrackerInterface interface {
+ GetCurrentEpochState() *chainphase.EpochState
+}
+
+// BrokerInterface defines minimal interface for broker operations
+type BrokerInterface interface {
+ QueueMessage(command broker.Command) error
+}
+
+// MLNodeBackgroundManager handles background operations for MLNodes:
+// - Model pre-downloading for upcoming epochs
+// - GPU hardware detection and updates
+type MLNodeBackgroundManager struct {
+ configManager NodesConfigManagerInterface
+ phaseTracker PhaseTrackerInterface
+ broker BrokerInterface
+ mlNodeClientFactory mlnodeclient.ClientFactory
+ checkInterval time.Duration
+}
+
+// NewMLNodeBackgroundManager creates a new MLNode background manager
+func NewMLNodeBackgroundManager(
+ configManager NodesConfigManagerInterface,
+ phaseTracker PhaseTrackerInterface,
+ broker BrokerInterface,
+ clientFactory mlnodeclient.ClientFactory,
+ checkInterval time.Duration,
+) *MLNodeBackgroundManager {
+ return &MLNodeBackgroundManager{
+ configManager: configManager,
+ phaseTracker: phaseTracker,
+ broker: broker,
+ mlNodeClientFactory: clientFactory,
+ checkInterval: checkInterval,
+ }
+}
+
+// Start begins the periodic background tasks loop
+func (m *MLNodeBackgroundManager) Start(ctx context.Context) {
+ ticker := time.NewTicker(m.checkInterval)
+ defer ticker.Stop()
+
+ logging.Info("MLNodeBackgroundManager started", types.System, "check_interval", m.checkInterval)
+
+ for {
+ select {
+ case <-ticker.C:
+ m.checkAndDownloadModels(ctx)
+ m.checkAndUpdateGPUs(ctx)
+ case <-ctx.Done():
+ logging.Info("MLNodeBackgroundManager stopped", types.System)
+ return
+ }
+ }
+}
+
+// checkAndDownloadModels performs the periodic check and triggers downloads if needed
+func (m *MLNodeBackgroundManager) checkAndDownloadModels(ctx context.Context) {
+ epochState := m.phaseTracker.GetCurrentEpochState()
+ if !m.isInDownloadWindow(epochState) {
+ return
+ }
+
+ logging.Info("Starting model pre-download check",
+ types.System,
+ "block", epochState.CurrentBlock.Height,
+ "phase", epochState.CurrentPhase)
+
+ nodes := m.configManager.GetNodes()
+ for _, node := range nodes {
+ m.checkNodeModels(node)
+ }
+}
+
+// isInDownloadWindow checks if we're in a safe window to download models
+func (m *MLNodeBackgroundManager) isInDownloadWindow(epochState *chainphase.EpochState) bool {
+ if epochState.IsNilOrNotSynced() {
+ return false
+ }
+
+ if epochState.CurrentPhase != types.InferencePhase {
+ return false
+ }
+
+ currentBlock := epochState.CurrentBlock.Height
+ setNewValidators := epochState.LatestEpoch.SetNewValidators()
+ inferenceValidationCutoff := epochState.LatestEpoch.InferenceValidationCutoff()
+
+ // Window: [SetNewValidators + 30, InferenceValidationCutoff - 200]
+ windowStart := setNewValidators + 30
+ windowEnd := inferenceValidationCutoff - 200
+
+ if currentBlock < windowStart || currentBlock > windowEnd {
+ return false
+ }
+
+ return true
+}
+
+// checkNodeModels checks and downloads models for a specific node
+func (m *MLNodeBackgroundManager) checkNodeModels(node apiconfig.InferenceNodeConfig) {
+ version := m.configManager.GetCurrentNodeVersion()
+ pocUrl := getPoCUrlWithVersion(node, version)
+ inferenceUrl := getInferenceUrlWithVersion(node, version)
+ client := m.mlNodeClientFactory.CreateClient(pocUrl, inferenceUrl)
+
+ ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+ defer cancel()
+
+ endpointAvailable := true
+
+ for modelId := range node.Models {
+ model := mlnodeclient.Model{
+ HfRepo: modelId,
+ HfCommit: nil, // nil = latest
+ }
+
+ statusResp, err := client.CheckModelStatus(ctx, model)
+ if err != nil {
+ var apiNotImplemented *mlnodeclient.ErrAPINotImplemented
+ if errors.As(err, &apiNotImplemented) {
+ if endpointAvailable {
+ logging.Info("Model pre-download endpoint not available",
+ types.System,
+ "node_id", node.Id)
+ endpointAvailable = false
+ }
+ break
+ }
+
+ logging.Warn("Failed to check model status",
+ types.System,
+ "node_id", node.Id,
+ "model", modelId,
+ "error", err.Error())
+ continue
+ }
+
+ switch statusResp.Status {
+ case mlnodeclient.ModelStatusNotFound, mlnodeclient.ModelStatusPartial:
+ logging.Info("Pre-downloading model",
+ types.System,
+ "model", modelId,
+ "node_id", node.Id)
+
+ _, err := client.DownloadModel(ctx, model)
+ if err != nil {
+ logging.Warn("Failed to start model download",
+ types.System,
+ "node_id", node.Id,
+ "model", modelId,
+ "error", err.Error())
+ }
+
+ case mlnodeclient.ModelStatusDownloading:
+ logging.Debug("Model already downloading",
+ types.System,
+ "model", modelId,
+ "node_id", node.Id)
+
+ case mlnodeclient.ModelStatusDownloaded:
+ logging.Debug("Model already downloaded",
+ types.System,
+ "model", modelId,
+ "node_id", node.Id)
+ }
+ }
+}
+
+func getPoCUrlWithVersion(node apiconfig.InferenceNodeConfig, version string) string {
+ if version == "" {
+ return getPoCUrl(node)
+ }
+ return getPoCUrlVersioned(node, version)
+}
+
+func getInferenceUrlWithVersion(node apiconfig.InferenceNodeConfig, version string) string {
+ if version == "" {
+ return getInferenceUrl(node)
+ }
+ return getInferenceUrlVersioned(node, version)
+}
+
+func getPoCUrl(node apiconfig.InferenceNodeConfig) string {
+ return formatURL(node.Host, node.PoCPort, node.PoCSegment)
+}
+
+func getPoCUrlVersioned(node apiconfig.InferenceNodeConfig, version string) string {
+ return formatURLWithVersion(node.Host, node.PoCPort, version, node.PoCSegment)
+}
+
+func getInferenceUrl(node apiconfig.InferenceNodeConfig) string {
+ return formatURL(node.Host, node.InferencePort, node.InferenceSegment)
+}
+
+func getInferenceUrlVersioned(node apiconfig.InferenceNodeConfig, version string) string {
+ return formatURLWithVersion(node.Host, node.InferencePort, version, node.InferenceSegment)
+}
+
+func formatURL(host string, port int, segment string) string {
+ return fmt.Sprintf("http://%s:%d%s", host, port, segment)
+}
+
+func formatURLWithVersion(host string, port int, version string, segment string) string {
+ return fmt.Sprintf("http://%s:%d/%s%s", host, port, version, segment)
+}
+
+// checkAndUpdateGPUs fetches GPU info from all nodes and updates hardware
+func (m *MLNodeBackgroundManager) checkAndUpdateGPUs(ctx context.Context) {
+ nodes := m.configManager.GetNodes()
+ updatedNodes := make([]apiconfig.InferenceNodeConfig, 0, len(nodes))
+
+ for _, node := range nodes {
+ updatedNodes = append(updatedNodes, node.DeepCopy())
+ }
+
+ for i := range updatedNodes {
+ node := &updatedNodes[i]
+
+ hardware, err := m.fetchNodeGPUHardware(ctx, node)
+ if err != nil {
+ var apiNotImplemented *mlnodeclient.ErrAPINotImplemented
+ if errors.As(err, &apiNotImplemented) {
+ logging.Info("GPU endpoint not available for node", types.Nodes, "node_id", node.Id)
+ } else {
+ logging.Warn("Failed to fetch GPU info for node", types.Nodes, "node_id", node.Id, "error", err.Error())
+ }
+ continue
+ }
+
+ if len(hardware) == 0 {
+ continue
+ }
+
+ // Update config
+ node.Hardware = hardware
+
+ // Update broker (for immediate chain sync)
+ responseChan := make(chan error, 1)
+ cmd := broker.UpdateNodeHardwareCommand{
+ NodeId: node.Id,
+ Hardware: hardware,
+ Response: responseChan,
+ }
+
+ if err := m.broker.QueueMessage(cmd); err != nil {
+ logging.Warn("Failed to queue hardware update", types.Nodes, "node_id", node.Id, "error", err.Error())
+ continue
+ }
+
+ if err := <-responseChan; err != nil {
+ logging.Warn("Failed to update broker hardware", types.Nodes, "node_id", node.Id, "error", err.Error())
+ } else {
+ logging.Info("Updated GPU hardware", types.Nodes, "node_id", node.Id, "hardware_count", len(hardware))
+ }
+ }
+
+ // Persist all changes to config
+ if err := m.configManager.SetNodes(updatedNodes); err != nil {
+ logging.Error("Failed to persist GPU hardware to config", types.Nodes, "error", err.Error())
+ }
+}
+
+// fetchNodeGPUHardware fetches GPU devices and transforms to Hardware entries
+func (m *MLNodeBackgroundManager) fetchNodeGPUHardware(ctx context.Context, node *apiconfig.InferenceNodeConfig) ([]apiconfig.Hardware, error) {
+ version := m.configManager.GetCurrentNodeVersion()
+ pocUrl := getPoCUrlWithVersion(*node, version)
+ inferenceUrl := getInferenceUrlWithVersion(*node, version)
+ client := m.mlNodeClientFactory.CreateClient(pocUrl, inferenceUrl)
+
+ timeoutCtx, cancel := context.WithTimeout(ctx, 10*time.Second)
+ defer cancel()
+
+ resp, err := client.GetGPUDevices(timeoutCtx)
+ if err != nil {
+ return nil, err
+ }
+
+ return transformGPUDevicesToHardware(resp.Devices), nil
+}
+
+// transformGPUDevicesToHardware groups GPUs by type and memory, returns Hardware list
+func transformGPUDevicesToHardware(devices []mlnodeclient.GPUDevice) []apiconfig.Hardware {
+ groupCounts := make(map[string]uint32)
+
+ for _, device := range devices {
+ // Skip unavailable, errored, or GPUs without memory info
+ if !device.IsAvailable || device.ErrorMessage != nil || device.TotalMemoryMB == nil {
+ continue
+ }
+
+ memoryGB := *device.TotalMemoryMB / 1024
+ key := fmt.Sprintf("%s | %dGB", device.Name, int(memoryGB))
+ groupCounts[key]++
+ }
+
+ hardware := make([]apiconfig.Hardware, 0, len(groupCounts))
+ for gpuType, count := range groupCounts {
+ hardware = append(hardware, apiconfig.Hardware{
+ Type: gpuType,
+ Count: count,
+ })
+ }
+
+ // Sort for consistent ordering
+ sort.Slice(hardware, func(i, j int) bool {
+ return hardware[i].Type < hardware[j].Type
+ })
+
+ return hardware
+}
diff --git a/decentralized-api/internal/modelmanager/mlnode_background_manager_test.go b/decentralized-api/internal/modelmanager/mlnode_background_manager_test.go
new file mode 100644
index 000000000..3fe26a5d7
--- /dev/null
+++ b/decentralized-api/internal/modelmanager/mlnode_background_manager_test.go
@@ -0,0 +1,964 @@
+package modelmanager
+
+import (
+ "context"
+ "decentralized-api/apiconfig"
+ "decentralized-api/broker"
+ "decentralized-api/chainphase"
+ "decentralized-api/mlnodeclient"
+ "errors"
+ "testing"
+ "time"
+
+ "github.com/productscience/inference/x/inference/types"
+)
+
+// Mock ConfigManager
+type mockConfigManager struct {
+ nodes []apiconfig.InferenceNodeConfig
+ currentNodeVersion string
+ setNodesError error
+}
+
+func (m *mockConfigManager) GetNodes() []apiconfig.InferenceNodeConfig {
+ return m.nodes
+}
+
+func (m *mockConfigManager) GetCurrentNodeVersion() string {
+ return m.currentNodeVersion
+}
+
+func (m *mockConfigManager) SetNodes(nodes []apiconfig.InferenceNodeConfig) error {
+ if m.setNodesError != nil {
+ return m.setNodesError
+ }
+ m.nodes = nodes
+ return nil
+}
+
+// Mock Broker
+type mockBroker struct {
+ queuedCommands []broker.Command
+ queueError error
+ executeError error
+}
+
+func (m *mockBroker) QueueMessage(cmd broker.Command) error {
+ if m.queueError != nil {
+ return m.queueError
+ }
+ m.queuedCommands = append(m.queuedCommands, cmd)
+
+ // Execute command immediately for testing
+ if updateCmd, ok := cmd.(broker.UpdateNodeHardwareCommand); ok {
+ if m.executeError != nil {
+ updateCmd.Response <- m.executeError
+ } else {
+ updateCmd.Response <- nil
+ }
+ }
+ return nil
+}
+
+// Mock PhaseTracker
+type mockPhaseTracker struct {
+ epochState *chainphase.EpochState
+}
+
+func (m *mockPhaseTracker) GetCurrentEpochState() *chainphase.EpochState {
+ return m.epochState
+}
+
+// Mock ClientFactory
+type mockClientFactory struct {
+ client mlnodeclient.MLNodeClient
+}
+
+func (m *mockClientFactory) CreateClient(pocUrl, inferenceUrl string) mlnodeclient.MLNodeClient {
+ return m.client
+}
+
+// Custom mock client for testing error handling
+type customMockClient struct {
+ *mlnodeclient.MockClient
+ callCount int
+}
+
+func (c *customMockClient) CheckModelStatus(ctx context.Context, model mlnodeclient.Model) (*mlnodeclient.ModelStatusResponse, error) {
+ c.callCount++
+ if c.callCount == 1 {
+ return nil, errors.New("network error")
+ }
+ return c.MockClient.CheckModelStatus(ctx, model)
+}
+
+// Test isInDownloadWindow
+func TestIsInDownloadWindow(t *testing.T) {
+ manager := &MLNodeBackgroundManager{}
+
+ t.Run("nil epoch state", func(t *testing.T) {
+ if manager.isInDownloadWindow(nil) {
+ t.Error("expected false for nil epoch state")
+ }
+ })
+
+ t.Run("not synced", func(t *testing.T) {
+ epochState := &chainphase.EpochState{
+ IsSynced: false,
+ }
+ if manager.isInDownloadWindow(epochState) {
+ t.Error("expected false for not synced state")
+ }
+ })
+
+ t.Run("not in inference phase", func(t *testing.T) {
+ epochState := &chainphase.EpochState{
+ IsSynced: true,
+ CurrentPhase: types.PoCGeneratePhase,
+ LatestEpoch: types.EpochContext{
+ EpochIndex: 1,
+ PocStartBlockHeight: 1000,
+ EpochParams: types.EpochParams{
+ PocStageDuration: 100,
+ PocValidationDuration: 100,
+ InferenceValidationCutoff: 200,
+ SetNewValidatorsDelay: 50,
+ },
+ },
+ CurrentBlock: chainphase.BlockInfo{Height: 1100},
+ }
+ if manager.isInDownloadWindow(epochState) {
+ t.Error("expected false for non-inference phase")
+ }
+ })
+
+ t.Run("before window start", func(t *testing.T) {
+ epochParams := types.EpochParams{
+ PocStageDuration: 1000,
+ PocValidationDuration: 1000,
+ InferenceValidationCutoff: 200,
+ SetNewValidatorsDelay: 100,
+ }
+ epochState := &chainphase.EpochState{
+ IsSynced: true,
+ CurrentPhase: types.InferencePhase,
+ LatestEpoch: types.NewEpochContext(
+ types.Epoch{
+ Index: 1,
+ PocStartBlockHeight: 10000,
+ },
+ epochParams,
+ ),
+ CurrentBlock: chainphase.BlockInfo{Height: 11100}, // Before windowStart (11130)
+ }
+ if manager.isInDownloadWindow(epochState) {
+ t.Error("expected false for block before window start")
+ }
+ })
+
+ t.Run("after window end", func(t *testing.T) {
+ epochParams := types.EpochParams{
+ PocStageDuration: 1000,
+ PocValidationDuration: 1000,
+ InferenceValidationCutoff: 200,
+ SetNewValidatorsDelay: 100,
+ }
+ ec := types.NewEpochContext(
+ types.Epoch{
+ Index: 1,
+ PocStartBlockHeight: 10000,
+ },
+ epochParams,
+ )
+ // NextPoCStart = 10000 + 1000 + 1000 = 12000
+ // InferenceValidationCutoff = 12000 - 200 = 11800
+ // windowEnd = 11800 - 200 = 11600
+ epochState := &chainphase.EpochState{
+ IsSynced: true,
+ CurrentPhase: types.InferencePhase,
+ LatestEpoch: ec,
+ CurrentBlock: chainphase.BlockInfo{Height: 11700}, // After windowEnd (11600)
+ }
+ if manager.isInDownloadWindow(epochState) {
+ t.Error("expected false for block after window end")
+ }
+ })
+
+ t.Run("inside window", func(t *testing.T) {
+ epochParams := types.EpochParams{
+ EpochLength: 10000,
+ PocStageDuration: 1000,
+ PocExchangeDuration: 100,
+ PocValidationDelay: 100,
+ PocValidationDuration: 1000,
+ SetNewValidatorsDelay: 100,
+ InferenceValidationCutoff: 500,
+ }
+ ec := types.NewEpochContext(
+ types.Epoch{
+ Index: 1,
+ PocStartBlockHeight: 10000,
+ },
+ epochParams,
+ )
+ // Calculation:
+ // getPocAnchor = 10000
+ // GetEndOfPoCStage = 0 + 1000 = 1000
+ // GetStartOfPoCValidationStage = 1000 + 100 = 1100
+ // GetEndOfPoCValidationStage = 1100 + 1000 = 2100
+ // GetSetNewValidatorsStage = 2100 + 100 = 2200
+ // SetNewValidators = 10000 + 2200 = 12200
+ // windowStart = 12200 + 30 = 12230
+ // NextPoCStart = 10000 + 10000 = 20000
+ // InferenceValidationCutoff = 20000 - 500 = 19500
+ // windowEnd = 19500 - 200 = 19300
+ epochState := &chainphase.EpochState{
+ IsSynced: true,
+ CurrentPhase: types.InferencePhase,
+ LatestEpoch: ec,
+ CurrentBlock: chainphase.BlockInfo{Height: 15000}, // Inside window [12230, 19300]
+ }
+ if !manager.isInDownloadWindow(epochState) {
+ t.Error("expected true for block inside window")
+ }
+ })
+}
+
+// Test checkNodeModels
+func TestCheckNodeModels(t *testing.T) {
+ t.Run("model not found triggers download", func(t *testing.T) {
+ mockClient := mlnodeclient.NewMockClient()
+ // Don't add to CachedModels - it will return NOT_FOUND by default
+
+ configMgr := &mockConfigManager{
+ nodes: []apiconfig.InferenceNodeConfig{
+ {
+ Id: "node1",
+ Host: "localhost",
+ PoCPort: 8080,
+ PoCSegment: "/api",
+ InferencePort: 8081,
+ InferenceSegment: "/inference",
+ Models: map[string]apiconfig.ModelConfig{
+ "test-model": {Args: []string{}},
+ },
+ },
+ },
+ currentNodeVersion: "",
+ }
+
+ factory := &mockClientFactory{client: mockClient}
+
+ manager := NewMLNodeBackgroundManager(
+ configMgr,
+ nil,
+ &mockBroker{},
+ factory,
+ 30*time.Minute,
+ )
+
+ manager.checkNodeModels(configMgr.nodes[0])
+
+ if mockClient.CheckModelStatusCalled != 1 {
+ t.Errorf("expected CheckModelStatus to be called once, got %d", mockClient.CheckModelStatusCalled)
+ }
+
+ if mockClient.DownloadModelCalled != 1 {
+ t.Errorf("expected DownloadModel to be called once, got %d", mockClient.DownloadModelCalled)
+ }
+ })
+
+ t.Run("partial model triggers download", func(t *testing.T) {
+ mockClient := mlnodeclient.NewMockClient()
+ mockClient.CachedModels["test-model:latest"] = mlnodeclient.ModelListItem{
+ Model: mlnodeclient.Model{
+ HfRepo: "test-model",
+ HfCommit: nil,
+ },
+ Status: mlnodeclient.ModelStatusPartial,
+ }
+
+ configMgr := &mockConfigManager{
+ nodes: []apiconfig.InferenceNodeConfig{
+ {
+ Id: "node1",
+ Host: "localhost",
+ PoCPort: 8080,
+ PoCSegment: "/api",
+ InferencePort: 8081,
+ InferenceSegment: "/inference",
+ Models: map[string]apiconfig.ModelConfig{
+ "test-model": {Args: []string{}},
+ },
+ },
+ },
+ currentNodeVersion: "",
+ }
+
+ factory := &mockClientFactory{client: mockClient}
+
+ manager := NewMLNodeBackgroundManager(
+ configMgr,
+ nil,
+ &mockBroker{},
+ factory,
+ 30*time.Minute,
+ )
+
+ manager.checkNodeModels(configMgr.nodes[0])
+
+ if mockClient.DownloadModelCalled != 1 {
+ t.Errorf("expected DownloadModel to be called once, got %d", mockClient.DownloadModelCalled)
+ }
+ })
+
+ t.Run("already downloading skips download", func(t *testing.T) {
+ mockClient := mlnodeclient.NewMockClient()
+ // Add to DownloadingModels to simulate downloading state
+ mockClient.DownloadingModels["test-model:latest"] = &mlnodeclient.DownloadProgress{
+ StartTime: 1234567890,
+ ElapsedSeconds: 100,
+ }
+
+ configMgr := &mockConfigManager{
+ nodes: []apiconfig.InferenceNodeConfig{
+ {
+ Id: "node1",
+ Host: "localhost",
+ PoCPort: 8080,
+ PoCSegment: "/api",
+ InferencePort: 8081,
+ InferenceSegment: "/inference",
+ Models: map[string]apiconfig.ModelConfig{
+ "test-model": {Args: []string{}},
+ },
+ },
+ },
+ currentNodeVersion: "",
+ }
+
+ factory := &mockClientFactory{client: mockClient}
+
+ manager := NewMLNodeBackgroundManager(
+ configMgr,
+ nil,
+ &mockBroker{},
+ factory,
+ 30*time.Minute,
+ )
+
+ manager.checkNodeModels(configMgr.nodes[0])
+
+ if mockClient.CheckModelStatusCalled != 1 {
+ t.Errorf("expected CheckModelStatus to be called once, got %d", mockClient.CheckModelStatusCalled)
+ }
+
+ if mockClient.DownloadModelCalled != 0 {
+ t.Errorf("expected DownloadModel not to be called, got %d", mockClient.DownloadModelCalled)
+ }
+ })
+
+ t.Run("already downloaded skips download", func(t *testing.T) {
+ mockClient := mlnodeclient.NewMockClient()
+ mockClient.CachedModels["test-model:latest"] = mlnodeclient.ModelListItem{
+ Model: mlnodeclient.Model{
+ HfRepo: "test-model",
+ HfCommit: nil,
+ },
+ Status: mlnodeclient.ModelStatusDownloaded,
+ }
+
+ configMgr := &mockConfigManager{
+ nodes: []apiconfig.InferenceNodeConfig{
+ {
+ Id: "node1",
+ Host: "localhost",
+ PoCPort: 8080,
+ PoCSegment: "/api",
+ InferencePort: 8081,
+ InferenceSegment: "/inference",
+ Models: map[string]apiconfig.ModelConfig{
+ "test-model": {Args: []string{}},
+ },
+ },
+ },
+ currentNodeVersion: "",
+ }
+
+ factory := &mockClientFactory{client: mockClient}
+
+ manager := NewMLNodeBackgroundManager(
+ configMgr,
+ nil,
+ &mockBroker{},
+ factory,
+ 30*time.Minute,
+ )
+
+ manager.checkNodeModels(configMgr.nodes[0])
+
+ if mockClient.CheckModelStatusCalled != 1 {
+ t.Errorf("expected CheckModelStatus to be called once, got %d", mockClient.CheckModelStatusCalled)
+ }
+
+ if mockClient.DownloadModelCalled != 0 {
+ t.Errorf("expected DownloadModel not to be called, got %d", mockClient.DownloadModelCalled)
+ }
+ })
+
+ t.Run("endpoint not implemented stops checking node", func(t *testing.T) {
+ mockClient := mlnodeclient.NewMockClient()
+ mockClient.CheckModelStatusError = &mlnodeclient.ErrAPINotImplemented{
+ Endpoint: "/api/v1/models/status",
+ StatusCode: 404,
+ }
+
+ configMgr := &mockConfigManager{
+ nodes: []apiconfig.InferenceNodeConfig{
+ {
+ Id: "node1",
+ Host: "localhost",
+ PoCPort: 8080,
+ PoCSegment: "/api",
+ InferencePort: 8081,
+ InferenceSegment: "/inference",
+ Models: map[string]apiconfig.ModelConfig{
+ "model1": {Args: []string{}},
+ "model2": {Args: []string{}},
+ },
+ },
+ },
+ currentNodeVersion: "",
+ }
+
+ factory := &mockClientFactory{client: mockClient}
+
+ manager := NewMLNodeBackgroundManager(
+ configMgr,
+ nil,
+ &mockBroker{},
+ factory,
+ 30*time.Minute,
+ )
+
+ manager.checkNodeModels(configMgr.nodes[0])
+
+ // Should only check once and then stop
+ if mockClient.CheckModelStatusCalled != 1 {
+ t.Errorf("expected CheckModelStatus to be called once, got %d", mockClient.CheckModelStatusCalled)
+ }
+
+ if mockClient.DownloadModelCalled != 0 {
+ t.Errorf("expected DownloadModel not to be called, got %d", mockClient.DownloadModelCalled)
+ }
+ })
+
+ t.Run("network error continues to next model", func(t *testing.T) {
+ // Create a custom mock that will fail only on first call
+ mockClient := &customMockClient{
+ MockClient: mlnodeclient.NewMockClient(),
+ callCount: 0,
+ }
+
+ configMgr := &mockConfigManager{
+ nodes: []apiconfig.InferenceNodeConfig{
+ {
+ Id: "node1",
+ Host: "localhost",
+ PoCPort: 8080,
+ PoCSegment: "/api",
+ InferencePort: 8081,
+ InferenceSegment: "/inference",
+ Models: map[string]apiconfig.ModelConfig{
+ "model1": {Args: []string{}},
+ "model2": {Args: []string{}},
+ },
+ },
+ },
+ currentNodeVersion: "",
+ }
+
+ factory := &mockClientFactory{client: mockClient}
+
+ manager := NewMLNodeBackgroundManager(
+ configMgr,
+ nil,
+ &mockBroker{},
+ factory,
+ 30*time.Minute,
+ )
+
+ manager.checkNodeModels(configMgr.nodes[0])
+
+ // Should try checking both models despite first error
+ if mockClient.callCount != 2 {
+ t.Errorf("expected CheckModelStatus to be called twice, got %d", mockClient.callCount)
+ }
+ })
+
+ t.Run("multiple models in config", func(t *testing.T) {
+ mockClient := mlnodeclient.NewMockClient()
+ // model1: NOT_FOUND (not in CachedModels)
+ // model2: DOWNLOADED
+ mockClient.CachedModels["model2:latest"] = mlnodeclient.ModelListItem{
+ Model: mlnodeclient.Model{
+ HfRepo: "model2",
+ HfCommit: nil,
+ },
+ Status: mlnodeclient.ModelStatusDownloaded,
+ }
+ // model3: NOT_FOUND (not in CachedModels)
+
+ configMgr := &mockConfigManager{
+ nodes: []apiconfig.InferenceNodeConfig{
+ {
+ Id: "node1",
+ Host: "localhost",
+ PoCPort: 8080,
+ PoCSegment: "/api",
+ InferencePort: 8081,
+ InferenceSegment: "/inference",
+ Models: map[string]apiconfig.ModelConfig{
+ "model1": {Args: []string{}},
+ "model2": {Args: []string{}},
+ "model3": {Args: []string{}},
+ },
+ },
+ },
+ currentNodeVersion: "",
+ }
+
+ factory := &mockClientFactory{client: mockClient}
+
+ manager := NewMLNodeBackgroundManager(
+ configMgr,
+ nil,
+ &mockBroker{},
+ factory,
+ 30*time.Minute,
+ )
+
+ manager.checkNodeModels(configMgr.nodes[0])
+
+ if mockClient.CheckModelStatusCalled != 3 {
+ t.Errorf("expected CheckModelStatus to be called 3 times, got %d", mockClient.CheckModelStatusCalled)
+ }
+
+ // Should download 2 models (model1 and model3 are NOT_FOUND)
+ if mockClient.DownloadModelCalled != 2 {
+ t.Errorf("expected DownloadModel to be called twice, got %d", mockClient.DownloadModelCalled)
+ }
+ })
+}
+
+// Test URL formatting
+func TestURLFormatting(t *testing.T) {
+ node := apiconfig.InferenceNodeConfig{
+ Host: "localhost",
+ PoCPort: 8080,
+ PoCSegment: "/api/v1",
+ InferencePort: 8081,
+ InferenceSegment: "/inference",
+ }
+
+ t.Run("PoC URL without version", func(t *testing.T) {
+ url := getPoCUrl(node)
+ expected := "http://localhost:8080/api/v1"
+ if url != expected {
+ t.Errorf("expected %s, got %s", expected, url)
+ }
+ })
+
+ t.Run("PoC URL with version", func(t *testing.T) {
+ url := getPoCUrlVersioned(node, "v2")
+ expected := "http://localhost:8080/v2/api/v1"
+ if url != expected {
+ t.Errorf("expected %s, got %s", expected, url)
+ }
+ })
+
+ t.Run("Inference URL without version", func(t *testing.T) {
+ url := getInferenceUrl(node)
+ expected := "http://localhost:8081/inference"
+ if url != expected {
+ t.Errorf("expected %s, got %s", expected, url)
+ }
+ })
+
+ t.Run("Inference URL with version", func(t *testing.T) {
+ url := getInferenceUrlVersioned(node, "v2")
+ expected := "http://localhost:8081/v2/inference"
+ if url != expected {
+ t.Errorf("expected %s, got %s", expected, url)
+ }
+ })
+
+ t.Run("URL with version helper", func(t *testing.T) {
+ url := getPoCUrlWithVersion(node, "v2")
+ expected := "http://localhost:8080/v2/api/v1"
+ if url != expected {
+ t.Errorf("expected %s, got %s", expected, url)
+ }
+ })
+
+ t.Run("URL without version helper (empty string)", func(t *testing.T) {
+ url := getPoCUrlWithVersion(node, "")
+ expected := "http://localhost:8080/api/v1"
+ if url != expected {
+ t.Errorf("expected %s, got %s", expected, url)
+ }
+ })
+}
+
+// Test GPU transformation
+func TestTransformGPUDevicesToHardware(t *testing.T) {
+ t.Run("identical GPUs grouped", func(t *testing.T) {
+ totalMem := int(24576) // 24GB in MB
+ devices := []mlnodeclient.GPUDevice{
+ {
+ Index: 0,
+ Name: "NVIDIA RTX 3090",
+ TotalMemoryMB: &totalMem,
+ IsAvailable: true,
+ ErrorMessage: nil,
+ },
+ {
+ Index: 1,
+ Name: "NVIDIA RTX 3090",
+ TotalMemoryMB: &totalMem,
+ IsAvailable: true,
+ ErrorMessage: nil,
+ },
+ }
+
+ hardware := transformGPUDevicesToHardware(devices)
+
+ if len(hardware) != 1 {
+ t.Errorf("expected 1 hardware entry, got %d", len(hardware))
+ }
+
+ if hardware[0].Type != "NVIDIA RTX 3090 | 24GB" {
+ t.Errorf("expected 'NVIDIA RTX 3090 | 24GB', got %s", hardware[0].Type)
+ }
+
+ if hardware[0].Count != 2 {
+ t.Errorf("expected count 2, got %d", hardware[0].Count)
+ }
+ })
+
+ t.Run("mixed GPU types", func(t *testing.T) {
+ mem3090 := int(24576)
+ mem4090 := int(24576)
+ devices := []mlnodeclient.GPUDevice{
+ {Name: "NVIDIA RTX 3090", TotalMemoryMB: &mem3090, IsAvailable: true},
+ {Name: "NVIDIA RTX 3090", TotalMemoryMB: &mem3090, IsAvailable: true},
+ {Name: "NVIDIA RTX 4090", TotalMemoryMB: &mem4090, IsAvailable: true},
+ }
+
+ hardware := transformGPUDevicesToHardware(devices)
+
+ if len(hardware) != 2 {
+ t.Errorf("expected 2 hardware entries, got %d", len(hardware))
+ }
+
+ // Check sorting
+ if hardware[0].Type != "NVIDIA RTX 3090 | 24GB" {
+ t.Errorf("expected first entry to be RTX 3090, got %s", hardware[0].Type)
+ }
+ if hardware[1].Type != "NVIDIA RTX 4090 | 24GB" {
+ t.Errorf("expected second entry to be RTX 4090, got %s", hardware[1].Type)
+ }
+ })
+
+ t.Run("skip unavailable GPUs", func(t *testing.T) {
+ mem := int(24576)
+ devices := []mlnodeclient.GPUDevice{
+ {Name: "NVIDIA RTX 3090", TotalMemoryMB: &mem, IsAvailable: false},
+ {Name: "NVIDIA RTX 4090", TotalMemoryMB: &mem, IsAvailable: true},
+ }
+
+ hardware := transformGPUDevicesToHardware(devices)
+
+ if len(hardware) != 1 {
+ t.Errorf("expected 1 hardware entry, got %d", len(hardware))
+ }
+
+ if hardware[0].Type != "NVIDIA RTX 4090 | 24GB" {
+ t.Errorf("expected RTX 4090, got %s", hardware[0].Type)
+ }
+ })
+
+ t.Run("skip GPUs with error", func(t *testing.T) {
+ mem := int(24576)
+ errMsg := "NVML error"
+ devices := []mlnodeclient.GPUDevice{
+ {Name: "NVIDIA RTX 3090", TotalMemoryMB: &mem, IsAvailable: true, ErrorMessage: &errMsg},
+ {Name: "NVIDIA RTX 4090", TotalMemoryMB: &mem, IsAvailable: true, ErrorMessage: nil},
+ }
+
+ hardware := transformGPUDevicesToHardware(devices)
+
+ if len(hardware) != 1 {
+ t.Errorf("expected 1 hardware entry, got %d", len(hardware))
+ }
+
+ if hardware[0].Type != "NVIDIA RTX 4090 | 24GB" {
+ t.Errorf("expected RTX 4090, got %s", hardware[0].Type)
+ }
+ })
+
+ t.Run("skip GPUs without memory info", func(t *testing.T) {
+ mem := int(24576)
+ devices := []mlnodeclient.GPUDevice{
+ {Name: "NVIDIA RTX 3090", TotalMemoryMB: nil, IsAvailable: true},
+ {Name: "NVIDIA RTX 4090", TotalMemoryMB: &mem, IsAvailable: true},
+ }
+
+ hardware := transformGPUDevicesToHardware(devices)
+
+ if len(hardware) != 1 {
+ t.Errorf("expected 1 hardware entry, got %d", len(hardware))
+ }
+ })
+
+ t.Run("memory conversion MB to GB", func(t *testing.T) {
+ mem := int(16384) // 16GB in MB
+ devices := []mlnodeclient.GPUDevice{
+ {Name: "NVIDIA RTX 3080", TotalMemoryMB: &mem, IsAvailable: true},
+ }
+
+ hardware := transformGPUDevicesToHardware(devices)
+
+ if hardware[0].Type != "NVIDIA RTX 3080 | 16GB" {
+ t.Errorf("expected 'NVIDIA RTX 3080 | 16GB', got %s", hardware[0].Type)
+ }
+ })
+
+ t.Run("empty device list", func(t *testing.T) {
+ hardware := transformGPUDevicesToHardware([]mlnodeclient.GPUDevice{})
+
+ if len(hardware) != 0 {
+ t.Errorf("expected empty hardware list, got %d", len(hardware))
+ }
+ })
+}
+
+// Test GPU check and update
+func TestCheckAndUpdateGPUs(t *testing.T) {
+ t.Run("successful GPU fetch and update", func(t *testing.T) {
+ mem := int(24576)
+ mockClient := &mlnodeclient.MockClient{
+ GPUDevices: []mlnodeclient.GPUDevice{
+ {Name: "NVIDIA RTX 3090", TotalMemoryMB: &mem, IsAvailable: true},
+ },
+ }
+
+ configMgr := &mockConfigManager{
+ nodes: []apiconfig.InferenceNodeConfig{
+ {
+ Id: "node1",
+ Host: "localhost",
+ PoCPort: 8080,
+ PoCSegment: "/api",
+ InferencePort: 8081,
+ InferenceSegment: "/inference",
+ },
+ },
+ }
+
+ broker := &mockBroker{}
+ factory := &mockClientFactory{client: mockClient}
+
+ manager := NewMLNodeBackgroundManager(
+ configMgr,
+ nil,
+ broker,
+ factory,
+ 30*time.Minute,
+ )
+
+ ctx := context.Background()
+ manager.checkAndUpdateGPUs(ctx)
+
+ // Verify broker was called
+ if len(broker.queuedCommands) != 1 {
+ t.Errorf("expected 1 broker command, got %d", len(broker.queuedCommands))
+ }
+
+ // Verify config was updated
+ if len(configMgr.nodes[0].Hardware) != 1 {
+ t.Errorf("expected 1 hardware entry, got %d", len(configMgr.nodes[0].Hardware))
+ }
+
+ if configMgr.nodes[0].Hardware[0].Type != "NVIDIA RTX 3090 | 24GB" {
+ t.Errorf("unexpected hardware type: %s", configMgr.nodes[0].Hardware[0].Type)
+ }
+ })
+
+ t.Run("ErrAPINotImplemented handling", func(t *testing.T) {
+ mockClient := &mlnodeclient.MockClient{
+ GetGPUDevicesError: &mlnodeclient.ErrAPINotImplemented{Endpoint: "/api/v1/gpu/devices"},
+ }
+
+ configMgr := &mockConfigManager{
+ nodes: []apiconfig.InferenceNodeConfig{
+ {Id: "node1", Host: "localhost", PoCPort: 8080, PoCSegment: "/api"},
+ },
+ }
+
+ broker := &mockBroker{}
+ factory := &mockClientFactory{client: mockClient}
+
+ manager := NewMLNodeBackgroundManager(
+ configMgr,
+ nil,
+ broker,
+ factory,
+ 30*time.Minute,
+ )
+
+ ctx := context.Background()
+ manager.checkAndUpdateGPUs(ctx)
+
+ // Should not call broker
+ if len(broker.queuedCommands) != 0 {
+ t.Errorf("expected 0 broker commands, got %d", len(broker.queuedCommands))
+ }
+
+ // Should not update config
+ if len(configMgr.nodes[0].Hardware) != 0 {
+ t.Errorf("expected 0 hardware entries, got %d", len(configMgr.nodes[0].Hardware))
+ }
+ })
+
+ t.Run("network error handling", func(t *testing.T) {
+ mockClient := &mlnodeclient.MockClient{
+ GetGPUDevicesError: errors.New("network error"),
+ }
+
+ configMgr := &mockConfigManager{
+ nodes: []apiconfig.InferenceNodeConfig{
+ {Id: "node1", Host: "localhost", PoCPort: 8080, PoCSegment: "/api"},
+ },
+ }
+
+ broker := &mockBroker{}
+ factory := &mockClientFactory{client: mockClient}
+
+ manager := NewMLNodeBackgroundManager(
+ configMgr,
+ nil,
+ broker,
+ factory,
+ 30*time.Minute,
+ )
+
+ ctx := context.Background()
+ manager.checkAndUpdateGPUs(ctx)
+
+ // Should not call broker
+ if len(broker.queuedCommands) != 0 {
+ t.Errorf("expected 0 broker commands, got %d", len(broker.queuedCommands))
+ }
+ })
+
+ t.Run("broker queue failure", func(t *testing.T) {
+ mem := int(24576)
+ mockClient := &mlnodeclient.MockClient{
+ GPUDevices: []mlnodeclient.GPUDevice{
+ {Name: "NVIDIA RTX 3090", TotalMemoryMB: &mem, IsAvailable: true},
+ },
+ }
+
+ configMgr := &mockConfigManager{
+ nodes: []apiconfig.InferenceNodeConfig{
+ {Id: "node1", Host: "localhost", PoCPort: 8080, PoCSegment: "/api"},
+ },
+ }
+
+ broker := &mockBroker{queueError: errors.New("queue full")}
+ factory := &mockClientFactory{client: mockClient}
+
+ manager := NewMLNodeBackgroundManager(
+ configMgr,
+ nil,
+ broker,
+ factory,
+ 30*time.Minute,
+ )
+
+ ctx := context.Background()
+ manager.checkAndUpdateGPUs(ctx)
+
+ // Config should still be updated
+ if len(configMgr.nodes[0].Hardware) != 1 {
+ t.Errorf("expected 1 hardware entry, got %d", len(configMgr.nodes[0].Hardware))
+ }
+ })
+
+ t.Run("config save failure", func(t *testing.T) {
+ mem := int(24576)
+ mockClient := &mlnodeclient.MockClient{
+ GPUDevices: []mlnodeclient.GPUDevice{
+ {Name: "NVIDIA RTX 3090", TotalMemoryMB: &mem, IsAvailable: true},
+ },
+ }
+
+ configMgr := &mockConfigManager{
+ nodes: []apiconfig.InferenceNodeConfig{
+ {Id: "node1", Host: "localhost", PoCPort: 8080, PoCSegment: "/api"},
+ },
+ setNodesError: errors.New("disk full"),
+ }
+
+ broker := &mockBroker{}
+ factory := &mockClientFactory{client: mockClient}
+
+ manager := NewMLNodeBackgroundManager(
+ configMgr,
+ nil,
+ broker,
+ factory,
+ 30*time.Minute,
+ )
+
+ ctx := context.Background()
+ manager.checkAndUpdateGPUs(ctx)
+
+ // Broker should still be called
+ if len(broker.queuedCommands) != 1 {
+ t.Errorf("expected 1 broker command, got %d", len(broker.queuedCommands))
+ }
+ })
+
+ t.Run("empty GPU list", func(t *testing.T) {
+ mockClient := &mlnodeclient.MockClient{
+ GPUDevices: []mlnodeclient.GPUDevice{},
+ }
+
+ configMgr := &mockConfigManager{
+ nodes: []apiconfig.InferenceNodeConfig{
+ {Id: "node1", Host: "localhost", PoCPort: 8080, PoCSegment: "/api"},
+ },
+ }
+
+ broker := &mockBroker{}
+ factory := &mockClientFactory{client: mockClient}
+
+ manager := NewMLNodeBackgroundManager(
+ configMgr,
+ nil,
+ broker,
+ factory,
+ 30*time.Minute,
+ )
+
+ ctx := context.Background()
+ manager.checkAndUpdateGPUs(ctx)
+
+ // Should not call broker for empty GPU list
+ if len(broker.queuedCommands) != 0 {
+ t.Errorf("expected 0 broker commands, got %d", len(broker.queuedCommands))
+ }
+ })
+}
diff --git a/decentralized-api/internal/nats/client/conn.go b/decentralized-api/internal/nats/client/conn.go
new file mode 100644
index 000000000..a1e08af64
--- /dev/null
+++ b/decentralized-api/internal/nats/client/conn.go
@@ -0,0 +1,25 @@
+package client
+
+import (
+ "decentralized-api/internal/nats/server"
+ "github.com/nats-io/nats.go"
+ "strconv"
+ "time"
+)
+
+func ConnectToNats(host string, port int, name string) (*nats.Conn, error) {
+ if host == "" {
+ host = server.DefaultHost
+ }
+
+ if port == 0 {
+ port = server.DefaultPort
+ }
+
+ return nats.Connect(
+ "nats://"+host+":"+strconv.Itoa(port),
+ nats.Name(name),
+ nats.MaxReconnects(-1),
+ nats.ReconnectWait(2*time.Second),
+ )
+}
diff --git a/decentralized-api/internal/nats/server/server.go b/decentralized-api/internal/nats/server/server.go
new file mode 100644
index 000000000..e00458986
--- /dev/null
+++ b/decentralized-api/internal/nats/server/server.go
@@ -0,0 +1,98 @@
+package server
+
+import (
+ "decentralized-api/apiconfig"
+ "decentralized-api/logging"
+ natssrv "github.com/nats-io/nats-server/v2/server"
+ "github.com/nats-io/nats.go"
+ "github.com/pkg/errors"
+ types2 "github.com/productscience/inference/x/inference/types"
+ "time"
+)
+
+const (
+ TxsToSendStream = "txs_to_send"
+ TxsToObserveStream = "txs_to_observe"
+
+ storageDir = "/root/.dapi/.nats"
+ DefaultPort = 4222
+ DefaultHost = "0.0.0.0"
+)
+
+type NatsServer interface {
+ Start() error
+}
+
+type server struct {
+ conf apiconfig.NatsServerConfig
+ ns *natssrv.Server
+}
+
+func NewServer(config apiconfig.NatsServerConfig) NatsServer {
+ return &server{
+ conf: config,
+ }
+}
+
+func (s *server) Start() error {
+ if s.conf.Host == "" {
+ s.conf.Host = DefaultHost
+ }
+
+ if s.conf.Port == 0 {
+ s.conf.Port = DefaultPort
+ }
+
+ logging.Info("starting nats server", types2.Messages, "port", s.conf.Port, "host", s.conf.Host)
+
+ opts := &natssrv.Options{
+ Host: s.conf.Host,
+ Port: s.conf.Port,
+ JetStream: true,
+ StoreDir: storageDir,
+ }
+
+ ns, err := natssrv.NewServer(opts)
+ if err != nil {
+ return errors.Wrap(err, "failed to create NATS server")
+ }
+
+ s.ns = ns
+ go ns.Start()
+
+ for i := 0; i < 3; i++ {
+ time.Sleep(1 * time.Second)
+ if ns.ReadyForConnections(2 * time.Second) {
+ break
+ }
+ if i == 2 {
+ return errors.New("NATS server not ready after 3 attempts")
+ }
+ }
+
+ return s.createJetStreamTopics([]string{TxsToSendStream, TxsToObserveStream})
+}
+
+func (s *server) createJetStreamTopics(topicNames []string) error {
+ nc, err := nats.Connect(s.ns.ClientURL())
+ if err != nil {
+ return errors.Wrap(err, "failed to connect to embedded NATS")
+ }
+ js, err := nc.JetStream()
+ if err != nil {
+ return errors.Wrap(err, "failed to get JetStream context")
+ }
+
+ for _, topic := range topicNames {
+ _, err = js.AddStream(&nats.StreamConfig{
+ Name: topic,
+ Subjects: []string{topic},
+ Storage: nats.FileStorage,
+ })
+
+ if err != nil && !errors.Is(err, nats.ErrStreamNameAlreadyInUse) {
+ return errors.Wrap(err, "failed to add stream for topic "+topic)
+ }
+ }
+ return nil
+}
diff --git a/decentralized-api/internal/poc/node_orchestrator.go b/decentralized-api/internal/poc/node_orchestrator.go
new file mode 100644
index 000000000..69e7926ea
--- /dev/null
+++ b/decentralized-api/internal/poc/node_orchestrator.go
@@ -0,0 +1,270 @@
+package poc
+
+import (
+ "context"
+ "decentralized-api/broker"
+ "decentralized-api/chainphase"
+ cosmos_client "decentralized-api/cosmosclient"
+ "decentralized-api/logging"
+ "decentralized-api/mlnodeclient"
+
+ "github.com/productscience/inference/x/inference/types"
+)
+
+const (
+ POC_VALIDATE_BATCH_RETRIES = 5
+ POC_VALIDATE_SAMPLES_PER_BATCH = 200
+)
+
+type NodePoCOrchestrator interface {
+ ValidateReceivedBatches(pocStageStartBlockHeight int64)
+}
+
+type NodePoCOrchestratorImpl struct {
+ pubKey string
+ nodeBroker *broker.Broker
+ callbackUrl string
+ chainBridge OrchestratorChainBridge
+ phaseTracker *chainphase.ChainPhaseTracker
+}
+
+type OrchestratorChainBridge interface {
+ PoCBatchesForStage(startPoCBlockHeight int64) (*types.QueryPocBatchesForStageResponse, error)
+ GetBlockHash(height int64) (string, error)
+ GetPocParams() (*types.PocParams, error)
+}
+
+type OrchestratorChainBridgeImpl struct {
+ cosmosClient cosmos_client.CosmosMessageClient
+ chainNodeUrl string
+}
+
+func (b *OrchestratorChainBridgeImpl) PoCBatchesForStage(startPoCBlockHeight int64) (*types.QueryPocBatchesForStageResponse, error) {
+ response, err := b.cosmosClient.NewInferenceQueryClient().PocBatchesForStage(b.cosmosClient.GetContext(), &types.QueryPocBatchesForStageRequest{BlockHeight: startPoCBlockHeight})
+ if err != nil {
+ logging.Error("Failed to query PoC batches for stage", types.PoC, "error", err)
+ return nil, err
+ }
+ return response, nil
+}
+
+func (b *OrchestratorChainBridgeImpl) GetPocParams() (*types.PocParams, error) {
+ response, err := b.cosmosClient.NewInferenceQueryClient().Params(b.cosmosClient.GetContext(), &types.QueryParamsRequest{})
+ if err != nil {
+ logging.Error("Failed to query params", types.PoC, "error", err)
+ return nil, err
+ }
+ pocParams := response.Params.PocParams
+ return pocParams, nil
+}
+
+func (b *OrchestratorChainBridgeImpl) GetBlockHash(height int64) (string, error) {
+ client, err := cosmos_client.NewRpcClient(b.chainNodeUrl)
+ if err != nil {
+ return "", err
+ }
+
+ block, err := client.Block(context.Background(), &height)
+ if err != nil {
+ return "", err
+ }
+
+ return block.Block.Hash().String(), err
+}
+
+func NewNodePoCOrchestratorForCosmosChain(pubKey string, nodeBroker *broker.Broker, callbackUrl string, chainNodeUrl string, cosmosClient cosmos_client.CosmosMessageClient, phaseTracker *chainphase.ChainPhaseTracker) NodePoCOrchestrator {
+ return &NodePoCOrchestratorImpl{
+ pubKey: pubKey,
+ nodeBroker: nodeBroker,
+ callbackUrl: callbackUrl,
+ chainBridge: &OrchestratorChainBridgeImpl{
+ cosmosClient: cosmosClient,
+ chainNodeUrl: chainNodeUrl,
+ },
+ phaseTracker: phaseTracker,
+ }
+}
+
+func NewNodePoCOrchestrator(pubKey string, nodeBroker *broker.Broker, callbackUrl string, chainBridge OrchestratorChainBridge, phaseTracker *chainphase.ChainPhaseTracker) NodePoCOrchestrator {
+ return &NodePoCOrchestratorImpl{
+ pubKey: pubKey,
+ nodeBroker: nodeBroker,
+ callbackUrl: callbackUrl,
+ chainBridge: chainBridge,
+ phaseTracker: phaseTracker,
+ }
+}
+
+func (o *NodePoCOrchestratorImpl) ValidateReceivedBatches(pocStageStartBlockHeight int64) {
+ logging.Info("ValidateReceivedBatches. Starting.", types.PoC, "pocStageStartBlockHeight", pocStageStartBlockHeight)
+ epochState := o.phaseTracker.GetCurrentEpochState()
+ // Use the parameter as storage key (trigger_height for confirmation PoC, validation start for regular PoC)
+ startOfPoCBlockHeight := pocStageStartBlockHeight
+ logging.Info("ValidateReceivedBatches. Current epoch state.", types.PoC,
+ "pocStageStartBlockHeight", pocStageStartBlockHeight,
+ "epochState.CurrentBlock.Height", epochState.CurrentBlock.Height,
+ "epochState.CurrentPhase", epochState.CurrentPhase,
+ "epochState.LatestEpoch.PocStartBlockHeight", epochState.LatestEpoch.PocStartBlockHeight,
+ "epochState.LatestEpoch.EpochIndex", epochState.LatestEpoch.EpochIndex)
+
+ // Determine block hash based on PoC type
+ var blockHash string
+ if epochState.CurrentPhase == types.InferencePhase && epochState.ActiveConfirmationPoCEvent != nil {
+ // Confirmation PoC - use hash from event (hash of block generation_start_height - 1)
+ blockHash = epochState.ActiveConfirmationPoCEvent.PocSeedBlockHash
+ logging.Info("ValidateReceivedBatches. Using confirmation PoC block hash from event.", types.PoC,
+ "pocStageStartBlockHeight", pocStageStartBlockHeight,
+ "triggerHeight", epochState.ActiveConfirmationPoCEvent.TriggerHeight,
+ "generationStartHeight", epochState.ActiveConfirmationPoCEvent.GenerationStartHeight,
+ "blockHash", blockHash)
+ } else {
+ // Regular PoC - query hash at startOfPoCBlockHeight
+ var err error
+ blockHash, err = o.chainBridge.GetBlockHash(startOfPoCBlockHeight)
+ if err != nil {
+ logging.Error("ValidateReceivedBatches. Failed to get block hash", types.PoC,
+ "pocStageStartBlockHeight", pocStageStartBlockHeight, "error", err)
+ return
+ }
+ logging.Info("ValidateReceivedBatches. Got start of PoC block hash.", types.PoC,
+ "pocStageStartBlockHeight", pocStageStartBlockHeight,
+ "pocStartBlockHeight", startOfPoCBlockHeight,
+ "blockHash", blockHash)
+ }
+
+ // 1. GET ALL SUBMITTED BATCHES!
+ // FIXME: might be too long of a transaction, paging might be needed
+ logging.Info("ValidateReceivedBatches. Querying batches from chain.", types.PoC,
+ "pocStageStartBlockHeight", pocStageStartBlockHeight,
+ "startOfPoCBlockHeight", startOfPoCBlockHeight)
+ allParticipantsBatches, err := o.chainBridge.PoCBatchesForStage(startOfPoCBlockHeight)
+ if err != nil {
+ logging.Error("ValidateReceivedBatches. Failed to get PoC allParticipantsBatches", types.PoC, "pocStageStartBlockHeight", pocStageStartBlockHeight, "error", err)
+ return
+ }
+ participants := make([]string, len(allParticipantsBatches.PocBatch))
+ for i, participantBatches := range allParticipantsBatches.PocBatch {
+ participants[i] = participantBatches.Participant
+ }
+ logging.Info("ValidateReceivedBatches. Got PoC allParticipantsBatches.", types.PoC,
+ "pocStageStartBlockHeight", pocStageStartBlockHeight,
+ "startOfPoCBlockHeight", startOfPoCBlockHeight,
+ "numParticipants", len(participants),
+ "participants", participants)
+
+ nodes, err := o.nodeBroker.GetNodes()
+ if err != nil {
+ logging.Error("ValidateReceivedBatches. Failed to get nodes", types.PoC, "pocStageStartBlockHeight", pocStageStartBlockHeight, "error", err)
+ return
+ }
+ logging.Info("ValidateReceivedBatches. Got nodes.", types.PoC, "pocStageStartBlockHeight", pocStageStartBlockHeight, "numNodes", len(nodes))
+ nodes = filterNodes(nodes)
+ logging.Info("ValidateReceivedBatches. Filtered nodes available for PoC validation.", types.PoC, "numNodes", len(nodes))
+
+ if len(nodes) == 0 {
+ logging.Error("ValidateReceivedBatches. No nodes available to validate PoC batches", types.PoC, "pocStageStartBlockHeight", pocStageStartBlockHeight)
+ return
+ }
+
+ pocParams, err := o.chainBridge.GetPocParams()
+ if err != nil {
+ logging.Error("ValidateReceivedBatches. Failed to get chain parameters", types.PoC, "pocStageStartBlockHeight", pocStageStartBlockHeight, "error", err)
+ return
+ }
+ samplesPerBatch := int64(pocParams.ValidationSampleSize)
+ if pocParams.ValidationSampleSize == 0 {
+ logging.Info("Defaulting to 200 samples per batch", types.PoC, "pocStageStartBlockHeight", pocStageStartBlockHeight)
+ samplesPerBatch = POC_VALIDATE_SAMPLES_PER_BATCH
+ }
+
+ attemptCounter := 0
+ successfulValidations := 0
+ failedValidations := 0
+
+ // Iterating over participants
+ for _, participantBatches := range allParticipantsBatches.PocBatch {
+ joinedBatch := mlnodeclient.ProofBatch{
+ PublicKey: participantBatches.HexPubKey,
+ BlockHash: blockHash,
+ BlockHeight: startOfPoCBlockHeight,
+ }
+
+ uniqueNonces := make(map[int64]struct{})
+
+ for _, b := range participantBatches.PocBatch {
+ if len(b.Nonces) != len(b.Dist) {
+ logging.Error("ValidateReceivedBatches. Nonces length mismatch. Skipping the batch", types.PoC,
+ "participant", participantBatches.Participant,
+ "batchId", b.BatchId)
+ continue
+ }
+
+ for i, nonce := range b.Nonces {
+ if _, exists := uniqueNonces[nonce]; !exists {
+ uniqueNonces[nonce] = struct{}{}
+
+ joinedBatch.Nonces = append(joinedBatch.Nonces, nonce)
+ joinedBatch.Dist = append(joinedBatch.Dist, b.Dist[i])
+ } else {
+ logging.Info("ValidateReceivedBatches. Duplicate nonce found", types.PoC,
+ "participant", participantBatches.Participant,
+ "batchId", b.BatchId,
+ "nonce", nonce)
+ }
+ }
+ }
+
+ batchToValidate := joinedBatch.SampleNoncesToValidate(o.pubKey, samplesPerBatch)
+
+ validationSucceeded := false
+ for attempt := range POC_VALIDATE_BATCH_RETRIES {
+ node := nodes[attemptCounter%len(nodes)]
+ attemptCounter++
+
+ logging.Info("ValidateReceivedBatches. Sending sampled batch for validation.", types.PoC,
+ "attempt", attempt,
+ "length", len(batchToValidate.Nonces),
+ "pocStageStartBlockHeight", pocStageStartBlockHeight,
+ "node.Id", node.Node.Id, "node.Host", node.Node.Host,
+ "participantBatches.Participant", participantBatches.Participant)
+ logging.Debug("ValidateReceivedBatches. Sending batch", types.PoC, "node", node.Node.Host, "participantBatches", batchToValidate)
+
+ // FIXME: copying: doesn't look good for large PoCBatch structures?
+ nodeClient := o.nodeBroker.NewNodeClient(&node.Node)
+ err = nodeClient.ValidateBatch(context.Background(), batchToValidate)
+ if err != nil {
+ logging.Error("ValidateReceivedBatches. Failed to send validate batch request to node", types.PoC, "pocStageStartBlockHeight", pocStageStartBlockHeight, "node", node.Node.Host, "error", err)
+ continue
+ }
+
+ validationSucceeded = true
+ break
+ }
+
+ if validationSucceeded {
+ successfulValidations++
+ } else {
+ failedValidations++
+ logging.Error("ValidateReceivedBatches. Failed to validate batch after all retry attempts", types.PoC,
+ "pocStageStartBlockHeight", pocStageStartBlockHeight,
+ "participantBatches.Participant", participantBatches.Participant,
+ "maxAttempts", POC_VALIDATE_BATCH_RETRIES)
+ }
+ }
+
+ logging.Info("ValidateReceivedBatches. Finished.", types.PoC,
+ "pocStageStartBlockHeight", pocStageStartBlockHeight,
+ "totalBatches", len(allParticipantsBatches.PocBatch),
+ "successfulValidations", successfulValidations,
+ "failedValidations", failedValidations)
+}
+
+func filterNodes(nodes []broker.NodeResponse) []broker.NodeResponse {
+ filtered := make([]broker.NodeResponse, 0, len(nodes))
+ for _, node := range nodes {
+ if node.State.CurrentStatus == types.HardwareNodeStatus_POC && node.State.PocCurrentStatus == broker.PocStatusValidating {
+ filtered = append(filtered, node)
+ }
+ }
+ return filtered
+}
diff --git a/decentralized-api/internal/poc/random_seed.go b/decentralized-api/internal/poc/random_seed.go
new file mode 100644
index 000000000..3a6e30e80
--- /dev/null
+++ b/decentralized-api/internal/poc/random_seed.go
@@ -0,0 +1,141 @@
+package poc
+
+import (
+ "decentralized-api/apiconfig"
+ "decentralized-api/cosmosclient"
+ "decentralized-api/logging"
+ "encoding/binary"
+ "encoding/hex"
+
+ "github.com/productscience/inference/api/inference/inference"
+ "github.com/productscience/inference/x/inference/types"
+)
+
+type RandomSeedManager interface {
+ GenerateSeedInfo(epochIndex uint64)
+ GetSeedForEpoch(epochIndex uint64) apiconfig.SeedInfo
+ CreateNewSeed(epochIndex uint64) (*apiconfig.SeedInfo, error)
+ ChangeCurrentSeed()
+ RequestMoney(epochIndex uint64)
+}
+
+type RandomSeedManagerImpl struct {
+ transactionRecorder cosmosclient.CosmosMessageClient
+ configManager *apiconfig.ConfigManager
+}
+
+func NewRandomSeedManager(
+ transactionRecorder cosmosclient.CosmosMessageClient,
+ configManager *apiconfig.ConfigManager,
+) *RandomSeedManagerImpl {
+ return &RandomSeedManagerImpl{
+ transactionRecorder: transactionRecorder,
+ configManager: configManager,
+ }
+}
+
+func (rsm *RandomSeedManagerImpl) GenerateSeedInfo(epochIndex uint64) {
+ logging.Debug("Old Seed Signature", types.Claims, rsm.configManager.GetCurrentSeed())
+ newSeed, err := rsm.CreateNewSeed(epochIndex)
+ if err != nil {
+ logging.Error("Failed to get next seed signature", types.Claims, "error", err)
+ return
+ }
+ err = rsm.configManager.SetUpcomingSeed(*newSeed)
+ if err != nil {
+ logging.Error("Failed to set upcoming seed", types.Claims, "error", err)
+ return
+ }
+ logging.Debug("New Seed Signature", types.Claims, "seed", rsm.configManager.GetUpcomingSeed())
+
+ err = rsm.transactionRecorder.SubmitSeed(&inference.MsgSubmitSeed{
+ EpochIndex: rsm.configManager.GetUpcomingSeed().EpochIndex,
+ Signature: rsm.configManager.GetUpcomingSeed().Signature,
+ })
+ if err != nil {
+ logging.Error("Failed to send SubmitSeed transaction", types.Claims, "error", err)
+ }
+}
+
+func (rsm *RandomSeedManagerImpl) ChangeCurrentSeed() {
+ rsm.configManager.AdvanceCurrentSeed()
+}
+
+func (rsm *RandomSeedManagerImpl) GetSeedForEpoch(epochIndex uint64) apiconfig.SeedInfo {
+ previousSeed := rsm.configManager.GetPreviousSeed()
+ if previousSeed.EpochIndex == epochIndex && previousSeed.Seed != 0 {
+ return previousSeed
+ }
+
+ seed, err := rsm.CreateNewSeed(epochIndex)
+ if err != nil {
+ logging.Error("Failed to create new seed", types.Claims, "error", err)
+ return apiconfig.SeedInfo{}
+ }
+ return *seed
+}
+
+func (rsm *RandomSeedManagerImpl) RequestMoney(epochIndex uint64) {
+ // FIXME: we can also imagine a scenario where we weren't updating the seed for a few epochs
+ // e.g. generation fails a few times in a row for some reason
+ // Solution: query seed here?
+ seed := rsm.GetSeedForEpoch(epochIndex)
+
+ // This will only happen in tests, and it starts a long retry process that
+ // obscures good failures
+ if seed.EpochIndex == 0 {
+ return
+ }
+
+ logging.Info("IsSetNewValidatorsStage: sending ClaimRewards transaction", types.Claims, "seed", seed)
+ err := rsm.transactionRecorder.ClaimRewards(&inference.MsgClaimRewards{
+ Seed: seed.Seed,
+ EpochIndex: seed.EpochIndex,
+ })
+ if err != nil {
+ logging.Error("Failed to send ClaimRewards transaction", types.Claims, "error", err)
+ }
+}
+
+func (rsm *RandomSeedManagerImpl) CreateNewSeed(epochIndex uint64) (*apiconfig.SeedInfo, error) {
+ newSeed, err := rsm.createSeedForEpoch(epochIndex)
+ if err != nil {
+ logging.Error("Failed to get seedBytes", types.Claims, "error", err)
+ return nil, err
+ }
+
+ // Encode seed for signing
+ seedBytes := make([]byte, 8)
+ binary.BigEndian.PutUint64(seedBytes, uint64(newSeed))
+
+ signature, err := rsm.transactionRecorder.SignBytes(seedBytes)
+ if err != nil {
+ logging.Error("Failed to sign bytes", types.Claims, "error", err)
+ return nil, err
+ }
+
+ return &apiconfig.SeedInfo{
+ Seed: newSeed,
+ EpochIndex: epochIndex,
+ Signature: hex.EncodeToString(signature),
+ }, nil
+}
+
+func (rsm *RandomSeedManagerImpl) createSeedForEpoch(epoch uint64) (int64, error) {
+ initialSeedBytes := make([]byte, 8)
+ binary.BigEndian.PutUint64(initialSeedBytes, epoch)
+
+ signed, err := rsm.transactionRecorder.SignBytes(initialSeedBytes)
+ if err != nil {
+ logging.Error("Failed to sign bytes", types.Claims, "error", err)
+ return 0, err
+ }
+
+ signed8bytes := signed[:8]
+ newSeed := int64(binary.BigEndian.Uint64(signed8bytes[:]) & ((1 << 63) - 1))
+ if newSeed == 0 {
+ newSeed = 1
+ }
+
+ return newSeed, nil
+}
diff --git a/decentralized-api/internal/server/admin/bls_handlers.go b/decentralized-api/internal/server/admin/bls_handlers.go
new file mode 100644
index 000000000..4b2b86c8d
--- /dev/null
+++ b/decentralized-api/internal/server/admin/bls_handlers.go
@@ -0,0 +1,71 @@
+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)
+}
diff --git a/decentralized-api/internal/server/admin/bridge_handlers.go b/decentralized-api/internal/server/admin/bridge_handlers.go
new file mode 100644
index 000000000..aadee7284
--- /dev/null
+++ b/decentralized-api/internal/server/admin/bridge_handlers.go
@@ -0,0 +1,57 @@
+package admin
+
+import (
+ "io"
+ "log/slog"
+ "strings"
+
+ pserver "decentralized-api/internal/server/public"
+
+ "github.com/labstack/echo/v4"
+)
+
+// postBridgeBlock handles POST requests to submit finalized blocks with optional receipts
+func (s *Server) postBridgeBlock(c echo.Context) error {
+ // Debug: Log raw request body
+ rawBody := c.Request().Body
+ bodyBytes, err := io.ReadAll(rawBody)
+ if err != nil {
+ slog.Error("Failed to read request body", "error", err)
+ return c.JSON(400, map[string]string{"error": "Failed to read request body"})
+ }
+
+ // 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)))
+
+ var blockData pserver.BridgeBlock
+ if err := c.Bind(&blockData); err != nil {
+ slog.Error("Failed to decode block data", "error", err)
+ return c.JSON(400, map[string]string{"error": "Invalid request body: " + err.Error()})
+ }
+
+ // Validate required fields
+ if blockData.BlockNumber == "" || blockData.ReceiptsRoot == "" || blockData.OriginChain == "" {
+ return c.JSON(400, map[string]string{"error": "Required fields missing: blockNumber, receiptsRoot, originChain"})
+ }
+
+ slog.Info("Received finalized block",
+ "blockNumber", blockData.BlockNumber,
+ "originChain", blockData.OriginChain,
+ "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()),
+ })
+}
diff --git a/decentralized-api/internal/server/admin/debug_training_endpoint.go b/decentralized-api/internal/server/admin/debug_training_endpoint.go
new file mode 100644
index 000000000..c97541f4e
--- /dev/null
+++ b/decentralized-api/internal/server/admin/debug_training_endpoint.go
@@ -0,0 +1,43 @@
+package admin
+
+import (
+ "github.com/labstack/echo/v4"
+ "github.com/productscience/inference/api/inference/inference"
+ "net/http"
+ "strconv"
+)
+
+type CreateDummyTrainingTaskDto struct {
+ TaskId uint64 `json:"task_id"`
+ NumNodes int32 `json:"num_nodes"`
+}
+
+func (s *Server) postDummyTrainingTask(ctx echo.Context) error {
+ var body CreateDummyTrainingTaskDto
+ if err := ctx.Bind(&body); err != nil {
+ return echo.NewHTTPError(http.StatusBadRequest, err)
+ }
+
+ assignees := make([]*inference.TrainingTaskAssignee, body.NumNodes)
+ for i := 0; i < int(body.NumNodes); i++ {
+ assignees[i] = &inference.TrainingTaskAssignee{
+ Participant: "participant" + strconv.Itoa(i),
+ NodeIds: []string{strconv.Itoa(i)},
+ }
+ }
+
+ msg := &inference.MsgCreateDummyTrainingTask{
+ Creator: s.recorder.GetAccountAddress(),
+ Task: &inference.TrainingTask{
+ Id: body.TaskId,
+ RequestedBy: s.recorder.GetAccountAddress(),
+ Assignees: assignees,
+ },
+ }
+ dst := &inference.MsgCreateDummyTrainingTaskResponse{}
+ err := s.recorder.SendTransactionSyncNoRetry(msg, dst)
+ if err != nil {
+ return echo.NewHTTPError(http.StatusInternalServerError, err)
+ }
+ return ctx.JSON(http.StatusOK, dst)
+}
diff --git a/decentralized-api/internal/server/admin/entity.go b/decentralized-api/internal/server/admin/entity.go
new file mode 100644
index 000000000..6d014721b
--- /dev/null
+++ b/decentralized-api/internal/server/admin/entity.go
@@ -0,0 +1,15 @@
+package admin
+
+type UnitOfComputePriceProposalDto struct {
+ Price uint64 `json:"price"`
+ Denom string `json:"denom"`
+}
+
+type RegisterModelDto struct {
+ Id string `json:"id"`
+ ContextInAiTokens uint64 `json:"context_in_ai_tokens"`
+ Quantization string `json:"quantization"`
+ InputPriceInAiTokens uint64 `json:"input_price_in_ai_tokens"`
+ OutputPriceInAiTokens uint64 `json:"output_price_in_ai_tokens"`
+ UnitsOfComputePerToken uint64 `json:"units_of_compute_per_token"`
+}
diff --git a/decentralized-api/internal/server/admin/errors.go b/decentralized-api/internal/server/admin/errors.go
new file mode 100644
index 000000000..6653b0a8f
--- /dev/null
+++ b/decentralized-api/internal/server/admin/errors.go
@@ -0,0 +1,8 @@
+package admin
+
+import (
+ "github.com/labstack/echo/v4"
+ "net/http"
+)
+
+var ErrNoMessagesFoundInTx = echo.NewHTTPError(http.StatusBadRequest, "no messages found in tx")
diff --git a/decentralized-api/internal/server/admin/node_handlers.go b/decentralized-api/internal/server/admin/node_handlers.go
new file mode 100644
index 000000000..54f3665c8
--- /dev/null
+++ b/decentralized-api/internal/server/admin/node_handlers.go
@@ -0,0 +1,270 @@
+package admin
+
+import (
+ "decentralized-api/apiconfig"
+ "decentralized-api/broker"
+ "decentralized-api/logging"
+ "fmt"
+ "net/http"
+
+ "github.com/labstack/echo/v4"
+ "github.com/productscience/inference/x/inference/types"
+)
+
+func (s *Server) getNodes(ctx echo.Context) error {
+ nodes, err := s.nodeBroker.GetNodes()
+ if err != nil {
+ logging.Error("Error getting nodes", types.Nodes, "error", err)
+ return err
+ }
+ return ctx.JSON(http.StatusOK, nodes)
+}
+
+func (s *Server) deleteNode(ctx echo.Context) error {
+ nodeId := ctx.Param("id")
+ logging.Info("Deleting node", types.Nodes, "node", nodeId)
+ response := make(chan bool, 2)
+
+ err := s.nodeBroker.QueueMessage(broker.RemoveNode{
+ NodeId: nodeId,
+ Response: response,
+ })
+ if err != nil {
+ logging.Error("Error deleting node", types.Nodes, "error", err)
+ return err
+ }
+ node := <-response
+ syncNodesWithConfig(s.nodeBroker, s.configManager)
+
+ return ctx.JSON(http.StatusOK, node)
+}
+
+func syncNodesWithConfig(nodeBroker *broker.Broker, config *apiconfig.ConfigManager) {
+ nodes, err := nodeBroker.GetNodes()
+ iNodes := make([]apiconfig.InferenceNodeConfig, len(nodes))
+ for i, n := range nodes {
+ node := n.Node
+
+ models := make(map[string]apiconfig.ModelConfig)
+ for model, cfg := range node.Models {
+ models[model] = apiconfig.ModelConfig{Args: cfg.Args}
+ }
+
+ iNodes[i] = apiconfig.InferenceNodeConfig{
+ Host: node.Host,
+ InferenceSegment: node.InferenceSegment,
+ InferencePort: node.InferencePort,
+ PoCSegment: node.PoCSegment,
+ PoCPort: node.PoCPort,
+ Models: models,
+ Id: node.Id,
+ MaxConcurrent: node.MaxConcurrent,
+ Hardware: node.Hardware,
+ }
+ }
+ err = config.SetNodes(iNodes)
+ if err != nil {
+ logging.Error("Error writing config", types.Nodes, "error", err)
+ }
+}
+
+func (s *Server) createNewNodes(ctx echo.Context) error {
+ var newNodes []apiconfig.InferenceNodeConfig
+ if err := ctx.Bind(&newNodes); err != nil {
+ logging.Error("Error decoding request", types.Nodes, "error", err)
+ return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("invalid request body: %v", err))
+ }
+
+ var outputNodes []apiconfig.InferenceNodeConfig
+ var errors []string
+ for i, node := range newNodes {
+ newNode, err := s.addNode(node)
+ if err != nil {
+ errorMsg := fmt.Sprintf("node[%d] (id: %s): %v", i, node.Id, err)
+ errors = append(errors, errorMsg)
+ logging.Error("Failed to add node in batch", types.Nodes, "index", i, "node_id", node.Id, "error", err)
+ continue
+ }
+ outputNodes = append(outputNodes, newNode)
+ }
+
+ if len(errors) > 0 && len(outputNodes) == 0 {
+ // All nodes failed
+ return echo.NewHTTPError(http.StatusBadRequest, map[string]interface{}{
+ "error": "all nodes failed validation",
+ "errors": errors,
+ })
+ }
+
+ if len(errors) > 0 {
+ // Some nodes succeeded, some failed
+ return ctx.JSON(http.StatusPartialContent, map[string]interface{}{
+ "nodes": outputNodes,
+ "errors": errors,
+ })
+ }
+
+ return ctx.JSON(http.StatusCreated, outputNodes)
+}
+
+func (s *Server) createNewNode(ctx echo.Context) error {
+ var newNode apiconfig.InferenceNodeConfig
+ if err := ctx.Bind(&newNode); err != nil {
+ logging.Error("Error decoding request", types.Nodes, "error", err)
+ return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("invalid request body: %v", err))
+ }
+
+ // Upsert: if node exists, update it; otherwise, create
+ nodes, err := s.nodeBroker.GetNodes()
+ if err != nil {
+ logging.Error("Error reading nodes", types.Nodes, "error", err)
+ return echo.NewHTTPError(http.StatusInternalServerError, fmt.Sprintf("failed to read nodes: %v", err))
+ }
+
+ exists := false
+ for _, n := range nodes {
+ if n.Node.Id == newNode.Id {
+ exists = true
+ break
+ }
+ }
+
+ if exists {
+ command := broker.NewUpdateNodeCommand(newNode)
+ err := s.nodeBroker.QueueMessage(command)
+ if err != nil {
+ return echo.NewHTTPError(http.StatusInternalServerError, fmt.Sprintf("failed to queue update command: %v", err))
+ }
+ response := <-command.Response
+ if response.Error != nil {
+ return echo.NewHTTPError(http.StatusInternalServerError, fmt.Sprintf("failed to update node: %v", response.Error))
+ }
+ node := response.Node
+ if node == nil {
+ // Model check failed - validation already passed above
+ return echo.NewHTTPError(http.StatusBadRequest, "failed to update node: one or more models are not valid governance models. Check logs for details.")
+ }
+ // sync config file with updated node list
+ syncNodesWithConfig(s.nodeBroker, s.configManager)
+ return ctx.JSON(http.StatusOK, node)
+ } else {
+ node, err := s.addNode(newNode)
+ if err != nil {
+ return err
+ }
+ return ctx.JSON(http.StatusOK, node)
+ }
+}
+
+func (s *Server) addNode(newNode apiconfig.InferenceNodeConfig) (apiconfig.InferenceNodeConfig, error) {
+ // Validate before queuing to provide clear error messages to API users
+ cmd := broker.NewRegisterNodeCommand(newNode)
+ err := s.nodeBroker.QueueMessage(cmd)
+ if err != nil {
+ return apiconfig.InferenceNodeConfig{}, echo.NewHTTPError(http.StatusInternalServerError, fmt.Sprintf("failed to queue register command: %v", err))
+ }
+
+ response := <-cmd.Response
+ if response.Error != nil {
+ logging.Error("Error creating new node", types.Nodes, "error", response.Error, "node_id", newNode.Id)
+ return apiconfig.InferenceNodeConfig{}, echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("failed to create node: %v", response.Error))
+ }
+
+ node := response.Node
+ if node == nil {
+ // Model check failed - validation already passed above
+ logging.Error("Error creating new node - model validation failed", types.Nodes, "node_id", newNode.Id)
+ return apiconfig.InferenceNodeConfig{}, echo.NewHTTPError(http.StatusBadRequest, "failed to create node: one or more models are not valid governance models. Check logs for details.")
+ }
+
+ newNodes := append(s.configManager.GetNodes(), *node)
+ err = s.configManager.SetNodes(newNodes)
+ if err != nil {
+ logging.Error("Error writing config", types.Config, "error", err, "node", newNode.Id)
+ return apiconfig.InferenceNodeConfig{}, echo.NewHTTPError(http.StatusInternalServerError, fmt.Sprintf("failed to save node configuration: %v", err))
+ }
+
+ return *node, nil
+}
+
+// enableNode handles POST /admin/v1/nodes/:id/enable
+func (s *Server) enableNode(c echo.Context) error {
+ nodeId := c.Param("id")
+ if nodeId == "" {
+ return c.JSON(http.StatusBadRequest, map[string]string{
+ "error": "node id is required",
+ })
+ }
+
+ response := make(chan error, 2)
+ err := s.nodeBroker.QueueMessage(broker.SetNodeAdminStateCommand{
+ NodeId: nodeId,
+ Enabled: true,
+ Response: response,
+ })
+ if err != nil {
+ return c.JSON(http.StatusInternalServerError, map[string]string{
+ "error": "failed to queue command: " + err.Error(),
+ })
+ }
+
+ if err := <-response; err != nil {
+ return c.JSON(http.StatusNotFound, map[string]string{
+ "error": err.Error(),
+ })
+ }
+
+ return c.JSON(http.StatusOK, map[string]interface{}{
+ "message": "node enabled successfully",
+ "node_id": nodeId,
+ })
+}
+
+// disableNode handles POST /admin/v1/nodes/:id/disable
+func (s *Server) disableNode(c echo.Context) error {
+ nodeId := c.Param("id")
+ if nodeId == "" {
+ return c.JSON(http.StatusBadRequest, map[string]string{
+ "error": "node id is required",
+ })
+ }
+
+ response := make(chan error, 2)
+ err := s.nodeBroker.QueueMessage(broker.SetNodeAdminStateCommand{
+ NodeId: nodeId,
+ Enabled: false,
+ Response: response,
+ })
+ if err != nil {
+ return c.JSON(http.StatusInternalServerError, map[string]string{
+ "error": "failed to queue command: " + err.Error(),
+ })
+ }
+
+ if err := <-response; err != nil {
+ return c.JSON(http.StatusNotFound, map[string]string{
+ "error": err.Error(),
+ })
+ }
+
+ return c.JSON(http.StatusOK, map[string]interface{}{
+ "message": "node disabled successfully",
+ "node_id": nodeId,
+ })
+}
+
+// exportDb returns a human-readable JSON snapshot of DB-backed dynamic config
+func (s *Server) exportDb(c echo.Context) error {
+ ctx := c.Request().Context()
+ db := s.configManager.SqlDb()
+ if db == nil || db.GetDb() == nil {
+ logging.Error("DB not initialized", types.Nodes)
+ return c.JSON(http.StatusInternalServerError, map[string]string{"error": "db not initialized"})
+ }
+ payload, err := apiconfig.ExportAllDb(ctx, db.GetDb())
+ if err != nil {
+ logging.Error("Failed to export DB state", types.Nodes, "error", err)
+ return c.JSON(http.StatusInternalServerError, map[string]string{"error": err.Error()})
+ }
+ return c.JSON(http.StatusOK, payload)
+}
diff --git a/decentralized-api/internal/server/admin/register_model_handler.go b/decentralized-api/internal/server/admin/register_model_handler.go
new file mode 100644
index 000000000..f8d0f5a41
--- /dev/null
+++ b/decentralized-api/internal/server/admin/register_model_handler.go
@@ -0,0 +1,42 @@
+package admin
+
+import (
+ "decentralized-api/cosmosclient"
+ "decentralized-api/logging"
+ "fmt"
+ "github.com/labstack/echo/v4"
+ "github.com/productscience/inference/api/inference/inference"
+ "github.com/productscience/inference/x/inference/types"
+ "net/http"
+)
+
+func (s *Server) registerModel(ctx echo.Context) error {
+ var body RegisterModelDto
+ if err := ctx.Bind(&body); err != nil {
+ return echo.NewHTTPError(http.StatusBadRequest, err)
+ }
+
+ authority := cosmosclient.GetProposalMsgSigner()
+ logging.Info("RegisterModel", types.Inferences, "authority", authority)
+ msg := &inference.MsgRegisterModel{
+ Authority: authority,
+ ProposedBy: s.recorder.GetAccountAddress(),
+ Id: body.Id,
+ UnitsOfComputePerToken: body.UnitsOfComputePerToken,
+ }
+
+ proposalData := &cosmosclient.ProposalData{
+ Metadata: "Created via decentralized-api",
+ Title: fmt.Sprintf("%s model proposal", body.Id),
+ Summary: fmt.Sprintf("This proposal suggests to serve a model %s and estimates it will take %d units of compute per token", body.Id, body.UnitsOfComputePerToken),
+ Expedited: false,
+ }
+
+ // TODO: make it a function of cosmosClient interface?
+ err := cosmosclient.SubmitProposal(s.recorder, msg, proposalData)
+ if err != nil {
+ logging.Error("SubmitProposal failed", types.Inferences, "err", err)
+ return err
+ }
+ return ctx.NoContent(http.StatusOK)
+}
diff --git a/decentralized-api/internal/server/admin/server.go b/decentralized-api/internal/server/admin/server.go
new file mode 100644
index 000000000..c37b1d060
--- /dev/null
+++ b/decentralized-api/internal/server/admin/server.go
@@ -0,0 +1,121 @@
+package admin
+
+import (
+ "decentralized-api/apiconfig"
+ "decentralized-api/broker"
+ cosmos_client "decentralized-api/cosmosclient"
+ "decentralized-api/internal/server/middleware"
+ pserver "decentralized-api/internal/server/public"
+ "decentralized-api/internal/validation"
+
+ upgradetypes "cosmossdk.io/x/upgrade/types"
+ blstypes "github.com/productscience/inference/x/bls/types"
+
+ "github.com/cosmos/cosmos-sdk/codec"
+ codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+ authztypes "github.com/cosmos/cosmos-sdk/x/authz"
+ banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
+ v1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1"
+ "github.com/labstack/echo/v4"
+ "github.com/productscience/inference/app"
+ collateraltypes "github.com/productscience/inference/x/collateral/types"
+ "github.com/productscience/inference/x/inference/types"
+ restrictionstypes "github.com/productscience/inference/x/restrictions/types"
+)
+
+type Server struct {
+ e *echo.Echo
+ nodeBroker *broker.Broker
+ configManager *apiconfig.ConfigManager
+ recorder cosmos_client.CosmosMessageClient
+ validator *validation.InferenceValidator
+ cdc *codec.ProtoCodec
+ blockQueue *pserver.BridgeQueue
+}
+
+func NewServer(
+ recorder cosmos_client.CosmosMessageClient,
+ nodeBroker *broker.Broker,
+ configManager *apiconfig.ConfigManager,
+ validator *validation.InferenceValidator,
+ blockQueue *pserver.BridgeQueue) *Server {
+ cdc := getCodec()
+
+ e := echo.New()
+ e.HTTPErrorHandler = middleware.TransparentErrorHandler
+ s := &Server{
+ e: e,
+ nodeBroker: nodeBroker,
+ configManager: configManager,
+ recorder: recorder,
+ validator: validator,
+ cdc: cdc,
+ blockQueue: blockQueue,
+ }
+
+ e.Use(middleware.LoggingMiddleware)
+ g := e.Group("/admin/v1/")
+
+ g.POST("nodes", s.createNewNode)
+ g.POST("nodes/batch", s.createNewNodes)
+ // For explicit updates, also allow PUT on a single node
+ g.PUT("nodes/:id", s.createNewNode)
+ g.GET("nodes/upgrade-status", s.getUpgradeStatus)
+ g.POST("nodes/version-status", s.postVersionStatus)
+ g.GET("nodes", s.getNodes)
+ g.DELETE("nodes/:id", s.deleteNode)
+ g.POST("nodes/:id/enable", s.enableNode)
+ g.POST("nodes/:id/disable", s.disableNode)
+
+ g.POST("unit-of-compute-price-proposal", s.postUnitOfComputePriceProposal)
+ g.GET("unit-of-compute-price-proposal", s.getUnitOfComputePriceProposal)
+
+ g.POST("models", s.registerModel)
+ g.POST("tx/send", s.sendTransaction)
+
+ g.POST("bls/request", s.postRequestThresholdSignature)
+
+ g.POST("debug/create-dummy-training-task", s.postDummyTrainingTask)
+
+ // Export DB state (human-readable JSON) for admin purposes
+ g.GET("export/db", s.exportDb)
+
+ // Return current unsanitized config as JSON
+ g.GET("config", s.getConfig)
+
+ // Manual validation recovery and claim endpoint
+ g.POST("claim-reward/recover", s.postClaimRewardRecover)
+
+ // EXPERIMENTAL: Setup and health report endpoint for participant onboarding
+ g.GET("setup/report", s.getSetupReport)
+
+ // Bridge
+ g.POST("bridge/block", s.postBridgeBlock)
+
+ return s
+}
+
+func getCodec() *codec.ProtoCodec {
+ interfaceRegistry := codectypes.NewInterfaceRegistry()
+ app.RegisterLegacyModules(interfaceRegistry)
+ types.RegisterInterfaces(interfaceRegistry)
+ banktypes.RegisterInterfaces(interfaceRegistry)
+ authztypes.RegisterInterfaces(interfaceRegistry)
+ v1.RegisterInterfaces(interfaceRegistry)
+ upgradetypes.RegisterInterfaces(interfaceRegistry)
+ collateraltypes.RegisterInterfaces(interfaceRegistry)
+ restrictionstypes.RegisterInterfaces(interfaceRegistry)
+ blstypes.RegisterInterfaces(interfaceRegistry)
+ cdc := codec.NewProtoCodec(interfaceRegistry)
+ return cdc
+}
+
+func (s *Server) Start(addr string) {
+ go s.e.Start(addr)
+}
+
+// getConfig returns the current configuration as JSON (unsanitized)
+func (s *Server) getConfig(c echo.Context) error {
+ cfg := s.configManager.GetConfig()
+ return c.JSONPretty(200, cfg, " ")
+}
diff --git a/decentralized-api/internal/server/admin/server_test.go b/decentralized-api/internal/server/admin/server_test.go
new file mode 100644
index 000000000..1935a8bd6
--- /dev/null
+++ b/decentralized-api/internal/server/admin/server_test.go
@@ -0,0 +1,180 @@
+package admin
+
+import (
+ "bytes"
+ "context"
+ "decentralized-api/apiconfig"
+ "decentralized-api/broker"
+ "decentralized-api/cosmosclient"
+ "decentralized-api/mlnodeclient"
+ "encoding/json"
+ "errors"
+ "net/http"
+ "net/http/httptest"
+ "os"
+ "testing"
+ "time"
+
+ "github.com/knadh/koanf/providers/file"
+ "github.com/labstack/echo/v4"
+ "github.com/productscience/inference/x/inference/types"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/mock"
+ "google.golang.org/grpc"
+)
+
+type mockParticipantInfo struct {
+ mock.Mock
+}
+
+func (m *mockParticipantInfo) GetAddress() string {
+ args := m.Called()
+ return args.String(0)
+}
+
+func (m *mockParticipantInfo) GetPubKey() string {
+ args := m.Called()
+ return args.String(0)
+}
+
+// mockInferenceQueryClient is a mock implementation of the inference QueryClient for testing
+type mockInferenceQueryClient struct {
+ types.QueryClient
+ mock.Mock
+}
+
+func (m *mockInferenceQueryClient) 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 setupTestServer(t *testing.T) (*Server, *apiconfig.ConfigManager, *mlnodeclient.MockClientFactory) {
+ // 1. Config Manager
+ tmpFile, err := os.CreateTemp("", "config-*.yaml")
+ assert.NoError(t, err)
+ t.Cleanup(func() { os.Remove(tmpFile.Name()) })
+
+ _, err = tmpFile.Write([]byte("nodes: []"))
+ assert.NoError(t, err)
+ tmpFile.Close()
+
+ configManager := &apiconfig.ConfigManager{
+ KoanProvider: file.Provider(tmpFile.Name()),
+ WriterProvider: apiconfig.NewFileWriteCloserProvider(tmpFile.Name()),
+ }
+ err = configManager.Load()
+ assert.NoError(t, err)
+
+ // 2. Broker Dependencies
+ mockCosmos := &cosmosclient.MockCosmosMessageClient{}
+ mockQueryClient := &mockInferenceQueryClient{}
+ mockQueryClient.On("ModelsAll", mock.Anything, mock.Anything).Return(&types.QueryModelsAllResponse{
+ Model: []types.Model{
+ {Id: "test-model"},
+ },
+ }, nil)
+ mockCosmos.On("NewInferenceQueryClient").Return(mockQueryClient)
+ bridge := broker.NewBrokerChainBridgeImpl(mockCosmos, "")
+ mockParticipant := &mockParticipantInfo{}
+ mockClientFactory := mlnodeclient.NewMockClientFactory()
+
+ mockParticipant.On("GetAddress").Return("test-participant")
+ mockCosmos.On("GetContext").Return(context.Background())
+
+ // 3. Broker
+ nodeBroker := broker.NewBroker(bridge, nil, mockParticipant, "", mockClientFactory, configManager)
+
+ // 4. Server
+ s := NewServer(mockCosmos, nodeBroker, configManager, nil, nil)
+
+ return s, configManager, mockClientFactory
+}
+
+func TestGetUpgradeStatus(t *testing.T) {
+ s, configManager, _ := setupTestServer(t)
+
+ t.Run("no upgrade plan", func(t *testing.T) {
+ req := httptest.NewRequest(http.MethodGet, "/admin/v1/nodes/upgrade-status", nil)
+ rec := httptest.NewRecorder()
+ s.e.ServeHTTP(rec, req)
+
+ assert.Equal(t, http.StatusOK, rec.Code)
+ assert.JSONEq(t, `{"message":"No upgrade plan active"}`, rec.Body.String())
+ })
+
+ t.Run("with upgrade plan", func(t *testing.T) {
+ version := "v1.2.3"
+ configManager.SetUpgradePlan(apiconfig.UpgradePlan{NodeVersion: version})
+ defer configManager.SetUpgradePlan(apiconfig.UpgradePlan{})
+
+ req := httptest.NewRequest(http.MethodGet, "/admin/v1/nodes/upgrade-status", nil)
+ rec := httptest.NewRecorder()
+ s.e.ServeHTTP(rec, req)
+
+ assert.Equal(t, http.StatusOK, rec.Code)
+ assert.JSONEq(t, `{}`, rec.Body.String()) // No nodes, so empty report
+ })
+}
+
+func TestPostVersionStatus(t *testing.T) {
+ s, configManager, mockClientFactory := setupTestServer(t)
+
+ nodeConfig := apiconfig.InferenceNodeConfig{
+ Id: "node-1",
+ Host: "localhost",
+ InferencePort: 8080,
+ InferenceSegment: "/api/v1",
+ PoCPort: 8081,
+ PoCSegment: "/api/v1",
+ MaxConcurrent: 3,
+ Models: map[string]apiconfig.ModelConfig{
+ "test-model": {Args: []string{}},
+ },
+ }
+ nodes := configManager.GetNodes()
+ nodes = append(nodes, nodeConfig)
+ err := configManager.SetNodes(nodes)
+ assert.NoError(t, err)
+ respChan := s.nodeBroker.LoadNodeToBroker(&nodeConfig)
+ select {
+ case response := <-respChan:
+ if response.Error != nil || response.Node == nil {
+ t.Fatal("failed to register node - node validation failed")
+ }
+ case <-time.After(1 * time.Second):
+ t.Fatal("timed out waiting for node to register")
+ }
+
+ t.Run("valid request", func(t *testing.T) {
+ version := "v1.2.4"
+ reqBody, _ := json.Marshal(versionStatusRequest{Version: version})
+ req := httptest.NewRequest(http.MethodPost, "/admin/v1/nodes/version-status", bytes.NewReader(reqBody))
+ req.Header.Set(echo.HeaderContentType, echo.MIMEApplicationJSON)
+ rec := httptest.NewRecorder()
+
+ // Pre-configure the mock client to return an error
+ pocURL := "http://localhost:8081/v1.2.4/api/v1"
+ mockClient := mockClientFactory.CreateClient(pocURL, "").(*mlnodeclient.MockClient)
+ mockClient.NodeStateError = errors.New("connection failed")
+
+ s.e.ServeHTTP(rec, req)
+
+ assert.Equal(t, http.StatusOK, rec.Code)
+ expected := `{"node-1":{"is_alive":false,"error":"connection failed"}}`
+ assert.JSONEq(t, expected, rec.Body.String())
+ })
+
+ t.Run("missing version", func(t *testing.T) {
+ reqBody, _ := json.Marshal(versionStatusRequest{})
+ req := httptest.NewRequest(http.MethodPost, "/admin/v1/nodes/version-status", bytes.NewReader(reqBody))
+ req.Header.Set(echo.HeaderContentType, echo.MIMEApplicationJSON)
+ rec := httptest.NewRecorder()
+
+ s.e.ServeHTTP(rec, req)
+
+ assert.Equal(t, http.StatusBadRequest, rec.Code)
+ })
+}
diff --git a/decentralized-api/internal/server/admin/setup_report.go b/decentralized-api/internal/server/admin/setup_report.go
new file mode 100644
index 000000000..1d6963808
--- /dev/null
+++ b/decentralized-api/internal/server/admin/setup_report.go
@@ -0,0 +1,800 @@
+package admin
+
+import (
+ "context"
+ "decentralized-api/apiconfig"
+ "decentralized-api/cosmosclient"
+ "encoding/base64"
+ "encoding/json"
+ "fmt"
+ "net/http"
+ "net/url"
+ "strings"
+ "sync"
+ "time"
+
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ authztypes "github.com/cosmos/cosmos-sdk/x/authz"
+ "github.com/labstack/echo/v4"
+ "github.com/productscience/inference/x/inference"
+ "github.com/productscience/inference/x/inference/types"
+)
+
+// Type Definitions
+
+type SetupReport struct {
+ Experimental bool `json:"experimental"`
+ GeneratedAt time.Time `json:"generated_at"`
+ CachedUntil time.Time `json:"cached_until"`
+ OverallStatus CheckStatus `json:"overall_status"`
+ Checks []Check `json:"checks"`
+ Summary ReportSummary `json:"summary"`
+}
+
+type Check struct {
+ ID string `json:"id"`
+ Status CheckStatus `json:"status"`
+ Message string `json:"message"`
+ Details interface{} `json:"details,omitempty"`
+}
+
+type CheckStatus string
+
+const (
+ PASS CheckStatus = "PASS"
+ FAIL CheckStatus = "FAIL"
+ UNAVAILABLE CheckStatus = "UNAVAILABLE"
+)
+
+type ReportSummary struct {
+ TotalChecks int `json:"total_checks"`
+ PassedChecks int `json:"passed_checks"`
+ FailedChecks int `json:"failed_checks"`
+ UnavailableChecks int `json:"unavailable_checks"`
+ Issues []string `json:"issues"`
+ Recommendations []string `json:"recommendations"`
+}
+
+type GPUDeviceInfo struct {
+ Index int `json:"index"`
+ Name string `json:"name"`
+ TotalMemoryGB float64 `json:"total_memory_gb"`
+ FreeMemoryGB float64 `json:"free_memory_gb"`
+ UsedMemoryGB float64 `json:"used_memory_gb"`
+ Utilization *int `json:"utilization_percent,omitempty"`
+ Temperature *int `json:"temperature_c,omitempty"`
+ Available bool `json:"available"`
+ Error *string `json:"error,omitempty"`
+}
+
+// Cache Management
+
+var (
+ cachedReport *SetupReport
+ cachedReportMutex sync.RWMutex
+)
+
+// EXPERIMENTAL: Setup report endpoint for participant onboarding validation
+func (s *Server) getSetupReport(c echo.Context) error {
+ ctx := c.Request().Context()
+
+ cachedReportMutex.RLock()
+ if cachedReport != nil && time.Now().Before(cachedReport.CachedUntil) {
+ report := cachedReport
+ cachedReportMutex.RUnlock()
+ return c.JSON(http.StatusOK, report)
+ }
+ cachedReportMutex.RUnlock()
+
+ report, err := s.generateSetupReport(ctx)
+ if err != nil {
+ if report != nil {
+ return c.JSON(http.StatusOK, report)
+ }
+ return echo.NewHTTPError(http.StatusInternalServerError, err.Error())
+ }
+
+ cachedReportMutex.Lock()
+ cachedReport = report
+ cachedReportMutex.Unlock()
+
+ return c.JSON(http.StatusOK, report)
+}
+
+func (s *Server) generateSetupReport(ctx context.Context) (*SetupReport, error) {
+ now := time.Now()
+ report := &SetupReport{
+ Experimental: true,
+ GeneratedAt: now,
+ CachedUntil: now.Add(1 * time.Minute),
+ Checks: []Check{},
+ }
+
+ checks := []Check{}
+ checks = append(checks, s.checkColdKey(ctx)...)
+ checks = append(checks, s.checkWarmKey(ctx)...)
+ checks = append(checks, s.checkPermissions(ctx))
+ checks = append(checks, s.checkConsensusKey(ctx)...)
+ checks = append(checks, s.checkParticipant(ctx))
+ checks = append(checks, s.checkMLNodes(ctx)...)
+ checks = append(checks, s.checkBlockSync(ctx))
+
+ report.Checks = checks
+ s.generateSummary(report)
+
+ return report, nil
+}
+
+func (s *Server) checkColdKey(ctx context.Context) []Check {
+ checks := []Check{}
+
+ nodeConfig := s.configManager.GetChainNodeConfig()
+ pubKey := s.recorder.GetAccountPubKey()
+ address := s.recorder.GetAccountAddress()
+
+ if pubKey == nil || address == "" || nodeConfig.AccountPublicKey == "" {
+ checks = append(checks, Check{
+ ID: "cold_key_configured",
+ Status: FAIL,
+ Message: "Cold key is not configured",
+ })
+ } else {
+ checks = append(checks, Check{
+ ID: "cold_key_configured",
+ Status: PASS,
+ Message: "Cold key is configured",
+ Details: map[string]interface{}{
+ "address": address,
+ "pubkey": nodeConfig.AccountPublicKey,
+ },
+ })
+ }
+
+ kr := s.recorder.GetKeyring()
+ _, err := (*kr).Key(address)
+ if err == nil {
+ checks = append(checks, Check{
+ ID: "cold_key_not_in_keyring",
+ Status: FAIL,
+ Message: "Cold key is in keyring (should only be in environment config)",
+ })
+ } else {
+ checks = append(checks, Check{
+ ID: "cold_key_not_in_keyring",
+ Status: PASS,
+ Message: "Cold key correctly NOT in keyring",
+ })
+ }
+
+ return checks
+}
+
+func (s *Server) checkWarmKey(ctx context.Context) []Check {
+ checks := []Check{}
+
+ nodeConfig := s.configManager.GetChainNodeConfig()
+ keyName := nodeConfig.SignerKeyName
+ kr := s.recorder.GetKeyring()
+
+ keyRecord, err := (*kr).Key(keyName)
+ if err != nil {
+ checks = append(checks, Check{
+ ID: "warm_key_in_keyring",
+ Status: FAIL,
+ Message: fmt.Sprintf("Warm key '%s' not found in keyring: %s", keyName, err.Error()),
+ })
+ return checks
+ }
+
+ checks = append(checks, Check{
+ ID: "warm_key_in_keyring",
+ Status: PASS,
+ Message: fmt.Sprintf("Warm key '%s' found in keyring", keyName),
+ })
+
+ pubKey, err := keyRecord.GetPubKey()
+ if err != nil {
+ checks = append(checks, Check{
+ ID: "warm_key_address_match",
+ Status: UNAVAILABLE,
+ Message: fmt.Sprintf("Failed to get public key from keyring: %s", err.Error()),
+ })
+ return checks
+ }
+
+ apiAccount := s.recorder.GetApiAccount()
+ addr, err := sdk.Bech32ifyAddressBytes(apiAccount.AddressPrefix, pubKey.Address())
+ if err != nil {
+ checks = append(checks, Check{
+ ID: "warm_key_address_match",
+ Status: UNAVAILABLE,
+ Message: fmt.Sprintf("Failed to convert address: %s", err.Error()),
+ })
+ return checks
+ }
+
+ signerAddr := s.recorder.GetSignerAddress()
+ if addr != signerAddr {
+ checks = append(checks, Check{
+ ID: "warm_key_address_match",
+ Status: FAIL,
+ Message: fmt.Sprintf("Warm key address mismatch: keyring=%s, signer=%s", addr, signerAddr),
+ })
+ } else {
+ checks = append(checks, Check{
+ ID: "warm_key_address_match",
+ Status: PASS,
+ Message: "Warm key address matches signer address",
+ })
+ }
+
+ return checks
+}
+
+func (s *Server) checkPermissions(ctx context.Context) Check {
+ coldKeyAddr := s.recorder.GetAccountAddress()
+ warmKeyAddr := s.recorder.GetSignerAddress()
+
+ authzQueryClient := authztypes.NewQueryClient(s.recorder.GetClientContext())
+ grantsResp, err := authzQueryClient.GranteeGrants(ctx, &authztypes.QueryGranteeGrantsRequest{
+ Grantee: warmKeyAddr,
+ })
+
+ if err != nil {
+ return Check{
+ ID: "permissions_granted",
+ Status: UNAVAILABLE,
+ Message: fmt.Sprintf("Unable to check permissions: %s", err.Error()),
+ }
+ }
+
+ grantedFromColdKey := make(map[string]*authztypes.GrantAuthorization)
+ 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
+ }
+ }
+ }
+
+ requiredPerms := []string{}
+ for _, msgType := range inference.InferenceOperationKeyPerms {
+ requiredPerms = append(requiredPerms, sdk.MsgTypeURL(msgType))
+ }
+
+ missingPerms := []string{}
+ expiringSoon := []string{}
+ blockTime := time.Now()
+
+ for _, msgTypeUrl := range requiredPerms {
+ grant, found := grantedFromColdKey[msgTypeUrl]
+ if !found {
+ missingPerms = append(missingPerms, msgTypeUrl)
+ continue
+ }
+
+ if grant.Expiration != nil && grant.Expiration.Before(blockTime.Add(7*24*time.Hour)) {
+ expiringSoon = append(expiringSoon, msgTypeUrl)
+ }
+ }
+
+ status := PASS
+ message := fmt.Sprintf("All %d required permissions granted", len(requiredPerms))
+
+ if len(missingPerms) > 0 {
+ status = FAIL
+ message = fmt.Sprintf("Missing %d of %d required permissions", len(missingPerms), len(requiredPerms))
+ } else if len(expiringSoon) > 0 {
+ message = fmt.Sprintf("All %d permissions granted, but %d expiring soon", len(requiredPerms), len(expiringSoon))
+ }
+
+ details := map[string]interface{}{
+ "cold_key_address": coldKeyAddr,
+ "warm_key_address": warmKeyAddr,
+ "granted": len(requiredPerms) - len(missingPerms),
+ "missing": len(missingPerms),
+ }
+
+ if len(missingPerms) > 0 {
+ details["missing_permissions"] = missingPerms
+ }
+
+ if len(expiringSoon) > 0 {
+ details["expiring_soon"] = expiringSoon
+ }
+
+ return Check{
+ ID: "permissions_granted",
+ Status: status,
+ Message: message,
+ Details: details,
+ }
+}
+
+func (s *Server) checkConsensusKey(ctx context.Context) []Check {
+ checks := []Check{}
+
+ // Get consensus key from local node
+ chainNodeUrl := s.configManager.GetChainNodeConfig().Url
+ rpcClient, err := cosmosclient.NewRpcClient(chainNodeUrl)
+ if err != nil {
+ checks = append(checks, Check{
+ ID: "consensus_key_match",
+ Status: UNAVAILABLE,
+ Message: fmt.Sprintf("Failed to connect to chain node: %s", err.Error()),
+ })
+ return checks
+ }
+
+ status, err := rpcClient.Status(context.Background())
+ if err != nil {
+ checks = append(checks, Check{
+ ID: "consensus_key_match",
+ Status: UNAVAILABLE,
+ Message: fmt.Sprintf("Failed to get node status: %s", err.Error()),
+ })
+ return checks
+ }
+
+ consensusKey := status.ValidatorInfo.PubKey
+ consensusKeyBase64 := base64.StdEncoding.EncodeToString(consensusKey.Bytes())
+
+ // Get participant info
+ myAddress := s.recorder.GetAccountAddress()
+ queryClient := s.recorder.NewInferenceQueryClient()
+ participantResp, err := queryClient.Participant(ctx, &types.QueryGetParticipantRequest{
+ Index: myAddress,
+ })
+
+ if err != nil {
+ checks = append(checks, Check{
+ ID: "consensus_key_match",
+ Status: UNAVAILABLE,
+ Message: fmt.Sprintf("Failed to query participant: %s", err.Error()),
+ })
+ return checks
+ }
+
+ participant := participantResp.Participant
+
+ // Check 1: Consensus key matches
+ if participant.ValidatorKey != consensusKeyBase64 {
+ checks = append(checks, Check{
+ ID: "consensus_key_match",
+ Status: FAIL,
+ Message: fmt.Sprintf("Consensus key mismatch: local=%s, registered=%s", consensusKeyBase64, participant.ValidatorKey),
+ Details: map[string]interface{}{
+ "consensus_pubkey": consensusKeyBase64,
+ "registered_pubkey": participant.ValidatorKey,
+ },
+ })
+ } else {
+ checks = append(checks, Check{
+ ID: "consensus_key_match",
+ Status: PASS,
+ Message: "Consensus key matches participant registration",
+ Details: map[string]interface{}{
+ "consensus_pubkey": consensusKeyBase64,
+ },
+ })
+ }
+
+ // Check 2: Active in current epoch
+ currentEpochResp, err := queryClient.GetCurrentEpoch(ctx, &types.QueryGetCurrentEpochRequest{})
+ if err != nil {
+ checks = append(checks, Check{
+ ID: "active_in_epoch",
+ Status: UNAVAILABLE,
+ Message: fmt.Sprintf("Failed to get current epoch: %s", err.Error()),
+ })
+ } else {
+ currentEpoch := currentEpochResp.Epoch
+
+ // Query active participants using store key
+ dataKey := types.ActiveParticipantsFullKey(currentEpoch)
+ result, err := cosmosclient.QueryByKey(rpcClient, "inference", dataKey)
+
+ if err != nil || len(result.Response.Value) == 0 {
+ checks = append(checks, Check{
+ ID: "active_in_epoch",
+ Status: UNAVAILABLE,
+ Message: fmt.Sprintf("Failed to query active participants for epoch %d", currentEpoch),
+ })
+ } else {
+ var activeParticipants types.ActiveParticipants
+ if err := s.cdc.Unmarshal(result.Response.Value, &activeParticipants); err != nil {
+ checks = append(checks, Check{
+ ID: "active_in_epoch",
+ Status: UNAVAILABLE,
+ Message: fmt.Sprintf("Failed to unmarshal active participants: %s", err.Error()),
+ })
+ } else {
+ myWeight := int64(0)
+ isActive := false
+ for _, ap := range activeParticipants.Participants {
+ if ap.Index == myAddress {
+ isActive = true
+ myWeight = ap.Weight
+ break
+ }
+ }
+
+ if isActive {
+ checks = append(checks, Check{
+ ID: "active_in_epoch",
+ Status: PASS,
+ Message: fmt.Sprintf("Participant is active in epoch %d with weight %d", currentEpoch, myWeight),
+ Details: map[string]interface{}{
+ "epoch": currentEpoch,
+ "weight": myWeight,
+ },
+ })
+ } else {
+ checks = append(checks, Check{
+ ID: "active_in_epoch",
+ Status: FAIL,
+ Message: fmt.Sprintf("Participant is NOT active in epoch %d", currentEpoch),
+ Details: map[string]interface{}{
+ "epoch": currentEpoch,
+ },
+ })
+ }
+ }
+ }
+ }
+
+ // Check 3: Validator status - check if present in validator set
+ // Query the current validator set to see if our consensus key is in it
+ validatorSetResp, err := rpcClient.Validators(context.Background(), nil, nil, nil)
+ if err != nil {
+ checks = append(checks, Check{
+ ID: "validator_in_set",
+ Status: UNAVAILABLE,
+ Message: fmt.Sprintf("Failed to query validator set: %s", err.Error()),
+ })
+ } else {
+ // Check if our consensus key is in the validator set
+ foundInSet := false
+ for _, val := range validatorSetResp.Validators {
+ if val.PubKey.Equals(consensusKey) {
+ foundInSet = true
+ break
+ }
+ }
+
+ if foundInSet {
+ checks = append(checks, Check{
+ ID: "validator_in_set",
+ Status: PASS,
+ Message: "Validator is active in consensus validator set",
+ Details: map[string]interface{}{
+ "consensus_pubkey": consensusKeyBase64,
+ },
+ })
+ } else {
+ checks = append(checks, Check{
+ ID: "validator_in_set",
+ Status: FAIL,
+ Message: "Validator is NOT in consensus validator set (may need to register or unjail)",
+ Details: map[string]interface{}{
+ "consensus_pubkey": consensusKeyBase64,
+ },
+ })
+ }
+ }
+
+ return checks
+}
+
+func (s *Server) checkParticipant(ctx context.Context) Check {
+ myAddress := s.recorder.GetAccountAddress()
+ queryClient := s.recorder.NewInferenceQueryClient()
+ participantResp, err := queryClient.Participant(ctx, &types.QueryGetParticipantRequest{
+ Index: myAddress,
+ })
+
+ if err != nil {
+ return Check{
+ ID: "missed_requests_threshold",
+ Status: UNAVAILABLE,
+ Message: fmt.Sprintf("Unable to query participant stats: %s", err.Error()),
+ }
+ }
+
+ stats := participantResp.Participant.CurrentEpochStats
+ totalRequests := stats.InferenceCount + stats.MissedRequests
+
+ missedPercentage := 0.0
+ if totalRequests > 0 {
+ missedPercentage = float64(stats.MissedRequests) / float64(totalRequests) * 100
+ }
+
+ status := PASS
+ message := fmt.Sprintf("Missed requests: %.1f%% (below 10%% threshold)", missedPercentage)
+
+ if missedPercentage >= 10.0 {
+ status = FAIL
+ message = fmt.Sprintf("Missed requests: %.1f%% (exceeds 10%% threshold)", missedPercentage)
+ }
+
+ return Check{
+ ID: "missed_requests_threshold",
+ Status: status,
+ Message: message,
+ Details: map[string]interface{}{
+ "inference_count": stats.InferenceCount,
+ "missed_requests": stats.MissedRequests,
+ "total_requests": totalRequests,
+ "missed_percentage": missedPercentage,
+ },
+ }
+}
+
+func (s *Server) checkMLNodes(ctx context.Context) []Check {
+ nodes := s.configManager.GetConfig().Nodes
+ checks := []Check{}
+
+ for _, node := range nodes {
+ // Build PoC URL
+ version := s.configManager.GetCurrentNodeVersion()
+ pocUrl := getPoCUrlWithVersion(node, version)
+
+ // Check health endpoint
+ healthUrl, _ := url.JoinPath(pocUrl, "/health")
+
+ client := &http.Client{Timeout: 5 * time.Second}
+ resp, err := client.Get(healthUrl)
+
+ healthy := false
+ errorMsg := ""
+ if err != nil {
+ errorMsg = err.Error()
+ } else if resp.StatusCode == 200 {
+ healthy = true
+ resp.Body.Close()
+ } else {
+ errorMsg = fmt.Sprintf("HTTP %d", resp.StatusCode)
+ resp.Body.Close()
+ }
+
+ // Query GPU devices
+ gpuDevices := []GPUDeviceInfo{}
+ gpuUrl, _ := url.JoinPath(pocUrl, "/api/v1/gpu/devices")
+ gpuResp, err := client.Get(gpuUrl)
+ if err == nil && gpuResp.StatusCode == 200 {
+ var gpuData struct {
+ Devices []struct {
+ Index int `json:"index"`
+ Name string `json:"name"`
+ TotalMemoryMB int `json:"total_memory_mb"`
+ FreeMemoryMB int `json:"free_memory_mb"`
+ UsedMemoryMB int `json:"used_memory_mb"`
+ UtilizationPercent *int `json:"utilization_percent"`
+ TemperatureC *int `json:"temperature_c"`
+ IsAvailable bool `json:"is_available"`
+ ErrorMessage *string `json:"error_message"`
+ } `json:"devices"`
+ Count int `json:"count"`
+ }
+ json.NewDecoder(gpuResp.Body).Decode(&gpuData)
+ gpuResp.Body.Close()
+
+ for _, dev := range gpuData.Devices {
+ gpuDevices = append(gpuDevices, GPUDeviceInfo{
+ Index: dev.Index,
+ Name: dev.Name,
+ TotalMemoryGB: float64(dev.TotalMemoryMB) / 1024,
+ FreeMemoryGB: float64(dev.FreeMemoryMB) / 1024,
+ UsedMemoryGB: float64(dev.UsedMemoryMB) / 1024,
+ Utilization: dev.UtilizationPercent,
+ Temperature: dev.TemperatureC,
+ Available: dev.IsAvailable,
+ Error: dev.ErrorMessage,
+ })
+ }
+ }
+
+ // Extract model names from Models map
+ models := []string{}
+ for modelId := range node.Models {
+ models = append(models, modelId)
+ }
+
+ checkID := fmt.Sprintf("mlnode_%s", node.Id)
+ status := PASS
+ message := "MLNode is healthy"
+ if !healthy {
+ status = FAIL
+ message = fmt.Sprintf("MLNode health check failed: %s", errorMsg)
+ }
+
+ checks = append(checks, Check{
+ ID: checkID,
+ Status: status,
+ Message: message,
+ Details: map[string]interface{}{
+ "id": node.Id,
+ "host": node.Host,
+ "models": models,
+ "gpus": gpuDevices,
+ },
+ })
+ }
+
+ return checks
+}
+
+func (s *Server) checkBlockSync(ctx context.Context) Check {
+ chainNodeUrl := s.configManager.GetChainNodeConfig().Url
+ rpcClient, err := cosmosclient.NewRpcClient(chainNodeUrl)
+ if err != nil {
+ return Check{
+ ID: "block_sync",
+ Status: UNAVAILABLE,
+ Message: fmt.Sprintf("Failed to connect to chain node: %s", err.Error()),
+ }
+ }
+
+ status, err := rpcClient.Status(context.Background())
+ if err != nil {
+ return Check{
+ ID: "block_sync",
+ Status: UNAVAILABLE,
+ Message: fmt.Sprintf("Failed to get node status: %s", err.Error()),
+ }
+ }
+
+ latestBlockTime := status.SyncInfo.LatestBlockTime
+ latestBlockHeight := status.SyncInfo.LatestBlockHeight
+ timeSinceLastBlock := time.Since(latestBlockTime)
+
+ // Check if block is recent (< 60 seconds old)
+ isHealthy := timeSinceLastBlock < 60*time.Second
+
+ checkStatus := PASS
+ message := fmt.Sprintf("Chain is synced. Latest block: %d, age: %s",
+ latestBlockHeight, timeSinceLastBlock.Round(time.Second))
+
+ if !isHealthy {
+ checkStatus = FAIL
+ message = fmt.Sprintf("Chain appears stalled. Latest block: %d, age: %s (> 60s)",
+ latestBlockHeight, timeSinceLastBlock.Round(time.Second))
+ }
+
+ return Check{
+ ID: "block_sync",
+ Status: checkStatus,
+ Message: message,
+ Details: map[string]interface{}{
+ "latest_height": latestBlockHeight,
+ "latest_block_time": latestBlockTime,
+ "seconds_since_block": int(timeSinceLastBlock.Seconds()),
+ },
+ }
+}
+
+// Summary Generation
+
+func (s *Server) generateSummary(report *SetupReport) {
+ totalChecks := 0
+ passedChecks := 0
+ failedChecks := 0
+ unavailableChecks := 0
+ issues := []string{}
+ recommendations := []string{}
+
+ // Recommendation map for common check IDs
+ recommendationMap := buildRecommendationMap()
+
+ // Process all checks
+ for _, check := range report.Checks {
+ totalChecks++
+
+ switch check.Status {
+ case PASS:
+ passedChecks++
+ case FAIL:
+ failedChecks++
+ issues = append(issues, check.Message)
+ if rec, ok := recommendationMap[check.ID]; ok {
+ recommendations = append(recommendations, rec)
+ }
+ // Add specific recommendations for MLNode failures
+ if strings.HasPrefix(check.ID, "mlnode_") {
+ if details, ok := check.Details.(map[string]interface{}); ok {
+ nodeID := details["id"]
+ host := details["host"]
+ recommendations = append(recommendations,
+ fmt.Sprintf("Check MLNode '%s' is running and accessible at %s", nodeID, host))
+ }
+ }
+ case UNAVAILABLE:
+ unavailableChecks++
+ issues = append(issues, fmt.Sprintf("Check unavailable: %s", check.Message))
+ }
+
+ // Check for unavailable GPUs in MLNode details
+ if strings.HasPrefix(check.ID, "mlnode_") && check.Status == PASS {
+ if details, ok := check.Details.(map[string]interface{}); ok {
+ if gpus, ok := details["gpus"].([]GPUDeviceInfo); ok {
+ if len(gpus) == 0 {
+ nodeID := details["id"]
+ issues = append(issues, fmt.Sprintf("No GPUs detected on MLNode '%s'", nodeID))
+ recommendations = append(recommendations,
+ fmt.Sprintf("Verify GPU drivers and CUDA installation on node '%s'", nodeID))
+ } else {
+ for _, gpu := range gpus {
+ if !gpu.Available {
+ nodeID := details["id"]
+ issues = append(issues,
+ fmt.Sprintf("GPU %d (%s) on node '%s' is not available", gpu.Index, gpu.Name, nodeID))
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // Set overall status
+ if failedChecks > 0 {
+ report.OverallStatus = FAIL
+ } else if unavailableChecks > 0 {
+ report.OverallStatus = UNAVAILABLE
+ } else {
+ report.OverallStatus = PASS
+ }
+
+ report.Summary = ReportSummary{
+ TotalChecks: totalChecks,
+ PassedChecks: passedChecks,
+ FailedChecks: failedChecks,
+ UnavailableChecks: unavailableChecks,
+ Issues: issues,
+ Recommendations: recommendations,
+ }
+}
+
+func buildRecommendationMap() map[string]string {
+ return map[string]string{
+ "cold_key_configured": "Verify ACCOUNT_PUBKEY environment variable is set correctly",
+ "cold_key_not_in_keyring": "Remove cold key from keyring - it should only be in environment config",
+ "warm_key_in_keyring": "Ensure warm key exists in keyring at configured location",
+ "warm_key_address_match": "Check KEY_NAME environment variable matches keyring key name",
+ "permissions_granted": "Run authz grant commands. See inference-chain/x/inference/permissions.go",
+ "consensus_key_match": "Verify validator node is running and consensus key matches participant registration",
+ "active_in_epoch": "Check PoC participation and ensure node is properly registered",
+ "validator_not_jailed": "Unjail validator or investigate validator status issues",
+ "missed_requests_threshold": "Investigate why requests are being missed. Check MLNode health and network connectivity",
+ "block_sync": "Check chain node is running and syncing properly",
+ }
+}
+
+// Helper Functions (copied from modelmanager for isolation)
+
+func getPoCUrlWithVersion(node apiconfig.InferenceNodeConfig, version string) string {
+ if version == "" {
+ return getPoCUrl(node)
+ }
+ return getPoCUrlVersioned(node, version)
+}
+
+func getPoCUrl(node apiconfig.InferenceNodeConfig) string {
+ return formatURL(node.Host, node.PoCPort, node.PoCSegment)
+}
+
+func getPoCUrlVersioned(node apiconfig.InferenceNodeConfig, version string) string {
+ return formatURLWithVersion(node.Host, node.PoCPort, version, node.PoCSegment)
+}
+
+func formatURL(host string, port int, segment string) string {
+ return fmt.Sprintf("http://%s:%d%s", host, port, segment)
+}
+
+func formatURLWithVersion(host string, port int, version string, segment string) string {
+ return fmt.Sprintf("http://%s:%d/%s%s", host, port, version, segment)
+}
diff --git a/decentralized-api/internal/server/admin/setup_report_test.go b/decentralized-api/internal/server/admin/setup_report_test.go
new file mode 100644
index 000000000..8c0de7c9e
--- /dev/null
+++ b/decentralized-api/internal/server/admin/setup_report_test.go
@@ -0,0 +1,212 @@
+package admin
+
+import (
+ "decentralized-api/apiconfig"
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+)
+
+// Note: Unit tests for individual check functions (cold key, warm key, permissions,
+// consensus key, participant stats, MLNode, block sync) would require extensive mocking
+// of the cosmos client, keyring, RPC client, and HTTP client.
+// The actual functionality is tested via integration tests and real usage.
+// We test only the components that don't require mocking below.
+
+// Test Summary Generation
+
+func TestGenerateSummary_AllPass(t *testing.T) {
+ s, _, _ := setupTestServer(t)
+
+ report := &SetupReport{
+ Checks: []Check{
+ {ID: "check1", Status: PASS, Message: "Check 1 passed"},
+ {ID: "check2", Status: PASS, Message: "Check 2 passed"},
+ {ID: "check3", Status: PASS, Message: "Check 3 passed"},
+ },
+ }
+
+ s.generateSummary(report)
+
+ assert.Equal(t, PASS, report.OverallStatus)
+ assert.Equal(t, 3, report.Summary.TotalChecks)
+ assert.Equal(t, 3, report.Summary.PassedChecks)
+ assert.Equal(t, 0, report.Summary.FailedChecks)
+ assert.Equal(t, 0, report.Summary.UnavailableChecks)
+ assert.Empty(t, report.Summary.Issues)
+ assert.Empty(t, report.Summary.Recommendations)
+}
+
+func TestGenerateSummary_WithFailures(t *testing.T) {
+ s, _, _ := setupTestServer(t)
+
+ report := &SetupReport{
+ Checks: []Check{
+ {ID: "check1", Status: PASS, Message: "Check 1 passed"},
+ {ID: "permissions_granted", Status: FAIL, Message: "Missing permissions"},
+ {ID: "check3", Status: PASS, Message: "Check 3 passed"},
+ },
+ }
+
+ s.generateSummary(report)
+
+ assert.Equal(t, FAIL, report.OverallStatus)
+ assert.Equal(t, 3, report.Summary.TotalChecks)
+ assert.Equal(t, 2, report.Summary.PassedChecks)
+ assert.Equal(t, 1, report.Summary.FailedChecks)
+ assert.Equal(t, 0, report.Summary.UnavailableChecks)
+ assert.Len(t, report.Summary.Issues, 1)
+ assert.Contains(t, report.Summary.Issues[0], "Missing permissions")
+ assert.Len(t, report.Summary.Recommendations, 1)
+ assert.Contains(t, report.Summary.Recommendations[0], "authz grant")
+}
+
+func TestGenerateSummary_WithUnavailable(t *testing.T) {
+ s, _, _ := setupTestServer(t)
+
+ report := &SetupReport{
+ Checks: []Check{
+ {ID: "check1", Status: PASS, Message: "Check 1 passed"},
+ {ID: "check2", Status: UNAVAILABLE, Message: "Could not check"},
+ {ID: "check3", Status: PASS, Message: "Check 3 passed"},
+ },
+ }
+
+ s.generateSummary(report)
+
+ assert.Equal(t, UNAVAILABLE, report.OverallStatus)
+ assert.Equal(t, 3, report.Summary.TotalChecks)
+ assert.Equal(t, 2, report.Summary.PassedChecks)
+ assert.Equal(t, 0, report.Summary.FailedChecks)
+ assert.Equal(t, 1, report.Summary.UnavailableChecks)
+ assert.Len(t, report.Summary.Issues, 1)
+ assert.Contains(t, report.Summary.Issues[0], "Check unavailable")
+}
+
+func TestGenerateSummary_MLNodeWithNoGPUs(t *testing.T) {
+ s, _, _ := setupTestServer(t)
+
+ report := &SetupReport{
+ Checks: []Check{
+ {
+ ID: "mlnode_node1",
+ Status: PASS,
+ Message: "MLNode is healthy",
+ Details: map[string]interface{}{
+ "id": "node1",
+ "host": "localhost",
+ "models": []string{"model1"},
+ "gpus": []GPUDeviceInfo{}, // No GPUs
+ },
+ },
+ },
+ }
+
+ s.generateSummary(report)
+
+ assert.Equal(t, PASS, report.OverallStatus)
+ assert.Len(t, report.Summary.Issues, 1)
+ assert.Contains(t, report.Summary.Issues[0], "No GPUs detected")
+ assert.Len(t, report.Summary.Recommendations, 1)
+ assert.Contains(t, report.Summary.Recommendations[0], "GPU drivers")
+}
+
+func TestGenerateSummary_MLNodeWithUnavailableGPU(t *testing.T) {
+ s, _, _ := setupTestServer(t)
+
+ report := &SetupReport{
+ Checks: []Check{
+ {
+ ID: "mlnode_node1",
+ Status: PASS,
+ Message: "MLNode is healthy",
+ Details: map[string]interface{}{
+ "id": "node1",
+ "host": "localhost",
+ "models": []string{"model1"},
+ "gpus": []GPUDeviceInfo{
+ {
+ Index: 0,
+ Name: "NVIDIA A100",
+ Available: false, // GPU not available
+ },
+ },
+ },
+ },
+ },
+ }
+
+ s.generateSummary(report)
+
+ assert.Equal(t, PASS, report.OverallStatus)
+ assert.Len(t, report.Summary.Issues, 1)
+ assert.Contains(t, report.Summary.Issues[0], "GPU 0")
+ assert.Contains(t, report.Summary.Issues[0], "not available")
+}
+
+// Caching and integration tests omitted due to complex mocking requirements.
+// The caching logic is tested in production usage.
+
+// Test Helper Functions
+
+func TestURLHelperFunctions(t *testing.T) {
+ node := apiconfig.InferenceNodeConfig{
+ Host: "localhost",
+ PoCPort: 8080,
+ PoCSegment: "/api/v1",
+ }
+
+ t.Run("formatURL", func(t *testing.T) {
+ url := formatURL("localhost", 8080, "/api/v1")
+ assert.Equal(t, "http://localhost:8080/api/v1", url)
+ })
+
+ t.Run("formatURLWithVersion", func(t *testing.T) {
+ url := formatURLWithVersion("localhost", 8080, "v2", "/api/v1")
+ assert.Equal(t, "http://localhost:8080/v2/api/v1", url)
+ })
+
+ t.Run("getPoCUrl", func(t *testing.T) {
+ url := getPoCUrl(node)
+ assert.Equal(t, "http://localhost:8080/api/v1", url)
+ })
+
+ t.Run("getPoCUrlVersioned", func(t *testing.T) {
+ url := getPoCUrlVersioned(node, "v2")
+ assert.Equal(t, "http://localhost:8080/v2/api/v1", url)
+ })
+
+ t.Run("getPoCUrlWithVersion empty version", func(t *testing.T) {
+ url := getPoCUrlWithVersion(node, "")
+ assert.Equal(t, "http://localhost:8080/api/v1", url)
+ })
+
+ t.Run("getPoCUrlWithVersion with version", func(t *testing.T) {
+ url := getPoCUrlWithVersion(node, "v2")
+ assert.Equal(t, "http://localhost:8080/v2/api/v1", url)
+ })
+}
+
+func TestBuildRecommendationMap(t *testing.T) {
+ recMap := buildRecommendationMap()
+
+ // Verify key recommendations exist
+ assert.Contains(t, recMap, "cold_key_configured")
+ assert.Contains(t, recMap, "permissions_granted")
+ assert.Contains(t, recMap, "consensus_key_match")
+ assert.Contains(t, recMap, "block_sync")
+
+ // Verify recommendations are actionable
+ assert.Contains(t, recMap["permissions_granted"], "authz grant")
+ assert.Contains(t, recMap["cold_key_configured"], "ACCOUNT_PUBKEY")
+}
+
+// Test Check Status Constants
+
+func TestCheckStatusConstants(t *testing.T) {
+ assert.Equal(t, CheckStatus("PASS"), PASS)
+ assert.Equal(t, CheckStatus("FAIL"), FAIL)
+ assert.Equal(t, CheckStatus("UNAVAILABLE"), UNAVAILABLE)
+}
+
+// Edge case tests omitted due to complex mocking requirements.
diff --git a/decentralized-api/internal/server/admin/transactions_handler.go b/decentralized-api/internal/server/admin/transactions_handler.go
new file mode 100644
index 000000000..8f71550ac
--- /dev/null
+++ b/decentralized-api/internal/server/admin/transactions_handler.go
@@ -0,0 +1,47 @@
+package admin
+
+import (
+ "decentralized-api/logging"
+ "fmt"
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ txtypes "github.com/cosmos/cosmos-sdk/types/tx"
+ "github.com/labstack/echo/v4"
+ "github.com/productscience/inference/x/inference/types"
+ "io"
+ "net/http"
+)
+
+func (s *Server) sendTransaction(ctx echo.Context) error {
+ logging.Info("Received send transaction request", types.Messages)
+ body, err := io.ReadAll(ctx.Request().Body)
+ if err != nil {
+ return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("failed to read request body: %v", err))
+ }
+
+ var tx txtypes.Tx
+ if err := s.cdc.UnmarshalJSON(body, &tx); err != nil {
+ return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("failed to unmarshal tx JSON: %v", err))
+ }
+
+ logging.Info("Unmarshalled tx", types.Messages, "tx", tx)
+
+ if len(tx.Body.Messages) == 0 {
+ return ErrNoMessagesFoundInTx
+ }
+
+ var msg sdk.Msg
+ msgAny := tx.Body.Messages[0]
+ if err := s.cdc.UnpackAny(msgAny, &msg); err != nil {
+ return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("failed to unpack message: %v", err))
+ }
+
+ logging.Info("Unpacked message", types.Messages, "Message", msg)
+
+ txResp, err := s.recorder.SendTransactionAsyncNoRetry(msg.(sdk.Msg))
+ if err != nil {
+ return err
+ }
+
+ logging.Info("TxResp", types.Messages, "txResp", *txResp)
+ return ctx.JSON(http.StatusOK, txResp)
+}
diff --git a/decentralized-api/internal/server/admin/unit_of_compute_proposal_handlers.go b/decentralized-api/internal/server/admin/unit_of_compute_proposal_handlers.go
new file mode 100644
index 000000000..42f71b6dd
--- /dev/null
+++ b/decentralized-api/internal/server/admin/unit_of_compute_proposal_handlers.go
@@ -0,0 +1,62 @@
+package admin
+
+import (
+ "decentralized-api/logging"
+ "fmt"
+ "net/http"
+
+ "github.com/labstack/echo/v4"
+ "github.com/productscience/inference/api/inference/inference"
+ "github.com/productscience/inference/x/inference/types"
+)
+
+func (s *Server) postUnitOfComputePriceProposal(ctx echo.Context) error {
+ var body UnitOfComputePriceProposalDto
+ if err := ctx.Bind(&body); err != nil {
+ return echo.NewHTTPError(http.StatusBadRequest, err)
+ }
+
+ price, err := getNanoCoinPrice(&body)
+ if err != nil {
+ return echo.NewHTTPError(http.StatusBadRequest, err)
+ }
+
+ msg := &inference.MsgSubmitUnitOfComputePriceProposal{
+ Price: price,
+ }
+
+ if err := s.recorder.SubmitUnitOfComputePriceProposal(msg); err != nil {
+ logging.Error("Failed to send a transaction: MsgSubmitUnitOfComputePriceProposal", types.Pricing, "error", err)
+ return err
+ }
+ return ctx.NoContent(http.StatusOK)
+}
+
+func (s *Server) getUnitOfComputePriceProposal(ctx echo.Context) error {
+ queryClient := s.recorder.NewInferenceQueryClient()
+ queryRequest := &types.QueryGetUnitOfComputePriceProposalRequest{
+ Participant: s.recorder.GetAccountAddress(),
+ }
+
+ queryResponse, err := queryClient.GetUnitOfComputePriceProposal(s.recorder.GetContext(), queryRequest)
+ if err != nil {
+ logging.Error("Failed to query unit of compute price proposal", types.Pricing, "error", err)
+ return err
+ }
+ return ctx.JSON(http.StatusOK, queryResponse)
+}
+
+func getNanoCoinPrice(proposal *UnitOfComputePriceProposalDto) (uint64, error) {
+ switch proposal.Denom {
+ case types.NanoCoin:
+ return proposal.Price, nil
+ case types.MicroCoin:
+ return proposal.Price * 1_000, nil
+ case types.MilliCoin:
+ return proposal.Price * 1_000_000, nil
+ case types.NativeCoin:
+ return proposal.Price * 1_000_000_000, nil
+ default:
+ return 0, fmt.Errorf("invalid denom: %s", proposal.Denom)
+ }
+}
diff --git a/decentralized-api/internal/server/admin/upgrade_handlers.go b/decentralized-api/internal/server/admin/upgrade_handlers.go
new file mode 100644
index 000000000..4ef589f1a
--- /dev/null
+++ b/decentralized-api/internal/server/admin/upgrade_handlers.go
@@ -0,0 +1,35 @@
+package admin
+
+import (
+ "net/http"
+
+ "github.com/labstack/echo/v4"
+)
+
+func (s *Server) getUpgradeStatus(c echo.Context) error {
+ plan := s.configManager.GetUpgradePlan()
+ if plan.NodeVersion == "" {
+ return c.JSON(http.StatusOK, map[string]string{"message": "No upgrade plan active"})
+ }
+
+ reports := s.nodeBroker.CheckVersionHealth(plan.NodeVersion)
+ return c.JSON(http.StatusOK, reports)
+}
+
+type versionStatusRequest struct {
+ Version string `json:"version"`
+}
+
+func (s *Server) postVersionStatus(c echo.Context) error {
+ var req versionStatusRequest
+ if err := c.Bind(&req); err != nil {
+ return echo.NewHTTPError(http.StatusBadRequest, "Invalid request body")
+ }
+
+ if req.Version == "" {
+ return echo.NewHTTPError(http.StatusBadRequest, "Version field is required")
+ }
+
+ reports := s.nodeBroker.CheckVersionHealth(req.Version)
+ return c.JSON(http.StatusOK, reports)
+}
diff --git a/decentralized-api/internal/server/admin/validation_recovery_handler.go b/decentralized-api/internal/server/admin/validation_recovery_handler.go
new file mode 100644
index 000000000..45752a2d9
--- /dev/null
+++ b/decentralized-api/internal/server/admin/validation_recovery_handler.go
@@ -0,0 +1,134 @@
+package admin
+
+import (
+ "decentralized-api/cosmosclient"
+ "decentralized-api/logging"
+ "net/http"
+ "strconv"
+
+ "github.com/labstack/echo/v4"
+ "github.com/productscience/inference/api/inference/inference"
+ "github.com/productscience/inference/x/inference/types"
+)
+
+type ClaimRewardRecoverRequest struct {
+ Seed *int64 `json:"seed,omitempty"` // Optional: if not provided, uses stored seed
+ ForceClaim bool `json:"force_claim"` // Force claim even if already claimed
+}
+
+type ClaimRewardRecoverResponse struct {
+ Success bool `json:"success"`
+ Message string `json:"message"`
+ EpochIndex uint64 `json:"epoch_index"`
+ Seed int64 `json:"seed"`
+ MissedValidations int `json:"missed_validations"`
+ AlreadyClaimed bool `json:"already_claimed"`
+ ClaimExecuted bool `json:"claim_executed"`
+}
+
+func (s *Server) postClaimRewardRecover(ctx echo.Context) error {
+ var req ClaimRewardRecoverRequest
+ if err := ctx.Bind(&req); err != nil {
+ return echo.NewHTTPError(http.StatusBadRequest, "Invalid request body")
+ }
+
+ // Always use the previous epoch (only epoch we can recover)
+ previousSeed := s.configManager.GetPreviousSeed()
+ epochIndex := previousSeed.EpochIndex
+
+ // Determine the seed to use
+ var seedValue int64
+ if req.Seed != nil {
+ // Custom seed provided
+ seedValue = *req.Seed
+ } else {
+ // Use stored seed
+ seedValue = previousSeed.Seed
+ }
+
+ // Check if seed is valid
+ if seedValue == 0 {
+ return echo.NewHTTPError(http.StatusBadRequest, "No valid seed available for previous epoch "+strconv.FormatUint(epochIndex, 10))
+ }
+
+ // Check if already claimed
+ alreadyClaimed := s.configManager.IsPreviousSeedClaimed()
+ if alreadyClaimed && !req.ForceClaim {
+ return ctx.JSON(http.StatusOK, ClaimRewardRecoverResponse{
+ Success: false,
+ Message: "Rewards already claimed for this epoch. Use force_claim=true to override.",
+ EpochIndex: epochIndex,
+ Seed: seedValue,
+ MissedValidations: 0,
+ AlreadyClaimed: true,
+ ClaimExecuted: false,
+ })
+ }
+
+ logging.Info("Starting manual validation recovery", types.Validation,
+ "epochIndex", epochIndex,
+ "seed", seedValue,
+ "alreadyClaimed", alreadyClaimed,
+ "forceClaim", req.ForceClaim)
+
+ // Detect missed validations
+ missedInferences, err := s.validator.DetectMissedValidations(epochIndex, seedValue)
+ if err != nil {
+ logging.Error("Failed to detect missed validations", types.Validation, "error", err)
+ return echo.NewHTTPError(http.StatusInternalServerError, "Failed to detect missed validations: "+err.Error())
+ }
+
+ missedCount := len(missedInferences)
+ logging.Info("Manual recovery detected missed validations", types.Validation,
+ "epochIndex", epochIndex,
+ "missedCount", missedCount)
+
+ // Execute recovery validations
+ if missedCount > 0 {
+ recoveredCount, _ := s.validator.ExecuteRecoveryValidations(missedInferences)
+
+ logging.Info("Manual recovery validations completed", types.Validation,
+ "epochIndex", epochIndex,
+ "recoveredCount", recoveredCount,
+ "missedCount", missedCount,
+ )
+
+ if recoveredCount > 0 {
+ s.validator.WaitForValidationsToBeRecorded()
+ }
+ }
+
+ // Claim rewards if not already claimed or if forced
+ claimExecuted := false
+ if !alreadyClaimed || req.ForceClaim {
+ // Cast to concrete type for RequestMoney
+ concreteRecorder := s.recorder.(*cosmosclient.InferenceCosmosClient)
+ err := concreteRecorder.ClaimRewards(&inference.MsgClaimRewards{
+ Seed: seedValue,
+ EpochIndex: epochIndex,
+ })
+ if err != nil {
+ logging.Error("Failed to claim rewards in manual recovery", types.Claims, "error", err)
+ return echo.NewHTTPError(http.StatusInternalServerError, "Failed to claim rewards: "+err.Error())
+ }
+
+ // Mark as claimed
+ err = s.configManager.MarkPreviousSeedClaimed()
+ if err != nil {
+ logging.Error("Failed to mark seed as claimed", types.Claims, "error", err)
+ }
+
+ claimExecuted = true
+ logging.Info("Manual recovery claim executed", types.Claims, "epochIndex", epochIndex)
+ }
+
+ return ctx.JSON(http.StatusOK, ClaimRewardRecoverResponse{
+ Success: true,
+ Message: "Manual claim reward recovery completed successfully",
+ EpochIndex: epochIndex,
+ Seed: seedValue,
+ MissedValidations: missedCount,
+ AlreadyClaimed: alreadyClaimed,
+ ClaimExecuted: claimExecuted,
+ })
+}
diff --git a/decentralized-api/internal/server/middleware/error_handler.go b/decentralized-api/internal/server/middleware/error_handler.go
new file mode 100644
index 000000000..596bf5199
--- /dev/null
+++ b/decentralized-api/internal/server/middleware/error_handler.go
@@ -0,0 +1,51 @@
+package middleware
+
+import (
+ "errors"
+ "net/http"
+
+ "github.com/labstack/echo/v4"
+)
+
+// TransparentErrorHandler ensures that errors returned by handlers are propagated
+// to the client with as much context as possible.
+//
+// Behaviour:
+// - If the error is *echo.HTTPError – use the embedded status code & message.
+// - Otherwise – treat it as an internal error but still return the original
+// error string so that the client can see what actually happened.
+//
+// The response body is always JSON in the following form:
+//
+// { "error": "" }
+//
+// NOTE: Make sure NOT to expose sensitive information in production.
+func TransparentErrorHandler(err error, c echo.Context) {
+ status, message := ExtractError(err)
+
+ // Avoid double responses
+ if c.Response().Committed {
+ return
+ }
+
+ // Always return JSON so that the client can reliably parse it.
+ // We ignore any error from JSON serialization because we are already in the error path.
+ _ = c.JSON(status, map[string]interface{}{"error": message})
+}
+
+func ExtractError(err error) (int, interface{}) {
+ var (
+ status = http.StatusInternalServerError
+ message interface{} = err.Error()
+ )
+
+ var he *echo.HTTPError
+ if errors.As(err, &he) {
+ status = he.Code
+ if he.Message != nil {
+ message = he.Message
+ }
+ }
+
+ return status, message
+}
diff --git a/decentralized-api/internal/server/middleware/error_handler_test.go b/decentralized-api/internal/server/middleware/error_handler_test.go
new file mode 100644
index 000000000..790cb53e4
--- /dev/null
+++ b/decentralized-api/internal/server/middleware/error_handler_test.go
@@ -0,0 +1,28 @@
+package middleware_test
+
+import (
+ "errors"
+ "net/http"
+ "testing"
+
+ "decentralized-api/internal/server/middleware"
+
+ "github.com/labstack/echo/v4"
+ "github.com/stretchr/testify/require"
+)
+
+func TestExtractError(t *testing.T) {
+ baseErr := errors.New("inference server is not running")
+
+ // 1. Generic error
+ status, msg := middleware.ExtractError(baseErr)
+ require.Equal(t, http.StatusInternalServerError, status)
+ require.Equal(t, baseErr.Error(), msg)
+
+ // 2. echo.HTTPError preserving original payload and status code
+ httpErr := echo.NewHTTPError(http.StatusBadRequest, baseErr)
+
+ status, msg = middleware.ExtractError(httpErr)
+ require.Equal(t, http.StatusBadRequest, status)
+ require.Equal(t, baseErr, msg)
+}
diff --git a/decentralized-api/internal/server/middleware/middleware.go b/decentralized-api/internal/server/middleware/middleware.go
new file mode 100644
index 000000000..10daf2cf2
--- /dev/null
+++ b/decentralized-api/internal/server/middleware/middleware.go
@@ -0,0 +1,16 @@
+package middleware
+
+import (
+ "decentralized-api/logging"
+ "github.com/labstack/echo/v4"
+ "github.com/productscience/inference/x/inference/types"
+)
+
+func LoggingMiddleware(next echo.HandlerFunc) echo.HandlerFunc {
+ return func(c echo.Context) error {
+ req := c.Request()
+ logging.Info("Received request", types.Server, "method", req.Method, "path", req.URL.Path)
+ logging.Debug("Request headers", types.Server, "headers", req.Header)
+ return next(c)
+ }
+}
diff --git a/decentralized-api/internal/server/mlnode/post_generated_batches_handler.go b/decentralized-api/internal/server/mlnode/post_generated_batches_handler.go
new file mode 100644
index 000000000..3222739a5
--- /dev/null
+++ b/decentralized-api/internal/server/mlnode/post_generated_batches_handler.go
@@ -0,0 +1,114 @@
+package mlnode
+
+import (
+ cosmos_client "decentralized-api/cosmosclient"
+ "decentralized-api/logging"
+ "net/http"
+
+ "decentralized-api/mlnodeclient"
+
+ "github.com/google/uuid"
+ "github.com/labstack/echo/v4"
+ "github.com/productscience/inference/api/inference/inference"
+ "github.com/productscience/inference/x/inference/types"
+)
+
+func (s *Server) postGeneratedBatches(ctx echo.Context) error {
+ var body mlnodeclient.ProofBatch
+
+ if err := ctx.Bind(&body); err != nil {
+ logging.Error("ProofBatch-callback. Failed to decode request body of type ProofBatch", types.PoC, "error", err)
+ return echo.NewHTTPError(http.StatusBadRequest, err)
+ }
+
+ logging.Debug("ProofBatch-callback. Received", types.PoC, "body", body)
+
+ var nodeId string
+ node, found := s.broker.GetNodeByNodeNum(body.NodeNum)
+ if found {
+ nodeId = node.Id
+ logging.Info("ProofBatch-callback. Found node by node num", types.PoC,
+ "nodeId", nodeId,
+ "nodeNum", body.NodeNum)
+ } else {
+ logging.Warn("ProofBatch-callback. Unknown NodeNum. Sending MsgSubmitPocBatch with empty nodeId",
+ types.PoC, "node_num", body.NodeNum)
+ }
+
+ msg := &inference.MsgSubmitPocBatch{
+ PocStageStartBlockHeight: body.BlockHeight,
+ Nonces: body.Nonces,
+ Dist: body.Dist,
+ BatchId: uuid.New().String(),
+ NodeId: nodeId,
+ }
+
+ if err := s.recorder.SubmitPocBatch(msg); err != nil {
+ logging.Error("ProofBatch-callback. Failed to submit MsgSubmitPocBatch", types.PoC, "error", err)
+ return err
+ }
+
+ return ctx.NoContent(http.StatusOK)
+}
+
+func (s *Server) postValidatedBatches(ctx echo.Context) error {
+ var body mlnodeclient.ValidatedBatch
+
+ if err := ctx.Bind(&body); err != nil {
+ logging.Error("ValidateReceivedBatches-callback. Failed to decode request body of type ValidatedBatch", types.PoC, "error", err)
+ return echo.NewHTTPError(http.StatusBadRequest, err)
+ }
+
+ logging.Debug("ValidateReceivedBatches-callback. ValidatedProofBatch received", types.PoC, "body", body)
+
+ address, err := cosmos_client.PubKeyToAddress(body.PublicKey)
+ if err != nil {
+ logging.Error("ValidateReceivedBatches-callback. Failed to convert public key to address", types.PoC,
+ "publicKey", body.PublicKey,
+ "NInvalid", body.NInvalid,
+ "ProbabilityHonest", body.ProbabilityHonest,
+ "FraudDetected", body.FraudDetected,
+ "error", err)
+ return err
+ }
+
+ logging.Info("ValidateReceivedBatches-callback. ValidatedProofBatch received", types.PoC,
+ "participant", address,
+ "NInvalid", body.NInvalid,
+ "ProbabilityHonest", body.ProbabilityHonest,
+ "FraudDetected", body.FraudDetected)
+
+ msg := &inference.MsgSubmitPocValidation{
+ ParticipantAddress: address,
+ PocStageStartBlockHeight: body.BlockHeight,
+ Nonces: body.Nonces,
+ Dist: body.Dist,
+ ReceivedDist: body.ReceivedDist,
+ RTarget: body.RTarget,
+ FraudThreshold: body.FraudThreshold,
+ NInvalid: body.NInvalid,
+ ProbabilityHonest: body.ProbabilityHonest,
+ FraudDetected: body.FraudDetected,
+ }
+
+ // FIXME: We empty all arrays to avoid too large chain transactions
+ // We can allow that, because we only use FraudDetected boolean
+ // when making a decision about participant's PoC submissions
+ // Will be fixed in future versions
+ emptyArrays(msg)
+
+ if err := s.recorder.SubmitPoCValidation(msg); err != nil {
+ logging.Error("ValidateReceivedBatches-callback. Failed to submit MsgSubmitValidatedPocBatch", types.PoC,
+ "participant", address,
+ "error", err)
+ return err
+ }
+
+ return ctx.NoContent(http.StatusOK)
+}
+
+func emptyArrays(msg *inference.MsgSubmitPocValidation) {
+ msg.Dist = make([]float64, 0)
+ msg.ReceivedDist = make([]float64, 0)
+ msg.Nonces = make([]int64, 0)
+}
diff --git a/decentralized-api/internal/server/mlnode/server.go b/decentralized-api/internal/server/mlnode/server.go
new file mode 100644
index 000000000..1d8a920bb
--- /dev/null
+++ b/decentralized-api/internal/server/mlnode/server.go
@@ -0,0 +1,43 @@
+package mlnode
+
+import (
+ "decentralized-api/broker"
+ cosmos_client "decentralized-api/cosmosclient"
+ "decentralized-api/internal/server/middleware"
+
+ "github.com/labstack/echo/v4"
+)
+
+type Server struct {
+ e *echo.Echo
+ recorder cosmos_client.CosmosMessageClient
+ broker *broker.Broker
+}
+
+// TODO breacking changes: url path, support on mlnode side
+func NewServer(recorder cosmos_client.CosmosMessageClient, broker *broker.Broker) *Server {
+ e := echo.New()
+
+ e.HTTPErrorHandler = middleware.TransparentErrorHandler
+
+ e.Use(middleware.LoggingMiddleware)
+ g := e.Group("/mlnode/v1/")
+
+ s := &Server{
+ e: e,
+ recorder: recorder,
+ broker: broker,
+ }
+
+ // keep old paths too for backward compatibility
+ g.POST("poc-batches/generated", s.postGeneratedBatches)
+ e.POST("/v1/poc-batches/generated", s.postGeneratedBatches)
+
+ g.POST("poc-batches/validated", s.postValidatedBatches)
+ e.POST("/v1/poc-batches/validated", s.postValidatedBatches)
+ return s
+}
+
+func (s *Server) Start(addr string) {
+ go s.e.Start(addr)
+}
diff --git a/decentralized-api/internal/server/public/active_participants_verification_handlers.go b/decentralized-api/internal/server/public/active_participants_verification_handlers.go
new file mode 100644
index 000000000..7b384e40e
--- /dev/null
+++ b/decentralized-api/internal/server/public/active_participants_verification_handlers.go
@@ -0,0 +1,101 @@
+package public
+
+import (
+ "context"
+ "cosmossdk.io/errors"
+ "decentralized-api/logging"
+ "decentralized-api/merkleproof"
+ "encoding/base64"
+ "encoding/hex"
+ cmcryptoed "github.com/cometbft/cometbft/crypto/ed25519"
+ rpcclient "github.com/cometbft/cometbft/rpc/client/http"
+ comettypes "github.com/cometbft/cometbft/types"
+ "github.com/labstack/echo/v4"
+ "github.com/productscience/inference/x/inference/types"
+ "net/http"
+ "net/url"
+)
+
+func (s *Server) postVerifyProof(ctx echo.Context) error {
+ var proofVerificationRequest ProofVerificationRequest
+ if err := ctx.Bind(&proofVerificationRequest); err != nil {
+ logging.Error("Error decoding request", types.Participants, "error", err)
+ return echo.NewHTTPError(http.StatusBadRequest, err)
+ }
+
+ dataKey := string(types.ActiveParticipantsFullKey(uint64(proofVerificationRequest.Epoch)))
+ verKey := "/inference/" + url.PathEscape(dataKey)
+
+ appHash, err := hex.DecodeString(proofVerificationRequest.AppHash)
+ if err != nil {
+ logging.Error("Error decoding app hash", types.Participants, "error", err)
+ return echo.NewHTTPError(http.StatusBadRequest, errors.Wrap(err, "Error decoding app hash"))
+ }
+
+ value, err := hex.DecodeString(proofVerificationRequest.Value)
+ if err != nil {
+ logging.Error("Error decoding value", types.Participants, "error", err)
+ return echo.NewHTTPError(http.StatusBadRequest, errors.Wrap(err, "Error decoding value"))
+ }
+
+ logging.Info("Attempting verification", types.Participants, "verKey", verKey, "appHash", appHash, "value", proofVerificationRequest.Value)
+
+ err = merkleproof.VerifyUsingProofRt(&proofVerificationRequest.ProofOps, appHash, verKey, value)
+ if err != nil {
+ logging.Info("VerifyUsingProofRt failed", types.Participants, "error", err)
+ return err
+ }
+ return ctx.NoContent(http.StatusOK)
+}
+
+func (s *Server) postVerifyBlock(ctx echo.Context) error {
+ var blockVerificationRequest VerifyBlockRequest
+ if err := ctx.Bind(&blockVerificationRequest); err != nil {
+ logging.Error("Error decoding request", types.Participants, "error", err)
+ return echo.NewHTTPError(http.StatusBadRequest, err)
+ }
+
+ block := &blockVerificationRequest.Block
+ valSet := make([]*comettypes.Validator, len(blockVerificationRequest.Validators))
+ for i, validator := range blockVerificationRequest.Validators {
+ pubKeyBytes, err := base64.StdEncoding.DecodeString(validator.PubKey)
+ if err != nil {
+ logging.Error("Error decoding public key", types.Participants, "error", err)
+ return echo.NewHTTPError(http.StatusBadRequest, errors.Wrap(err, "Error decoding public key"))
+ }
+
+ pubKey := cmcryptoed.PubKey(pubKeyBytes)
+ valSet[i] = comettypes.NewValidator(pubKey, validator.VotingPower)
+ }
+
+ err := debug(s.configManager.GetChainNodeConfig().Url, block)
+ if err != nil {
+ logging.Error("Debug block verification failed!", types.Participants, "error", err)
+ return err
+ }
+
+ logging.Info("Received validators", types.Participants, "height", block.Height, "valSet", valSet)
+
+ err = merkleproof.VerifyCommit(block.Header.ChainID, block.LastCommit, &block.Header, valSet)
+ if err != nil {
+ logging.Error("Block signature verification failed", types.Participants, "error", err)
+ return err
+ }
+ return ctx.NoContent(http.StatusOK)
+}
+
+func debug(address string, block *comettypes.Block) error {
+ rpcClient, err := rpcclient.New(address, "/websocket")
+ if err != nil {
+ return err
+ }
+
+ valSetRes, err := rpcClient.Validators(context.Background(), &block.Height, nil, nil)
+ if err != nil {
+ return err
+ }
+ valSet := valSetRes.Validators
+ logging.Info("Ground truth validators", types.Participants, "height", block.Height, "valSet", valSet)
+
+ return merkleproof.VerifyCommit(block.Header.ChainID, block.LastCommit, &block.Header, valSet)
+}
diff --git a/decentralized-api/internal/server/public/app_info_handlers.go b/decentralized-api/internal/server/public/app_info_handlers.go
new file mode 100644
index 000000000..0eb80a7e0
--- /dev/null
+++ b/decentralized-api/internal/server/public/app_info_handlers.go
@@ -0,0 +1,37 @@
+package public
+
+import (
+ "decentralized-api/logging"
+ "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"
+)
+
+func (s *Server) getVersions(ctx echo.Context) 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 ctx.JSON(http.StatusInternalServerError, map[string]string{
+ "error": "failed to get node info",
+ })
+ }
+ nodeVersion := resp.ApplicationVersion
+
+ return ctx.JSON(http.StatusOK, map[string]any{
+ "timestamp": time.Now().UTC().Format(time.RFC3339),
+ "api_version": map[string]string{
+ "application_name": version.AppName,
+ "version": version.Version,
+ "commit": version.Commit,
+ },
+ "node_version": map[string]string{
+ "application_name": nodeVersion.Name,
+ "version": nodeVersion.Version,
+ "commit": nodeVersion.GitCommit,
+ },
+ })
+}
diff --git a/decentralized-api/internal/server/public/bls_handlers.go b/decentralized-api/internal/server/public/bls_handlers.go
new file mode 100644
index 000000000..a83ef96d1
--- /dev/null
+++ b/decentralized-api/internal/server/public/bls_handlers.go
@@ -0,0 +1,118 @@
+package public
+
+import (
+ "context"
+ "encoding/hex"
+ "net/http"
+ "strconv"
+ "strings"
+
+ bls12381 "github.com/consensys/gnark-crypto/ecc/bls12-381"
+ "github.com/consensys/gnark-crypto/ecc/bls12-381/fp"
+ "github.com/labstack/echo/v4"
+ blsTypes "github.com/productscience/inference/x/bls/types"
+)
+
+// getBLSEpochByID handles requests for BLS epoch data
+func (s *Server) getBLSEpochByID(c echo.Context) error {
+ idStr := c.Param("id")
+ epochID, err := strconv.ParseUint(idStr, 10, 64)
+ if err != nil {
+ return echo.NewHTTPError(http.StatusBadRequest, "Invalid epoch ID")
+ }
+
+ blsQueryClient := s.recorder.NewBLSQueryClient()
+ res, err := blsQueryClient.EpochBLSData(context.Background(), &blsTypes.QueryEpochBLSDataRequest{
+ EpochId: epochID,
+ })
+ if err != nil {
+ return echo.NewHTTPError(http.StatusInternalServerError, "Failed to query BLS epoch data: "+err.Error())
+ }
+
+ // Convenience fields: uncompressed G2 group key (256 bytes) and uncompressed validation signature (128 bytes)
+ var uncompressedG2 []byte
+ if len(res.EpochData.GroupPublicKey) == 96 {
+ var g2 bls12381.G2Affine
+ if err := g2.Unmarshal(res.EpochData.GroupPublicKey); err == nil {
+ appendFp64 := func(e fp.Element, dst *[]byte) {
+ be48 := e.Bytes()
+ var limb [64]byte
+ copy(limb[64-48:], be48[:])
+ *dst = append(*dst, limb[:]...)
+ }
+ // Order: X.c0, X.c1, Y.c0, Y.c1
+ appendFp64(g2.X.A0, &uncompressedG2)
+ appendFp64(g2.X.A1, &uncompressedG2)
+ appendFp64(g2.Y.A0, &uncompressedG2)
+ appendFp64(g2.Y.A1, &uncompressedG2)
+ }
+ }
+
+ var uncompressedValSig []byte
+ if len(res.EpochData.ValidationSignature) == 48 {
+ var g1 bls12381.G1Affine
+ if err := g1.Unmarshal(res.EpochData.ValidationSignature); err == nil {
+ appendFp64 := func(e fp.Element, dst *[]byte) {
+ be48 := e.Bytes()
+ var limb [64]byte
+ copy(limb[64-48:], be48[:])
+ *dst = append(*dst, limb[:]...)
+ }
+ appendFp64(g1.X, &uncompressedValSig)
+ appendFp64(g1.Y, &uncompressedValSig)
+ }
+ }
+
+ return c.JSON(http.StatusOK, map[string]interface{}{
+ "epoch_data": res.EpochData,
+ "group_public_key_uncompressed_256": uncompressedG2,
+ "validation_signature_uncompressed_128": uncompressedValSig,
+ })
+}
+
+// getBLSSignatureByRequestID handles requests for BLS signature data
+func (s *Server) getBLSSignatureByRequestID(c echo.Context) error {
+ requestIDHex := c.Param("request_id")
+ requestIDBytes, err := hex.DecodeString(requestIDHex)
+ if err != nil {
+ return echo.NewHTTPError(http.StatusBadRequest, "Invalid request ID format (must be hex-encoded)")
+ }
+
+ blsQueryClient := s.recorder.NewBLSQueryClient()
+ res, err := blsQueryClient.SigningStatus(context.Background(), &blsTypes.QuerySigningStatusRequest{
+ RequestId: requestIDBytes,
+ })
+ if err != nil {
+ // If the request is not found, return null instead of an error to match client expectations
+ if strings.Contains(err.Error(), "not found") {
+ return c.JSON(http.StatusOK, map[string]interface{}{"signing_request": nil})
+ }
+ return echo.NewHTTPError(http.StatusInternalServerError, "Failed to query BLS signature data: "+err.Error())
+ }
+
+ // Augment response with 128-byte uncompressed G1 signature (x||y, each 64-byte big-endian) if available
+ var uncompressedSig []byte
+ if res != nil && res.SigningRequest.Status == blsTypes.ThresholdSigningStatus_THRESHOLD_SIGNING_STATUS_COMPLETED {
+ sig := res.SigningRequest.FinalSignature
+ if len(sig) == 48 {
+ var g1 bls12381.G1Affine
+ if err := g1.Unmarshal(sig); err == nil {
+ // Build 64-byte big-endian limbs from 48-byte field elements
+ appendFp64 := func(e fp.Element, dst *[]byte) {
+ be48 := e.Bytes()
+ var limb [64]byte
+ copy(limb[64-48:], be48[:])
+ *dst = append(*dst, limb[:]...)
+ }
+ appendFp64(g1.X, &uncompressedSig)
+ appendFp64(g1.Y, &uncompressedSig)
+ }
+ }
+ }
+
+ // Return composite JSON with original signing_request and convenience field
+ return c.JSON(http.StatusOK, map[string]interface{}{
+ "signing_request": res.SigningRequest,
+ "uncompressed_signature_128": uncompressedSig, // base64-encoded in JSON
+ })
+}
diff --git a/decentralized-api/internal/server/public/bridge_handlers.go b/decentralized-api/internal/server/public/bridge_handlers.go
new file mode 100644
index 000000000..928722311
--- /dev/null
+++ b/decentralized-api/internal/server/public/bridge_handlers.go
@@ -0,0 +1,396 @@
+package public
+
+import (
+ "decentralized-api/cosmosclient"
+ cosmos_client "decentralized-api/cosmosclient"
+
+ "fmt"
+ "io"
+ "log/slog"
+ "net/http"
+ "sort"
+ "strconv"
+ "strings"
+ "sync"
+ "time"
+
+ "github.com/labstack/echo/v4"
+ "github.com/productscience/inference/x/inference/types"
+)
+
+// BlockQueue manages a queue of blocks to be processed
+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
+}
+
+// PostBlockResponse is returned by postBlock on success
+type PostBlockResponse struct {
+ Status string `json:"status"`
+ Message string `json:"message"`
+ BlockNumber string `json:"blockNumber"`
+ ReceiptsCount int `json:"receiptsCount"`
+ QueueSize int `json:"queueSize"`
+}
+
+// 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"`
+}
+
+// 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
+ }
+
+ // Start the queue processor
+ go queue.init()
+
+ return queue
+}
+
+// AddBlock adds a block to the queue
+func (q *BridgeQueue) AddBlock(block BridgeBlock) string {
+ 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
+ }
+
+ q.pendingBlocks[block.BlockNumber] = &block
+
+ slog.Info("Bridge queue: Added block as pending",
+ "blockNumber", block.BlockNumber,
+ "originChain", block.OriginChain,
+ "receiptsCount", len(block.Receipts),
+ "queueLength", len(q.pendingBlocks))
+
+ // 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
+ }
+ }
+
+ return block.BlockNumber
+}
+
+// GetPendingBlocks returns all pending blocks
+func (q *BridgeQueue) GetPendingBlocks() []BridgeBlock {
+ q.lock.RLock()
+ defer q.lock.RUnlock()
+
+ result := make([]BridgeBlock, 0, len(q.pendingBlocks))
+ for _, block := range q.pendingBlocks {
+ result = append(result, *block)
+ }
+
+ return result
+}
+
+// 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()
+ }
+ }
+}
+
+// processBlocks processes queued blocks in order starting from the earliest
+func (q *BridgeQueue) processBlocks() {
+ for {
+ block, exists := q.getNextBlock()
+ if !exists {
+ break
+ }
+
+ // 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)
+ }
+ }
+}
+
+// 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 blockNum, pendingBlock := range q.pendingBlocks {
+ blocks = append(blocks, struct {
+ blockNumber string
+ block BridgeBlock
+ }{
+ blockNumber: blockNum,
+ block: *pendingBlock,
+ })
+ }
+
+ // 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",
+ "chain", block.OriginChain,
+ "contract", receipt.ContractAddress,
+ "owner", receipt.OwnerAddress,
+ "publicKey", receipt.OwnerPubKey,
+ "amount", receipt.Amount,
+ "blockNumber", block.BlockNumber,
+ "receiptIndex", receipt.ReceiptIndex)
+
+ // Derive Cosmos address from public key
+ 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
+ }
+
+ // 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{
+ Validator: q.recorder.GetAccountAddress(),
+ OriginChain: block.OriginChain,
+ ContractAddress: receipt.ContractAddress,
+ OwnerAddress: cosmosAddress,
+ OwnerPubKey: ownerPubKey,
+ Amount: receipt.Amount,
+ BlockNumber: block.BlockNumber,
+ ReceiptIndex: receipt.ReceiptIndex,
+ ReceiptsRoot: block.ReceiptsRoot,
+ }
+
+ err = q.recorder.BridgeExchange(msg)
+ if err != nil {
+ slog.Error("Error processing bridge exchange",
+ "error", err,
+ "blockNumber", block.BlockNumber,
+ "receiptIndex", receipt.ReceiptIndex)
+ }
+}
+
+// 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)
+ if err != nil {
+ slog.Error("Failed to read request body", "error", err)
+ return echo.NewHTTPError(http.StatusBadRequest, "Failed to read request body")
+ }
+
+ // 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)))
+
+ 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())
+ }
+
+ // Validate required fields
+ if blockData.BlockNumber == "" || blockData.ReceiptsRoot == "" || blockData.OriginChain == "" {
+ return echo.NewHTTPError(http.StatusBadRequest, "Required fields missing: blockNumber, receiptsRoot, originChain")
+ }
+
+ 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)
+ }
+
+ // 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: len(s.blockQueue.pendingBlocks),
+ })
+}
+
+// getBridgeStatus returns information about the queue status
+func (s *Server) getBridgeStatus(c echo.Context) error {
+ pendingBlocks := s.blockQueue.GetPendingBlocks()
+
+ // Group blocks by number
+ blockCountByNumber := make(map[string]int)
+
+ // 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)
+ }
+ }
+
+ 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]
+ })
+
+ 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,
+ }
+
+ return c.JSON(http.StatusOK, response)
+}
+
+// getBridgeAddresses returns bridge addresses for a specific chain by name
+func (s *Server) getBridgeAddresses(c echo.Context) error {
+ chainName := c.QueryParam("chain")
+
+ if chainName == "" {
+ return echo.NewHTTPError(http.StatusBadRequest, "Chain parameter is required (e.g., 'ethereum', 'polygon')")
+ }
+
+ // 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)
+ }
+
+ return c.JSON(http.StatusOK, &BridgeAddressesResponse{
+ ChainName: chainName,
+ ChainID: chainId,
+ Addresses: addressList,
+ })
+}
diff --git a/decentralized-api/internal/server/public/debug_handlers.go b/decentralized-api/internal/server/public/debug_handlers.go
new file mode 100644
index 000000000..c87ed0301
--- /dev/null
+++ b/decentralized-api/internal/server/public/debug_handlers.go
@@ -0,0 +1,37 @@
+package public
+
+import (
+ "cosmossdk.io/errors"
+ cosmos_client "decentralized-api/cosmosclient"
+ "decentralized-api/logging"
+ "decentralized-api/merkleproof"
+ "github.com/labstack/echo/v4"
+ "github.com/productscience/inference/x/inference/types"
+ "net/http"
+ "strconv"
+)
+
+func (s *Server) debugPubKeyToAddr(ctx echo.Context) error {
+ pubkey := ctx.Param("pubkey")
+ addr, err := cosmos_client.PubKeyToAddress(pubkey)
+ if err != nil {
+ logging.Error("Failed to convert pubkey to address", types.Participants, "error", err)
+ return echo.NewHTTPError(http.StatusBadRequest, errors.Wrap(err, "invalid pubkey"))
+ }
+ return ctx.String(http.StatusOK, addr)
+}
+
+func (s *Server) debugVerify(ctx echo.Context) error {
+ heightStr := ctx.Param("height")
+ height, err := strconv.ParseInt(heightStr, 10, 64)
+ if err != nil {
+ return echo.NewHTTPError(http.StatusBadRequest, errors.Wrap(err, "invalid height"))
+ }
+
+ logging.Debug("Verifying block signatures", types.System, "height", height)
+ if err := merkleproof.VerifyBlockSignatures(s.configManager.GetChainNodeConfig().Url, height); err != nil {
+ logging.Error("Failed to verify block signatures", types.Participants, "error", err)
+ return err
+ }
+ return ctx.String(http.StatusOK, "Block signatures verified")
+}
diff --git a/decentralized-api/internal/server/public/entities.go b/decentralized-api/internal/server/public/entities.go
new file mode 100644
index 000000000..da94e5970
--- /dev/null
+++ b/decentralized-api/internal/server/public/entities.go
@@ -0,0 +1,158 @@
+package public
+
+import (
+ "net/http"
+
+ cryptotypes "github.com/cometbft/cometbft/proto/tendermint/crypto"
+ comettypes "github.com/cometbft/cometbft/types"
+ "github.com/productscience/inference/x/inference/types"
+)
+
+type ChatRequest struct {
+ Body []byte
+ Request *http.Request
+ OpenAiRequest OpenAiRequest
+ AuthKey string // signature signing inference request
+ Seed string
+ InferenceId string
+ RequesterAddress string // address of participant, who signed inference request
+ TransferAddress string
+ Timestamp int64 // timestamp of the request
+ TransferSignature string // signature of the transfer address
+}
+
+type OpenAiRequest struct {
+ Model string `json:"model"`
+ Seed int32 `json:"seed"`
+ MaxTokens int32 `json:"max_tokens"`
+ MaxCompletionTokens int32 `json:"max_completion_tokens"`
+ Messages []Message `json:"messages"`
+}
+
+type Message struct {
+ Content string `json:"content"` // The content of the message
+}
+
+type ExecutorDestination struct {
+ Url string `json:"url"`
+ Address string `json:"address"`
+}
+
+type ModelsResponse struct {
+ Models []types.Model `json:"models"`
+}
+
+type ActiveParticipantWithProof struct {
+ ActiveParticipants types.ActiveParticipants `json:"active_participants"`
+ Addresses []string `json:"addresses"`
+ ActiveParticipantsBytes string `json:"active_participants_bytes"`
+ ProofOps *cryptotypes.ProofOps `json:"proof_ops"`
+ Validators []*comettypes.Validator `json:"validators"`
+ Block *comettypes.Block `json:"block"`
+ ExcludedParticipants []ExcludedParticipant `json:"excluded_participants"`
+ // CommitInfo storetypes.CommitInfo `json:"commit_info"`
+}
+
+type ExcludedParticipant struct {
+ Address string `json:"address"`
+ Reason string `json:"reason"`
+ ExclusionBlockHeight int64 `json:"exclusion_block_height"`
+}
+
+type ParticipantDto struct {
+ Id string `json:"id"`
+ Url string `json:"url"`
+ CoinsOwed int64 `json:"coins_owed"`
+ RefundsOwed int64 `json:"refunds_owed"`
+ Balance int64 `json:"balance"`
+ VotingPower int64 `json:"voting_power"`
+ Reputation float32 `json:"reputation"`
+}
+
+type ParticipantsDto struct {
+ Participants []ParticipantDto `json:"participants"`
+ BlockHeight int64 `json:"block_height"`
+}
+
+type StartTrainingDto struct {
+ HardwareResources []HardwareResourcesDto `json:"hardware_resources"`
+ Config TrainingConfigDto `json:"config"`
+}
+
+type HardwareResourcesDto struct {
+ Type string `json:"type"`
+ Count uint32 `json:"count"`
+}
+
+type TrainingConfigDto struct {
+ Datasets TrainingDatasetsDto `json:"datasets"`
+ NumUocEstimationSteps uint32 `json:"num_uoc_estimation_steps"`
+}
+
+type TrainingDatasetsDto struct {
+ Train string `json:"train"`
+ Test string `json:"test"`
+}
+
+type LockTrainingNodesDto struct {
+ TrainingTaskId uint64 `json:"training_task_id"`
+ NodeIds []string `json:"node_ids"`
+}
+
+type ProofVerificationRequest struct {
+ Value string `json:"value"`
+ AppHash string `json:"app_hash"`
+ ProofOps cryptotypes.ProofOps `json:"proof_ops"`
+ Epoch int64 `json:"epoch"`
+}
+
+type VerifyBlockRequest struct {
+ Block comettypes.Block `json:"block"`
+ Validators []Validator `json:"validators"`
+}
+
+type Validator struct {
+ PubKey string `json:"pub_key"`
+ VotingPower int64 `json:"voting_power"`
+}
+
+type UnitOfComputePriceProposalDto struct {
+ Price uint64 `json:"price"`
+ Denom string `json:"denom"`
+}
+
+type PricingDto struct {
+ Price uint64 `json:"unit_of_compute_price"` // Legacy field for backward compatibility
+ Models []ModelPriceDto `json:"models"`
+ // Dynamic pricing information
+ DynamicPricingEnabled bool `json:"dynamic_pricing_enabled"`
+}
+
+type RegisterModelDto struct {
+ Id string `json:"id"`
+ UnitsOfComputePerToken uint64 `json:"units_of_compute_per_token"`
+}
+
+type ModelPriceDto struct {
+ Id string `json:"id"`
+ UnitsOfComputePerToken uint64 `json:"units_of_compute_per_token"` // Legacy field for backward compatibility
+ PricePerToken uint64 `json:"price_per_token"` // Current price (dynamic or legacy)
+ // Model metrics information
+ Utilization *float64 `json:"utilization,omitempty"` // Current utilization if available
+ Capacity *int64 `json:"capacity,omitempty"` // Model capacity if available
+}
+
+// FinalizedBlock represents a finalized block with optional receipts
+type BridgeBlock struct {
+ BlockNumber string `json:"blockNumber"`
+ OriginChain string `json:"originChain"` // Name of the origin chain (e.g., "ethereum")
+ ReceiptsRoot string `json:"receiptsRoot"` // Merkle root of receipts trie for transaction verification
+ Receipts []BridgeReceipt `json:"receipts,omitempty"` // Optional list of receipts
+}
+type BridgeReceipt struct {
+ ContractAddress string `json:"contract"` // Address of the smart contract on the origin chain
+ OwnerAddress string `json:"owner"` // Address of the token owner on the origin chain
+ OwnerPubKey string `json:"publicKey"` // Public key of the token owner on the origin chain
+ Amount string `json:"amount"` // Amount of tokens to be bridged
+ ReceiptIndex string `json:"receiptIndex"` // Index of the transaction receipt in the block
+}
diff --git a/decentralized-api/internal/server/public/errors.go b/decentralized-api/internal/server/public/errors.go
new file mode 100644
index 000000000..145d5d918
--- /dev/null
+++ b/decentralized-api/internal/server/public/errors.go
@@ -0,0 +1,19 @@
+package public
+
+import (
+ "github.com/labstack/echo/v4"
+ "net/http"
+)
+
+var (
+ ErrRequestAuth = echo.NewHTTPError(http.StatusUnauthorized, "Authorization is required")
+ ErrInferenceParticipantNotFound = echo.NewHTTPError(http.StatusNotFound, "Inference participant not found")
+ ErrInsufficientBalance = echo.NewHTTPError(http.StatusPaymentRequired, "Insufficient balance")
+
+ ErrIdRequired = echo.NewHTTPError(http.StatusBadRequest, "Id is required")
+ ErrAddressRequired = echo.NewHTTPError(http.StatusBadRequest, "Address is required")
+ ErrInvalidEpochId = echo.NewHTTPError(http.StatusBadRequest, "Invalid epoch id")
+ ErrInvalidTrainingJobId = echo.NewHTTPError(http.StatusBadRequest, "Invalid training job id")
+ ErrEpochIsNotReached = echo.NewHTTPError(http.StatusBadRequest, "Epoch is not reached")
+ ErrInferenceNotFound = echo.NewHTTPError(http.StatusNotFound, "Inference not found")
+)
diff --git a/decentralized-api/internal/server/public/get_chat_handler.go b/decentralized-api/internal/server/public/get_chat_handler.go
new file mode 100644
index 000000000..1e595f959
--- /dev/null
+++ b/decentralized-api/internal/server/public/get_chat_handler.go
@@ -0,0 +1,48 @@
+package public
+
+import (
+ "decentralized-api/logging"
+ "github.com/labstack/echo/v4"
+ "github.com/productscience/inference/x/inference/types"
+ "google.golang.org/grpc/codes"
+ "google.golang.org/grpc/status"
+ "net/http"
+ "net/url"
+)
+
+func (s *Server) getChatById(ctx echo.Context) error {
+ logging.Debug("GetCompletion received", types.Inferences)
+ encodedId := ctx.Param("id")
+ if encodedId == "" {
+ return ErrIdRequired
+ }
+
+ // URL decode the inference ID
+ id, err := url.QueryUnescape(encodedId)
+ if err != nil {
+ logging.Error("Failed to decode inference ID", types.Inferences, "encodedId", encodedId, "error", err)
+ return echo.NewHTTPError(http.StatusBadRequest, "Invalid inference ID")
+ }
+
+ logging.Debug("GET inference", types.Inferences, "id", id)
+
+ queryClient := s.recorder.NewInferenceQueryClient()
+ response, err := queryClient.Inference(ctx.Request().Context(), &types.QueryGetInferenceRequest{Index: id})
+ if err != nil {
+ if grpcStatus, ok := status.FromError(err); ok && grpcStatus.Code() == codes.NotFound {
+ logging.Debug("Inference not found", types.Inferences, "id", id, "error", err)
+ return ErrInferenceNotFound
+ }
+
+ // return 500
+ logging.Error("Failed to get inference", types.Inferences, "id", id, "error", err)
+ return err
+ }
+
+ if response == nil {
+ logging.Error("Inference not found", types.Inferences, "id", id)
+ return ErrInferenceNotFound
+ }
+
+ return ctx.JSON(http.StatusOK, response.Inference)
+}
diff --git a/decentralized-api/internal/server/public/get_epoch.go b/decentralized-api/internal/server/public/get_epoch.go
new file mode 100644
index 000000000..98f50341a
--- /dev/null
+++ b/decentralized-api/internal/server/public/get_epoch.go
@@ -0,0 +1,60 @@
+package public
+
+import (
+ "decentralized-api/logging"
+ "github.com/labstack/echo/v4"
+ "github.com/productscience/inference/x/inference/types"
+ "net/http"
+)
+
+type EpochResponse struct {
+ BlockHeight int64 `json:"block_height"`
+ LatestEpoch LatestEpochDto `json:"latest_epoch"`
+ Phase types.EpochPhase `json:"phase"`
+ EpochStages types.EpochStages `json:"epoch_stages"`
+ NextEpochStages types.EpochStages `json:"next_epoch_stages"`
+ EpochParams types.EpochParams `json:"epoch_params"`
+ IsConfirmationPocActive bool `json:"is_confirmation_poc_active"`
+ ActiveConfirmationPocEvent *types.ConfirmationPoCEvent `json:"active_confirmation_poc_event,omitempty"`
+}
+
+// LatestEpochDto, had to indroduced it, because types.Epoch doesn't serialize when
+// Index and PocStartBlockHeight are 0
+type LatestEpochDto struct {
+ Index uint64 `json:"index"`
+ PocStartBlockHeight int64 `json:"poc_start_block_height"`
+}
+
+func (s *Server) getEpochById(ctx echo.Context) error {
+ epochParam := ctx.Param("epoch")
+ if epochParam != "latest" {
+ return echo.NewHTTPError(http.StatusBadRequest, "Only getting info for current epoch is supported at the moment")
+ }
+
+ queryClient := s.recorder.NewInferenceQueryClient()
+ epochInfo, err := queryClient.EpochInfo(ctx.Request().Context(), &types.QueryEpochInfoRequest{})
+ if err != nil {
+ logging.Error("Failed to get latest epoch info", types.EpochGroup, "error", err)
+ return echo.NewHTTPError(http.StatusInternalServerError, err.Error())
+ }
+
+ epochParams := *epochInfo.Params.EpochParams
+
+ epochContext := types.NewEpochContext(epochInfo.LatestEpoch, epochParams)
+ nextEpochContext := epochContext.NextEpochContext()
+
+ response := EpochResponse{
+ BlockHeight: epochInfo.BlockHeight,
+ LatestEpoch: LatestEpochDto{
+ Index: epochInfo.LatestEpoch.Index,
+ PocStartBlockHeight: epochInfo.LatestEpoch.PocStartBlockHeight,
+ },
+ Phase: epochContext.GetCurrentPhase(epochInfo.BlockHeight),
+ EpochStages: epochContext.GetEpochStages(),
+ NextEpochStages: nextEpochContext.GetEpochStages(),
+ EpochParams: *epochInfo.Params.EpochParams,
+ IsConfirmationPocActive: epochInfo.IsConfirmationPocActive,
+ ActiveConfirmationPocEvent: epochInfo.ActiveConfirmationPocEvent,
+ }
+ return ctx.JSON(http.StatusOK, response)
+}
diff --git a/decentralized-api/internal/server/public/get_models_handler.go b/decentralized-api/internal/server/public/get_models_handler.go
new file mode 100644
index 000000000..3a0122869
--- /dev/null
+++ b/decentralized-api/internal/server/public/get_models_handler.go
@@ -0,0 +1,57 @@
+package public
+
+import (
+ "net/http"
+
+ "github.com/labstack/echo/v4"
+ "github.com/productscience/inference/x/inference/types"
+)
+
+func (s *Server) getModels(ctx echo.Context) error {
+ queryClient := s.recorder.NewInferenceQueryClient()
+ context := s.recorder.GetContext()
+
+ // Get the current epoch group to find out which models are active.
+ currentEpoch, err := queryClient.CurrentEpochGroupData(context, &types.QueryCurrentEpochGroupDataRequest{})
+ if err != nil {
+ return err
+ }
+
+ var activeModels []types.Model
+ parentEpochData := currentEpoch.GetEpochGroupData()
+
+ // Iterate over the subgroup models to get the snapshot for each one.
+ for _, modelId := range parentEpochData.SubGroupModels {
+ req := &types.QueryGetEpochGroupDataRequest{
+ EpochIndex: parentEpochData.EpochIndex,
+ ModelId: modelId,
+ }
+ modelEpochData, err := queryClient.EpochGroupData(context, req)
+ if err != nil {
+ // If a model subgroup is listed but not found, we can log it, but we shouldn't fail the entire request.
+ continue
+ }
+
+ if modelEpochData.EpochGroupData.ModelSnapshot != nil {
+ activeModels = append(activeModels, *modelEpochData.EpochGroupData.ModelSnapshot)
+ }
+ }
+
+ return ctx.JSON(http.StatusOK, &ModelsResponse{
+ Models: activeModels,
+ })
+}
+
+func (s *Server) getGovernanceModels(ctx echo.Context) error {
+ queryClient := s.recorder.NewInferenceQueryClient()
+ context := s.recorder.GetContext()
+
+ modelsResponse, err := queryClient.ModelsAll(context, &types.QueryModelsAllRequest{})
+ if err != nil {
+ return err
+ }
+
+ return ctx.JSON(http.StatusOK, &ModelsResponse{
+ Models: modelsResponse.Model,
+ })
+}
diff --git a/decentralized-api/internal/server/public/get_participants_handler.go b/decentralized-api/internal/server/public/get_participants_handler.go
new file mode 100644
index 000000000..90d53a811
--- /dev/null
+++ b/decentralized-api/internal/server/public/get_participants_handler.go
@@ -0,0 +1,374 @@
+package public
+
+import (
+ "context"
+ cosmos_client "decentralized-api/cosmosclient"
+ "decentralized-api/logging"
+ "decentralized-api/merkleproof"
+ "encoding/base64"
+ "encoding/hex"
+ "fmt"
+ "net/http"
+ "net/url"
+ "strconv"
+ "strings"
+
+ comettypes "github.com/cometbft/cometbft/types"
+
+ "github.com/cometbft/cometbft/crypto/tmhash"
+ rpcclient "github.com/cometbft/cometbft/rpc/client/http"
+ coretypes "github.com/cometbft/cometbft/rpc/core/types"
+ "github.com/cosmos/cosmos-sdk/codec"
+ codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+ grpctypes "github.com/cosmos/cosmos-sdk/types/grpc"
+ "github.com/cosmos/cosmos-sdk/types/query"
+ "github.com/labstack/echo/v4"
+ "github.com/productscience/inference/x/inference/types"
+ "google.golang.org/grpc"
+ "google.golang.org/grpc/metadata"
+)
+
+func (s *Server) getInferenceParticipantByAddress(c echo.Context) error {
+ address := c.Param("address")
+ if address == "" {
+ return ErrAddressRequired
+ }
+
+ logging.Debug("GET inference participant", types.Inferences, "address", address)
+
+ queryClient := s.recorder.NewInferenceQueryClient()
+ response, err := queryClient.InferenceParticipant(c.Request().Context(), &types.QueryInferenceParticipantRequest{
+ Address: address,
+ })
+ if err != nil {
+ logging.Error("Failed to get inference participant", types.Inferences, "address", address, "error", err)
+ return err
+ }
+
+ if response == nil {
+ logging.Error("Inference participant not found", types.Inferences, "address", address)
+ return ErrInferenceParticipantNotFound
+ }
+
+ return c.JSON(http.StatusOK, response)
+}
+
+func (s *Server) getParticipantsByEpoch(c echo.Context) error {
+ epoch, err := s.resolveEpochFromContext(c)
+ if err != nil {
+ logging.Error("Failed to resolve epoch from context", types.Server, "error", err)
+ return err
+ }
+
+ resp, err := s.getParticipants(c.Request().Context(), epoch)
+ if err != nil {
+ return err
+ }
+ return c.JSON(http.StatusOK, resp)
+}
+
+// resolveEpochFromContext extracts the epoch from the context parameters.
+// If the epoch is "current", it returns nil
+func (s *Server) resolveEpochFromContext(c echo.Context) (uint64, error) {
+ epochParam := c.Param("epoch")
+ if epochParam == "" {
+ return 0, ErrInvalidEpochId
+ }
+
+ if epochParam == "current" {
+ queryClient := s.recorder.NewInferenceQueryClient()
+ currEpoch, err := queryClient.GetCurrentEpoch(s.recorder.GetContext(), &types.QueryGetCurrentEpochRequest{})
+ if err != nil {
+ logging.Error("Failed to get current epoch", types.Participants, "error", err)
+ return 0, err
+ }
+ logging.Info("Current epoch resolved.", types.Participants, "epoch", currEpoch.Epoch)
+ return currEpoch.Epoch, nil
+ } else {
+ epochId, err := strconv.ParseUint(epochParam, 10, 64)
+ if err != nil {
+ return 0, ErrInvalidEpochId
+ }
+ return epochId, nil
+ }
+}
+
+func (s *Server) getParticipants(ctx context.Context, epoch uint64) (*ActiveParticipantWithProof, error) {
+ // FIXME: now we can set active participants even for epoch 0, fix InitGenesis for that
+ if epoch == 0 {
+ return nil, echo.NewHTTPError(http.StatusBadRequest, "Epoch enumeration starts with 1")
+ }
+
+ interfaceRegistry := codectypes.NewInterfaceRegistry()
+ types.RegisterInterfaces(interfaceRegistry)
+
+ cdc := codec.NewProtoCodec(interfaceRegistry)
+
+ rpcClient, err := cosmos_client.NewRpcClient(s.configManager.GetChainNodeConfig().Url)
+ if err != nil {
+ logging.Error("Failed to create rpc client", types.System, "error", err)
+ return nil, err
+ }
+
+ result, err := queryActiveParticipants(rpcClient, cdc, epoch)
+ if err != nil {
+ logging.Error("Failed to query active participants. Outer", types.Participants, "error", err)
+ return nil, err
+ }
+
+ var activeParticipants types.ActiveParticipants
+ if err := cdc.Unmarshal(result.Response.Value, &activeParticipants); err != nil {
+ logging.Error("Failed to unmarshal active participant", types.Participants, "error", err)
+ return nil, err
+ }
+ logging.Info("Active participants retrieved", types.Participants,
+ "epoch", epoch,
+ "activeParticipants", activeParticipants)
+
+ block, err := rpcClient.Block(context.Background(), &activeParticipants.CreatedAtBlockHeight)
+ if err != nil || block == nil {
+ logging.Error("Failed to get block", types.Participants, "error", err)
+ return nil, err
+ }
+
+ heightP1 := activeParticipants.CreatedAtBlockHeight + 1
+ blockP1, err := rpcClient.Block(context.Background(), &heightP1)
+ if err != nil || blockP1 == nil {
+ logging.Error("Failed to get block + 1", types.Participants, "error", err)
+ }
+
+ vals, err := rpcClient.Validators(context.Background(), &activeParticipants.CreatedAtBlockHeight, nil, nil)
+ if err != nil || vals == nil {
+ logging.Error("Failed to get validators", types.Participants, "error", err)
+ return nil, err
+ }
+
+ // we need to verify proof from block N using hash from N+1,
+ // because hash of block N is made after Commit() and stored in
+ // header of block N+1. It works so to make each block 'link' to previous and have chain of blocks.
+ if result.Response.ProofOps != nil {
+ s.verifyProof(epoch, result, blockP1)
+ }
+
+ activeParticipantsBytes := hex.EncodeToString(result.Response.Value)
+
+ addresses := make([]string, len(activeParticipants.Participants))
+ for i, participant := range activeParticipants.Participants {
+ addresses[i], err = pubKeyToAddress3(participant.ValidatorKey)
+ if err != nil {
+ logging.Error("Failed to convert public key to address", types.Participants, "error", err)
+ }
+ }
+
+ var returnBlock *comettypes.Block
+ if blockP1 != nil {
+ returnBlock = blockP1.Block
+ }
+
+ return &ActiveParticipantWithProof{
+ ActiveParticipants: activeParticipants,
+ Addresses: addresses,
+ ActiveParticipantsBytes: activeParticipantsBytes,
+ ProofOps: result.Response.ProofOps,
+ Validators: vals.Validators,
+ Block: returnBlock,
+ ExcludedParticipants: s.getExcludedParticipants(ctx, epoch),
+ }, nil
+}
+
+func (s *Server) getExcludedParticipants(ctx context.Context, epoch uint64) []ExcludedParticipant {
+ queryClient := s.recorder.NewInferenceQueryClient()
+ excluded, err := queryClient.ExcludedParticipants(ctx, &types.QueryExcludedParticipantsRequest{EpochIndex: epoch})
+ if err != nil {
+ logging.Error("Failed to get excluded participants", types.Participants, "error", err)
+ return make([]ExcludedParticipant, 0)
+ }
+
+ excludedList := make([]ExcludedParticipant, len(excluded.Items))
+ for i, participant := range excluded.Items {
+ excludedList[i] = ExcludedParticipant{
+ Address: participant.Address,
+ Reason: participant.Reason,
+ ExclusionBlockHeight: int64(participant.ExclusionBlockHeight),
+ }
+ }
+
+ logging.Debug("Retrieved excluded participants", types.Participants, "count", len(excludedList))
+ return excludedList
+}
+
+func (s *Server) verifyProof(epoch uint64, result *coretypes.ResultABCIQuery, block *coretypes.ResultBlock) {
+ dataKey := types.ActiveParticipantsFullKey(epoch)
+ // Build the key path used by proof verification. We percent-encode the raw
+ // binary key so the path is a valid UTF-8/URL string.
+ verKey := "/inference/" + url.PathEscape(string(dataKey))
+ // verKey2 := string(result.Response.Key)
+ logging.Info("Attempting verification", types.Participants, "verKey", verKey)
+ err := merkleproof.VerifyUsingProofRt(result.Response.ProofOps, block.Block.AppHash, verKey, result.Response.Value)
+ if err != nil {
+ logging.Error("VerifyUsingProofRt failed", types.Participants, "error", err)
+ }
+
+ err = merkleproof.VerifyUsingMerkleProof(result.Response.ProofOps, block.Block.AppHash, "inference", string(dataKey), result.Response.Value)
+ if err != nil {
+ logging.Error("VerifyUsingMerkleProof failed", types.Participants, "error", err)
+ }
+}
+
+func (s *Server) getAllParticipants(ctx echo.Context) error {
+ queryClient := s.recorder.NewInferenceQueryClient()
+ var participants []ParticipantDto
+ var nextKey []byte
+ var pinnedCtx context.Context
+ var blockHeight int64
+
+ // First page: capture height from response headers
+ {
+ var hdr metadata.MD
+ req := &types.QueryAllParticipantRequest{
+ Pagination: &query.PageRequest{Key: nil, Limit: 1000},
+ }
+ resp, err := queryClient.ParticipantAll(ctx.Request().Context(), req, grpc.Header(&hdr))
+ if err != nil {
+ return err
+ }
+ // Pin height for subsequent pages
+ heights := hdr.Get(grpctypes.GRPCBlockHeightHeader)
+ if len(heights) == 0 {
+ return fmt.Errorf("missing %s header", grpctypes.GRPCBlockHeightHeader)
+ }
+ pinnedCtx = metadata.NewOutgoingContext(ctx.Request().Context(), metadata.Pairs(grpctypes.GRPCBlockHeightHeader, heights[0]))
+ if h, err := strconv.ParseInt(heights[0], 10, 64); err == nil {
+ blockHeight = h
+ }
+
+ // Convert this first page immediately
+ for _, p := range resp.Participant {
+ balances, err := s.recorder.BankBalances(pinnedCtx, p.Address)
+ pBalance := int64(0)
+ if err == nil {
+ for _, balance := range balances {
+ if balance.Denom == "ngonka" {
+ pBalance = balance.Amount.Int64()
+ }
+ }
+ if pBalance == 0 {
+ logging.Debug("Participant has no balance", types.Participants, "address", p.Address)
+ }
+ } else {
+ logging.Warn("Failed to get balance for participant", types.Participants, "address", p.Address, "error", err)
+ }
+ participants = append(participants, ParticipantDto{
+ Id: p.Address,
+ Url: p.InferenceUrl,
+ CoinsOwed: p.CoinBalance,
+ Balance: pBalance,
+ VotingPower: int64(p.Weight),
+ })
+ }
+ if resp.Pagination != nil {
+ nextKey = resp.Pagination.NextKey
+ }
+ }
+
+ // Process remaining pages
+ for len(nextKey) > 0 {
+ req := &types.QueryAllParticipantRequest{
+ Pagination: &query.PageRequest{Key: nextKey, Limit: 1000},
+ }
+ resp, err := queryClient.ParticipantAll(pinnedCtx, req)
+ if err != nil {
+ return err
+ }
+
+ // Convert this page immediately
+ for _, p := range resp.Participant {
+ balances, err := s.recorder.BankBalances(pinnedCtx, p.Address)
+ pBalance := int64(0)
+ if err == nil {
+ for _, balance := range balances {
+ if balance.Denom == "ngonka" {
+ pBalance = balance.Amount.Int64()
+ }
+ }
+ if pBalance == 0 {
+ logging.Debug("Participant has no balance", types.Participants, "address", p.Address)
+ }
+ } else {
+ logging.Warn("Failed to get balance for participant", types.Participants, "address", p.Address, "error", err)
+ }
+ participants = append(participants, ParticipantDto{
+ Id: p.Address,
+ Url: p.InferenceUrl,
+ CoinsOwed: p.CoinBalance,
+ Balance: pBalance,
+ VotingPower: int64(p.Weight),
+ })
+ }
+
+ if resp.Pagination == nil || len(resp.Pagination.NextKey) == 0 {
+ break
+ }
+ nextKey = resp.Pagination.NextKey
+ }
+
+ return ctx.JSON(http.StatusOK, &ParticipantsDto{
+ Participants: participants,
+ BlockHeight: blockHeight,
+ })
+}
+
+func queryActiveParticipants(rpcClient *rpcclient.HTTP, cdc *codec.ProtoCodec, epoch uint64) (*coretypes.ResultABCIQuery, error) {
+ dataKey := types.ActiveParticipantsFullKey(epoch)
+ result, err := cosmos_client.QueryByKey(rpcClient, "inference", dataKey)
+ if err != nil {
+ logging.Error("Failed to query active participants. Req 1", types.Participants, "error", err)
+ return nil, err
+ }
+
+ logging.Info("[PARTICIPANTS-DEBUG] Raw active participants query result", types.Participants,
+ "epoch", epoch,
+ "value_bytes", len(result.Response.Value))
+
+ if len(result.Response.Value) == 0 {
+ logging.Error("Active participants query returned empty value", types.Participants, "epoch", epoch)
+ return nil, echo.NewHTTPError(http.StatusNotFound, "No active participants found for the specified epoch. "+
+ "Looks like PoC failed!")
+ }
+
+ var activeParticipants types.ActiveParticipants
+ if err := cdc.Unmarshal(result.Response.Value, &activeParticipants); err != nil {
+ logging.Error("Failed to unmarshal active participant. Req 1", types.Participants, "error", err)
+ return nil, err
+ }
+
+ logging.Info("[PARTICIPANTS-DEBUG] Unmarshalled ActiveParticipants", types.Participants,
+ "epoch", epoch,
+ "created_at_block_height", activeParticipants.CreatedAtBlockHeight,
+ "effective_block_height", activeParticipants.EffectiveBlockHeight)
+
+ // We disable the second query with proof for now, because:
+ // 1. Data migration happened, and we can't validate pre-migration records recursively;
+ // they are now signed by the validators active during the epoch.
+ // 2. The implemented proof system has a bug anyway and needs to be revisited
+
+ blockHeight := activeParticipants.CreatedAtBlockHeight
+ result, err = cosmos_client.QueryByKeyWithOptions(rpcClient, "inference", dataKey, blockHeight, true)
+ if err != nil {
+ logging.Error("Failed to query active participant. Req 2", types.Participants, "error", err)
+ return nil, err
+ }
+
+ return result, err
+}
+
+func pubKeyToAddress3(pubKey string) (string, error) {
+ pubKeyBytes, err := base64.StdEncoding.DecodeString(pubKey)
+ if err != nil {
+ return "", err
+ }
+
+ valAddr := tmhash.SumTruncated(pubKeyBytes)
+ valAddrHex := strings.ToUpper(hex.EncodeToString(valAddr))
+ return valAddrHex, nil
+}
diff --git a/decentralized-api/internal/server/public/get_participants_handler_test.go b/decentralized-api/internal/server/public/get_participants_handler_test.go
new file mode 100644
index 000000000..fcf1fd37e
--- /dev/null
+++ b/decentralized-api/internal/server/public/get_participants_handler_test.go
@@ -0,0 +1,105 @@
+package public
+
+import (
+ "context"
+ "encoding/json"
+ "fmt"
+ "net"
+ "net/http"
+ "net/http/httptest"
+ "testing"
+
+ "decentralized-api/cosmosclient"
+
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ grpctypes "github.com/cosmos/cosmos-sdk/types/grpc"
+ "github.com/cosmos/cosmos-sdk/types/query"
+ "github.com/labstack/echo/v4"
+ "github.com/productscience/inference/x/inference/types"
+ "github.com/stretchr/testify/mock"
+ "github.com/stretchr/testify/require"
+ "google.golang.org/grpc"
+ "google.golang.org/grpc/metadata"
+ "google.golang.org/grpc/test/bufconn"
+)
+
+type fakeQueryServer struct {
+ types.UnimplementedQueryServer
+
+ firstPageParticipants []types.Participant
+ secondPageParticipants []types.Participant
+ receivedHeights []string
+}
+
+func (f *fakeQueryServer) ParticipantAll(ctx context.Context, req *types.QueryAllParticipantRequest) (*types.QueryAllParticipantResponse, error) {
+ if req.Pagination == nil || len(req.Pagination.Key) == 0 {
+ md := metadata.Pairs(grpctypes.GRPCBlockHeightHeader, "12345")
+ _ = grpc.SendHeader(ctx, md)
+ return &types.QueryAllParticipantResponse{
+ Participant: f.firstPageParticipants,
+ Pagination: &query.PageResponse{NextKey: []byte("next"), Total: uint64(len(f.firstPageParticipants) + len(f.secondPageParticipants))},
+ }, nil
+ }
+ if md, ok := metadata.FromIncomingContext(ctx); ok {
+ f.receivedHeights = append(f.receivedHeights, md.Get(grpctypes.GRPCBlockHeightHeader)...)
+ }
+ return &types.QueryAllParticipantResponse{
+ Participant: f.secondPageParticipants,
+ Pagination: &query.PageResponse{NextKey: nil, Total: uint64(len(f.firstPageParticipants) + len(f.secondPageParticipants))},
+ }, nil
+}
+
+func startBufGRPCServer(t *testing.T, srv types.QueryServer) (*grpc.ClientConn, func()) {
+ t.Helper()
+ listener := bufconn.Listen(1 << 20)
+ server := grpc.NewServer()
+ types.RegisterQueryServer(server, srv)
+ go func() { _ = server.Serve(listener) }()
+ dialer := func(context.Context, string) (net.Conn, error) { return listener.Dial() }
+ conn, err := grpc.DialContext(context.Background(), "bufnet", grpc.WithContextDialer(dialer), grpc.WithInsecure())
+ require.NoError(t, err)
+ cleanup := func() { server.Stop(); _ = listener.Close(); _ = conn.Close() }
+ return conn, cleanup
+}
+
+func TestGetAllParticipants_PaginationAndPinnedHeight(t *testing.T) {
+ first := make([]types.Participant, 100)
+ second := make([]types.Participant, 50)
+ for i := 0; i < 100; i++ {
+ first[i] = types.Participant{Address: fmt.Sprintf("addr%03d", i), InferenceUrl: "http://node", CoinBalance: int64(i), Weight: int32(i)}
+ }
+ for i := 0; i < 50; i++ {
+ second[i] = types.Participant{Address: fmt.Sprintf("addr%03d", 100+i), InferenceUrl: "http://node", CoinBalance: int64(100 + i), Weight: int32(100 + i)}
+ }
+
+ fq := &fakeQueryServer{firstPageParticipants: first, secondPageParticipants: second}
+ conn, cleanup := startBufGRPCServer(t, fq)
+ defer cleanup()
+
+ mc := &cosmosclient.MockCosmosMessageClient{}
+ mc.On("NewInferenceQueryClient").Return(types.NewQueryClient(conn))
+ mc.On("BankBalances", mock.Anything, mock.AnythingOfType("string")).Return([]sdk.Coin{sdk.NewInt64Coin("ngonka", 42)}, nil)
+
+ e := echo.New()
+ s := &Server{e: e, recorder: mc}
+ req := httptest.NewRequest(http.MethodGet, "/participants", nil)
+ rec := httptest.NewRecorder()
+ c := e.NewContext(req, rec)
+
+ require.NoError(t, s.getAllParticipants(c))
+ require.Equal(t, http.StatusOK, rec.Code)
+
+ var dto ParticipantsDto
+ require.NoError(t, json.Unmarshal(rec.Body.Bytes(), &dto))
+ require.Equal(t, int64(12345), dto.BlockHeight)
+ require.Len(t, dto.Participants, 150)
+ require.Equal(t, "addr000", dto.Participants[0].Id)
+ require.Equal(t, int64(42), dto.Participants[0].Balance)
+ last := dto.Participants[len(dto.Participants)-1]
+ require.Equal(t, "addr149", last.Id)
+
+ require.GreaterOrEqual(t, len(fq.receivedHeights), 1)
+ require.Equal(t, "12345", fq.receivedHeights[0])
+
+ mc.AssertExpectations(t)
+}
diff --git a/decentralized-api/internal/server/public/get_poc_batches_handler.go b/decentralized-api/internal/server/public/get_poc_batches_handler.go
new file mode 100644
index 000000000..05e4e9e1f
--- /dev/null
+++ b/decentralized-api/internal/server/public/get_poc_batches_handler.go
@@ -0,0 +1,40 @@
+package public
+
+import (
+ "decentralized-api/logging"
+ "fmt"
+ "github.com/labstack/echo/v4"
+ "github.com/productscience/inference/x/inference/types"
+ "net/http"
+ "strconv"
+)
+
+func (s *Server) getPoCBatches(c echo.Context) error {
+ epoch := c.Param("epoch")
+ logging.Debug("getPoCBatches", types.PoC, "epoch", epoch)
+
+ value, err := strconv.ParseInt(epoch, 10, 64)
+ if err != nil {
+ logging.Error("Failed to parse epoch", types.PoC, "error", err)
+ return ErrInvalidEpochId
+ }
+
+ logging.Debug("Requesting PoC batches.", types.PoC, "epoch", value)
+
+ queryClient := s.recorder.NewInferenceQueryClient()
+ response, err := queryClient.PocBatchesForStage(s.recorder.GetContext(), &types.QueryPocBatchesForStageRequest{
+ BlockHeight: value,
+ })
+ if err != nil {
+ logging.Error("Failed to get PoC batches.", types.PoC, "epoch", value)
+ return err
+ }
+
+ if response == nil {
+ logging.Error("PoC batches batches not found", types.PoC, "epoch", value)
+ msg := fmt.Sprintf("PoC batches batches not found. epoch = %d", value)
+ return echo.NewHTTPError(http.StatusNotFound, msg)
+ }
+
+ return c.JSON(http.StatusOK, response)
+}
diff --git a/decentralized-api/internal/server/public/get_pricing_handler.go b/decentralized-api/internal/server/public/get_pricing_handler.go
new file mode 100644
index 000000000..daa26a424
--- /dev/null
+++ b/decentralized-api/internal/server/public/get_pricing_handler.go
@@ -0,0 +1,210 @@
+package public
+
+import (
+ "context"
+ "decentralized-api/logging"
+ "net/http"
+ "time"
+
+ "github.com/labstack/echo/v4"
+ "github.com/productscience/inference/x/inference/types"
+)
+
+func (s *Server) getPricing(ctx echo.Context) error {
+ queryClient := s.recorder.NewInferenceQueryClient()
+ context := s.recorder.GetContext()
+ req := &types.QueryCurrentEpochGroupDataRequest{}
+ response, err := queryClient.CurrentEpochGroupData(context, req)
+ // FIXME: handle epoch 0, there's a default price specifically for that,
+ // but at the moment you just return 0 (since when epoch == 0 you get empty struct from CurrentEpochGroupData)
+ if err != nil {
+ return err
+ }
+ unitOfComputePrice := response.EpochGroupData.UnitOfComputePrice
+
+ parentEpochData := response.GetEpochGroupData()
+ models := make([]ModelPriceDto, 0, len(parentEpochData.SubGroupModels))
+
+ for _, modelId := range parentEpochData.SubGroupModels {
+ req := &types.QueryGetEpochGroupDataRequest{
+ EpochIndex: parentEpochData.EpochIndex,
+ ModelId: modelId,
+ }
+ modelEpochData, err := queryClient.EpochGroupData(context, req)
+ if err != nil {
+ continue
+ }
+
+ if modelEpochData.EpochGroupData.ModelSnapshot != nil {
+ m := modelEpochData.EpochGroupData.ModelSnapshot
+ pricePerToken := m.UnitsOfComputePerToken * uint64(unitOfComputePrice)
+ models = append(models, ModelPriceDto{
+ Id: m.Id,
+ UnitsOfComputePerToken: m.UnitsOfComputePerToken,
+ PricePerToken: pricePerToken,
+ })
+ }
+ }
+
+ return ctx.JSON(http.StatusOK, &PricingDto{
+ Price: uint64(unitOfComputePrice),
+ Models: models,
+ })
+}
+
+func (s *Server) getGovernancePricing(ctx echo.Context) error {
+ queryClient := s.recorder.NewInferenceQueryClient()
+ context := s.recorder.GetContext()
+
+ // Get the unit of compute price from the latest epoch data, as this is always the most current price.
+ response, err := queryClient.CurrentEpochGroupData(context, &types.QueryCurrentEpochGroupDataRequest{})
+ if err != nil {
+ // In case of an error (e.g., first epoch), we might not have a price yet. Default to 0.
+ return err
+ }
+ unitOfComputePrice := response.EpochGroupData.UnitOfComputePrice
+
+ // Get all governance models to calculate their pricing.
+ modelsResponse, err := queryClient.ModelsAll(context, &types.QueryModelsAllRequest{})
+ if err != nil {
+ return err
+ }
+
+ // Check if dynamic pricing is enabled and get dynamic pricing data
+ dynamicPricingEnabled, dynamicPrices, err := s.getDynamicPricingData()
+ if err != nil {
+ logging.Warn("Failed to get dynamic pricing data, falling back to legacy pricing", types.Pricing, "error", err)
+ dynamicPricingEnabled = false
+ }
+
+ // Get utilization data if dynamic pricing is enabled
+ var modelMetrics map[string]ModelMetrics
+ if dynamicPricingEnabled {
+ modelMetrics = s.getModelMetrics(queryClient, context)
+ }
+
+ models := make([]ModelPriceDto, len(modelsResponse.Model))
+ for i, m := range modelsResponse.Model {
+ // Legacy price calculation
+ legacyPricePerToken := m.UnitsOfComputePerToken * uint64(unitOfComputePrice)
+
+ modelDto := ModelPriceDto{
+ Id: m.Id,
+ UnitsOfComputePerToken: m.UnitsOfComputePerToken,
+ PricePerToken: legacyPricePerToken,
+ }
+
+ // Use dynamic pricing if available, otherwise keep legacy price
+ if dynamicPricingEnabled {
+ if dynamicPrice, exists := dynamicPrices[m.Id]; exists {
+ // Override with current dynamic price
+ modelDto.PricePerToken = dynamicPrice
+ }
+
+ // Add capacity and utilization information from preloaded data
+ if metrics, exists := modelMetrics[m.Id]; exists {
+ capacity := int64(metrics.Capacity)
+ modelDto.Capacity = &capacity
+ modelDto.Utilization = &metrics.Utilization
+ }
+ }
+
+ models[i] = modelDto
+ }
+
+ return ctx.JSON(http.StatusOK, &PricingDto{
+ Price: uint64(unitOfComputePrice),
+ Models: models,
+ DynamicPricingEnabled: dynamicPricingEnabled,
+ })
+}
+
+// ModelMetrics contains utilization and capacity data for a model
+type ModelMetrics struct {
+ Utilization float64
+ Capacity uint64
+}
+
+// getModelMetrics calculates utilization and gets capacity for all models in one go
+func (s *Server) getModelMetrics(queryClient types.QueryClient, context context.Context) map[string]ModelMetrics {
+ metricsData := make(map[string]ModelMetrics)
+
+ // Get all model capacities in one request
+ capacitiesResponse, err := queryClient.GetAllModelCapacities(context, &types.QueryGetAllModelCapacitiesRequest{})
+ if err != nil {
+ logging.Warn("Failed to get model capacities", types.Pricing, "error", err)
+ return metricsData
+ }
+
+ // Create capacity lookup map
+ capacityMap := make(map[string]uint64)
+ for _, modelCapacity := range capacitiesResponse.ModelCapacities {
+ capacityMap[modelCapacity.ModelId] = modelCapacity.Capacity
+ // Initialize metrics with capacity (utilization will be calculated next)
+ metricsData[modelCapacity.ModelId] = ModelMetrics{
+ Capacity: modelCapacity.Capacity,
+ Utilization: 0.0, // Default to 0, will be updated if stats available
+ }
+ }
+
+ // Get dynamic pricing parameters for time window
+ params, err := queryClient.Params(context, &types.QueryParamsRequest{})
+ if err != nil || params.Params.DynamicPricingParams == nil {
+ return metricsData // Return with capacity data only
+ }
+
+ // Calculate time window (similar to BeginBlocker logic)
+ currentTime := time.Now().Unix()
+ timeWindowStart := currentTime - int64(params.Params.DynamicPricingParams.UtilizationWindowDuration)
+
+ // Get stats for all models in time window
+ statsResponse, err := queryClient.InferencesAndTokensStatsByModels(context, &types.QueryInferencesAndTokensStatsByModelsRequest{
+ TimeFrom: timeWindowStart,
+ TimeTo: currentTime,
+ })
+ if err != nil {
+ logging.Warn("Failed to get model stats for utilization", types.Pricing, "error", err)
+ return metricsData // Return with capacity data only
+ }
+
+ // Calculate utilization for each model and update metrics
+ for _, modelStat := range statsResponse.StatsModels {
+ if capacity, exists := capacityMap[modelStat.Model]; exists && capacity > 0 {
+ // Calculate utilization = tokens_used / capacity
+ utilization := float64(modelStat.AiTokens) / float64(capacity)
+
+ // Update the metrics with calculated utilization
+ metricsData[modelStat.Model] = ModelMetrics{
+ Capacity: capacity,
+ Utilization: utilization,
+ }
+ }
+ }
+
+ return metricsData
+}
+
+// getDynamicPricingData queries dynamic pricing information from the chain
+func (s *Server) getDynamicPricingData() (bool, map[string]uint64, error) {
+ queryClient := s.recorder.NewInferenceQueryClient()
+ context := s.recorder.GetContext()
+
+ // Get all model prices directly from the chain's KV storage
+ pricesResponse, err := queryClient.GetAllModelPerTokenPrices(context, &types.QueryGetAllModelPerTokenPricesRequest{})
+ if err != nil {
+ return false, nil, err
+ }
+
+ // Convert to map format
+ modelPrices := make(map[string]uint64)
+ for _, modelPrice := range pricesResponse.ModelPrices {
+ modelPrices[modelPrice.ModelId] = modelPrice.Price
+ }
+
+ // If no prices returned, dynamic pricing is not enabled/working
+ if len(modelPrices) == 0 {
+ return false, nil, nil
+ }
+
+ return true, modelPrices, nil
+}
diff --git a/decentralized-api/internal/server/public/post_chat_handler.go b/decentralized-api/internal/server/public/post_chat_handler.go
new file mode 100644
index 000000000..fd6123bd9
--- /dev/null
+++ b/decentralized-api/internal/server/public/post_chat_handler.go
@@ -0,0 +1,864 @@
+package public
+
+import (
+ "bytes"
+ "context"
+ "decentralized-api/apiconfig"
+ "decentralized-api/broker"
+ "decentralized-api/completionapi"
+ "decentralized-api/logging"
+ "decentralized-api/utils"
+ "encoding/json"
+ "fmt"
+ "io"
+ "math/rand"
+ "net/http"
+ "net/url"
+ "strconv"
+ "sync"
+ "time"
+
+ coretypes "github.com/cometbft/cometbft/rpc/core/types"
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ "github.com/labstack/echo/v4"
+ "github.com/productscience/inference/api/inference/inference"
+ "github.com/productscience/inference/cmd/inferenced/cmd"
+ "github.com/productscience/inference/x/inference/calculations"
+ "github.com/productscience/inference/x/inference/types"
+)
+
+// AuthKeyContext represents the context in which an AuthKey was used
+type AuthKeyContext int
+
+const (
+ // TransferContext indicates the AuthKey was used for a transfer request
+ TransferContext AuthKeyContext = 1
+ // ExecutorContext indicates the AuthKey was used for an executor request
+ ExecutorContext AuthKeyContext = 2
+ // BothContexts indicates the AuthKey was used for both transfer and executor requests
+ BothContexts = TransferContext | ExecutorContext
+)
+
+// (unused) sentinel was replaced by broker.ActionError classification
+
+// Package-level variables for AuthKey reuse prevention
+var (
+ // Map for O(1) lookup of existing AuthKeys and their contexts
+ usedAuthKeys = make(map[string]AuthKeyContext)
+
+ // Map for O(1) lookup of what to remove, organized by block height
+ authKeysByBlock = make(map[int64][]string)
+
+ // Track the oldest block height we're storing
+ oldestBlockHeight int64
+
+ // Mutex for thread safety
+ authKeysMutex sync.RWMutex
+
+ // Reference to the config manager for accessing validation parameters
+ configManagerRef *apiconfig.ConfigManager
+)
+
+// checkAndRecordAuthKey checks if an AuthKey has been used before and records it if not
+// Returns true if the key has been used before in the specified context, false otherwise
+func checkAndRecordAuthKey(authKey string, currentBlockHeight int64, context AuthKeyContext) bool {
+ authKeysMutex.RLock()
+ existingContext, exists := usedAuthKeys[authKey]
+ authKeysMutex.RUnlock()
+
+ if exists {
+ // If the key exists, check if it's been used in the current context
+ if existingContext&context != 0 {
+ return true // Key was used before in this context
+ }
+
+ // Key exists but hasn't been used in this context, update the context
+ authKeysMutex.Lock()
+ defer authKeysMutex.Unlock()
+
+ // Update the context to include the new context
+ usedAuthKeys[authKey] = existingContext | context
+ return false // Key wasn't used before in this context
+ }
+
+ // Key doesn't exist, add it with the current context
+ authKeysMutex.Lock()
+ defer authKeysMutex.Unlock()
+
+ usedAuthKeys[authKey] = context
+
+ authKeysByBlock[currentBlockHeight] = append(authKeysByBlock[currentBlockHeight], authKey)
+
+ if oldestBlockHeight == 0 {
+ oldestBlockHeight = currentBlockHeight
+ }
+
+ cleanupExpiredAuthKeys(currentBlockHeight)
+
+ return false // Key wasn't used before
+}
+
+// cleanupExpiredAuthKeys removes auth keys from block heights based on timestamp_expiration parameter
+func cleanupExpiredAuthKeys(currentBlockHeight int64) {
+ // Default expiration is 4 blocks if configManager is not set
+ expirationBlocks := int64(4)
+
+ // If configManager is available, use twice the timestamp_expiration value
+ if configManagerRef != nil {
+ validationParams := configManagerRef.GetValidationParams()
+ timestampExpiration := validationParams.TimestampExpiration
+
+ // Use default value if parameter is not set
+ if timestampExpiration == 0 {
+ timestampExpiration = 10 // Default 10 seconds
+ }
+
+ // Use twice the timestamp_expiration value (converted to blocks)
+ // Assuming average block time of 5 seconds
+ expirationBlocks = (timestampExpiration * 2) / 4
+
+ // Ensure we keep at least 4 blocks for safety
+ if expirationBlocks < 4 {
+ expirationBlocks = 4
+ }
+
+ logging.Debug("Auth key expiration", types.Inferences,
+ "timestampExpiration", timestampExpiration,
+ "expirationBlocks", expirationBlocks)
+ }
+
+ expirationHeight := currentBlockHeight - expirationBlocks
+
+ for height := oldestBlockHeight; height < expirationHeight; height++ {
+ keys, exists := authKeysByBlock[height]
+ if !exists {
+ continue
+ }
+
+ for _, key := range keys {
+ delete(usedAuthKeys, key)
+ }
+
+ delete(authKeysByBlock, height)
+ }
+
+ if oldestBlockHeight < expirationHeight {
+ oldestBlockHeight = expirationHeight
+ }
+}
+
+func (s *Server) postChat(ctx echo.Context) error {
+ logging.Debug("PostChat. Received request", types.Inferences, "path", ctx.Request().URL.Path)
+
+ chatRequest, err := readRequest(ctx.Request(), s.recorder.GetAccountAddress())
+ if err != nil {
+ return err
+ }
+
+ if chatRequest.AuthKey == "" {
+ logging.Warn("Request without authorization", types.Server, "path", ctx.Request().URL.Path)
+ return ErrRequestAuth
+ }
+
+ if chatRequest.InferenceId != "" && chatRequest.Seed != "" {
+ logging.Info("Executor request", types.Inferences, "inferenceId", chatRequest.InferenceId, "seed", chatRequest.Seed)
+ return s.handleExecutorRequest(ctx, chatRequest, ctx.Response().Writer)
+ } else {
+ logging.Info("Transfer request", types.Inferences, "requesterAddress", chatRequest.RequesterAddress)
+ return s.handleTransferRequest(ctx, chatRequest)
+ }
+}
+
+func (s *Server) handleTransferRequest(ctx echo.Context, request *ChatRequest) error {
+ logging.Debug("GET inference requester for transfer", types.Inferences, "address", request.RequesterAddress)
+
+ queryClient := s.recorder.NewInferenceQueryClient()
+ requester, err := queryClient.InferenceParticipant(ctx.Request().Context(), &types.QueryInferenceParticipantRequest{Address: request.RequesterAddress})
+ if err != nil {
+ logging.Error("Failed to get inference requester", types.Inferences, "address", request.RequesterAddress, "error", err)
+ return err
+ }
+
+ promptText := ""
+ for _, message := range request.OpenAiRequest.Messages {
+ promptText += message.Content + "\n"
+ }
+
+ promptTokenCount, err := s.getPromptTokenEstimation(promptText, request.OpenAiRequest.Model)
+
+ if err != nil {
+ logging.Error("Failed to get prompt token estimation", types.Inferences, "error", err)
+ return err
+ }
+
+ logging.Info("Prompt token estimation", types.Inferences, "count", promptTokenCount, "model", request.OpenAiRequest.Model)
+
+ if err := s.validateRequester(ctx.Request().Context(), request, requester, promptTokenCount); err != nil {
+ return err
+ }
+
+ status, err := s.recorder.Status(context.Background())
+ if err != nil {
+ logging.Error("Failed to get status", types.Inferences, "error", err)
+ return err
+ }
+
+ if err := validateRequest(request, status, s.configManager); err != nil {
+ return err
+ }
+
+ requestBlockHeight := status.SyncInfo.LatestBlockHeight
+ can, estimatedKB := s.bandwidthLimiter.CanAcceptRequest(requestBlockHeight, int(promptTokenCount), int(request.OpenAiRequest.MaxTokens))
+ if !can {
+ logging.Warn("Bandwidth limit exceeded", types.Inferences, "address", request.RequesterAddress)
+ url := s.configManager.GetApiConfig().PublicUrl
+ return echo.NewHTTPError(http.StatusTooManyRequests, "Transfer Agent capacity reached. Try another TA from "+url+"/v1/epochs/current/participants")
+ }
+
+ s.bandwidthLimiter.RecordRequest(requestBlockHeight, estimatedKB)
+ defer s.bandwidthLimiter.ReleaseRequest(requestBlockHeight, estimatedKB)
+
+ executor, err := s.getExecutorForRequest(ctx.Request().Context(), request.OpenAiRequest.Model)
+ if err != nil {
+ logging.Error("Failed to get executor", types.Inferences, "error", err)
+ return err
+ }
+
+ seed := rand.Int31()
+ inferenceUUID := request.AuthKey
+ inferenceRequest, err := createInferenceStartRequest(s, request, seed, request.AuthKey, executor, s.configManager.GetCurrentNodeVersion(), promptTokenCount)
+ if err != nil {
+ logging.Error("Failed to create inference start request", types.Inferences, "error", err)
+ return err
+ }
+
+ go func() {
+ logging.Debug("Starting inference", types.Inferences, "id", inferenceRequest.InferenceId)
+ if s.configManager.GetApiConfig().TestMode && request.OpenAiRequest.Seed == 8675309 {
+ time.Sleep(10 * time.Second)
+ }
+ err := s.recorder.StartInference(inferenceRequest)
+ if err != nil {
+ logging.Error("Failed to submit MsgStartInference", types.Inferences, "id", inferenceRequest.InferenceId, "error", err)
+ } else {
+ logging.Debug("Submitted MsgStartInference", types.Inferences, "id", inferenceRequest.InferenceId)
+ }
+ }()
+
+ // It's important here to send the ORIGINAL body, not the finalRequest body. The executor will AGAIN go through
+ // the same process to create the same final request body
+ logging.Debug("Sending request to executor", types.Inferences, "url", executor.Url, "seed", seed, "inferenceId", inferenceUUID)
+
+ if s.configManager.GetApiConfig().PublicUrl == executor.Url {
+ // node found itself as executor
+
+ request.InferenceId = inferenceUUID
+ request.Seed = strconv.Itoa(int(seed))
+ request.TransferAddress = s.recorder.GetAccountAddress()
+ request.TransferSignature = inferenceRequest.TransferSignature
+
+ logging.Info("Execute request on same node, fill request with extra data", types.Inferences, "inferenceId", request.InferenceId, "seed", request.Seed)
+ return s.handleExecutorRequest(ctx, request, ctx.Response().Writer)
+ }
+
+ req, err := http.NewRequest(http.MethodPost, executor.Url+"/v1/chat/completions", bytes.NewReader(request.Body))
+ if err != nil {
+ logging.Error("handleTransferRequest. Failed to create request to the executor node", types.Inferences, "error", err)
+ return err
+ }
+
+ // TODO use echo.Redirect?
+ req.Header.Set(utils.XInferenceIdHeader, inferenceUUID)
+ req.Header.Set(utils.XSeedHeader, strconv.Itoa(int(seed)))
+ req.Header.Set(utils.AuthorizationHeader, request.AuthKey)
+ req.Header.Set(utils.XTimestampHeader, strconv.FormatInt(request.Timestamp, 10))
+ req.Header.Set(utils.XTransferAddressHeader, request.TransferAddress)
+ req.Header.Set(utils.XRequesterAddressHeader, request.RequesterAddress)
+ req.Header.Set(utils.XTASignatureHeader, inferenceRequest.TransferSignature)
+ req.Header.Set("Content-Type", request.Request.Header.Get("Content-Type"))
+
+ resp, err := http.DefaultClient.Do(req)
+ if err != nil {
+ logging.Error("Failed to make http request to executor", types.Inferences, "error", err, "url", executor.Url)
+ return err
+ }
+ defer resp.Body.Close()
+
+ logging.Info("Proxying response from executor", types.Inferences,
+ "inferenceId", inferenceUUID,
+ "executor", executor.Address)
+ proxyResponse(resp, ctx.Response().Writer, false, nil, inferenceUUID)
+ return nil
+}
+
+func (s *Server) getPromptTokenEstimation(text string, model string) (int, error) {
+ return len(text), nil
+}
+
+func validateRequest(request *ChatRequest, status *coretypes.ResultStatus, configManager *apiconfig.ConfigManager) error {
+ lastHeightTime := status.SyncInfo.LatestBlockTime.UnixNano()
+ currentBlockHeight := status.SyncInfo.LatestBlockHeight
+
+ // Get validation parameters from config
+ validationParams := configManager.GetValidationParams()
+ logging.Info("Validating timestamp", types.Inferences,
+ "timestampExpiration", validationParams.TimestampExpiration,
+ "timestampAdvance", validationParams.TimestampAdvance,
+ "lastHeightTime", lastHeightTime,
+ "requestTimestamp", request.Timestamp)
+ err := calculations.ValidateTimestamp(request.Timestamp, lastHeightTime, validationParams.TimestampExpiration, validationParams.TimestampAdvance, 0)
+
+ if err != nil {
+ logging.Warn("Invalid timestamp", types.Inferences,
+ "inferenceId", request.InferenceId,
+ "status", status,
+ "error", err)
+ return echo.NewHTTPError(http.StatusBadRequest, err.Error())
+ }
+
+ // Check if AuthKey has been used before for a transfer request
+ if checkAndRecordAuthKey(request.AuthKey, currentBlockHeight, TransferContext) {
+ logging.Warn("AuthKey reuse detected for transfer request", types.Inferences, "authKey", request.AuthKey)
+ return echo.NewHTTPError(http.StatusBadRequest, "AuthKey has already been used for a transfer request")
+ }
+
+ return nil
+}
+
+func (s *Server) getPromptTokenCount(text string, model string) (int, error) {
+ type tokenizeRequest struct {
+ Model string `json:"model"`
+ Prompt string `json:"prompt"`
+ }
+ type tokenizeResponse struct {
+ TokenCount int `json:"count"`
+ }
+
+ response, err := broker.DoWithLockedNodeHTTPRetry(s.nodeBroker, model, nil, 1, func(node *broker.Node) (*http.Response, *broker.ActionError) {
+ tokenizeUrl, err := url.JoinPath(node.InferenceUrlWithVersion(s.configManager.GetCurrentNodeVersion()), "/tokenize")
+ if err != nil {
+ return nil, broker.NewApplicationActionError(err)
+ }
+
+ reqBody := tokenizeRequest{
+ Model: model,
+ Prompt: text,
+ }
+ jsonData, err := json.Marshal(reqBody)
+ if err != nil {
+ return nil, broker.NewApplicationActionError(err)
+ }
+
+ resp, postErr := http.Post(
+ tokenizeUrl,
+ "application/json",
+ bytes.NewReader(jsonData),
+ )
+ if postErr != nil {
+ return nil, broker.NewTransportActionError(postErr)
+ }
+ return resp, nil
+ })
+
+ if err != nil {
+ return 0, err
+ }
+ defer response.Body.Close()
+
+ if response.StatusCode != http.StatusOK {
+ return 0, fmt.Errorf("tokenize request failed with status: %d", response.StatusCode)
+ }
+
+ var result tokenizeResponse
+ if err := json.NewDecoder(response.Body).Decode(&result); err != nil {
+ return 0, err
+ }
+
+ return result.TokenCount, nil
+}
+
+func (s *Server) extractPromptTextFromRequest(requestBytes []byte) (string, error) {
+ var openAiRequest OpenAiRequest
+ err := json.Unmarshal(requestBytes, &openAiRequest)
+ if err != nil {
+ return "", err
+ }
+
+ promptText := ""
+ for _, message := range openAiRequest.Messages {
+ promptText += message.Content + "\n"
+ }
+ return promptText, nil
+}
+
+func (s *Server) handleExecutorRequest(ctx echo.Context, request *ChatRequest, w http.ResponseWriter) error {
+ inferenceId := request.InferenceId
+ err := s.validateFullRequest(ctx, request)
+ if err != nil {
+ return err
+ }
+
+ seed, err := strconv.Atoi(request.Seed)
+ if err != nil {
+ logging.Warn("Unable to parse seed", types.Inferences, "seed", request.Seed)
+ return echo.ErrBadRequest
+ }
+
+ modifiedRequestBody, err := completionapi.ModifyRequestBody(request.Body, int32(seed))
+ if err != nil {
+ logging.Warn("Unable to modify request body", types.Inferences, "error", err)
+ return err
+ }
+
+ logging.Info("Attempting to lock node for inference", types.Inferences,
+ "inferenceId", inferenceId, "nodeVersion", s.configManager.GetCurrentNodeVersion())
+ resp, err := broker.DoWithLockedNodeHTTPRetry(s.nodeBroker, request.OpenAiRequest.Model, nil, 3, func(node *broker.Node) (*http.Response, *broker.ActionError) {
+ logging.Info("Successfully acquired node lock for inference", types.Inferences,
+ "inferenceId", inferenceId, "node", node.Id, "url", node.InferenceUrlWithVersion(s.configManager.GetCurrentNodeVersion()))
+
+ completionsUrl, err := url.JoinPath(node.InferenceUrlWithVersion(s.configManager.GetCurrentNodeVersion()), "/v1/chat/completions")
+ if err != nil {
+ return nil, broker.NewApplicationActionError(err)
+ }
+ resp, postErr := http.Post(
+ completionsUrl,
+ request.Request.Header.Get("Content-Type"),
+ bytes.NewReader(modifiedRequestBody.NewBody),
+ )
+ if postErr != nil {
+ return nil, broker.NewTransportActionError(postErr)
+ }
+ return resp, nil
+ })
+ if err != nil {
+ logging.Error("Failed to get response from inference node", types.Inferences,
+ "inferenceId", inferenceId, "error", err)
+ return err
+ }
+ defer resp.Body.Close()
+
+ logging.Info("Node lock released for inference", types.Inferences, "inferenceId", inferenceId)
+
+ if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+ msg := getInferenceErrorMessage(resp)
+ logging.Warn("Inference node response with an error", types.Inferences, "code", resp.StatusCode, "msg", msg)
+ return echo.NewHTTPError(http.StatusInternalServerError, msg)
+ }
+
+ responseProcessor := completionapi.NewExecutorResponseProcessor(request.InferenceId)
+ logging.Debug("Proxying response from inference node", types.Inferences, "inferenceId", request.InferenceId)
+ proxyResponse(resp, w, true, responseProcessor, inferenceId)
+
+ logging.Debug("Processing response from inference node", types.Inferences, "inferenceId", request.InferenceId)
+ completionResponse, err := responseProcessor.GetResponse()
+
+ if err != nil || completionResponse == nil {
+ logging.Error("Failed to parse response data into CompletionResponse", types.Inferences, "error", err)
+ return err
+ }
+
+ err = s.sendInferenceTransaction(request.InferenceId, completionResponse, request.Body, s.recorder.GetAccountAddress(), request)
+ if err != nil {
+ // Not http.Error, because we assume we already returned everything to the client during proxyResponse execution
+ logging.Error("Failed to send inference transaction", types.Inferences, "error", err)
+ return nil
+ }
+ return nil
+}
+
+func (s *Server) getAllowedPubKeys(ctx echo.Context, granterAddress string) ([]string, error) {
+ queryClient := s.recorder.NewInferenceQueryClient()
+ grantees, err := queryClient.GranteesByMessageType(ctx.Request().Context(), &types.QueryGranteesByMessageTypeRequest{
+ GranterAddress: granterAddress,
+ MessageTypeUrl: "/inference.inference.MsgStartInference",
+ })
+ if err != nil {
+ return nil, fmt.Errorf("failed to get grantees to sign inference: %w", err)
+ }
+ granteesPubkeys := make([]string, len(grantees.Grantees)+1)
+ for i, grantee := range grantees.Grantees {
+ granteesPubkeys[i] = grantee.PubKey
+ }
+
+ granterAccount, err := queryClient.InferenceParticipant(ctx.Request().Context(), &types.QueryInferenceParticipantRequest{Address: granterAddress})
+ if err != nil {
+ logging.Error("Failed to get granter account", types.Inferences, "address", granterAddress, "error", err)
+ return nil, err
+ }
+ granterPubKey := granterAccount.Pubkey
+
+ granteesPubkeys[len(granteesPubkeys)-1] = granterPubKey
+ return granteesPubkeys, nil
+}
+
+func (s *Server) validateFullRequest(ctx echo.Context, request *ChatRequest) error {
+ queryClient := s.recorder.NewInferenceQueryClient()
+ dev, err := queryClient.InferenceParticipant(ctx.Request().Context(), &types.QueryInferenceParticipantRequest{Address: request.RequesterAddress})
+ if err != nil {
+ logging.Error("Failed to get inference requester", types.Inferences, "address", request.RequesterAddress, "error", err)
+ return err
+ }
+
+ transferPubkeys, err := s.getAllowedPubKeys(ctx, request.TransferAddress)
+ if err != nil {
+ logging.Error("Failed to get grantees to sign inference", types.Inferences, "error", err)
+ return err
+ }
+ logging.Info("Transfer pubkeys", types.Inferences, "pubkeys", transferPubkeys)
+
+ if err := validateTransferRequest(request, dev.Pubkey); err != nil {
+ logging.Error("Unable to validate request against PubKey", types.Inferences, "error", err)
+ return echo.NewHTTPError(http.StatusUnauthorized, "Unable to validate request against PubKey:"+err.Error())
+ }
+
+ if err = validateExecuteRequestWithGrantees(request, transferPubkeys, s.recorder.GetAccountAddress(), request.TransferSignature); err != nil {
+ logging.Error("Unable to validate request against TransferSignature", types.Inferences, "error", err)
+ return echo.NewHTTPError(http.StatusUnauthorized, "Unable to validate request against TransferSignature:"+err.Error())
+ }
+
+ err = s.validateTimestampNonce(request)
+ if err != nil {
+ return err
+ }
+ return nil
+}
+
+func (s *Server) validateTimestampNonce(request *ChatRequest) error {
+ status, err := s.recorder.Status(context.Background())
+ if err != nil {
+ logging.Error("Failed to get status", types.Inferences, "error", err)
+ return err
+ }
+
+ currentBlockHeight := status.SyncInfo.LatestBlockHeight
+ lastHeightTime := status.SyncInfo.LatestBlockTime.UnixNano()
+
+ // Get validation parameters from config
+ validationParams := s.configManager.GetValidationParams()
+ timestampExpirationNs := validationParams.TimestampExpiration * int64(time.Second)
+ timestampAdvanceNs := validationParams.TimestampAdvance * int64(time.Second)
+
+ // Use default values if parameters are not set
+ if timestampExpirationNs == 0 {
+ timestampExpirationNs = 10 * int64(time.Second)
+ }
+ if timestampAdvanceNs == 0 {
+ timestampAdvanceNs = 10 * int64(time.Second)
+ }
+
+ requestOffset := lastHeightTime - request.Timestamp
+ logging.Info("Request offset for executor", types.Inferences,
+ "offset", time.Duration(requestOffset).String(),
+ "lastHeightTime", lastHeightTime,
+ "requestTimestamp", request.Timestamp)
+
+ if requestOffset > timestampExpirationNs {
+ logging.Warn("Request timestamp is too old", types.Inferences,
+ "inferenceId", request.InferenceId,
+ "offset", time.Duration(requestOffset).String())
+ return echo.NewHTTPError(http.StatusBadRequest, "Request timestamp is too old")
+ }
+
+ if requestOffset < -timestampAdvanceNs {
+ logging.Warn("Request timestamp is in the future", types.Inferences,
+ "inferenceId", request.InferenceId,
+ "offset", time.Duration(requestOffset).String())
+ return echo.NewHTTPError(http.StatusBadRequest, "Request timestamp is in the future")
+ }
+
+ if checkAndRecordAuthKey(request.AuthKey, currentBlockHeight, ExecutorContext) {
+ logging.Warn("AuthKey reuse detected for executor request", types.Inferences, "authKey", request.AuthKey)
+ return echo.NewHTTPError(http.StatusBadRequest, "AuthKey has already been used for an executor request")
+ }
+ return nil
+}
+
+func (s *Server) getExecutorForRequest(ctx context.Context, model string) (*ExecutorDestination, error) {
+ queryClient := s.recorder.NewInferenceQueryClient()
+ response, err := queryClient.GetRandomExecutor(ctx, &types.QueryGetRandomExecutorRequest{
+ Model: model,
+ })
+ if err != nil {
+ return nil, err
+ }
+ executor := response.Executor
+ logging.Info("Executor selected", types.Inferences, "address", executor.Address, "url", executor.InferenceUrl)
+ return &ExecutorDestination{
+ Url: executor.InferenceUrl,
+ Address: executor.Address,
+ }, nil
+}
+
+// calculateSignature calculates a signature for the given components and agent type
+func (s *Server) calculateSignature(payload string, timestamp int64, transferAddress string, executorAddress string, agentType calculations.SignatureType) (string, error) {
+ components := calculations.SignatureComponents{
+ Payload: payload,
+ Timestamp: timestamp,
+ TransferAddress: transferAddress,
+ ExecutorAddress: executorAddress,
+ }
+
+ signerAddressStr := s.recorder.GetSignerAddress()
+ signerAddress, err := sdk.AccAddressFromBech32(signerAddressStr)
+ if err != nil {
+ logging.Error("Failed to parse address", types.Inferences, "address", signerAddressStr, "error", err)
+ return "", err
+ }
+ accountSigner := &cmd.AccountSigner{
+ Addr: signerAddress,
+ Keyring: s.recorder.GetKeyring(),
+ }
+
+ signature, err := calculations.Sign(accountSigner, components, agentType)
+ if err != nil {
+ logging.Error("Failed to sign signature", types.Inferences, "error", err, "agentType", agentType)
+ return "", err
+ }
+
+ return signature, nil
+}
+
+func (s *Server) sendInferenceTransaction(inferenceId string, response completionapi.CompletionResponse, requestBody []byte, executorAddress string, request *ChatRequest) error {
+ responseHash, err := response.GetHash()
+ if err != nil || responseHash == "" {
+ logging.Error("Failed to get responseHash from response", types.Inferences, "error", err)
+ return err
+ }
+ model, err := response.GetModel()
+ if err != nil || model == "" {
+ logging.Error("Failed to get model from response", types.Inferences, "error", err)
+ return err
+ }
+ id, err := response.GetInferenceId()
+ if err != nil || id == "" {
+ logging.Error("Failed to get id from response", types.Inferences, "error", err)
+ return err
+ }
+ usage, err := response.GetUsage()
+ if err != nil {
+ logging.Warn("Failed to get usage from response", types.Inferences, "error", err)
+ return err
+ }
+
+ // If streaming response doesn't have prompt tokens, get accurate count via tokenization
+ if usage.PromptTokens == 0 {
+ logging.Info("Streaming response missing prompt tokens, using tokenization", types.Inferences, "inferenceId", inferenceId)
+ promptText, err := s.extractPromptTextFromRequest(requestBody)
+ if err != nil {
+ logging.Warn("Failed to extract prompt text for tokenization", types.Inferences, "error", err)
+ } else {
+ model, _ := response.GetModel()
+ actualPromptTokens, err := s.getPromptTokenCount(promptText, model)
+ if err != nil {
+ logging.Warn("Failed to get actual prompt token count", types.Inferences, "error", err)
+ } else {
+ logging.Info("Updated prompt tokens via tokenization", types.Inferences, "inferenceId", inferenceId, "tokens", actualPromptTokens)
+ usage.PromptTokens = uint64(actualPromptTokens)
+ }
+ }
+ }
+
+ logging.Debug("Usage from response", types.Inferences, "usage", usage)
+ bodyBytes, err := response.GetBodyBytes()
+ if err != nil || bodyBytes == nil {
+ logging.Error("Failed to get body bytes from response", types.Inferences, "error", err)
+ return err
+ }
+
+ if s.recorder != nil {
+ // Calculate executor signature
+ executorSignature, err := s.calculateSignature(string(request.Body), request.Timestamp, request.TransferAddress, executorAddress, calculations.ExecutorAgent)
+ if err != nil {
+ return err
+ }
+
+ message := &inference.MsgFinishInference{
+ Creator: executorAddress,
+ InferenceId: inferenceId,
+ ResponseHash: responseHash,
+ ResponsePayload: string(bodyBytes),
+ PromptTokenCount: usage.PromptTokens,
+ CompletionTokenCount: usage.CompletionTokens,
+ ExecutedBy: executorAddress,
+ TransferredBy: request.TransferAddress,
+ TransferSignature: request.TransferSignature,
+ ExecutorSignature: executorSignature,
+ RequestTimestamp: request.Timestamp,
+ RequestedBy: request.RequesterAddress,
+ OriginalPrompt: string(request.Body),
+ Model: model,
+ }
+
+ logging.Info("Submitting MsgFinishInference", types.Inferences, "inferenceId", inferenceId)
+ err = s.recorder.FinishInference(message)
+ if err != nil {
+ logging.Error("Failed to submit MsgFinishInference", types.Inferences, "inferenceId", inferenceId, "error", err)
+ } else {
+ logging.Debug("Submitted MsgFinishInference", types.Inferences, "inferenceId", inferenceId)
+ }
+ }
+ return nil
+}
+
+func getPromptHash(requestBytes []byte) (string, string, error) {
+ canonicalJSON, err := utils.CanonicalizeJSON(requestBytes)
+ if err != nil {
+ return "", "", err
+ }
+
+ promptHash := utils.GenerateSHA256Hash(canonicalJSON)
+ return promptHash, canonicalJSON, nil
+}
+
+func createInferenceStartRequest(s *Server, request *ChatRequest, seed int32, inferenceId string, executor *ExecutorDestination, nodeVersion string, promptTokenCount int) (*inference.MsgStartInference, error) {
+ finalRequest, err := completionapi.ModifyRequestBody(request.Body, seed)
+ if err != nil {
+ return nil, err
+ }
+ promptHash, promptPayload, err := getPromptHash(finalRequest.NewBody)
+ if err != nil {
+ return nil, err
+ }
+ maxTokens := 0
+ if request.OpenAiRequest.MaxCompletionTokens > 0 {
+ maxTokens = int(request.OpenAiRequest.MaxCompletionTokens)
+ } else if request.OpenAiRequest.MaxTokens > 0 {
+ maxTokens = int(request.OpenAiRequest.MaxTokens)
+ }
+ transaction := &inference.MsgStartInference{
+ InferenceId: inferenceId,
+ PromptHash: promptHash,
+ PromptPayload: promptPayload,
+ RequestedBy: request.RequesterAddress,
+ Model: request.OpenAiRequest.Model,
+ AssignedTo: executor.Address,
+ NodeVersion: nodeVersion,
+ MaxTokens: uint64(maxTokens),
+ PromptTokenCount: uint64(promptTokenCount),
+ RequestTimestamp: request.Timestamp,
+ OriginalPrompt: string(request.Body),
+ }
+
+ signature, err := s.calculateSignature(string(request.Body), request.Timestamp, request.TransferAddress, executor.Address, calculations.TransferAgent)
+ if err != nil {
+ return nil, err
+ }
+ transaction.TransferSignature = signature
+
+ logging.Debug("Prompt token count for inference", types.Inferences, "inferenceId", inferenceId, "count", promptTokenCount)
+ return transaction, nil
+}
+
+func getInferenceErrorMessage(resp *http.Response) string {
+ msg := fmt.Sprintf("Inference node response with an error. code = %d.", resp.StatusCode)
+ bodyBytes, err := io.ReadAll(resp.Body)
+ if err == nil {
+ return msg + fmt.Sprintf(" error = %s.", string(bodyBytes))
+ } else {
+ return msg
+ }
+}
+
+func readRequest(request *http.Request, transferAddress string) (*ChatRequest, error) {
+ body, err := readRequestBody(request)
+ if err != nil {
+ logging.Error("Unable to read request body", types.Server, "error", err)
+ return nil, err
+ }
+
+ openAiRequest := OpenAiRequest{}
+ err = json.Unmarshal(body, &openAiRequest)
+ if err != nil {
+ return nil, err
+ }
+
+ timestamp, err := strconv.ParseInt(request.Header.Get(utils.XTimestampHeader), 10, 64)
+ if err != nil {
+ timestamp = 0
+ }
+ if request.Header.Get(utils.XTransferAddressHeader) != "" {
+ transferAddress = request.Header.Get(utils.XTransferAddressHeader)
+ }
+
+ return &ChatRequest{
+ Body: body,
+ Request: request,
+ OpenAiRequest: openAiRequest,
+ AuthKey: request.Header.Get(utils.AuthorizationHeader),
+ Seed: request.Header.Get(utils.XSeedHeader),
+ InferenceId: request.Header.Get(utils.XInferenceIdHeader),
+ RequesterAddress: request.Header.Get(utils.XRequesterAddressHeader),
+ Timestamp: timestamp,
+ TransferAddress: transferAddress,
+ TransferSignature: request.Header.Get(utils.XTASignatureHeader),
+ }, nil
+}
+
+func readRequestBody(r *http.Request) ([]byte, error) {
+ var buf bytes.Buffer
+ if _, err := io.Copy(&buf, r.Body); err != nil {
+ return nil, err
+ }
+ defer r.Body.Close()
+ return buf.Bytes(), nil
+}
+
+// validateRequester validates requester with dynamic pricing fallback to legacy
+func (s *Server) validateRequester(ctx context.Context, request *ChatRequest, requester *types.QueryInferenceParticipantResponse, promptTokenCount int) error {
+ if requester == nil {
+ logging.Error("Inference participant not found", types.Inferences, "address", request.RequesterAddress)
+ return ErrInferenceParticipantNotFound
+ }
+
+ err := validateTransferRequest(request, requester.Pubkey)
+ if err != nil {
+ logging.Error("Unable to validate request against PubKey", types.Inferences, "error", err)
+ return echo.NewHTTPError(http.StatusUnauthorized, "Unable to validate request against PubKey:"+err.Error())
+ }
+
+ if request.OpenAiRequest.MaxTokens == 0 {
+ request.OpenAiRequest.MaxTokens = calculations.DefaultMaxTokens
+ }
+
+ var escrowNeeded uint64
+ var perTokenPrice uint64
+
+ // Try to get dynamic pricing first
+ queryClient := s.recorder.NewInferenceQueryClient()
+ priceResponse, err := queryClient.GetModelPerTokenPrice(ctx, &types.QueryGetModelPerTokenPriceRequest{
+ ModelId: request.OpenAiRequest.Model,
+ })
+
+ if err == nil && priceResponse.Found {
+ // Use dynamic pricing
+ perTokenPrice = priceResponse.Price
+
+ logging.Debug("Using dynamic pricing", types.Inferences,
+ "perTokenPrice", perTokenPrice,
+ "model", request.OpenAiRequest.Model)
+ } else {
+ // Fall back to legacy pricing
+ logging.Warn("Failed to get dynamic pricing, falling back to legacy calculation", types.Inferences, "error", err)
+ perTokenPrice = uint64(calculations.PerTokenCost)
+
+ logging.Debug("Using legacy pricing", types.Inferences,
+ "perTokenPrice", perTokenPrice)
+ }
+
+ // Calculate escrow using consistent formula: (PromptTokens + MaxTokens) × PerTokenPrice
+ totalTokens := uint64(promptTokenCount) + uint64(request.OpenAiRequest.MaxTokens)
+ escrowNeeded = totalTokens * perTokenPrice
+
+ logging.Debug("Escrow calculation", types.Inferences,
+ "escrowNeeded", escrowNeeded,
+ "perTokenPrice", perTokenPrice,
+ "promptTokens", promptTokenCount,
+ "maxTokens", request.OpenAiRequest.MaxTokens,
+ "totalTokens", totalTokens)
+
+ logging.Debug("Client balance", types.Inferences, "balance", requester.Balance)
+ if requester.Balance < int64(escrowNeeded) {
+ return ErrInsufficientBalance
+ }
+ return nil
+}
diff --git a/decentralized-api/internal/server/public/post_participant_handler.go b/decentralized-api/internal/server/public/post_participant_handler.go
new file mode 100644
index 000000000..602331633
--- /dev/null
+++ b/decentralized-api/internal/server/public/post_participant_handler.go
@@ -0,0 +1,48 @@
+package public
+
+import (
+ "decentralized-api/internal/server/public_entities"
+ "decentralized-api/logging"
+ "net/http"
+
+ "github.com/labstack/echo/v4"
+ "github.com/productscience/inference/api/inference/inference"
+ "github.com/productscience/inference/x/inference/types"
+)
+
+func (s *Server) submitNewParticipantHandler(ctx echo.Context) error {
+ var body public_entities.SubmitUnfundedNewParticipantDto
+
+ if err := ctx.Bind(&body); err != nil {
+ logging.Error("Failed to decode request body", types.Participants, "error", err)
+ return echo.NewHTTPError(http.StatusBadRequest, err)
+ }
+
+ logging.Debug("SubmitNewParticipantDto", types.Participants, "body", body)
+
+ if body.Address == "" || body.PubKey == "" {
+ return echo.NewHTTPError(http.StatusBadRequest, "Address and PubKey are required")
+ }
+ if err := s.submitNewUnfundedParticipant(body); err != nil {
+ return err
+ }
+ return ctx.NoContent(http.StatusOK)
+}
+
+func (s *Server) submitNewUnfundedParticipant(body public_entities.SubmitUnfundedNewParticipantDto) error {
+ msg := &inference.MsgSubmitNewUnfundedParticipant{
+ Address: body.Address,
+ Url: body.Url,
+ ValidatorKey: body.ValidatorKey,
+ PubKey: body.PubKey,
+ WorkerKey: body.WorkerKey,
+ }
+
+ logging.Debug("Submitting NewUnfundedParticipant", types.Participants, "message", msg)
+
+ if err := s.recorder.SubmitNewUnfundedParticipant(msg); err != nil {
+ logging.Error("Failed to submit MsgSubmitNewUnfundedParticipant", types.Participants, "error", err)
+ return err
+ }
+ return nil
+}
diff --git a/decentralized-api/internal/server/public/proxy.go b/decentralized-api/internal/server/public/proxy.go
new file mode 100644
index 000000000..7225f8d4f
--- /dev/null
+++ b/decentralized-api/internal/server/public/proxy.go
@@ -0,0 +1,109 @@
+package public
+
+import (
+ "bufio"
+ "decentralized-api/completionapi"
+ "decentralized-api/logging"
+ "fmt"
+ "github.com/productscience/inference/x/inference/types"
+ "io"
+ "net"
+ "net/http"
+ "strings"
+)
+
+func proxyResponse(
+ resp *http.Response,
+ w http.ResponseWriter,
+ excludeContentLength bool,
+ responseProcessor completionapi.ResponseProcessor,
+ inferenceId string,
+) {
+ // Make sure to copy response headers to the client
+ for key, values := range resp.Header {
+ // Skip Content-Length, because we're modifying body
+ if excludeContentLength && key == "Content-Length" {
+ continue
+ }
+
+ for _, value := range values {
+ w.Header().Add(key, value)
+ }
+ }
+
+ contentType := resp.Header.Get("Content-Type")
+ if strings.HasPrefix(contentType, "text/event-stream") {
+ logging.Debug("Proxying text/event-stream response", types.Inferences, "status_code", resp.StatusCode, "content_type", contentType, "inference_id", inferenceId)
+ proxyTextStreamResponse(resp, w, responseProcessor, inferenceId)
+ } else {
+ logging.Debug("Proxying JSON response", types.Inferences, "status_code", resp.StatusCode, "content_type", contentType, "inference_id", inferenceId)
+ proxyJsonResponse(resp, w, responseProcessor, inferenceId)
+ }
+}
+
+func proxyTextStreamResponse(resp *http.Response, w http.ResponseWriter, responseProcessor completionapi.ResponseProcessor, inferenceId string) {
+ w.WriteHeader(resp.StatusCode)
+
+ // Stream the response from the completion server to the client
+ scanner := bufio.NewScanner(resp.Body)
+ for scanner.Scan() {
+ line := scanner.Text()
+
+ // DEBUG LOG
+ logging.Debug("Chunk", types.Inferences, "inferenceId", inferenceId, "line", line)
+
+ var lineToProxy = line
+ if responseProcessor != nil {
+ var err error
+ lineToProxy, err = responseProcessor.ProcessStreamedResponse(line)
+ if err != nil {
+ logging.Error("Failed to process streamed response line", types.Inferences,
+ "inferenceId", inferenceId, "error", err, "line", line,
+ )
+ http.Error(w, err.Error(), http.StatusInternalServerError)
+ return
+ }
+ }
+
+ logging.Debug("Chunk to proxy", types.Inferences, "inference_id", inferenceId, "line", lineToProxy)
+
+ // Forward the line to the client
+ _, err := fmt.Fprintln(w, lineToProxy)
+ if err != nil {
+ if opErr, ok := err.(*net.OpError); ok {
+ logging.Warn("Stream cancelled during streaming", types.Inferences, "inferenceId", inferenceId, "error", opErr)
+ resp.Body.Close()
+ return
+ }
+
+ logging.Error("Error while streaming response", types.Inferences, "inferenceId", inferenceId, "error", err)
+ http.Error(w, err.Error(), http.StatusInternalServerError)
+ return
+ }
+ }
+
+ if err := scanner.Err(); err != nil {
+ logging.Error("Error after streaming response", types.Inferences, "inferenceId", inferenceId, "error", err)
+ }
+}
+
+func proxyJsonResponse(resp *http.Response, w http.ResponseWriter, responseProcessor completionapi.ResponseProcessor, inferenceId string) {
+ var bodyBytes, err = io.ReadAll(resp.Body)
+ if err != nil {
+ logging.Error("Failed to read inference node response body", types.Inferences, "inferenceId", inferenceId, "error", err)
+ http.Error(w, fmt.Sprintf("Failed to read inference node response body. inferenceId = %s", inferenceId), http.StatusInternalServerError)
+ return
+ }
+
+ if responseProcessor != nil {
+ bodyBytes, err = responseProcessor.ProcessJsonResponse(bodyBytes)
+ if err != nil {
+ logging.Error("Failed to process inference node response", types.Inferences, "inferenceId", inferenceId, "error", err)
+ http.Error(w, fmt.Sprintf("Failed to process inference node response. inferenceId = %s", inferenceId), http.StatusInternalServerError)
+ return
+ }
+ }
+
+ w.WriteHeader(resp.StatusCode)
+ w.Write(bodyBytes)
+}
diff --git a/decentralized-api/internal/server/public/restrictions_handlers.go b/decentralized-api/internal/server/public/restrictions_handlers.go
new file mode 100644
index 000000000..ff7bcda4e
--- /dev/null
+++ b/decentralized-api/internal/server/public/restrictions_handlers.go
@@ -0,0 +1,41 @@
+package public
+
+import (
+ "net/http"
+
+ "github.com/labstack/echo/v4"
+ restrictionstypes "github.com/productscience/inference/x/restrictions/types"
+)
+
+// Query-only handlers for restrictions module
+func (s *Server) getRestrictionsStatus(c echo.Context) error {
+ queryClient := s.recorder.NewRestrictionsQueryClient()
+ response, err := queryClient.TransferRestrictionStatus(c.Request().Context(), &restrictionstypes.QueryTransferRestrictionStatusRequest{})
+ if err != nil {
+ return err
+ }
+ return c.JSON(http.StatusOK, response)
+}
+
+func (s *Server) getRestrictionsExemptions(c echo.Context) error {
+ queryClient := s.recorder.NewRestrictionsQueryClient()
+ response, err := queryClient.TransferExemptions(c.Request().Context(), &restrictionstypes.QueryTransferExemptionsRequest{})
+ if err != nil {
+ return err
+ }
+ return c.JSON(http.StatusOK, response)
+}
+
+func (s *Server) getRestrictionsExemptionUsage(c echo.Context) error {
+ id := c.Param("id")
+ account := c.Param("account")
+ queryClient := s.recorder.NewRestrictionsQueryClient()
+ response, err := queryClient.ExemptionUsage(c.Request().Context(), &restrictionstypes.QueryExemptionUsageRequest{
+ ExemptionId: id,
+ AccountAddress: account,
+ })
+ if err != nil {
+ return err
+ }
+ return c.JSON(http.StatusOK, response)
+}
diff --git a/decentralized-api/internal/server/public/server.go b/decentralized-api/internal/server/public/server.go
new file mode 100644
index 000000000..07280e944
--- /dev/null
+++ b/decentralized-api/internal/server/public/server.go
@@ -0,0 +1,110 @@
+package public
+
+import (
+ "decentralized-api/apiconfig"
+ "decentralized-api/broker"
+ "decentralized-api/chainphase"
+ "decentralized-api/cosmosclient"
+ "decentralized-api/internal"
+ "decentralized-api/internal/server/middleware"
+ "decentralized-api/training"
+ "net/http"
+
+ "github.com/labstack/echo/v4"
+)
+
+type Server struct {
+ e *echo.Echo
+ nodeBroker *broker.Broker
+ configManager *apiconfig.ConfigManager
+ recorder cosmosclient.CosmosMessageClient
+ trainingExecutor *training.Executor
+ blockQueue *BridgeQueue
+ bandwidthLimiter *internal.BandwidthLimiter
+}
+
+// TODO: think about rate limits
+func NewServer(
+ nodeBroker *broker.Broker,
+ configManager *apiconfig.ConfigManager,
+ recorder cosmosclient.CosmosMessageClient,
+ trainingExecutor *training.Executor,
+ blockQueue *BridgeQueue,
+ phaseTracker *chainphase.ChainPhaseTracker) *Server {
+ e := echo.New()
+ e.HTTPErrorHandler = middleware.TransparentErrorHandler
+
+ // Set the package-level configManagerRef
+ configManagerRef = configManager
+
+ s := &Server{
+ e: e,
+ nodeBroker: nodeBroker,
+ configManager: configManager,
+ recorder: recorder,
+ trainingExecutor: trainingExecutor,
+ blockQueue: blockQueue,
+ }
+
+ s.bandwidthLimiter = internal.NewBandwidthLimiterFromConfig(configManager, recorder, phaseTracker)
+
+ e.Use(middleware.LoggingMiddleware)
+ g := e.Group("/v1/")
+
+ g.GET("status", s.getStatus)
+
+ g.POST("chat/completions", s.postChat)
+ g.GET("chat/completions/:id", s.getChatById)
+
+ g.GET("participants/:address", s.getInferenceParticipantByAddress)
+ g.GET("participants", s.getAllParticipants)
+ g.POST("participants", s.submitNewParticipantHandler)
+
+ g.POST("training/tasks", s.postTrainingTask)
+ g.GET("training/tasks", s.getTrainingTasks)
+ g.GET("training/tasks/:id", s.getTrainingTask)
+ g.POST("training/lock-nodes", s.lockTrainingNodes)
+
+ g.POST("verify-proof", s.postVerifyProof)
+ g.POST("verify-block", s.postVerifyBlock)
+
+ g.GET("pricing", s.getPricing)
+ g.GET("models", s.getModels)
+ g.GET("governance/pricing", s.getGovernancePricing)
+ g.GET("governance/models", s.getGovernanceModels)
+ g.GET("poc-batches/:epoch", s.getPoCBatches)
+
+ g.GET("debug/pubkey-to-addr/:pubkey", s.debugPubKeyToAddr)
+ g.GET("debug/verify/:height", s.debugVerify)
+
+ g.GET("versions", s.getVersions)
+
+ g.GET("bridge/status", s.getBridgeStatus)
+ g.GET("bridge/addresses", s.getBridgeAddresses)
+
+ g.GET("epochs/:epoch", s.getEpochById)
+ g.GET("epochs/:epoch/participants", s.getParticipantsByEpoch)
+
+ // BLS Query Endpoints
+ blsGroup := g.Group("bls/")
+ blsGroup.GET("epoch/:id", s.getBLSEpochByID)
+ blsGroup.GET("epochs/:id", s.getBLSEpochByID)
+ blsGroup.GET("signatures/:request_id", s.getBLSSignatureByRequestID)
+
+ // Restrictions public API (query-only)
+ g.GET("restrictions/status", s.getRestrictionsStatus)
+ g.GET("restrictions/exemptions", s.getRestrictionsExemptions)
+ g.GET("restrictions/exemptions/:id/usage/:account", s.getRestrictionsExemptionUsage)
+
+ return s
+}
+
+func (s *Server) Start(addr string) {
+ go s.e.Start(addr)
+}
+
+func (s *Server) getStatus(ctx echo.Context) error {
+ return ctx.JSON(http.StatusOK, struct {
+ Status string `json:"status"`
+ }{Status: "ok"})
+}
diff --git a/decentralized-api/internal/server/public/training_jobs_handlers.go b/decentralized-api/internal/server/public/training_jobs_handlers.go
new file mode 100644
index 000000000..cd5689223
--- /dev/null
+++ b/decentralized-api/internal/server/public/training_jobs_handlers.go
@@ -0,0 +1,81 @@
+package public
+
+import (
+ "github.com/labstack/echo/v4"
+ "github.com/productscience/inference/api/inference/inference"
+ "github.com/productscience/inference/x/inference/types"
+ "net/http"
+ "strconv"
+)
+
+// TODO add signature verification
+func (s *Server) postTrainingTask(ctx echo.Context) error {
+ var body StartTrainingDto
+ if err := ctx.Bind(&body); err != nil {
+ return echo.NewHTTPError(http.StatusBadRequest, err)
+ }
+
+ var hardwareResources = make([]*inference.TrainingHardwareResources, len(body.HardwareResources))
+ for i, hr := range body.HardwareResources {
+ hardwareResources[i] = &inference.TrainingHardwareResources{
+ Type_: hr.Type,
+ Count: hr.Count,
+ }
+ }
+
+ msg := &inference.MsgCreateTrainingTask{
+ HardwareResources: hardwareResources,
+ Config: &inference.TrainingConfig{
+ Datasets: &inference.TrainingDatasets{
+ Train: body.Config.Datasets.Train,
+ Test: body.Config.Datasets.Test,
+ },
+ NumUocEstimationSteps: body.Config.NumUocEstimationSteps,
+ },
+ }
+
+ msgResponse, err := s.recorder.CreateTrainingTask(msg)
+ if err != nil {
+ return err
+ }
+ return ctx.JSON(http.StatusCreated, msgResponse)
+}
+
+func (s *Server) getTrainingTasks(ctx echo.Context) error {
+ queryClient := s.recorder.NewInferenceQueryClient()
+ tasks, err := queryClient.TrainingTaskAll(s.recorder.GetContext(), &types.QueryTrainingTaskAllRequest{})
+ if err != nil {
+ return err
+ }
+
+ return ctx.JSON(http.StatusOK, tasks)
+}
+
+func (s *Server) getTrainingTask(ctx echo.Context) error {
+ idParam := ctx.Param("id")
+ uintId, err := strconv.ParseUint(idParam, 10, 64)
+ if err != nil {
+ return ErrInvalidTrainingJobId
+ }
+
+ queryClient := s.recorder.NewInferenceQueryClient()
+ task, err := queryClient.TrainingTask(s.recorder.GetContext(), &types.QueryTrainingTaskRequest{Id: uintId})
+ if err != nil {
+ return err
+ }
+
+ return ctx.JSON(http.StatusOK, task)
+}
+
+func (s *Server) lockTrainingNodes(ctx echo.Context) error {
+ var body LockTrainingNodesDto
+ if err := ctx.Bind(&body); err != nil {
+ return echo.NewHTTPError(http.StatusBadRequest, err)
+ }
+
+ if err := s.trainingExecutor.PreassignTask(body.TrainingTaskId, body.NodeIds); err != nil {
+ return echo.NewHTTPError(http.StatusInternalServerError, err)
+ }
+
+ return nil
+}
diff --git a/decentralized-api/internal/server/public/utils.go b/decentralized-api/internal/server/public/utils.go
new file mode 100644
index 000000000..c7d3a0d66
--- /dev/null
+++ b/decentralized-api/internal/server/public/utils.go
@@ -0,0 +1,25 @@
+package public
+
+import (
+ "github.com/productscience/inference/x/inference/calculations"
+)
+
+func validateTransferRequest(request *ChatRequest, devPubkey string) error {
+ components := calculations.SignatureComponents{
+ Payload: string(request.Body),
+ Timestamp: request.Timestamp,
+ TransferAddress: request.TransferAddress,
+ ExecutorAddress: "",
+ }
+ return calculations.ValidateSignature(components, calculations.TransferAgent, devPubkey, request.AuthKey)
+}
+
+func validateExecuteRequestWithGrantees(request *ChatRequest, transferPubkeys []string, executorAddress string, transferSignature string) error {
+ components := calculations.SignatureComponents{
+ Payload: string(request.Body),
+ Timestamp: request.Timestamp,
+ TransferAddress: request.TransferAddress,
+ ExecutorAddress: executorAddress,
+ }
+ return calculations.ValidateSignatureWithGrantees(components, calculations.ExecutorAgent, transferPubkeys, transferSignature)
+}
diff --git a/decentralized-api/internal/server/public_entities/entities.go b/decentralized-api/internal/server/public_entities/entities.go
new file mode 100644
index 000000000..ae3fa1fdb
--- /dev/null
+++ b/decentralized-api/internal/server/public_entities/entities.go
@@ -0,0 +1,9 @@
+package public_entities
+
+type SubmitUnfundedNewParticipantDto struct {
+ Address string `json:"address"`
+ Url string `json:"url"`
+ ValidatorKey string `json:"validator_key"`
+ PubKey string `json:"pub_key"`
+ WorkerKey string `json:"worker_key"`
+}
diff --git a/decentralized-api/internal/startup/reward_recovery.go b/decentralized-api/internal/startup/reward_recovery.go
new file mode 100644
index 000000000..5ea388746
--- /dev/null
+++ b/decentralized-api/internal/startup/reward_recovery.go
@@ -0,0 +1,227 @@
+package startup
+
+import (
+ "context"
+ "decentralized-api/apiconfig"
+ "decentralized-api/chainphase"
+ "decentralized-api/cosmosclient"
+ "decentralized-api/internal/validation"
+ "decentralized-api/logging"
+ "time"
+
+ "github.com/productscience/inference/api/inference/inference"
+ "github.com/productscience/inference/x/inference/types"
+)
+
+const waitTimeBlocksFromLaunch = 60
+const waitBetweenAttempts = 100
+
+func NewRewardRecoveryChecker(
+ phaseTracker *chainphase.ChainPhaseTracker,
+ recorder *cosmosclient.InferenceCosmosClient,
+ validator *validation.InferenceValidator,
+ configManager *apiconfig.ConfigManager,
+) *RewardRecoveryChecker {
+ return &RewardRecoveryChecker{
+ launchBlockHeight: 0,
+ lastRecoveryBlockHeight: 0,
+ phaseTracker: phaseTracker,
+ recorder: recorder,
+ validator: validator,
+ configManager: configManager,
+ }
+}
+
+type RewardRecoveryChecker struct {
+ launchBlockHeight int64
+ lastRecoveryBlockHeight int64
+ phaseTracker *chainphase.ChainPhaseTracker
+ recorder *cosmosclient.InferenceCosmosClient
+ validator *validation.InferenceValidator
+ configManager *apiconfig.ConfigManager
+}
+
+func (c *RewardRecoveryChecker) RecoverIfNeeded(
+ currentBlockHeight int64,
+) {
+ if c.launchBlockHeight == 0 {
+ logging.Info("[AutoRewardRecovery] Launch block height not set, setting to current block height", types.Claims,
+ "currentBlockHeight", currentBlockHeight)
+ c.launchBlockHeight = currentBlockHeight
+ }
+
+ if currentBlockHeight < (c.launchBlockHeight + waitTimeBlocksFromLaunch) {
+ logging.Debug("[AutoRewardRecovery] Waiting for launch", types.Claims,
+ "currentBlockHeight", currentBlockHeight,
+ "launchBlockHeight", c.launchBlockHeight)
+ return
+ }
+
+ if currentBlockHeight < (c.lastRecoveryBlockHeight + waitBetweenAttempts) {
+ logging.Debug("[AutoRewardRecovery] Waiting for last recovery", types.Claims,
+ "currentBlockHeight", currentBlockHeight,
+ "lastRecoveryBlockHeight", c.lastRecoveryBlockHeight)
+ return
+ }
+
+ latestEpoch := c.phaseTracker.GetCurrentEpochState().LatestEpoch
+ inferenceValidationCutoff := latestEpoch.InferenceValidationCutoff()
+ if currentBlockHeight > inferenceValidationCutoff {
+ logging.Debug("[AutoRewardRecovery] Inference validation cutoff reached", types.Claims,
+ "currentBlockHeight", currentBlockHeight,
+ "inferenceValidationCutoff", inferenceValidationCutoff)
+ return
+ }
+
+ if latestEpoch.GetCurrentPhase(currentBlockHeight) != types.InferencePhase {
+ logging.Debug("[AutoRewardRecovery] Not in inference phase", types.Claims,
+ "currentBlockHeight", currentBlockHeight,
+ "latestEpoch", latestEpoch)
+ return
+ }
+
+ c.lastRecoveryBlockHeight = currentBlockHeight
+ go func() {
+ c.AutoRewardRecovery()
+ }()
+}
+
+// AutoRewardRecovery checks for unclaimed settle amounts and attempts to recover rewards on startup
+func (c *RewardRecoveryChecker) AutoRewardRecovery() {
+ logging.Info("[AutoRewardRecovery] Starting automatic reward recovery check", types.Claims)
+
+ // Get participant address
+ address := c.recorder.GetAddress()
+ if address == "" {
+ logging.Error("[AutoRewardRecovery] Cannot perform reward recovery: no participant address", types.Claims)
+ return
+ }
+
+ // Query for settle amount
+ queryClient := c.recorder.NewInferenceQueryClient()
+ ctx, cancel := context.WithTimeout(c.recorder.GetContext(), 30*time.Second)
+ defer cancel()
+
+ settleAmountResp, err := queryClient.SettleAmount(ctx, &types.QueryGetSettleAmountRequest{
+ Participant: address,
+ })
+ if err != nil {
+ // This is expected if no settle amount exists
+ logging.Debug("[AutoRewardRecovery] No settle amount found for participant", types.Claims, "address", address, "error", err)
+ return
+ }
+
+ if settleAmountResp == nil {
+ logging.Debug("[AutoRewardRecovery] No settle amount data available", types.Claims, "address", address)
+ return
+ }
+
+ settleAmount := settleAmountResp.SettleAmount
+ totalAmount := settleAmount.RewardCoins + settleAmount.WorkCoins
+ logging.Info("[AutoRewardRecovery] Found settle amount for participant", types.Claims,
+ "address", address,
+ "rewardCoins", settleAmount.RewardCoins,
+ "workCoins", settleAmount.WorkCoins,
+ "totalAmount", totalAmount,
+ "epochIndex", settleAmount.EpochIndex)
+
+ // Check if we have unclaimed rewards (totalAmount > 0 indicates pending rewards)
+ if totalAmount <= 0 {
+ logging.Info("[AutoRewardRecovery] No unclaimed rewards found", types.Claims, "address", address, "totalAmount", totalAmount)
+ return
+ }
+
+ // Get the previous seed for this epoch
+ previousSeed := c.configManager.GetPreviousSeed()
+
+ // Check if the settle amount epoch matches our stored epoch
+ if previousSeed.EpochIndex != settleAmount.EpochIndex {
+ logging.Warn("[AutoRewardRecovery] Settle amount epoch doesn't match stored previous seed epoch", types.Claims,
+ "settleAmountEpoch", settleAmount.EpochIndex,
+ "storedSeedEpoch", previousSeed.EpochIndex,
+ "address", address)
+
+ // We could still try with the settle amount epoch, but it's risky
+ // For now, let's be conservative and skip
+ return
+ }
+
+ // Check if we have a valid seed
+ if previousSeed.Seed == 0 {
+ logging.Warn("[AutoRewardRecovery] No valid seed available for reward recovery", types.Claims,
+ "epochIndex", settleAmount.EpochIndex,
+ "address", address)
+ return
+ }
+
+ logging.Info("[AutoRewardRecovery] Attempting automatic reward recovery", types.Claims,
+ "epochIndex", settleAmount.EpochIndex,
+ "seed", previousSeed.Seed,
+ "totalAmount", totalAmount,
+ "address", address)
+
+ // Perform validation recovery using the same logic as the admin endpoint
+ missedInferences, err := c.validator.DetectMissedValidations(previousSeed.EpochIndex, previousSeed.Seed)
+ if err != nil {
+ logging.Error("[AutoRewardRecovery] Failed to detect missed validations during startup", types.Claims,
+ "epochIndex", settleAmount.EpochIndex,
+ "error", err)
+ return
+ }
+
+ missedCount := len(missedInferences)
+ logging.Info("[AutoRewardRecovery] Startup recovery detected missed validations", types.Claims,
+ "epochIndex", settleAmount.EpochIndex,
+ "missedCount", missedCount,
+ "address", address)
+
+ // Execute recovery validations if any were missed
+ if missedCount > 0 {
+ recoveredCount, err := c.validator.ExecuteRecoveryValidations(missedInferences)
+ if err != nil {
+ logging.Error("[AutoRewardRecovery] Failed to execute recovery validations during startup", types.Claims,
+ "epochIndex", settleAmount.EpochIndex,
+ "missedCount", missedCount,
+ "error", err)
+ return
+ }
+
+ logging.Info("[AutoRewardRecovery] Startup recovery validations completed", types.Claims,
+ "epochIndex", settleAmount.EpochIndex,
+ "recoveredCount", recoveredCount,
+ "missedCount", missedCount,
+ "address", address)
+
+ // Wait for validations to be recorded on-chain
+ if recoveredCount > 0 {
+ logging.Info("[AutoRewardRecovery] Waiting for startup recovery validations to be recorded on-chain", types.Claims,
+ "epochIndex", settleAmount.EpochIndex,
+ "recoveredCount", recoveredCount)
+ c.validator.WaitForValidationsToBeRecorded()
+ }
+ }
+
+ // Attempt to claim rewards
+ err = c.recorder.ClaimRewards(&inference.MsgClaimRewards{
+ Seed: previousSeed.Seed,
+ EpochIndex: previousSeed.EpochIndex,
+ })
+ if err != nil {
+ logging.Error("[AutoRewardRecovery] Failed to claim rewards during startup recovery", types.Claims,
+ "epochIndex", settleAmount.EpochIndex,
+ "error", err)
+ return
+ }
+
+ // Mark as claimed to prevent duplicate attempts
+ err = c.configManager.MarkPreviousSeedClaimed()
+ if err != nil {
+ logging.Error("[AutoRewardRecovery] Failed to mark seed as claimed after successful recovery", types.Claims,
+ "epochIndex", settleAmount.EpochIndex,
+ "error", err)
+ }
+
+ logging.Info("[AutoRewardRecovery] Automatic reward recovery completed successfully", types.Claims,
+ "epochIndex", settleAmount.EpochIndex,
+ "address", address)
+}
diff --git a/decentralized-api/internal/utils/utils.go b/decentralized-api/internal/utils/utils.go
new file mode 100644
index 000000000..8fb6a9e7b
--- /dev/null
+++ b/decentralized-api/internal/utils/utils.go
@@ -0,0 +1,49 @@
+package utils
+
+import (
+ "decentralized-api/completionapi"
+ "decentralized-api/utils"
+ "encoding/base64"
+ "encoding/hex"
+ "encoding/json"
+)
+
+// UnquoteEventValue removes JSON quotes from event values
+// Cosmos SDK events often have JSON-encoded values like "\"1\"" which need to be unquoted to "1"
+func UnquoteEventValue(value string) (string, error) {
+ var unquoted string
+ err := json.Unmarshal([]byte(value), &unquoted)
+ if err != nil {
+ return value, nil // Return original value if unquoting fails
+ }
+ return unquoted, nil
+}
+
+// DecodeBase64IfPossible attempts to decode a string as base64
+// Returns the decoded bytes if successful, or an error if not valid base64
+func DecodeBase64IfPossible(s string) ([]byte, error) {
+ return base64.StdEncoding.DecodeString(s)
+}
+
+// DecodeHex decodes a hex string to bytes
+// Returns the decoded bytes if successful, or an error if not valid hex
+func DecodeHex(s string) ([]byte, error) {
+ return hex.DecodeString(s)
+}
+
+func GetResponseHash(bodyBytes []byte) (string, *completionapi.Response, error) {
+ if (bodyBytes == nil) || (len(bodyBytes) == 0) {
+ return "", nil, nil
+ }
+ var response completionapi.Response
+ if err := json.Unmarshal(bodyBytes, &response); err != nil {
+ return "", nil, err
+ }
+
+ var content string
+ for _, choice := range response.Choices {
+ content += choice.Message.Content
+ }
+ hash := utils.GenerateSHA256Hash(content)
+ return hash, &response, nil
+}
diff --git a/decentralized-api/internal/validation/inference_validation.go b/decentralized-api/internal/validation/inference_validation.go
new file mode 100644
index 000000000..11ab4f16e
--- /dev/null
+++ b/decentralized-api/internal/validation/inference_validation.go
@@ -0,0 +1,1169 @@
+package validation
+
+import (
+ "bytes"
+ "context"
+ "decentralized-api/apiconfig"
+ "decentralized-api/broker"
+ "decentralized-api/chainphase"
+ "decentralized-api/completionapi"
+ "decentralized-api/cosmosclient"
+ "decentralized-api/internal/utils"
+ "decentralized-api/logging"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "io"
+ "math"
+ "net/http"
+ "net/url"
+ "slices"
+ "sort"
+ "sync"
+ "time"
+
+ "github.com/cosmos/cosmos-sdk/types/query"
+ "github.com/google/uuid"
+ "github.com/productscience/inference/api/inference/inference"
+ "github.com/productscience/inference/x/inference/calculations"
+ "github.com/productscience/inference/x/inference/types"
+ "google.golang.org/grpc/codes"
+ "google.golang.org/grpc/status"
+)
+
+type InferenceValidator struct {
+ recorder cosmosclient.CosmosMessageClient
+ nodeBroker *broker.Broker
+ configManager *apiconfig.ConfigManager
+ phaseTracker *chainphase.ChainPhaseTracker
+ validatorClient *ValidatorClient
+}
+
+func NewInferenceValidator(
+ nodeBroker *broker.Broker,
+ configManager *apiconfig.ConfigManager,
+ recorder cosmosclient.CosmosMessageClient,
+ phaseTracker *chainphase.ChainPhaseTracker) *InferenceValidator {
+
+ var validatorClient *ValidatorClient
+ validatorConfig := configManager.GetConfig().Validator
+ if validatorConfig.VllmUrl != "" {
+ validatorClient = NewValidatorClient(validatorConfig.VllmUrl)
+ }
+
+ return &InferenceValidator{
+ nodeBroker: nodeBroker,
+ configManager: configManager,
+ recorder: recorder,
+ phaseTracker: phaseTracker,
+ validatorClient: validatorClient,
+ }
+}
+
+func (s *InferenceValidator) VerifyInvalidation(events map[string][]string, recorder cosmosclient.InferenceCosmosClient) {
+ inferenceIds, ok := events["inference_validation.inference_id"]
+ if !ok || len(inferenceIds) == 0 {
+ logging.Error("No inference_id found in events", types.Validation)
+ return
+ }
+ inferenceId := inferenceIds[0]
+
+ logging.Debug("Verifying invalidation", types.Validation, "inference_id", inferenceId)
+
+ queryClient := recorder.NewInferenceQueryClient()
+
+ r, err := queryClient.Inference(recorder.GetContext(), &types.QueryGetInferenceRequest{Index: inferenceId})
+ if err != nil {
+ // FIXME: what should we do with validating the transaction?
+ logging.Warn("Failed to query Inference for revalidation.", types.Validation, "error", err)
+ return
+ }
+
+ logInferencesToValidate([]string{inferenceId})
+ go func() {
+ s.validateInferenceAndSendValMessage(r.Inference, recorder, true)
+ }()
+
+}
+
+// shouldValidateInference determines if the current participant should validate a specific inference
+// This function extracts the core validation decision logic for reuse in recovery scenarios
+func (s *InferenceValidator) shouldValidateInference(
+ inferenceDetails *types.InferenceValidationDetails,
+ seed int64,
+ validatorPower uint64,
+ validatorAddress string,
+ validationParams *types.ValidationParams,
+) (bool, string) {
+ // Skip if this participant is the executor
+ if inferenceDetails.ExecutorId == validatorAddress {
+ return false, "Skipping validation: participant is the executor"
+ }
+
+ // Skip if total power is invalid
+ if inferenceDetails.TotalPower <= inferenceDetails.ExecutorPower {
+ return false, "Skipping validation: total power is less than or equal to executor power"
+ }
+
+ // Use the same validation logic as real-time validations
+ shouldValidate, message := calculations.ShouldValidate(
+ seed,
+ inferenceDetails,
+ uint32(inferenceDetails.TotalPower),
+ uint32(validatorPower),
+ uint32(inferenceDetails.ExecutorPower),
+ validationParams)
+
+ return shouldValidate, message
+}
+
+func (s *InferenceValidator) getNodeModelsAtEpoch(epochIndex uint64, address string) (map[string]bool, error) {
+ supportedModels := make(map[string]bool)
+ parentEpochData, err := s.nodeBroker.GetChainBridge().GetEpochGroupDataByModelId(epochIndex, "")
+ if err != nil {
+ logging.Error("Failed to get epoch group data by model id", types.ValidationRecovery, "error", err)
+ return nil, fmt.Errorf("failed to get epoch group data by model id: %w", err)
+ }
+ for _, modelId := range parentEpochData.EpochGroupData.SubGroupModels {
+ subgroupResp, err := s.nodeBroker.GetChainBridge().GetEpochGroupDataByModelId(parentEpochData.EpochGroupData.EpochIndex, modelId)
+ if err != nil {
+ logging.Error("Failed to get subgroup epoch data", types.ValidationRecovery, "model_id", modelId, "error", err)
+ continue
+ }
+ if subgroupResp == nil {
+ logging.Warn("Subgroup epoch data response is nil", types.ValidationRecovery, "model_id", modelId)
+ continue
+ }
+
+ subgroup := subgroupResp.EpochGroupData
+ if subgroup.ModelSnapshot == nil {
+ logging.Error("ModelSnapshot is nil in subgroup", types.ValidationRecovery, "model_id", modelId)
+ continue
+ }
+
+ for _, weightInfo := range subgroup.ValidationWeights {
+ if weightInfo.MemberAddress == address {
+ supportedModels[modelId] = true
+ }
+ }
+ }
+ logging.Info("Supported models at epoch", types.ValidationRecovery, "epochIndex", epochIndex, "supportedModels", supportedModels, "address", address)
+
+ return supportedModels, nil
+}
+
+func (s *InferenceValidator) getCurrentSupportedModels() (map[string]bool, error) {
+ supportedModels := make(map[string]bool)
+ nodes, err := s.nodeBroker.GetNodes()
+ if err != nil {
+ logging.Error("Failed to get nodes from broker", types.ValidationRecovery, "error", err)
+ return nil, fmt.Errorf("failed to get nodes: %w", err)
+ }
+ for _, node := range nodes {
+ nodeState := node.State
+ for model := range nodeState.EpochModels {
+ supportedModels[model] = true
+ }
+ }
+ logging.Debug("Supported models", types.ValidationRecovery, "supportedModels", supportedModels)
+ return supportedModels, nil
+}
+
+// DetectMissedValidations identifies which validations were missed for a specific epoch
+// Returns a list of inference objects that the current participant should have validated but didn't
+func (s *InferenceValidator) DetectMissedValidations(epochIndex uint64, seed int64) ([]types.Inference, error) {
+ logging.Info("Starting missed validation detection", types.ValidationRecovery, "epochIndex", epochIndex, "seed", seed)
+
+ queryClient := s.recorder.NewInferenceQueryClient()
+ address := s.recorder.GetAddress()
+
+ // Get all inferences (automatically pruned to recent 2-3 epochs) with pagination
+ var allInferences []types.Inference
+ var nextKey []byte
+
+ for {
+ req := &types.QueryAllInferenceRequest{
+ Pagination: &query.PageRequest{
+ Key: nextKey,
+ Limit: 1000, // Use larger page size for efficiency
+ },
+ }
+
+ resp, err := queryClient.InferenceAll(s.recorder.GetContext(), req)
+ if err != nil {
+ logging.Error("Failed to query inferences page", types.ValidationRecovery, "error", err)
+ return nil, fmt.Errorf("failed to query inferences: %w", err)
+ }
+
+ allInferences = append(allInferences, resp.Inference...)
+
+ // Check if there are more pages
+ if resp.Pagination == nil || len(resp.Pagination.NextKey) == 0 {
+ break
+ }
+ nextKey = resp.Pagination.NextKey
+ }
+
+ logging.Debug("Retrieved all inferences", types.ValidationRecovery, "totalCount", len(allInferences))
+
+ // Filter inferences by epoch
+ var epochInferences []types.Inference
+ for _, inf := range allInferences {
+ if inf.EpochId == epochIndex {
+ epochInferences = append(epochInferences, inf)
+ }
+ }
+
+ if len(epochInferences) == 0 {
+ logging.Info("No inferences found for epoch", types.ValidationRecovery, "epochIndex", epochIndex)
+ return []types.Inference{}, nil
+ }
+
+ logging.Info("Found inferences for epoch", types.ValidationRecovery, "epochIndex", epochIndex, "count", len(epochInferences))
+
+ // Create a map for quick lookup of inferences by ID
+ inferenceMap := make(map[string]types.Inference)
+ inferenceIds := make([]string, len(epochInferences))
+ for i, inf := range epochInferences {
+ inferenceIds[i] = inf.InferenceId
+ inferenceMap[inf.InferenceId] = inf
+ }
+
+ // Process inference IDs in batches to avoid "request body too large" errors
+ const batchSize = 1000 // Reasonable batch size to stay under request limits
+ var allValidationDetails []*types.InferenceValidationDetails
+ var validatorPower uint64
+
+ for i := 0; i < len(inferenceIds); i += batchSize {
+ end := i + batchSize
+ if end > len(inferenceIds) {
+ end = len(inferenceIds)
+ }
+
+ batch := inferenceIds[i:end]
+ logging.Debug("Processing validation parameters batch", types.ValidationRecovery,
+ "batchNumber", (i/batchSize)+1,
+ "batchSize", len(batch),
+ "totalBatches", (len(inferenceIds)+batchSize-1)/batchSize)
+
+ batchResp, err := queryClient.GetInferenceValidationParameters(s.recorder.GetContext(), &types.QueryGetInferenceValidationParametersRequest{
+ Ids: batch,
+ Requester: address,
+ })
+ if err != nil {
+ logging.Error("Failed to get validation parameters for batch", types.ValidationRecovery,
+ "batchNumber", (i/batchSize)+1,
+ "batchSize", len(batch),
+ "error", err)
+ return nil, fmt.Errorf("failed to get validation parameters for batch %d: %w", (i/batchSize)+1, err)
+ }
+
+ allValidationDetails = append(allValidationDetails, batchResp.Details...)
+
+ // Capture ValidatorPower from the first batch (it should be the same across all batches)
+ if i == 0 {
+ validatorPower = batchResp.ValidatorPower
+ }
+ }
+
+ // Create a combined response structure
+ validationParamsResp := &types.QueryGetInferenceValidationParametersResponse{
+ Details: allValidationDetails,
+ ValidatorPower: validatorPower,
+ }
+
+ logging.Info("Completed batched validation parameter queries", types.ValidationRecovery,
+ "totalInferences", len(inferenceIds),
+ "totalBatches", (len(inferenceIds)+batchSize-1)/batchSize,
+ "retrievedDetails", len(allValidationDetails))
+
+ // Get validation params
+ params, err := queryClient.Params(s.recorder.GetContext(), &types.QueryParamsRequest{})
+ if err != nil {
+ logging.Error("Failed to get params", types.ValidationRecovery, "error", err)
+ return nil, fmt.Errorf("failed to get params: %w", err)
+ }
+
+ // Get what validations were already submitted by this participant
+ epochGroupValidationsResp, err := queryClient.EpochGroupValidations(s.recorder.GetContext(), &types.QueryGetEpochGroupValidationsRequest{
+ Participant: address,
+ EpochIndex: epochIndex,
+ })
+
+ // Create a set of already validated inference IDs
+ alreadyValidated := make(map[string]bool)
+ if err == nil {
+ for _, inferenceId := range epochGroupValidationsResp.EpochGroupValidations.ValidatedInferences {
+ alreadyValidated[inferenceId] = true
+ }
+ } else {
+ if status.Code(err) == codes.NotFound {
+ logging.Info("No epoch group validations found", types.ValidationRecovery, "participant", address, "epochIndex", epochIndex)
+ } else {
+ logging.Warn("Failed to get epoch group validations", types.ValidationRecovery, "error", err, "participant", address, "epochIndex", epochIndex)
+ }
+ }
+ supportedModels, err := s.getNodeModelsAtEpoch(epochIndex, address)
+ if err != nil {
+ logging.Error("Failed to get supported models at epoch", types.ValidationRecovery, "error", err)
+ return nil, fmt.Errorf("failed to get supported models at epoch: %w", err)
+ }
+
+ // Check each inference to see if it should have been validated but wasn't
+ var missedValidations []types.Inference
+ for _, inferenceDetails := range validationParamsResp.Details {
+ if !supportedModels[inferenceDetails.Model] {
+ logging.Debug("Skipping inference - model not supported by any node", types.ValidationRecovery, "inferenceId", inferenceDetails.InferenceId, "model", inferenceDetails.Model)
+ continue
+ }
+ // Check if this participant should validate this inference
+ shouldValidate, message := s.shouldValidateInference(
+ inferenceDetails,
+ seed,
+ validationParamsResp.ValidatorPower,
+ address,
+ params.Params.ValidationParams)
+
+ logging.Debug("Validation check result", types.ValidationRecovery,
+ "inferenceId", inferenceDetails.InferenceId,
+ "shouldValidate", shouldValidate,
+ "message", message,
+ "alreadyValidated", alreadyValidated[inferenceDetails.InferenceId])
+
+ // If should validate but didn't, add to missed list
+ if shouldValidate && !alreadyValidated[inferenceDetails.InferenceId] {
+ if inference, exists := inferenceMap[inferenceDetails.InferenceId]; exists {
+ missedValidations = append(missedValidations, inference)
+ logging.Info("Found missed validation", types.ValidationRecovery, "inferenceId", inferenceDetails.InferenceId)
+ } else {
+ logging.Warn("Inference not found in map", types.ValidationRecovery, "inferenceId", inferenceDetails.InferenceId)
+ }
+ }
+ }
+
+ logging.Info("Missed validation detection complete", types.ValidationRecovery,
+ "epochIndex", epochIndex,
+ "totalInferences", len(epochInferences),
+ "missedValidations", len(missedValidations))
+
+ return missedValidations, nil
+}
+
+// ExecuteRecoveryValidations executes validation for a list of missed inferences
+// This function uses the inference data already obtained and executes validations in parallel goroutines
+// It waits for all validations to complete before returning
+func (s *InferenceValidator) ExecuteRecoveryValidations(missedInferences []types.Inference) (int, error) {
+
+ availableModels, err := s.getCurrentSupportedModels()
+ if err != nil {
+ logging.Error("Failed to get currently available models", types.ValidationRecovery, "error", err)
+ return 0, fmt.Errorf("failed to get currently available models: %w", err)
+ }
+
+ missedInferencesToValidate := []types.Inference{}
+ for _, inf := range missedInferences {
+ if availableModels[inf.Model] {
+ missedInferencesToValidate = append(missedInferencesToValidate, inf)
+ } else {
+ logging.Info("Can't recover validation for inference, model not available", types.ValidationRecovery, "inferenceId", inf.InferenceId, "model", inf.Model)
+ }
+ }
+
+ if len(missedInferences) > len(missedInferencesToValidate) {
+ logging.Warn("Some inferences can't be recovered, model not available", types.ValidationRecovery, "missedInferences", len(missedInferences), "missedInferencesToValidate", len(missedInferencesToValidate))
+ }
+
+ if len(missedInferencesToValidate) == 0 {
+ logging.Info("No missed validations to execute", types.ValidationRecovery)
+ return 0, nil
+ }
+
+ logging.Info("Starting recovery validation execution", types.ValidationRecovery, "missedValidations", len(missedInferencesToValidate))
+
+ var wg sync.WaitGroup
+
+ // Execute recovery validations in parallel goroutines with WaitGroup synchronization
+ for _, inf := range missedInferencesToValidate {
+ wg.Add(1)
+ go func(inference types.Inference) {
+ defer wg.Done()
+
+ logging.Info("Executing recovery validation", types.ValidationRecovery, "inferenceId", inference.InferenceId)
+
+ // Use existing validation infrastructure
+ // The validateInferenceAndSendValMessage function handles all validation logic, node locking, and message sending
+ // Cast the interface back to concrete type (safe since it's always *InferenceCosmosClient)
+ concreteRecorder := s.recorder.(*cosmosclient.InferenceCosmosClient)
+ s.validateInferenceAndSendValMessage(inference, *concreteRecorder, false)
+
+ logging.Info("Recovery validation completed", types.ValidationRecovery, "inferenceId", inference.InferenceId)
+ }(inf)
+ }
+
+ // Wait for all recovery validations to complete
+ logging.Info("Waiting for all recovery validations to complete", types.ValidationRecovery, "count", len(missedInferences))
+ wg.Wait()
+
+ logging.Info("All recovery validations completed", types.ValidationRecovery, "count", len(missedInferences))
+ return len(missedInferencesToValidate), nil
+}
+
+func (s *InferenceValidator) WaitForValidationsToBeRecorded() {
+ const maxTimeoutBlocks = 60
+ epochLength := s.phaseTracker.GetEpochParams().EpochLength
+ timeoutBlocks := min(epochLength/10, maxTimeoutBlocks)
+
+ time.Sleep(5 * time.Duration(timeoutBlocks) * time.Second)
+}
+
+func (s *InferenceValidator) SampleInferenceToValidate(ids []string, transactionRecorder cosmosclient.InferenceCosmosClient) {
+ if ids == nil {
+ logging.Debug("No inferences to validate", types.Validation)
+ return
+ }
+
+ logging.Debug("Sampling inf transactions to validate", types.Validation)
+
+ queryClient := transactionRecorder.NewInferenceQueryClient()
+
+ r, err := queryClient.GetInferenceValidationParameters(transactionRecorder.GetContext(), &types.QueryGetInferenceValidationParametersRequest{
+ Ids: ids,
+ Requester: transactionRecorder.GetAddress(),
+ })
+ if err != nil {
+ // FIXME: what should we do with validating the transaction?
+ logging.Warn("Failed to query GetInferenceValidationParameters.", types.Validation, "error", err)
+ return
+ }
+
+ params, err := queryClient.Params(transactionRecorder.GetContext(), &types.QueryParamsRequest{})
+ if err != nil {
+ logging.Error("Failed to get params", types.Validation, "error", err)
+ return
+ }
+
+ supportedModels, err := s.getCurrentSupportedModels()
+ if err != nil {
+ logging.Error("Failed to get currently available models", types.Validation, "error", err)
+ return
+ }
+
+ logInferencesToSample(r.Details)
+
+ address := transactionRecorder.GetAddress()
+ currentSeed := s.configManager.GetCurrentSeed().Seed
+ var toValidateIds []string
+
+ for _, inferenceWithExecutor := range r.Details {
+ if !supportedModels[inferenceWithExecutor.Model] {
+ logging.Debug("Skipping inference by not supported model", types.Validation, "inferenceId", inferenceWithExecutor.InferenceId, "model", inferenceWithExecutor.Model)
+ continue
+ }
+ // Use the extracted validation decision logic
+ shouldValidate, message := s.shouldValidateInference(
+ inferenceWithExecutor,
+ currentSeed,
+ r.ValidatorPower,
+ address,
+ params.Params.ValidationParams)
+
+ logging.Info(message, types.Validation, "inferenceId", inferenceWithExecutor.InferenceId, "seed", currentSeed, "validator", address)
+
+ if shouldValidate {
+ toValidateIds = append(toValidateIds, inferenceWithExecutor.InferenceId)
+ }
+ }
+
+ logInferencesToValidate(toValidateIds)
+ for _, inf := range toValidateIds {
+ go func() {
+ response, err := queryClient.Inference(transactionRecorder.GetContext(), &types.QueryGetInferenceRequest{Index: inf})
+ if err != nil {
+ logging.Error("Failed to get inference by id", types.Validation, "id", response, "error", err)
+ return
+ }
+ s.validateInferenceAndSendValMessage(response.Inference, transactionRecorder, false)
+ }()
+ }
+}
+
+func logInferencesToSample(inferences []*types.InferenceValidationDetails) {
+ var ids []struct {
+ InferenceId string
+ ExecutorId string
+ }
+
+ for _, inf := range inferences {
+ ids = append(ids, struct {
+ InferenceId string
+ ExecutorId string
+ }{
+ InferenceId: inf.InferenceId,
+ ExecutorId: inf.ExecutorId,
+ })
+ }
+
+ logging.Info("Inferences to sample", types.Validation, "ids", ids)
+}
+
+func logInferencesToValidate(toValidate []string) {
+ var ids []string
+ for _, inf := range toValidate {
+ ids = append(ids, inf)
+ }
+ logging.Info("Inferences to validate", types.Validation, "inferences", ids)
+}
+
+func (s *InferenceValidator) validateInferenceAndSendValMessage(inf types.Inference, transactionRecorder cosmosclient.InferenceCosmosClient, revalidation bool) {
+ const maxRetries = 5
+ const retryInterval = 4 * time.Minute
+
+ var valResult ValidationResult
+ var err error
+
+ // Retry logic for LockNode operation
+ for attempt := 1; attempt <= maxRetries; attempt++ {
+ valResult, err = broker.LockNode(s.nodeBroker, inf.Model, func(node *broker.Node) (ValidationResult, error) {
+ return s.validate(inf, node)
+ })
+
+ if err == nil {
+ // Success, break out of retry loop
+ break
+ }
+
+ // For all errors, check if we should retry
+ if attempt < maxRetries {
+ logging.Warn("Failed to validate inference, retrying", types.Validation,
+ "id", inf.InferenceId,
+ "attempt", attempt,
+ "maxRetries", maxRetries,
+ "error", err,
+ "nextRetryIn", retryInterval)
+ time.Sleep(retryInterval)
+ } else {
+ // Final attempt failed - check if it's ErrNoNodesAvailable for special handling
+ if errors.Is(err, broker.ErrNoNodesAvailable) {
+ logging.Warn("Failed to validate inference after all retry attempts. No nodes available, probably unsupported model.", types.Validation, "id", inf.InferenceId, "attempts", maxRetries, "error", err)
+ return
+ } else {
+ logging.Error("Failed to validate inference after all retry attempts", types.Validation,
+ "id", inf.InferenceId,
+ "attempts", maxRetries,
+ "error", err)
+ return
+ }
+ }
+ }
+
+ msgValidation, err := ToMsgValidation(valResult)
+ if err != nil {
+ logging.Error("Failed to convert to MsgValidation.", types.Validation, "id", inf.InferenceId, "error", err)
+ return
+ }
+ msgValidation.Revalidation = revalidation
+
+ if err = transactionRecorder.ReportValidation(msgValidation); err != nil {
+ logging.Error("Failed to report validation.", types.Validation, "id", inf.InferenceId, "error", err)
+ return
+ }
+
+ logging.Info("Successfully validated inference", types.Validation, "id", inf.InferenceId)
+}
+
+func checkSequenceFromArtifact(
+ enforcedTokens completionapi.EnforcedTokens,
+ runSeed string,
+ originalLogits []completionapi.Logprob,
+) error {
+ if runSeed == "" {
+ return nil
+ }
+
+ if len(enforcedTokens.Tokens) != len(originalLogits) {
+ return fmt.Errorf("length mismatch: enforced_tokens=%d, logits=%d",
+ len(enforcedTokens.Tokens), len(originalLogits))
+ }
+
+ for i := 0; i < len(enforcedTokens.Tokens); i++ {
+ enforcedToken := enforcedTokens.Tokens[i]
+ actualToken := originalLogits[i].Token
+
+ if len(enforcedToken.TopTokens) == 0 {
+ return fmt.Errorf("position %d: empty top_tokens", i)
+ }
+
+ found := slices.Contains(enforcedToken.TopTokens, actualToken)
+ if !found {
+ return fmt.Errorf("position %d: token '%s' not in top_tokens %v",
+ i, actualToken, enforcedToken.TopTokens)
+ }
+ }
+
+ return nil
+}
+
+func (s *InferenceValidator) performDistributionCheck(
+ ctx context.Context,
+ inference types.Inference,
+ inferenceNode *broker.Node,
+ requestMap map[string]interface{},
+ originalLogits []completionapi.Logprob,
+) (ValidationResult, error) {
+ if s.validatorClient == nil {
+ logging.Warn("Validator client not configured, skipping distribution check", types.Validation, "id", inference.InferenceId)
+ return nil, errors.New("validator client not configured")
+ }
+
+ logging.Info("Starting distribution check with vLLM setup", types.Validation, "id", inference.InferenceId, "model", inference.Model)
+
+ var additionalArgs []string
+ if inferenceNode != nil {
+ if modelArgs, ok := inferenceNode.Models[inference.Model]; ok {
+ additionalArgs = modelArgs.Args
+ logging.Debug("Using model args from broker node", types.Validation, "model", inference.Model, "args", additionalArgs)
+ } else {
+ logging.Warn("Model not found in broker node models", types.Validation, "model", inference.Model)
+ }
+ }
+
+ if len(additionalArgs) == 0 {
+ additionalArgs = []string{"--dtype", "auto"}
+ logging.Debug("Using default args", types.Validation, "args", additionalArgs)
+ }
+
+ modelConfig := SetModelRequest{
+ Model: inference.Model,
+ Dtype: "auto",
+ AdditionalArgs: additionalArgs,
+ }
+
+ defer func() {
+ if err := s.validatorClient.StopVLLM(ctx); err != nil {
+ logging.Warn("Failed to stop vLLM after distribution check", types.Validation, "error", err)
+ }
+ }()
+
+ statusResp, err := s.validatorClient.PerformInferenceWithSetup(ctx, modelConfig, requestMap)
+ if err != nil {
+ return nil, fmt.Errorf("failed to perform inference with vLLM setup: %w", err)
+ }
+
+ logging.Debug("Validator response received", types.Validation, "result", statusResp.Result)
+
+ validatorLogits, err := extractLogitsFromValidatorResult(statusResp.Result)
+ if err != nil {
+ return nil, fmt.Errorf("failed to extract logits from validator result: %w", err)
+ }
+
+ baseResult := BaseValidationResult{
+ InferenceId: inference.InferenceId,
+ ResponseBytes: []byte{},
+ }
+
+ return compareDistributions(originalLogits, validatorLogits, baseResult), nil
+}
+
+func extractLogitsFromValidatorResult(result map[string]interface{}) ([]completionapi.Logprob, error) {
+ choices, ok := result["choices"].([]interface{})
+ if !ok || len(choices) == 0 {
+ logging.Error("No choices in validator result", types.Validation, "result", result)
+ return nil, errors.New("no choices in validator result")
+ }
+
+ firstChoice, ok := choices[0].(map[string]interface{})
+ if !ok {
+ logging.Error("Invalid choice format", types.Validation, "choice", choices[0])
+ return nil, errors.New("invalid choice format")
+ }
+
+ logging.Debug("First choice from validator", types.Validation, "choice", firstChoice)
+
+ logprobsData, ok := firstChoice["logprobs"].(map[string]interface{})
+ if !ok {
+ var keys []string
+ for k := range firstChoice {
+ keys = append(keys, k)
+ }
+ logging.Error("No logprobs in choice", types.Validation, "choice_keys", keys, "choice", firstChoice)
+ return nil, errors.New("no logprobs in choice")
+ }
+
+ contentData, ok := logprobsData["content"].([]interface{})
+ if !ok {
+ return nil, errors.New("no content in logprobs")
+ }
+
+ var logits []completionapi.Logprob
+ for _, item := range contentData {
+ itemMap, ok := item.(map[string]interface{})
+ if !ok {
+ continue
+ }
+
+ token, _ := itemMap["token"].(string)
+ logprob, _ := itemMap["logprob"].(float64)
+
+ topLogprobsData, ok := itemMap["top_logprobs"].([]interface{})
+ if !ok {
+ continue
+ }
+
+ var topLogprobs []completionapi.TopLogprobs
+ for _, topItem := range topLogprobsData {
+ topMap, ok := topItem.(map[string]interface{})
+ if !ok {
+ continue
+ }
+
+ topToken, _ := topMap["token"].(string)
+ topLogprob, _ := topMap["logprob"].(float64)
+
+ topLogprobs = append(topLogprobs, completionapi.TopLogprobs{
+ Token: topToken,
+ Logprob: topLogprob,
+ })
+ }
+
+ logits = append(logits, completionapi.Logprob{
+ Token: token,
+ Logprob: logprob,
+ TopLogprobs: topLogprobs,
+ })
+ }
+
+ return logits, nil
+}
+
+func compareDistributions(
+ originalLogits []completionapi.Logprob,
+ validatorLogits []completionapi.Logprob,
+ baseResult BaseValidationResult,
+) ValidationResult {
+ if len(originalLogits) != len(validatorLogits) {
+ logging.Warn("Different length of logits in distribution check", types.Validation,
+ "lengthOriginal", len(originalLogits), "lengthValidator", len(validatorLogits))
+ return &DifferentLengthValidationResult{baseResult}
+ }
+
+ distance, err := customDistance(originalLogits, validatorLogits)
+ if err != nil {
+ logging.Error("Error calculating distance in distribution check", types.Validation, "error", err)
+ return &DifferentLengthValidationResult{baseResult}
+ }
+
+ similarity := 1 - distance
+ if similarity < 0 {
+ logging.Error("Similarity value is negative in distribution check", types.Validation, "similarity", similarity)
+ similarity = 0
+ }
+
+ return &SimilarityValidationResult{
+ BaseValidationResult: baseResult,
+ Value: similarity,
+ }
+}
+
+func (s *InferenceValidator) validate(inference types.Inference, inferenceNode *broker.Node) (ValidationResult, error) {
+ logging.Debug("Validating inference", types.Validation, "id", inference.InferenceId)
+
+ if inference.Status == types.InferenceStatus_STARTED {
+ logging.Error("Inference not finished", types.Validation, "status", inference.Status, "inference", inference)
+ return nil, errors.New("Inference is not finished. id = " + inference.InferenceId)
+ }
+
+ var requestMap map[string]interface{}
+ if err := json.Unmarshal([]byte(inference.PromptPayload), &requestMap); err != nil {
+ return &InvalidInferenceResult{inference.InferenceId, "Failed to unmarshal inference.PromptPayload.", err}, nil
+ }
+
+ originalResponse, err := unmarshalResponse(&inference)
+ if err != nil {
+ return &InvalidInferenceResult{inference.InferenceId, "Failed to unmarshal inference.ResponsePayload.", err}, nil
+ }
+
+ enforcedTokens, err := originalResponse.GetEnforcedTokens()
+ if err != nil {
+ return &InvalidInferenceResult{inference.InferenceId, "Failed to get enforced string.", err}, nil
+ }
+
+ // From here on, errors are on the part of the validator, not the inference that was passed in
+ requestMap["enforced_tokens"] = enforcedTokens
+ requestMap["stream"] = false
+ requestMap["skip_special_tokens"] = false
+ delete(requestMap, "stream_options")
+
+ requestBody, err := json.Marshal(requestMap)
+ if err != nil {
+ return nil, err
+ }
+
+ completionsUrl, err := url.JoinPath(inferenceNode.InferenceUrlWithVersion(s.configManager.GetCurrentNodeVersion()), "v1/chat/completions")
+ if err != nil {
+ logging.Error("Failed to join url", types.Validation, "url", inferenceNode.InferenceUrlWithVersion(s.configManager.GetCurrentNodeVersion()), "error", err)
+ return nil, err
+ }
+
+ resp, err := http.Post(
+ completionsUrl,
+ "application/json",
+ bytes.NewReader(requestBody),
+ )
+ if err != nil {
+ return nil, err
+ }
+
+ respBodyBytes, err := io.ReadAll(resp.Body)
+ if err != nil {
+ return nil, err
+ }
+
+ logging.Debug("responseValidation", types.Validation, "validation", string(respBodyBytes))
+ responseValidation, err := completionapi.NewCompletionResponseFromBytes(respBodyBytes)
+ if err != nil {
+ logging.Error("Failed to unmarshal responseValidation", types.Validation, "id", inference.InferenceId, "error", err)
+ return nil, err
+ }
+
+ originalLogits := originalResponse.ExtractLogits()
+ validationLogits := responseValidation.ExtractLogits()
+ baseResult := BaseValidationResult{
+ InferenceId: inference.InferenceId,
+ ResponseBytes: respBodyBytes,
+ }
+ if len(originalLogits) == 0 || len(validationLogits) == 0 {
+ logging.Error("No logits found in original or validation response", types.Validation, "id", inference.InferenceId, "originalLogits", originalLogits, "validationLogits", validationLogits)
+ return nil, errors.New("no logits found in original or validation response")
+ }
+
+ logitsComparisonResult := compareLogits(originalLogits, validationLogits, baseResult)
+ if !logitsComparisonResult.IsSuccessful() {
+ return logitsComparisonResult, nil
+ }
+
+ if err := checkSequenceFromArtifact(enforcedTokens, enforcedTokens.RunSeed, originalLogits); err != nil {
+ return &InvalidInferenceResult{inference.InferenceId, "Sequence check failed", err}, nil
+ }
+
+ return s.performDistributionCheckIfConfigured(inference, inferenceNode, requestMap, originalLogits)
+}
+
+func (s *InferenceValidator) extractInferenceData(inference *types.Inference) (map[string]interface{}, completionapi.CompletionResponse, completionapi.EnforcedTokens, ValidationResult, error) {
+ var requestMap map[string]interface{}
+ if err := json.Unmarshal([]byte(inference.PromptPayload), &requestMap); err != nil {
+ return nil, nil, completionapi.EnforcedTokens{}, &InvalidInferenceResult{inference.InferenceId, "Failed to unmarshal inference.PromptPayload.", err}, nil
+ }
+
+ originalResponse, err := unmarshalResponse(inference)
+ if err != nil {
+ return nil, nil, completionapi.EnforcedTokens{}, &InvalidInferenceResult{inference.InferenceId, "Failed to unmarshal inference.ResponsePayload.", err}, nil
+ }
+
+ enforcedTokens, err := originalResponse.GetEnforcedTokens()
+ if err != nil {
+ return nil, nil, completionapi.EnforcedTokens{}, &InvalidInferenceResult{inference.InferenceId, "Failed to get enforced tokens.", err}, nil
+ }
+
+ return requestMap, originalResponse, enforcedTokens, nil, nil
+}
+
+func (s *InferenceValidator) performNodeInference(
+ inference types.Inference,
+ inferenceNode *broker.Node,
+ requestMap map[string]interface{},
+ enforcedTokens completionapi.EnforcedTokens,
+) (completionapi.CompletionResponse, error) {
+ requestMap["enforced_tokens"] = enforcedTokens
+ requestMap["stream"] = false
+ requestMap["skip_special_tokens"] = false
+ delete(requestMap, "stream_options")
+
+ requestBody, err := json.Marshal(requestMap)
+ if err != nil {
+ return nil, fmt.Errorf("failed to marshal request: %w", err)
+ }
+
+ completionsUrl, err := url.JoinPath(inferenceNode.InferenceUrlWithVersion(s.configManager.GetCurrentNodeVersion()), "v1/chat/completions")
+ if err != nil {
+ logging.Error("Failed to join url", types.Validation, "url", inferenceNode.InferenceUrlWithVersion(s.configManager.GetCurrentNodeVersion()), "error", err)
+ return nil, err
+ }
+
+ resp, err := http.Post(completionsUrl, "application/json", bytes.NewReader(requestBody))
+ if err != nil {
+ return nil, fmt.Errorf("failed to post to node: %w", err)
+ }
+ defer resp.Body.Close()
+
+ respBodyBytes, err := io.ReadAll(resp.Body)
+ if err != nil {
+ return nil, fmt.Errorf("failed to read response body: %w", err)
+ }
+
+ logging.Debug("responseValidation", types.Validation, "validation", string(respBodyBytes))
+ responseValidation, err := completionapi.NewCompletionResponseFromBytes(respBodyBytes)
+ if err != nil {
+ logging.Error("Failed to unmarshal responseValidation", types.Validation, "id", inference.InferenceId, "error", err)
+ return nil, err
+ }
+
+ return responseValidation, nil
+}
+
+func (s *InferenceValidator) performDistributionCheckIfConfigured(
+ inference types.Inference,
+ inferenceNode *broker.Node,
+ requestMap map[string]interface{},
+ originalLogits []completionapi.Logprob,
+) (ValidationResult, error) {
+ if s.validatorClient == nil {
+ logging.Debug("Validator client not configured, skipping distribution check", types.Validation, "id", inference.InferenceId)
+ baseResult := BaseValidationResult{
+ InferenceId: inference.InferenceId,
+ ResponseBytes: []byte{},
+ }
+ return &SimilarityValidationResult{BaseValidationResult: baseResult, Value: 1.0}, nil
+ }
+
+ logging.Info("Performing distribution check", types.Validation, "id", inference.InferenceId)
+ ctx, cancel := context.WithTimeout(context.Background(), 10*time.Minute)
+ defer cancel()
+
+ distributionResult, err := s.performDistributionCheck(ctx, inference, inferenceNode, requestMap, originalLogits)
+ if err != nil {
+ logging.Error("Distribution check failed", types.Validation, "id", inference.InferenceId, "error", err)
+ return nil, err
+ }
+
+ logging.Info("Distribution check completed", types.Validation, "id", inference.InferenceId, "successful", distributionResult.IsSuccessful())
+ return distributionResult, nil
+}
+
+func unmarshalResponse(inference *types.Inference) (completionapi.CompletionResponse, error) {
+ resp, err := completionapi.NewCompletionResponseFromLinesFromResponsePayload(inference.ResponsePayload)
+
+ if err != nil {
+ logging.Error("Failed to unmarshal inference.ResponsePayload.", types.Validation, "id", inference.InferenceId, "error", err)
+ }
+
+ switch resp.(type) {
+ case *completionapi.StreamedCompletionResponse:
+ logging.Info("Unmarshalled inference.ResponsePayload into StreamedResponse", types.Validation, "id", inference.InferenceId)
+ case *completionapi.JsonCompletionResponse:
+ logging.Info("Unmarshalled inference.ResponsePayload into JsonResponse", types.Validation, "id", inference.InferenceId)
+ default:
+ logging.Error("Failed to unmarshal inference.ResponsePayload into StreamedResponse or JsonResponse", types.Validation, "id", inference.InferenceId)
+ }
+
+ return resp, err
+}
+
+type ValidationResult interface {
+ GetInferenceId() string
+
+ GetValidationResponseBytes() []byte
+
+ IsSuccessful() bool
+}
+
+type BaseValidationResult struct {
+ InferenceId string
+ ResponseBytes []byte
+}
+
+func (r BaseValidationResult) GetInferenceId() string {
+ return r.InferenceId
+}
+
+func (r BaseValidationResult) GetValidationResponseBytes() []byte {
+ return r.ResponseBytes
+}
+
+type DifferentLengthValidationResult struct {
+ BaseValidationResult
+}
+
+func (DifferentLengthValidationResult) IsSuccessful() bool {
+ return false
+}
+
+type DifferentTokensValidationResult struct {
+ BaseValidationResult
+}
+
+func (DifferentTokensValidationResult) IsSuccessful() bool {
+ return false
+}
+
+type SimilarityValidationResult struct {
+ BaseValidationResult
+ Value float64
+}
+
+func (r SimilarityValidationResult) IsSuccessful() bool {
+ return r.Value > 0.99
+}
+
+type InvalidInferenceResult struct {
+ InferenceId string
+ Reason string
+ Error error
+}
+
+func (r InvalidInferenceResult) IsSuccessful() bool {
+ return false
+}
+
+func (r InvalidInferenceResult) GetInferenceId() string {
+ return r.InferenceId
+}
+
+func (r InvalidInferenceResult) GetValidationResponseBytes() []byte {
+ return []byte{}
+}
+
+func compareLogits(
+ originalLogits []completionapi.Logprob,
+ validationLogits []completionapi.Logprob,
+ baseComparisonResult BaseValidationResult,
+) ValidationResult {
+ if len(originalLogits) != len(validationLogits) {
+ logging.Warn("Different length of logits", types.Validation, "originalLogits", originalLogits, "validationLogits", validationLogits, "lengthOriginal", len(originalLogits), "lengthValidation", len(validationLogits))
+ }
+ if len(validationLogits) < len(originalLogits) {
+ logging.Warn("Validation logits are shorter than original logits", types.Validation, "originalLogits", originalLogits, "validationLogits", validationLogits, "lengthOriginal", len(originalLogits), "lengthValidation", len(validationLogits))
+ return &DifferentLengthValidationResult{baseComparisonResult}
+ }
+
+ for i := range originalLogits {
+ o := originalLogits[i]
+ v := validationLogits[i]
+ if o.Token != v.Token {
+ logging.Error("Different tokens in logits", types.Validation, "originalLogits", originalLogits, "validationLogits", validationLogits)
+
+ return &DifferentTokensValidationResult{baseComparisonResult}
+ }
+ }
+ similarity := customSimilarity(originalLogits, validationLogits)
+
+ return &SimilarityValidationResult{BaseValidationResult: baseComparisonResult, Value: similarity}
+}
+
+func customSimilarity(
+ originalLogprobs []completionapi.Logprob,
+ validationLogprobs []completionapi.Logprob,
+) float64 {
+ distance, err := customDistance(originalLogprobs, validationLogprobs)
+ if err != nil {
+ logging.Error("Error calculating custom distance", types.Validation, "error", err)
+ return 0
+ }
+ similarity := 1 - distance
+ if similarity < 0 {
+ logging.Error("Similarity value is negative", types.Validation, "similarity", similarity)
+ return 0
+ }
+ return similarity
+}
+
+func customDistance(
+ originalLogprobs []completionapi.Logprob,
+ validationLogprobs []completionapi.Logprob,
+) (float64, error) {
+ distance := 0.0
+ for i := range originalLogprobs {
+ o := originalLogprobs[i]
+ v := validationLogprobs[i]
+ posDistance, err := positionDistance(o.TopLogprobs, v.TopLogprobs)
+ if err != nil {
+ logging.Error("Error calculating position distance", types.Validation, "error", err)
+ return math.Inf(1), err
+ }
+ distance += posDistance
+ }
+ totalLogprobs := max(100, len(originalLogprobs)) * len(originalLogprobs[0].TopLogprobs)
+
+ return distance / float64(totalLogprobs), nil
+}
+
+func positionDistance(
+ originalLogprobs []completionapi.TopLogprobs,
+ validationLogprobs []completionapi.TopLogprobs,
+) (float64, error) {
+ if len(originalLogprobs) == 0 || len(validationLogprobs) == 0 {
+ return 0.0, fmt.Errorf("empty logprobs provided")
+ }
+ distance := 0.0
+
+ originalLogprobMap := make(map[string]float64)
+ for _, o := range originalLogprobs {
+ originalLogprobMap[o.Token] = o.Logprob
+ }
+ sortedLogprobs := make([]float64, 0, len(originalLogprobMap))
+ for _, logprob := range originalLogprobMap {
+ sortedLogprobs = append(sortedLogprobs, logprob)
+ }
+
+ sort.Float64s(sortedLogprobs)
+
+ var minOriginalLogprob1, minOriginalLogprob2 float64
+ if len(sortedLogprobs) >= 2 {
+ minOriginalLogprob1 = sortedLogprobs[0]
+ minOriginalLogprob2 = sortedLogprobs[1]
+ } else if len(sortedLogprobs) == 1 {
+ minOriginalLogprob1 = sortedLogprobs[0]
+ minOriginalLogprob2 = minOriginalLogprob1 - 100.0
+ }
+
+ // Estimate the next logprob value (2 as fine)
+ nextOriginalLogprob := minOriginalLogprob1 - (minOriginalLogprob2 - minOriginalLogprob1)
+
+ for _, v := range validationLogprobs {
+ var originalLogprob float64
+ if origProb, exists := originalLogprobMap[v.Token]; exists {
+ originalLogprob = origProb
+ } else {
+ originalLogprob = nextOriginalLogprob
+ }
+
+ denom := 1e-6 + math.Abs(v.Logprob) + math.Abs(originalLogprob)
+ distance += math.Abs(v.Logprob-originalLogprob) / denom / 2.0
+ }
+
+ return distance, nil
+}
+
+func ToMsgValidation(result ValidationResult) (*inference.MsgValidation, error) {
+ // Match type of result from implementations of ValidationResult
+ var simVal float64
+ switch result.(type) {
+ case *DifferentLengthValidationResult:
+ logging.Warn("Different length validation result", types.Validation)
+ simVal = 0
+ case *DifferentTokensValidationResult:
+ logging.Warn("Different tokens validation result", types.Validation)
+ simVal = 0
+ case *SimilarityValidationResult:
+ simVal = result.(*SimilarityValidationResult).Value
+ logging.Info("Cosine similarity validation result", types.Validation, "cosineSimValue", simVal)
+ case *InvalidInferenceResult:
+ simVal = 0
+ logging.Warn("Invalid inference result", types.Validation, "reason", result.(*InvalidInferenceResult).Reason, "inferenceId", result.GetInferenceId(), "error", result.(*InvalidInferenceResult).Error)
+ default:
+ logging.Error("Unknown validation result type", types.Validation, "type", fmt.Sprintf("%T", result), "result", result)
+ return nil, errors.New("unknown validation result type")
+ }
+
+ responseHash, _, err := utils.GetResponseHash(result.GetValidationResponseBytes())
+ if err != nil {
+ logging.Error("Failed to get response hash", types.Validation, "error", err)
+ return nil, err
+ }
+
+ return &inference.MsgValidation{
+ Id: uuid.New().String(),
+ InferenceId: result.GetInferenceId(),
+ ResponseHash: responseHash,
+ Value: simVal,
+ }, nil
+}
diff --git a/decentralized-api/internal/validation/proposal.md b/decentralized-api/internal/validation/proposal.md
new file mode 100644
index 000000000..d52394c45
--- /dev/null
+++ b/decentralized-api/internal/validation/proposal.md
@@ -0,0 +1,69 @@
+# Intro
+
+The task can be separated into three somewhat independent parts.
+I think it's better to release them 1 by 1, so we're not overwhelmed
+with the amount of changes in a single update: easier to test and debug.
+Especially since we're releasing it combined with the scheduling changes.
+
+# 1. Claim reward
+
+## Current state
+
+In `msg_server_claim_reward.go` there's a `getMustBeValidatedInferences` that:
+
+1. Fetches all `InferenceValidationDetails` using `{epochGroupId}` key
+2. Uses the revealed seed that is part of the `MsgClaimReward` to filter the inferences that were meant to be validated by this participant
+3. If there's a mismatch, then the participant doesn't get their reward
+4. `InferenceValidationDetails` is populated in `msg_server_finish_inference.go` in the `MsgInferenceValidation` handler
+
+**Problem:** Participants who're fully occupied with PoC can't validate inferences made during PoC and get no reward.
+
+## Proposed solution
+
+1. **Migration:** `InferenceValidationDetails` now indexed by `{epochId}` instead of `{epochGroupId}`
+**Note:** we can skip the migration for now and keep using `{epochGroupId}` as an index for now.
+2. If `max(Inference.startBlockHeight, Inference.endBlockHeight) >= nextPocStart - inferenceValidationCutoff`
+then it gets assigned `epochId + 1`
+**Migration:**: set the `inferenceValidationCutoff` in `EpochParams`
+3. If we're doing this task first (this is what I'd suggest, since it's the most tricky part)
+then we're just filtering such inferences out of `getMustBeValidatedInferences`
+4. Then, when we make #2, we can filter them back in
+
+**To discuss:**
+
+1. `Inference` entities also have `epoch_id`. Should they match the `epoch_id` of `InferenceValidationDetails`?
+Or is it ok if `Inference.epoch_id = X`, but `InferenceValidationDetails.epoch_id = X + 1`?
+Happens for inferences that happened during or right before the PoC.
+
+# 2. Validation trigger
+
+## Current state
+
+1. `event_listener.go` listens to finish inference/requires revalidation events and feeds them to `InferenceValidator`
+2. `InferenceValidator` immediately spawns a new goroutine to execute the validation request
+
+**Problem:**
+The nodes might be unavailable and we will lose the validation request.
+
+## Proposed solution
+
+1. Create a `InferenceValidationTaskStorage` interface and it's first implementation: `InMemoryInferenceValidationTaskStorage`
+2. In `event_listener.go` instead of immediately spawning a goroutine, we will store the validation request in the `InferenceValidationTaskStorage`
+3. `InferenceValidator` now will spawn a woker pool that will periodically check the tasks in the storage and execute them when nodes are available
+
+# 3. Persistent validation task storage
+
+**Problem**: The current implementation of `InferenceValidationTaskStorage` is in-memory, which means that if the node restarts, all tasks are lost.
+
+## Proposed solution (short term)
+
+On server reboot, when initializing `InferenceValidationTaskStorage`, query the chain and try to determine which inferences need to be validated.
+
+## Proposed solution (long term)
+
+`OnDiskValidationTaskStorage`
+
+## Proposed solution (ideal)
+
+A separate middleware service between the chain node and the API that will analyze each transaction and create a task in a participant's local DB.
+Like a more reliable event listener that will guarantee not to miss any blocks.
diff --git a/decentralized-api/internal/validation/testdata/distribution_check_valid.json b/decentralized-api/internal/validation/testdata/distribution_check_valid.json
new file mode 100644
index 000000000..d64454b67
--- /dev/null
+++ b/decentralized-api/internal/validation/testdata/distribution_check_valid.json
@@ -0,0 +1 @@
+{"id":"chatcmpl-e124baa8fad644e28b97a043df097377","object":"chat.completion","created":1765305607,"model":"facebook/opt-125m","choices":[{"index":0,"message":{"role":"assistant","reasoning_content":null,"content":"\\n<|im_end|>\\n<|im_end|>\\n<|im_end|>\\n<|im_end|>\\n<|im_end|>\\n<|im_end|>\\n<|im_end|>\\n<|im_end|>\\n<|im_end|","tool_calls":[]},"logprobs":{"content":[{"token":"\\","logprob":-0.02170860767364502,"bytes":[92],"top_logprobs":[{"token":"\\","logprob":-0.02170860767364502,"bytes":[92]},{"token":"\n","logprob":-4.1310834884643555,"bytes":[10]},{"token":"|","logprob":-5.9904584884643555,"bytes":[124]}]},{"token":"n","logprob":-0.000007748573807475623,"bytes":[110],"top_logprobs":[{"token":"n","logprob":-0.000007748573807475623,"bytes":[110]},{"token":"u","logprob":-12.843757629394531,"bytes":[117]},{"token":"r","logprob":-13.015632629394531,"bytes":[114]}]},{"token":"<","logprob":-0.0054885647259652615,"bytes":[60],"top_logprobs":[{"token":"<","logprob":-0.0054885647259652615,"bytes":[60]},{"token":"\n","logprob":-5.989863395690918,"bytes":[10]},{"token":"","logprob":-0.0002719986077863723,"bytes":[62],"top_logprobs":[{"token":">","logprob":-0.0002719986077863723,"bytes":[62]},{"token":"|","logprob":-9.406521797180176,"bytes":[124]},{"token":"\n","logprob":-9.469021797180176,"bytes":[10]}]},{"token":"\\","logprob":-0.0019030333496630192,"bytes":[92],"top_logprobs":[{"token":"\\","logprob":-0.0019030333496630192,"bytes":[92]},{"token":"\n","logprob":-6.517528057098389,"bytes":[10]},{"token":"|","logprob":-9.03315258026123,"bytes":[124]}]},{"token":"n","logprob":-9.536738616588991E-7,"bytes":[110],"top_logprobs":[{"token":"n","logprob":-9.536738616588991E-7,"bytes":[110]},{"token":"r","logprob":-14.937500953674316,"bytes":[114]},{"token":"u","logprob":-15.312500953674316,"bytes":[117]}]},{"token":"<","logprob":-0.001566136721521616,"bytes":[60],"top_logprobs":[{"token":"<","logprob":-0.001566136721521616,"bytes":[60]},{"token":"","logprob":-0.00005209310256759636,"bytes":[62],"top_logprobs":[{"token":">","logprob":-0.00005209310256759636,"bytes":[62]},{"token":"><","logprob":-10.843802452087402,"bytes":[62,60]},{"token":"|","logprob":-11.734427452087402,"bytes":[124]}]},{"token":"\\","logprob":-0.00041559641249477863,"bytes":[92],"top_logprobs":[{"token":"\\","logprob":-0.00041559641249477863,"bytes":[92]},{"token":"\n","logprob":-8.000415802001953,"bytes":[10]},{"token":" \\","logprob":-11.016040802001953,"bytes":[32,92]}]},{"token":"n","logprob":-7.152555099310121E-7,"bytes":[110],"top_logprobs":[{"token":"n","logprob":-7.152555099310121E-7,"bytes":[110]},{"token":"r","logprob":-15.062500953674316,"bytes":[114]},{"token":"u","logprob":-15.531250953674316,"bytes":[117]}]},{"token":"<","logprob":-0.0008266131044365466,"bytes":[60],"top_logprobs":[{"token":"<","logprob":-0.0008266131044365466,"bytes":[60]},{"token":"","logprob":-0.000025987286790041253,"bytes":[62],"top_logprobs":[{"token":">","logprob":-0.000025987286790041253,"bytes":[62]},{"token":"><","logprob":-11.359400749206543,"bytes":[62,60]},{"token":">(","logprob":-12.875025749206543,"bytes":[62,40]}]},{"token":"\\","logprob":-0.00011777184408856556,"bytes":[92],"top_logprobs":[{"token":"\\","logprob":-0.00011777184408856556,"bytes":[92]},{"token":"\n","logprob":-9.265742301940918,"bytes":[10]},{"token":" \\","logprob":-11.843867301940918,"bytes":[32,92]}]},{"token":"n","logprob":-5.960462772236497E-7,"bytes":[110],"top_logprobs":[{"token":"n","logprob":-5.960462772236497E-7,"bytes":[110]},{"token":"r","logprob":-15.375000953674316,"bytes":[114]},{"token":"u","logprob":-15.656250953674316,"bytes":[117]}]},{"token":"<","logprob":-0.0004234609368722886,"bytes":[60],"top_logprobs":[{"token":"<","logprob":-0.0004234609368722886,"bytes":[60]},{"token":"","logprob":-0.00001645074735279195,"bytes":[62],"top_logprobs":[{"token":">","logprob":-0.00001645074735279195,"bytes":[62]},{"token":"><","logprob":-11.765641212463379,"bytes":[62,60]},{"token":">>","logprob":-12.968766212463379,"bytes":[62,62]}]},{"token":"\\","logprob":-0.00004160317621426657,"bytes":[92],"top_logprobs":[{"token":"\\","logprob":-0.00004160317621426657,"bytes":[92]},{"token":"\n","logprob":-10.296916961669922,"bytes":[10]},{"token":" \\","logprob":-12.765666961669922,"bytes":[32,92]}]},{"token":"n","logprob":-5.960462772236497E-7,"bytes":[110],"top_logprobs":[{"token":"n","logprob":-5.960462772236497E-7,"bytes":[110]},{"token":"u","logprob":-15.312500953674316,"bytes":[117]},{"token":"r","logprob":-15.562500953674316,"bytes":[114]}]},{"token":"<","logprob":-0.0002547178009990603,"bytes":[60],"top_logprobs":[{"token":"<","logprob":-0.0002547178009990603,"bytes":[60]},{"token":"","logprob":-0.000013708974620385561,"bytes":[62],"top_logprobs":[{"token":">","logprob":-0.000013708974620385561,"bytes":[62]},{"token":"><","logprob":-11.92188835144043,"bytes":[62,60]},{"token":">>","logprob":-12.85938835144043,"bytes":[62,62]}]},{"token":"\\","logprob":-0.0000252720492426306,"bytes":[92],"top_logprobs":[{"token":"\\","logprob":-0.0000252720492426306,"bytes":[92]},{"token":"\n","logprob":-10.796899795532227,"bytes":[10]},{"token":" \\","logprob":-13.250024795532227,"bytes":[32,92]}]},{"token":"n","logprob":-5.960462772236497E-7,"bytes":[110],"top_logprobs":[{"token":"n","logprob":-5.960462772236497E-7,"bytes":[110]},{"token":"u","logprob":-15.125000953674316,"bytes":[117]},{"token":"r","logprob":-15.765625953674316,"bytes":[114]}]},{"token":"<","logprob":-0.00016819016309455037,"bytes":[60],"top_logprobs":[{"token":"<","logprob":-0.00016819016309455037,"bytes":[60]},{"token":"","logprob":-0.000011324817933200393,"bytes":[62],"top_logprobs":[{"token":">","logprob":-0.000011324817933200393,"bytes":[62]},{"token":"><","logprob":-12.109386444091797,"bytes":[62,60]},{"token":">>","logprob":-12.953136444091797,"bytes":[62,62]}]},{"token":"\\","logprob":-0.000018715683836489916,"bytes":[92],"top_logprobs":[{"token":"\\","logprob":-0.000018715683836489916,"bytes":[92]},{"token":"\n","logprob":-11.062519073486328,"bytes":[10]},{"token":" \\","logprob":-13.765644073486328,"bytes":[32,92]}]},{"token":"n","logprob":-7.152555099310121E-7,"bytes":[110],"top_logprobs":[{"token":"n","logprob":-7.152555099310121E-7,"bytes":[110]},{"token":"u","logprob":-15.015625953674316,"bytes":[117]},{"token":"\n","logprob":-15.781250953674316,"bytes":[10]}]},{"token":"<","logprob":-0.00016425691137555987,"bytes":[60],"top_logprobs":[{"token":"<","logprob":-0.00016425691137555987,"bytes":[60]},{"token":"","logprob":-0.000009894321920000948,"bytes":[62],"top_logprobs":[{"token":">","logprob":-0.000009894321920000948,"bytes":[62]},{"token":"><","logprob":-12.218759536743164,"bytes":[62,60]},{"token":">>","logprob":-13.062509536743164,"bytes":[62,62]}]},{"token":"\\","logprob":-0.00001847726889536716,"bytes":[92],"top_logprobs":[{"token":"\\","logprob":-0.00001847726889536716,"bytes":[92]},{"token":"\n","logprob":-11.062518119812012,"bytes":[10]},{"token":" \\","logprob":-14.046893119812012,"bytes":[32,92]}]},{"token":"n","logprob":-7.152555099310121E-7,"bytes":[110],"top_logprobs":[{"token":"n","logprob":-7.152555099310121E-7,"bytes":[110]},{"token":"u","logprob":-14.921875953674316,"bytes":[117]},{"token":"\n","logprob":-15.968750953674316,"bytes":[10]}]},{"token":"<","logprob":-0.0000877341881277971,"bytes":[60],"top_logprobs":[{"token":"<","logprob":-0.0000877341881277971,"bytes":[60]},{"token":"","logprob":-0.000007510157047363464,"bytes":[62],"top_logprobs":[{"token":">","logprob":-0.000007510157047363464,"bytes":[62]},{"token":"><","logprob":-12.421882629394531,"bytes":[62,60]},{"token":">>","logprob":-13.312507629394531,"bytes":[62,62]}]},{"token":"\\","logprob":-0.000012993727978027891,"bytes":[92],"top_logprobs":[{"token":"\\","logprob":-0.000012993727978027891,"bytes":[92]},{"token":"\n","logprob":-11.42188835144043,"bytes":[10]},{"token":">","logprob":-14.42188835144043,"bytes":[62]}]},{"token":"n","logprob":-9.536738616588991E-7,"bytes":[110],"top_logprobs":[{"token":"n","logprob":-9.536738616588991E-7,"bytes":[110]},{"token":"u","logprob":-14.390625953674316,"bytes":[117]},{"token":"\n","logprob":-15.671875953674316,"bytes":[10]}]},{"token":"<","logprob":-0.00006878139538457617,"bytes":[60],"top_logprobs":[{"token":"<","logprob":-0.00006878139538457617,"bytes":[60]},{"token":"30min with no activity)
+- LRU-style eviction if total epochs exceed limit (100 epochs)
+
+#### 4. ValidationOrchestrator
+The worker that processes validation tasks:
+```go
+type ValidationOrchestrator struct {
+ storage ValidationTaskStorage
+ validator *InferenceValidator
+ phaseTracker *chainphase.ChainPhaseTracker
+ nodeBroker *broker.Broker
+ recorder cosmosclient.InferenceCosmosClient
+
+ // Configuration
+ maxRetries int
+ retryDelay time.Duration
+ workerCount int
+}
+```
+
+### Data Flow
+
+```
+Event → ValidationRequest → ValidationTaskStorage → ValidationOrchestrator → NodeBroker → Validation
+ ↓ ↓ ↓ ↓ ↓
+EventListener AddTask() ProcessTasks() LockNode() Execute
+```
+
+#### Phase 1: Task Submission
+1. `event_listener.go` receives inference finish/validation events
+2. Instead of spawning goroutines, creates `ValidationTask` objects
+3. Determines epoch ID from inference data
+4. Submits task to `ValidationTaskStorage.AddTask()`
+
+#### Phase 2: Task Processing
+1. `ValidationOrchestrator` runs N worker goroutines (default: 3)
+2. Each worker continuously polls for tasks from current/recent epochs
+3. Worker checks if epoch/phase is suitable for validation
+4. Attempts to lock node from broker
+5. If successful: executes validation, if failed: requeues with delay
+
+#### Phase 3: Epoch Management
+1. Orchestrator monitors current epoch via `ChainPhaseTracker`
+2. Determines which epochs are "stale" (>2 epochs old)
+3. Calls `ValidationTaskStorage.CleanupEpoch()` for old epochs
+4. Storage automatically cleans up empty/inactive epoch channels
+
+### Error Handling & Retries
+
+#### Retry Logic
+- `ErrNoNodesAvailable`: Retry after 30s (up to 10 times)
+- Network errors: Exponential backoff (1s, 2s, 4s, 8s, 16s)
+- Validation errors: Log and report as failed (no retry)
+- Max age: Tasks older than 2 hours are discarded
+
+#### Back-pressure Management
+- Each epoch queue has capacity limit (1000 tasks)
+- If queue full: log warning and drop oldest tasks
+- Global task limit: 50,000 active tasks across all epochs
+- Memory monitoring: cleanup if RAM usage exceeds threshold
+
+## Implementation Plan (1-2 Days)
+
+1. Define interfaces and structs (`validation_task.go`, `validation_task_storage.go`)
+2. Implement `InMemoryValidationTaskStorage` with basic operations
+3. Create `ValidationOrchestrator` skeleton with worker loops
+4. Integrate storage cleanup and epoch management
+5. Modify `InferenceValidator` to submit tasks instead of spawning goroutines
+6. Update `event_listener.go` to use new validation system
+7. Add monitoring, metrics, and error handling
+8. Integration testing and bug fixes
+
+## File Structure
+
+```
+decentralized-api/internal/validation/
+├── inference_validation.go # Modified: remove goroutines, add task submission
+├── validation_task.go # New: task definitions and types
+├── validation_task_storage.go # New: storage interface and implementation
+├── validation_orchestrator.go # New: worker that processes tasks
+└── validation_test.go # New: comprehensive tests
+```
+
+## Key Benefits
+
+1. **Reliability**: Automatic retries for transient failures
+2. **Resource Management**: Respects node availability and system state
+3. **Observability**: Clear metrics on task queues, success rates, retries
+4. **Scalability**: Easy to tune worker count and queue sizes
+5. **Memory Efficiency**: Automatic cleanup of old epoch data
+6. **Maintainability**: Clear separation of concerns
+
+## Risks & Mitigations
+
+| Risk | Mitigation |
+|------|------------|
+| Memory leaks from uncleaned epochs | Automatic cleanup + monitoring |
+| Task queue overflow | Capacity limits + back-pressure |
+| Worker deadlocks | Timeout contexts + graceful shutdown |
+| Lost tasks during restart | Log critical tasks + graceful degradation |
+| Integration complexity | Gradual rollout + feature flags |
+
+## Monitoring & Metrics
+
+- Tasks queued/processed per epoch
+- Average task processing time
+- Retry rates by error type
+- Memory usage of storage system
+- Node lock success/failure rates
+- Queue depths and cleanup events
+
+## Future Enhancements (Beyond MVP)
+
+1. **Persistent Storage**: Replace RAM storage with Redis/DB for restarts
+2. **Priority Queues**: High-priority validations (governance, disputes)
+3. **Load Balancing**: Distribute tasks across multiple validator nodes
+4. **Circuit Breakers**: Temporarily disable problematic models/nodes
+5. **Batch Processing**: Group validations for efficiency
+
+This architecture provides a solid foundation for reliable validation while keeping the implementation scope manageable for a 1-2 day sprint.
\ No newline at end of file
diff --git a/decentralized-api/internal/validation/validation_test.go b/decentralized-api/internal/validation/validation_test.go
new file mode 100644
index 000000000..bb40783af
--- /dev/null
+++ b/decentralized-api/internal/validation/validation_test.go
@@ -0,0 +1,477 @@
+package validation
+
+import (
+ "context"
+ "decentralized-api/completionapi"
+ "encoding/json"
+ "os"
+ "testing"
+)
+
+const (
+ inferenceJsonPath = "testdata/inference_response.json"
+ validationJsonPath = "testdata/validation_response.json"
+
+ inferenceQuantJsonPath = "testdata/inference_response_int4.json"
+ validationFP8tJsonPath = "testdata/validation_response_fp8.json"
+
+ sequenceCheckValid1Path = "testdata/sequence_check_valid.json"
+ sequenceCheckValid2Path = "testdata/sequence_check_valid2.json"
+ DistributionCheckValidPath = "testdata/distribution_check_valid.json"
+)
+
+func loadResponse(path string) (*completionapi.Response, error) {
+ response, err := os.ReadFile(path)
+ if err != nil {
+ return nil, err
+ }
+ var r completionapi.Response
+ if err := json.Unmarshal(response, &r); err != nil {
+ return nil, err
+ }
+ return &r, nil
+}
+
+func TestValidation(t *testing.T) {
+ inferenceResponse, err := loadResponse(inferenceJsonPath)
+ if err != nil {
+ t.Fatalf("Failed to read inference response: %v", err)
+ }
+
+ validationResponse, err := loadResponse(validationJsonPath)
+ if err != nil {
+ t.Fatalf("Failed to read validation response: %v", err)
+ }
+
+ baseResult := BaseValidationResult{
+ InferenceId: "1",
+ ResponseBytes: []byte{},
+ }
+
+ val := compareLogits(inferenceResponse.Choices[0].Logprobs.Content, validationResponse.Choices[0].Logprobs.Content, baseResult)
+ t.Logf("Validation result: %v", val)
+}
+
+func TestValidationQuant(t *testing.T) {
+ inferenceResponse, err := loadResponse(inferenceQuantJsonPath)
+ if err != nil {
+ t.Fatalf("Failed to read inference response: %v", err)
+ }
+
+ validationResponse, err := loadResponse(validationFP8tJsonPath)
+ if err != nil {
+ t.Fatalf("Failed to read validation response: %v", err)
+ }
+
+ baseResult := BaseValidationResult{
+ InferenceId: "1",
+ ResponseBytes: []byte{},
+ }
+
+ val := compareLogits(inferenceResponse.Choices[0].Logprobs.Content, validationResponse.Choices[0].Logprobs.Content, baseResult)
+ t.Logf("Validation result: %v", val)
+}
+
+func TestSequenceCheckValidTokensInTopK(t *testing.T) {
+ runSeed := "test_seed_12345"
+
+ enforcedTokens := completionapi.EnforcedTokens{
+ RunSeed: runSeed,
+ Tokens: []completionapi.EnforcedToken{
+ {Token: "Hello", TopTokens: []string{"Hello", "Hi", "Hey"}},
+ {Token: "world", TopTokens: []string{"world", "universe", "earth"}},
+ },
+ }
+
+ logits := []completionapi.Logprob{
+ {Token: "Hello"},
+ {Token: "world"},
+ }
+
+ err := checkSequenceFromArtifact(enforcedTokens, runSeed, logits)
+ if err != nil {
+ t.Fatalf("Sequence check should pass when all tokens are in top_k: %v", err)
+ }
+}
+
+func TestSequenceCheckInvalidTokenNotInTopK(t *testing.T) {
+ runSeed := "test_seed_12345"
+
+ enforcedTokens := completionapi.EnforcedTokens{
+ RunSeed: runSeed,
+ Tokens: []completionapi.EnforcedToken{
+ {Token: "Hello", TopTokens: []string{"Hello", "Hi", "Hey"}},
+ {Token: "world", TopTokens: []string{"world", "universe", "earth"}},
+ },
+ }
+
+ logits := []completionapi.Logprob{
+ {Token: "Hello"},
+ {Token: "INVALID"},
+ }
+
+ err := checkSequenceFromArtifact(enforcedTokens, runSeed, logits)
+ if err == nil {
+ t.Fatal("Expected sequence check to fail when token not in top_k")
+ }
+}
+
+func TestSequenceCheckEmptySeed(t *testing.T) {
+ enforcedTokens := completionapi.EnforcedTokens{
+ RunSeed: "",
+ Tokens: []completionapi.EnforcedToken{
+ {Token: "Hello", TopTokens: []string{"Hello", "Hi"}},
+ },
+ }
+
+ logits := []completionapi.Logprob{
+ {Token: "Hello"},
+ }
+
+ err := checkSequenceFromArtifact(enforcedTokens, "", logits)
+ if err != nil {
+ t.Fatalf("Empty seed should skip validation: %v", err)
+ }
+}
+
+func TestSequenceCheckLengthMismatch(t *testing.T) {
+ runSeed := "test_seed"
+
+ enforcedTokens := completionapi.EnforcedTokens{
+ RunSeed: runSeed,
+ Tokens: []completionapi.EnforcedToken{
+ {Token: "Hello", TopTokens: []string{"Hello"}},
+ },
+ }
+
+ logits := []completionapi.Logprob{
+ {Token: "Hello"},
+ {Token: "world"},
+ }
+
+ err := checkSequenceFromArtifact(enforcedTokens, runSeed, logits)
+ if err == nil {
+ t.Fatal("Expected error for length mismatch")
+ }
+}
+
+func TestSequenceCheckRealData1(t *testing.T) {
+ response, err := loadResponse(sequenceCheckValid1Path)
+ if err != nil {
+ t.Fatalf("Failed to load test response: %v", err)
+ }
+
+ if len(response.Choices) == 0 {
+ t.Fatal("No choices in response")
+ }
+
+ choice := response.Choices[0]
+ runSeed := choice.Logprobs.RunSeed
+
+ if runSeed == "" {
+ t.Skip("No run_seed in test data, skipping sequence check test")
+ }
+
+ var enforcedTokens completionapi.EnforcedTokens
+ enforcedTokens.RunSeed = runSeed
+
+ for _, logprob := range choice.Logprobs.Content {
+ var topTokens []string
+ for _, topLogprob := range logprob.TopLogprobs {
+ topTokens = append(topTokens, topLogprob.Token)
+ }
+ enforcedTokens.Tokens = append(enforcedTokens.Tokens, completionapi.EnforcedToken{
+ Token: logprob.Token,
+ TopTokens: topTokens,
+ })
+ }
+
+ err = checkSequenceFromArtifact(enforcedTokens, runSeed, choice.Logprobs.Content)
+ if err != nil {
+ t.Errorf("Sequence check failed for valid data: %v", err)
+ t.Logf("run_seed: %s", runSeed)
+ t.Logf("Token count: %d", len(choice.Logprobs.Content))
+ if len(choice.Logprobs.Content) > 0 {
+ t.Logf("First token: %s, top_tokens: %v",
+ choice.Logprobs.Content[0].Token,
+ enforcedTokens.Tokens[0].TopTokens)
+ }
+ } else {
+ t.Logf("Sequence check passed for %d tokens", len(choice.Logprobs.Content))
+ }
+}
+
+func TestSequenceCheckRealData2(t *testing.T) {
+ response, err := loadResponse(sequenceCheckValid2Path)
+ if err != nil {
+ t.Fatalf("Failed to load test response: %v", err)
+ }
+
+ if len(response.Choices) == 0 {
+ t.Fatal("No choices in response")
+ }
+
+ choice := response.Choices[0]
+ runSeed := choice.Logprobs.RunSeed
+
+ if runSeed == "" {
+ t.Skip("No run_seed in test data, skipping sequence check test")
+ }
+
+ var enforcedTokens completionapi.EnforcedTokens
+ enforcedTokens.RunSeed = runSeed
+
+ for _, logprob := range choice.Logprobs.Content {
+ var topTokens []string
+ for _, topLogprob := range logprob.TopLogprobs {
+ topTokens = append(topTokens, topLogprob.Token)
+ }
+ enforcedTokens.Tokens = append(enforcedTokens.Tokens, completionapi.EnforcedToken{
+ Token: logprob.Token,
+ TopTokens: topTokens,
+ })
+ }
+
+ err = checkSequenceFromArtifact(enforcedTokens, runSeed, choice.Logprobs.Content)
+ if err != nil {
+ t.Errorf("Sequence check failed for valid data: %v", err)
+ t.Logf("run_seed: %s", runSeed)
+ t.Logf("Token count: %d", len(choice.Logprobs.Content))
+ } else {
+ t.Logf("Sequence check passed for %d tokens", len(choice.Logprobs.Content))
+ }
+}
+
+func TestSequenceCheckTamperedToken(t *testing.T) {
+ response, err := loadResponse(sequenceCheckValid1Path)
+ if err != nil {
+ t.Fatalf("Failed to load test response: %v", err)
+ }
+
+ if len(response.Choices) == 0 || len(response.Choices[0].Logprobs.Content) < 2 {
+ t.Fatal("Insufficient data in response")
+ }
+
+ choice := response.Choices[0]
+ runSeed := choice.Logprobs.RunSeed
+
+ if runSeed == "" {
+ t.Skip("No run_seed in test data, skipping test")
+ }
+
+ var enforcedTokens completionapi.EnforcedTokens
+ enforcedTokens.RunSeed = runSeed
+
+ for _, logprob := range choice.Logprobs.Content {
+ var topTokens []string
+ for _, topLogprob := range logprob.TopLogprobs {
+ topTokens = append(topTokens, topLogprob.Token)
+ }
+ enforcedTokens.Tokens = append(enforcedTokens.Tokens, completionapi.EnforcedToken{
+ Token: logprob.Token,
+ TopTokens: topTokens,
+ })
+ }
+
+ tamperedLogits := make([]completionapi.Logprob, len(choice.Logprobs.Content))
+ copy(tamperedLogits, choice.Logprobs.Content)
+ tamperedLogits[1].Token = "TAMPERED_TOKEN_12345"
+
+ err = checkSequenceFromArtifact(enforcedTokens, runSeed, tamperedLogits)
+ if err == nil {
+ t.Error("Expected sequence check to fail with tampered token, but it passed")
+ }
+}
+
+func TestSequenceCheckWrongSeed(t *testing.T) {
+ response1, err := loadResponse(sequenceCheckValid1Path)
+ if err != nil {
+ t.Fatalf("Failed to load first test response: %v", err)
+ }
+
+ response2, err := loadResponse(sequenceCheckValid2Path)
+ if err != nil {
+ t.Fatalf("Failed to load second test response: %v", err)
+ }
+
+ if len(response1.Choices) == 0 || len(response2.Choices) == 0 {
+ t.Fatal("Missing choices in responses")
+ }
+
+ choice1 := response1.Choices[0]
+ choice2 := response2.Choices[0]
+
+ if choice1.Logprobs.RunSeed == "" || choice2.Logprobs.RunSeed == "" {
+ t.Skip("No run_seed in test data, skipping test")
+ }
+
+ var enforcedTokens completionapi.EnforcedTokens
+ enforcedTokens.RunSeed = choice1.Logprobs.RunSeed
+
+ for _, logprob := range choice1.Logprobs.Content {
+ var topTokens []string
+ for _, topLogprob := range logprob.TopLogprobs {
+ topTokens = append(topTokens, topLogprob.Token)
+ }
+ enforcedTokens.Tokens = append(enforcedTokens.Tokens, completionapi.EnforcedToken{
+ Token: logprob.Token,
+ TopTokens: topTokens,
+ })
+ }
+
+ err = checkSequenceFromArtifact(enforcedTokens, choice2.Logprobs.RunSeed, choice1.Logprobs.Content)
+ if err != nil {
+ t.Logf("Sequence check correctly rejected mismatched run_seed")
+ }
+}
+
+func TestDistributionCheckWithVLLM(t *testing.T) {
+ if testing.Short() {
+ t.Skip("Skipping distribution check test in short mode")
+ }
+
+ vllmURL := "http://localhost:8080"
+ validatorClient := NewValidatorClient(vllmURL)
+
+ response, err := loadResponse(DistributionCheckValidPath)
+ if err != nil {
+ t.Fatalf("Failed to load test response: %v", err)
+ }
+ if len(response.Choices) == 0 {
+ t.Fatal("No choices in response")
+ }
+ choice1 := response.Choices[0]
+
+ model := response.Model
+ if model == "" {
+ t.Fatal("No model in response")
+ }
+
+ requestMap := map[string]any{
+ "model": model,
+ "messages": []map[string]string{
+ {
+ "role": "user",
+ "content": "Who won the world series in 2020? Generate a funny and original text.",
+ },
+ },
+ "max_tokens": 80,
+ "temperature": 0.5,
+ "seed": 40,
+ "run_seed": choice1.Logprobs.RunSeed,
+ "stream": false,
+ "logprobs": 1,
+ "top_logprobs": 3,
+ }
+
+ t.Logf("Testing distribution check with model: %s", model)
+ t.Logf("vLLM URL: %s", vllmURL)
+
+ modelConfig := SetModelRequest{
+ Model: model,
+ Dtype: "auto",
+ AdditionalArgs: []string{"--max-model-len", "2048", "--gpu-memory-utilization", "0.5", "--chat-template \"<|im_start|>{{ role }}\\n{{ content }}<|im_end|>\""},
+ }
+
+ ctx := context.Background()
+
+ t.Log("Running first inference...")
+ statusResp1, err := validatorClient.PerformInferenceWithSetup(ctx, modelConfig, requestMap)
+ if err != nil {
+ t.Fatalf("Failed to perform first inference with vLLM setup: %v", err)
+ }
+
+ t.Logf("First inference completed with status: %s", statusResp1.Status)
+
+ if err := validatorClient.StopVLLM(ctx); err != nil {
+ t.Logf("Warning: Failed to stop vLLM after first inference: %v", err)
+ }
+
+ logits1, err := extractLogitsFromValidatorResult(statusResp1.Result)
+ t.Logf("DEBUG: logits1=%+v, err=%v", statusResp1.Result, err)
+ if err != nil {
+ t.Fatalf("Failed to extract logits from first result: %v", err)
+ }
+
+ t.Logf("Extracted %d tokens from first inference", len(logits1))
+ if len(logits1) > 0 {
+ t.Logf("First token: %s (logprob: %.4f, top_logprobs: %d)",
+ logits1[0].Token, logits1[0].Logprob, len(logits1[0].TopLogprobs))
+ }
+
+ t.Log("Running second inference with same parameters...")
+ statusResp2, err := validatorClient.PerformInferenceWithSetup(ctx, modelConfig, requestMap)
+ if err != nil {
+ t.Fatalf("Failed to perform second inference with vLLM setup: %v", err)
+ }
+
+ t.Logf("Second inference completed with status: %s", statusResp2.Status)
+
+ if err := validatorClient.StopVLLM(ctx); err != nil {
+ t.Logf("Warning: Failed to stop vLLM after second inference: %v", err)
+ }
+
+ logits2, err := extractLogitsFromValidatorResult(statusResp2.Result)
+ if err != nil {
+ t.Fatalf("Failed to extract logits from second result: %v", err)
+ }
+
+ t.Logf("Extracted %d tokens from second inference", len(logits2))
+
+ fileLogits := response.Choices[0].Logprobs.Content
+ t.Logf("Extracted %d tokens from file response", len(fileLogits))
+
+ baseResult := BaseValidationResult{
+ InferenceId: "test-distribution-check",
+ ResponseBytes: []byte{},
+ }
+
+ t.Log("\n=== Comparing vLLM inference 1 vs inference 2 ===")
+ result := compareDistributions(logits1, logits2, baseResult)
+ t.Logf("Distribution comparison result: %T", result)
+
+ if similarityResult, ok := result.(*SimilarityValidationResult); ok {
+ t.Logf("Similarity score (vLLM 1 vs 2): %.6f", similarityResult.Value)
+ t.Logf("Is successful (>0.99): %v", similarityResult.IsSuccessful())
+
+ if !similarityResult.IsSuccessful() {
+ t.Fatalf("vLLM inference 1 vs 2 comparison failed: similarity %.6f is below threshold", similarityResult.Value)
+ }
+ } else {
+ t.Fatalf("Expected SimilarityValidationResult, got %T", result)
+ }
+
+ t.Log("\n=== Comparing vLLM inference 1 vs file response ===")
+ resultVsFile1 := compareDistributions(logits1, fileLogits, baseResult)
+ if similarityResult, ok := resultVsFile1.(*SimilarityValidationResult); ok {
+ t.Logf("Similarity score (vLLM 1 vs file): %.6f", similarityResult.Value)
+ if !similarityResult.IsSuccessful() {
+ t.Fatalf("vLLM inference 1 vs file comparison failed: similarity %.6f is below threshold", similarityResult.Value)
+ }
+ } else {
+ t.Fatalf("Expected SimilarityValidationResult for vLLM 1 vs file, got %T", resultVsFile1)
+ }
+
+ t.Log("\n=== Comparing vLLM inference 2 vs file response ===")
+ resultVsFile2 := compareDistributions(logits2, fileLogits, baseResult)
+ if similarityResult, ok := resultVsFile2.(*SimilarityValidationResult); ok {
+ t.Logf("Similarity score (vLLM 2 vs file): %.6f", similarityResult.Value)
+ if !similarityResult.IsSuccessful() {
+ t.Fatalf("vLLM inference 2 vs file comparison failed: similarity %.6f is below threshold", similarityResult.Value)
+ }
+ } else {
+ t.Fatalf("Expected SimilarityValidationResult for vLLM 2 vs file, got %T", resultVsFile2)
+ }
+
+ if len(logits1) > 0 && len(logits2) > 0 {
+ t.Log("\nFirst 3 tokens comparison:")
+ for i := 0; i < 3 && i < len(logits1) && i < len(logits2); i++ {
+ t.Logf(" Position %d:", i)
+ t.Logf(" vLLM 1: %s (%.4f)", logits1[i].Token, logits1[i].Logprob)
+ t.Logf(" vLLM 2: %s (%.4f)", logits2[i].Token, logits2[i].Logprob)
+ if i < len(fileLogits) {
+ t.Logf(" File: %s (%.4f)", fileLogits[i].Token, fileLogits[i].Logprob)
+ }
+ }
+ }
+}
diff --git a/decentralized-api/internal/validation/validator_client.go b/decentralized-api/internal/validation/validator_client.go
new file mode 100644
index 000000000..fc1b5cb7f
--- /dev/null
+++ b/decentralized-api/internal/validation/validator_client.go
@@ -0,0 +1,335 @@
+package validation
+
+import (
+ "bytes"
+ "context"
+ "decentralized-api/logging"
+ "encoding/json"
+ "fmt"
+ "io"
+ "net/http"
+ "time"
+
+ "github.com/productscience/inference/x/inference/types"
+)
+
+type ValidatorClient struct {
+ baseURL string
+ httpClient *http.Client
+ currentModel string
+}
+
+func NewValidatorClient(baseURL string) *ValidatorClient {
+ return &ValidatorClient{
+ baseURL: baseURL,
+ httpClient: &http.Client{
+ Timeout: 10 * time.Minute,
+ },
+ }
+}
+
+type ValidatorInferenceResponse struct {
+ Status string `json:"status"`
+ Result map[string]interface{} `json:"result,omitempty"`
+ Error string `json:"error,omitempty"`
+}
+
+type DownloadModelRequest struct {
+ RepoID string `json:"repo_id"`
+ Revision *string `json:"revision,omitempty"`
+}
+
+type DownloadModelResponse struct {
+ Status string `json:"status"`
+ RepoID string `json:"repo_id"`
+ Path string `json:"path"`
+}
+
+type SetModelRequest struct {
+ Model string `json:"model"`
+ Dtype string `json:"dtype"`
+ AdditionalArgs []string `json:"additional_args"`
+}
+
+type SetModelResponse struct {
+ Status string `json:"status"`
+ Model string `json:"model"`
+}
+
+type StartVLLMResponse struct {
+ Status string `json:"status"`
+ Message string `json:"message"`
+}
+
+type StopVLLMResponse struct {
+ Status string `json:"status"`
+ Message string `json:"message"`
+}
+
+type HealthResponse struct {
+ Status string `json:"status"`
+ VllmStatus string `json:"vllm_status"`
+ VllmAvailable bool `json:"vllm_available"`
+ QueueSize int `json:"queue_size"`
+ IsProcessing bool `json:"is_processing"`
+}
+
+func (vc *ValidatorClient) DownloadModel(ctx context.Context, repoID string, revision *string) error {
+ req := DownloadModelRequest{
+ RepoID: repoID,
+ Revision: revision,
+ }
+
+ reqBody, err := json.Marshal(req)
+ if err != nil {
+ return fmt.Errorf("failed to marshal download request: %w", err)
+ }
+
+ downloadURL := fmt.Sprintf("%s/api/v1/models/download", vc.baseURL)
+ httpReq, err := http.NewRequestWithContext(ctx, "POST", downloadURL, bytes.NewReader(reqBody))
+ if err != nil {
+ return fmt.Errorf("failed to create download request: %w", err)
+ }
+ httpReq.Header.Set("Content-Type", "application/json")
+
+ resp, err := vc.httpClient.Do(httpReq)
+ if err != nil {
+ return fmt.Errorf("failed to download model: %w", err)
+ }
+ defer resp.Body.Close()
+
+ if resp.StatusCode != http.StatusOK {
+ body, _ := io.ReadAll(resp.Body)
+ return fmt.Errorf("download returned status %d: %s", resp.StatusCode, string(body))
+ }
+
+ var downloadResp DownloadModelResponse
+ if err := json.NewDecoder(resp.Body).Decode(&downloadResp); err != nil {
+ return fmt.Errorf("failed to decode download response: %w", err)
+ }
+
+ logging.Info("Model download initiated", types.Validation, "repo_id", repoID, "path", downloadResp.Path)
+ return nil
+}
+
+func (vc *ValidatorClient) SetModel(ctx context.Context, model string, dtype string, additionalArgs []string) error {
+ req := SetModelRequest{
+ Model: model,
+ Dtype: dtype,
+ AdditionalArgs: additionalArgs,
+ }
+
+ reqBody, err := json.Marshal(req)
+ if err != nil {
+ return fmt.Errorf("failed to marshal set model request: %w", err)
+ }
+
+ setModelURL := fmt.Sprintf("%s/api/v1/models/set", vc.baseURL)
+ httpReq, err := http.NewRequestWithContext(ctx, "POST", setModelURL, bytes.NewReader(reqBody))
+ if err != nil {
+ return fmt.Errorf("failed to create set model request: %w", err)
+ }
+ httpReq.Header.Set("Content-Type", "application/json")
+
+ resp, err := vc.httpClient.Do(httpReq)
+ if err != nil {
+ return fmt.Errorf("failed to set model: %w", err)
+ }
+ defer resp.Body.Close()
+
+ if resp.StatusCode != http.StatusOK {
+ body, _ := io.ReadAll(resp.Body)
+ return fmt.Errorf("set model returned status %d: %s", resp.StatusCode, string(body))
+ }
+
+ var setModelResp SetModelResponse
+ if err := json.NewDecoder(resp.Body).Decode(&setModelResp); err != nil {
+ return fmt.Errorf("failed to decode set model response: %w", err)
+ }
+
+ vc.currentModel = model
+ logging.Info("Model set successfully", types.Validation, "model", model)
+ return nil
+}
+
+func (vc *ValidatorClient) StartVLLM(ctx context.Context) error {
+ startURL := fmt.Sprintf("%s/api/v1/vllm/start", vc.baseURL)
+ httpReq, err := http.NewRequestWithContext(ctx, "POST", startURL, nil)
+ if err != nil {
+ return fmt.Errorf("failed to create start request: %w", err)
+ }
+
+ resp, err := vc.httpClient.Do(httpReq)
+ if err != nil {
+ return fmt.Errorf("failed to start vLLM: %w", err)
+ }
+ defer resp.Body.Close()
+
+ if resp.StatusCode != http.StatusOK {
+ body, _ := io.ReadAll(resp.Body)
+ return fmt.Errorf("start vLLM returned status %d: %s", resp.StatusCode, string(body))
+ }
+
+ var startResp StartVLLMResponse
+ if err := json.NewDecoder(resp.Body).Decode(&startResp); err != nil {
+ return fmt.Errorf("failed to decode start response: %w", err)
+ }
+
+ logging.Info("vLLM started successfully", types.Validation, "message", startResp.Message)
+ return nil
+}
+
+func (vc *ValidatorClient) StopVLLM(ctx context.Context) error {
+ stopURL := fmt.Sprintf("%s/api/v1/vllm/stop", vc.baseURL)
+ httpReq, err := http.NewRequestWithContext(ctx, "POST", stopURL, nil)
+ if err != nil {
+ return fmt.Errorf("failed to create stop request: %w", err)
+ }
+
+ resp, err := vc.httpClient.Do(httpReq)
+ if err != nil {
+ return fmt.Errorf("failed to stop vLLM: %w", err)
+ }
+ defer resp.Body.Close()
+
+ if resp.StatusCode != http.StatusOK {
+ body, _ := io.ReadAll(resp.Body)
+ return fmt.Errorf("stop vLLM returned status %d: %s", resp.StatusCode, string(body))
+ }
+
+ var stopResp StopVLLMResponse
+ if err := json.NewDecoder(resp.Body).Decode(&stopResp); err != nil {
+ return fmt.Errorf("failed to decode stop response: %w", err)
+ }
+
+ logging.Info("vLLM stopped successfully", types.Validation, "message", stopResp.Message)
+ return nil
+}
+
+func (vc *ValidatorClient) GetHealth(ctx context.Context) (*HealthResponse, error) {
+ healthURL := fmt.Sprintf("%s/api/v1/health", vc.baseURL)
+ httpReq, err := http.NewRequestWithContext(ctx, "GET", healthURL, nil)
+ if err != nil {
+ return nil, fmt.Errorf("failed to create health request: %w", err)
+ }
+
+ resp, err := vc.httpClient.Do(httpReq)
+ if err != nil {
+ return nil, fmt.Errorf("failed to get health: %w", err)
+ }
+ defer resp.Body.Close()
+
+ if resp.StatusCode != http.StatusOK {
+ body, _ := io.ReadAll(resp.Body)
+ return nil, fmt.Errorf("health check returned status %d: %s", resp.StatusCode, string(body))
+ }
+
+ var healthResp HealthResponse
+ if err := json.NewDecoder(resp.Body).Decode(&healthResp); err != nil {
+ return nil, fmt.Errorf("failed to decode health response: %w", err)
+ }
+
+ return &healthResp, nil
+}
+
+func (vc *ValidatorClient) EnsureVLLMReady(ctx context.Context, modelConfig SetModelRequest) error {
+ health, err := vc.GetHealth(ctx)
+ if err != nil {
+ return fmt.Errorf("failed to get health status: %w", err)
+ }
+
+ if health.VllmAvailable && vc.currentModel == modelConfig.Model {
+ logging.Debug("vLLM already running with correct model", types.Validation, "model", modelConfig.Model)
+ return nil
+ }
+
+ if health.VllmAvailable && vc.currentModel != modelConfig.Model {
+ logging.Info("vLLM running with different model, stopping", types.Validation, "current", vc.currentModel, "required", modelConfig.Model)
+ if err := vc.StopVLLM(ctx); err != nil {
+ return fmt.Errorf("failed to stop vLLM: %w", err)
+ }
+ time.Sleep(5 * time.Second)
+ }
+
+ logging.Info("Setting up vLLM for model", types.Validation, "model", modelConfig.Model, "dtype", modelConfig.Dtype, "additional_args", modelConfig.AdditionalArgs)
+
+ if err := vc.SetModel(ctx, modelConfig.Model, modelConfig.Dtype, modelConfig.AdditionalArgs); err != nil {
+ return fmt.Errorf("failed to set model: %w", err)
+ }
+
+ if err := vc.StartVLLM(ctx); err != nil {
+ return fmt.Errorf("failed to start vLLM: %w", err)
+ }
+
+ maxRetries := 30
+ for i := 0; i < maxRetries; i++ {
+ time.Sleep(2 * time.Second)
+ health, err := vc.GetHealth(ctx)
+ if err == nil && health.VllmAvailable {
+ logging.Info("vLLM is ready", types.Validation, "model", modelConfig.Model)
+ return nil
+ }
+ logging.Debug("Waiting for vLLM to be ready", types.Validation, "attempt", i+1, "max", maxRetries)
+ }
+
+ return fmt.Errorf("vLLM failed to become ready after %d attempts", maxRetries)
+}
+
+func (vc *ValidatorClient) SubmitInference(ctx context.Context, requestMap map[string]interface{}) (*ValidatorInferenceResponse, error) {
+ reqBody, err := json.Marshal(requestMap)
+ if err != nil {
+ return nil, fmt.Errorf("failed to marshal request: %w", err)
+ }
+
+ logging.Debug("Submitting inference to validator", types.Validation, "request", requestMap, "body", string(reqBody))
+
+ submitURL := fmt.Sprintf("%s/v1/chat/completions", vc.baseURL)
+ httpReq, err := http.NewRequestWithContext(ctx, "POST", submitURL, bytes.NewReader(reqBody))
+ if err != nil {
+ return nil, fmt.Errorf("failed to create request: %w", err)
+ }
+ httpReq.Header.Set("Content-Type", "application/json")
+
+ resp, err := vc.httpClient.Do(httpReq)
+ if err != nil {
+ return nil, fmt.Errorf("failed to submit inference: %w", err)
+ }
+ defer resp.Body.Close()
+
+ if resp.StatusCode != http.StatusOK {
+ body, _ := io.ReadAll(resp.Body)
+ return nil, fmt.Errorf("validator returned status %d: %s", resp.StatusCode, string(body))
+ }
+
+ body, err := io.ReadAll(resp.Body)
+ if err != nil {
+ return nil, fmt.Errorf("failed to read response body: %w", err)
+ }
+
+ logging.Debug("Validator response", types.Validation, "body", string(body))
+
+ var result map[string]interface{}
+ if err := json.Unmarshal(body, &result); err != nil {
+ return nil, fmt.Errorf("failed to decode response: %w", err)
+ }
+
+ return &ValidatorInferenceResponse{
+ Status: "completed",
+ Result: result,
+ }, nil
+}
+
+func (vc *ValidatorClient) PerformInferenceWithSetup(ctx context.Context, modelConfig SetModelRequest, requestMap map[string]interface{}) (*ValidatorInferenceResponse, error) {
+ if err := vc.EnsureVLLMReady(ctx, modelConfig); err != nil {
+ return nil, fmt.Errorf("failed to ensure vLLM is ready: %w", err)
+ }
+
+ statusResp, err := vc.SubmitInference(ctx, requestMap)
+ if err != nil {
+ return nil, fmt.Errorf("failed to submit inference: %w", err)
+ }
+
+ logging.Debug("Completed inference with validator", types.Validation)
+
+ return statusResp, nil
+}
diff --git a/decentralized-api/logging/logging.go b/decentralized-api/logging/logging.go
new file mode 100644
index 000000000..fddf563fd
--- /dev/null
+++ b/decentralized-api/logging/logging.go
@@ -0,0 +1,65 @@
+package logging
+
+import (
+ "context"
+ "github.com/productscience/inference/x/inference/types"
+ "log/slog"
+ "os"
+ "reflect"
+)
+
+func setNoopLogger() {
+ var logLevel slog.LevelVar
+ // Set the level above all normal levels
+ logLevel.Set(slog.Level(100))
+
+ logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
+ Level: &logLevel,
+ }))
+ slog.SetDefault(logger)
+}
+
+func WithNoopLogger(action func() (any, error)) (any, error) {
+ currentLogger := slog.Default()
+ defer slog.SetDefault(currentLogger)
+
+ setNoopLogger()
+ return action()
+}
+
+func Warn(msg string, subSystem types.SubSystem, keyvals ...interface{}) {
+ withSubsystem := append([]interface{}{"subsystem", subSystem}, keyvals...)
+ slog.Warn(msg, withSubsystem...)
+}
+
+func Info(msg string, subSystem types.SubSystem, keyvals ...interface{}) {
+ withSubsystem := append([]interface{}{"subsystem", subSystem}, keyvals...)
+ slog.Info(msg, withSubsystem...)
+}
+
+func Error(msg string, subSystem types.SubSystem, keyvals ...interface{}) {
+ withSubsystem := append([]interface{}{"subsystem", subSystem}, keyvals...)
+
+ // Check for error values and add their types
+ for i := 0; i < len(keyvals); i += 2 {
+ if i+1 < len(keyvals) {
+ if err, ok := keyvals[i+1].(error); ok {
+ errorType := reflect.TypeOf(err).String()
+ withSubsystem = append(withSubsystem, "error-type", errorType)
+ }
+ }
+ }
+
+ slog.Error(msg, withSubsystem...)
+}
+func Debug(msg string, subSystem types.SubSystem, keyvals ...interface{}) {
+ withSubsystem := append([]interface{}{"subsystem", subSystem}, keyvals...)
+ slog.Debug(msg, withSubsystem...)
+}
+
+const TraceLevel = -8
+
+func Trace(msg string, subSystem types.SubSystem, keyvals ...interface{}) {
+ withSubsystem := append([]interface{}{"subsystem", subSystem}, keyvals...)
+ slog.Log(context.Background(), TraceLevel, msg, withSubsystem...)
+}
diff --git a/decentralized-api/main.go b/decentralized-api/main.go
new file mode 100644
index 000000000..57abd88a2
--- /dev/null
+++ b/decentralized-api/main.go
@@ -0,0 +1,257 @@
+package main
+
+import (
+ "context"
+ "decentralized-api/apiconfig"
+ "decentralized-api/broker"
+ "decentralized-api/chainphase"
+ "decentralized-api/cosmosclient"
+ "decentralized-api/internal/bls"
+ "decentralized-api/internal/event_listener"
+ "decentralized-api/internal/modelmanager"
+ "decentralized-api/internal/nats/server"
+ "decentralized-api/internal/poc"
+ adminserver "decentralized-api/internal/server/admin"
+ mlserver "decentralized-api/internal/server/mlnode"
+ pserver "decentralized-api/internal/server/public"
+ "decentralized-api/mlnodeclient"
+ "net"
+
+ "github.com/productscience/inference/api/inference/inference"
+ "google.golang.org/grpc"
+ "google.golang.org/grpc/reflection"
+
+ "decentralized-api/internal/validation"
+ "decentralized-api/logging"
+ "decentralized-api/participant"
+ "decentralized-api/training"
+ "encoding/json"
+ "fmt"
+ "log"
+ "log/slog"
+ "os"
+ "strconv"
+ "strings"
+ "time"
+
+ "github.com/productscience/inference/x/inference/types"
+)
+
+func main() {
+ if len(os.Args) >= 2 && os.Args[1] == "status" {
+ logging.WithNoopLogger(func() (interface{}, error) {
+ config, err := apiconfig.LoadDefaultConfigManager()
+ if err != nil {
+ log.Fatalf("Error loading config: %v", err)
+ }
+ returnStatus(config)
+ return nil, nil
+ })
+
+ return
+ }
+ if len(os.Args) >= 2 && os.Args[1] == "pre-upgrade" {
+ os.Exit(1)
+ }
+
+ config, err := apiconfig.LoadDefaultConfigManager()
+ if err != nil {
+ log.Fatalf("Error loading config: %v", err)
+ }
+
+ if config.GetApiConfig().TestMode {
+ slog.SetLogLoggerLevel(slog.LevelDebug)
+ }
+
+ natssrv := server.NewServer(config.GetNatsConfig())
+ if err := natssrv.Start(); err != nil {
+ panic(err)
+ }
+
+ recorder, err := cosmosclient.NewInferenceCosmosClientWithRetry(
+ context.Background(),
+ "gonka",
+ 20,
+ 5*time.Second,
+ config,
+ )
+ if err != nil {
+ panic(err)
+ }
+
+ // Version sync is handled later in the event processing loop when blockchain is fully ready
+ // This prevents EOF errors during startup from breaking the entire application
+
+ chainPhaseTracker := chainphase.NewChainPhaseTracker()
+ // NOTE: getParams is waiting for rpc to be ready, don't add request before it
+ params, err := getParams(context.Background(), *recorder)
+ if err != nil {
+ logging.Error("Failed to get params", types.System, "error", err)
+ return
+ }
+ chainPhaseTracker.UpdateEpochParams(*params.Params.EpochParams)
+
+ participantInfo, err := participant.NewCurrentParticipantInfo(recorder)
+ if err != nil {
+ logging.Error("Failed to get participant info", types.Participants, "error", err)
+ return
+ }
+ chainBridge := broker.NewBrokerChainBridgeImpl(recorder, config.GetChainNodeConfig().Url)
+ nodeBroker := broker.NewBroker(chainBridge, chainPhaseTracker, participantInfo, config.GetApiConfig().PoCCallbackUrl, &mlnodeclient.HttpClientFactory{}, config)
+
+ nodes := config.GetNodes()
+ for _, node := range nodes {
+ responseChan := nodeBroker.LoadNodeToBroker(&node)
+ if responseChan != nil {
+ response := <-responseChan
+ if response.Error != nil {
+ logging.Error("Failed to load node to broker. Skipping", types.Nodes, "node_id", node.Id, "error", response.Error)
+ } else if response.Node == nil {
+ logging.Error("Failed to load node to broker, response.Node == nil and response.Error == nil. Skipping", types.Nodes, "node_id", node.Id)
+ } else {
+ logging.Info("Successfully loaded node to broker", types.Nodes, "node_id", response.Node.Id)
+ }
+ }
+ }
+
+ if err := participant.RegisterParticipantIfNeeded(recorder, config); err != nil {
+ logging.Error("Failed to register participant", types.Participants, "error", err)
+ return
+ }
+
+ logging.Debug("Initializing PoC orchestrator",
+ types.PoC, "name", recorder.GetApiAccount().SignerAccount.Name,
+ "address", participantInfo.GetAddress(),
+ "pubkey", participantInfo.GetPubKey())
+
+ nodePocOrchestrator := poc.NewNodePoCOrchestratorForCosmosChain(
+ participantInfo.GetPubKey(),
+ nodeBroker,
+ config.GetApiConfig().PoCCallbackUrl,
+ config.GetChainNodeConfig().Url,
+ recorder,
+ chainPhaseTracker,
+ )
+ logging.Info("node PocOrchestrator orchestrator initialized", types.PoC, "nodePocOrchestrator", nodePocOrchestrator)
+
+ tendermintClient := cosmosclient.TendermintClient{
+ ChainNodeUrl: config.GetChainNodeConfig().Url,
+ }
+ // Create a cancellable context for the entire system
+ ctx, cancel := context.WithCancel(context.Background())
+ defer cancel() // Ensure resources are cleaned up
+
+ // Start periodic config auto-flush of dynamic data to DB
+ config.StartAutoFlush(ctx, 60*time.Second)
+
+ training.NewAssigner(recorder, &tendermintClient, ctx)
+ trainingExecutor := training.NewExecutor(ctx, nodeBroker, recorder)
+
+ validator := validation.NewInferenceValidator(nodeBroker, config, recorder, chainPhaseTracker)
+ blsManager := bls.NewBlsManager(*recorder)
+ listener := event_listener.NewEventListener(config, nodePocOrchestrator, nodeBroker, validator, *recorder, trainingExecutor, chainPhaseTracker, cancel, blsManager)
+ // TODO: propagate trainingExecutor
+ go listener.Start(ctx)
+
+ mlnodeBackgroundManager := modelmanager.NewMLNodeBackgroundManager(
+ config,
+ chainPhaseTracker,
+ nodeBroker,
+ &mlnodeclient.HttpClientFactory{},
+ 30*time.Minute,
+ )
+ go mlnodeBackgroundManager.Start(ctx)
+
+ addr := fmt.Sprintf(":%v", config.GetApiConfig().PublicServerPort)
+ logging.Info("start public server on addr", types.Server, "addr", addr)
+
+ // Bridge external block queue
+ blockQueue := pserver.NewBlockQueue(recorder)
+
+ publicServer := pserver.NewServer(nodeBroker, config, recorder, trainingExecutor, blockQueue, chainPhaseTracker)
+ publicServer.Start(addr)
+
+ addr = fmt.Sprintf(":%v", config.GetApiConfig().MLServerPort)
+ logging.Info("start ml server on addr", types.Server, "addr", addr)
+ mlServer := mlserver.NewServer(recorder, nodeBroker)
+ mlServer.Start(addr)
+
+ addr = fmt.Sprintf(":%v", config.GetApiConfig().AdminServerPort)
+ logging.Info("start admin server on addr", types.Server, "addr", addr)
+ adminServer := adminserver.NewServer(recorder, nodeBroker, config, validator, blockQueue)
+ adminServer.Start(addr)
+
+ mlGrpcServerPort := config.GetApiConfig().MlGrpcServerPort
+ if mlGrpcServerPort == 0 {
+ mlGrpcServerPort = 9300
+ logging.Info("ml grpc server port not set, using default port 9300", types.Server)
+ }
+ addr = fmt.Sprintf(":%v", mlGrpcServerPort)
+ logging.Info("start training server on addr", types.Server, "addr", addr)
+ grpcServer := grpc.NewServer()
+ trainingServer := training.NewServer(recorder, trainingExecutor)
+ inference.RegisterNetworkNodeServiceServer(grpcServer, trainingServer)
+ reflection.Register(grpcServer)
+ lis, err := net.Listen("tcp", addr)
+ if err != nil {
+ log.Fatalf("failed to listen: %v", err)
+ }
+ go func() {
+ if err := grpcServer.Serve(lis); err != nil {
+ log.Fatalf("failed to serve: %v", err)
+ }
+ }()
+
+ logging.Info("Servers started", types.Server, "addr", addr)
+
+ <-ctx.Done()
+
+ ctxFlush, cancelFlush := context.WithTimeout(context.Background(), 10*time.Second)
+ defer cancelFlush()
+ logging.Info("Flushing config to the DB on app exit", types.Config)
+ _ = config.FlushNow(ctxFlush)
+
+ // Close DB gracefully
+ if db := config.SqlDb().GetDb(); db != nil {
+ _ = db.Close()
+ }
+
+ os.Exit(1) // Exit with an error for cosmovisor to restart the process
+}
+
+func returnStatus(config *apiconfig.ConfigManager) {
+ height := config.GetHeight()
+ status := map[string]interface{}{
+ "sync_info": map[string]string{
+ "latest_block_height": strconv.FormatInt(height, 10),
+ },
+ }
+ jsonData, err := json.MarshalIndent(status, "", " ")
+ if err != nil {
+ panic(err)
+ }
+ fmt.Println(string(jsonData))
+ os.Exit(0)
+}
+
+func getParams(ctx context.Context, transactionRecorder cosmosclient.InferenceCosmosClient) (*types.QueryParamsResponse, error) {
+ var params *types.QueryParamsResponse
+ var err error
+ for i := 0; i < 10; i++ {
+ params, err = transactionRecorder.NewInferenceQueryClient().Params(ctx, &types.QueryParamsRequest{})
+ if err == nil {
+ return params, nil
+ }
+
+ if strings.HasPrefix(err.Error(), "rpc error: code = Unknown desc = inference is not ready") {
+ logging.Info("Inference not ready, retrying...", types.System, "attempt", i+1, "error", err)
+ time.Sleep(2 * time.Second) // Try a longer wait for specific inference delays
+ continue
+ }
+ // If not an RPC error, log and return early
+ logging.Error("Failed to get chain params", types.System, "error", err)
+ return nil, err
+ }
+ logging.Error("Exhausted all retries to get chain params", types.System, "error", err)
+ return nil, err
+}
diff --git a/decentralized-api/merkleproof/verify.go b/decentralized-api/merkleproof/verify.go
new file mode 100644
index 000000000..3cd3c4e33
--- /dev/null
+++ b/decentralized-api/merkleproof/verify.go
@@ -0,0 +1,98 @@
+package merkleproof
+
+import (
+ "context"
+ "cosmossdk.io/store/rootmulti"
+ "fmt"
+ cryptotypes "github.com/cometbft/cometbft/proto/tendermint/crypto"
+ "github.com/cometbft/cometbft/rpc/client/http"
+ comettypes "github.com/cometbft/cometbft/types"
+ ibctypes "github.com/cosmos/ibc-go/v8/modules/core/23-commitment/types"
+)
+
+func VerifyBlockSignatures(address string, height int64) error {
+ // Step 1: Create a new RPC client
+ rpcClient, err := http.New(address, "/websocket")
+ if err != nil {
+ return err
+ }
+
+ // Step 2: Get the block and its commit at the desired height
+ blockRes, err := rpcClient.Block(context.Background(), &height)
+ if err != nil {
+ return err
+ }
+ block := blockRes.Block
+ commit := blockRes.Block.LastCommit
+
+ // Step 3: Get the validator set at height - 1 (previous height)
+ valSetRes, err := rpcClient.Validators(context.Background(), &height, nil, nil)
+ if err != nil {
+ return err
+ }
+ valSet := valSetRes.Validators
+
+ // Step 4: Verify the signatures
+ err = VerifyCommit(block.Header.ChainID, commit, &block.Header, valSet)
+ if err != nil {
+ return fmt.Errorf("block signature verification failed: %v", err)
+ }
+
+ fmt.Println("Block signature verification successful!")
+ return nil
+}
+
+func VerifyCommit(chainID string, commit *comettypes.Commit, header *comettypes.Header, validators []*comettypes.Validator) error {
+ // Reconstruct the validator set
+ valSet := comettypes.NewValidatorSet(validators)
+
+ // Verify the commit signatures against the validator set
+ if err := valSet.VerifyCommit(chainID, commit.BlockID, header.Height-1, commit); err != nil {
+ return fmt.Errorf("invalid commit signatures")
+ }
+
+ return nil
+}
+
+/*
+ func VerifyProof(proofOps *cryptotypes.ProofOps, key, value, appHash []byte) error {
+ merkleProof, err := ibctypes.ConvertProofs(proofOps)
+ merkleProof.Verify()
+
+ // Important to use runtime from the rootmulti package
+ proofRt := rootmulti.DefaultProofRuntime()
+ proofRt.VerifyValue(proofOps, key, value, appHash)
+
+ proofOperator, err := merkle.ValueOpDecoder(proofOps.Ops[0])
+ if err != nil {
+ return err
+ }
+
+ // Compute the root hash from the proof
+ rootHash := proofOperator.()
+ // OR THIS: merkleProof.Verify(rootHash, value)
+
+ // Compare the computed root hash with the app hash
+ if !bytes.Equal(rootHash, appHash) {
+ return fmt.Errorf("computed root hash does not match app hash")
+ }
+
+ return nil
+ }
+*/
+func VerifyUsingProofRt(proofOps *cryptotypes.ProofOps, root []byte, keypath string, value []byte) error {
+ proofRt := rootmulti.DefaultProofRuntime()
+ return proofRt.VerifyValue(proofOps, root, keypath, value)
+}
+
+func VerifyUsingMerkleProof(proofOps *cryptotypes.ProofOps, root []byte, moduleKey string, valueKey string, value []byte) error {
+ merkleProof, err := ibctypes.ConvertProofs(proofOps)
+ if err != nil {
+ return err
+ }
+
+ merkleRoot := ibctypes.MerkleRoot{Hash: root}
+ path := ibctypes.MerklePath{KeyPath: []string{moduleKey, valueKey}}
+
+ return merkleProof.VerifyMembership(ibctypes.GetSDKSpecs(), merkleRoot, path, value)
+}
diff --git a/decentralized-api/mlnodeclient/client.go b/decentralized-api/mlnodeclient/client.go
new file mode 100644
index 000000000..30cccd0fd
--- /dev/null
+++ b/decentralized-api/mlnodeclient/client.go
@@ -0,0 +1,328 @@
+package mlnodeclient
+
+import (
+ "context"
+ "decentralized-api/logging"
+ "decentralized-api/utils"
+ "encoding/json"
+ "fmt"
+ "net/http"
+ "net/url"
+ "strconv"
+ "time"
+
+ "github.com/productscience/inference/x/inference/training"
+ "github.com/productscience/inference/x/inference/types"
+)
+
+const (
+ trainStartPath = "/api/v1/train/start"
+ trainStatusPath = "/api/v1/train/status"
+ stopPath = "/api/v1/stop"
+ nodeStatePath = "/api/v1/state"
+ powStatusPath = "/api/v1/pow/status"
+ inferenceUpPath = "/api/v1/inference/up"
+)
+
+type Client struct {
+ pocUrl string
+ inferenceUrl string
+ client http.Client
+ mlGrpcCallbackAddress string
+}
+
+func NewNodeClient(pocUrl string, inferenceUrl string) *Client {
+ return &Client{
+ pocUrl: pocUrl,
+ inferenceUrl: inferenceUrl,
+ client: http.Client{
+ Timeout: 15 * time.Minute,
+ },
+ mlGrpcCallbackAddress: "api-private:9300", // TODO: PRTODO: make this configurable
+ }
+}
+
+type StartTraining struct {
+ TrainConfig TrainConfig `json:"train_config"`
+ TrainEnv TrainEnv `json:"train_env"`
+}
+
+type TrainConfig struct {
+ Project string `json:"project"`
+ Name string `json:"name"`
+ Description string `json:"description"`
+ Group string `json:"group"`
+ Tags []string `json:"tags"`
+ Train TrainParams `json:"train"`
+ Data DataConfig `json:"data"`
+ Optim OptimConfig `json:"optim"`
+ Diloco DilocoConfig `json:"diloco"`
+ Ckpt Checkpoint `json:"ckpt"`
+}
+
+type TrainParams struct {
+ MicroBatchSize int `json:"micro_bs"`
+ EvalInterval int `json:"eval_interval"`
+}
+
+type DataConfig struct {
+ SeqLength int `json:"seq_length"`
+}
+
+type OptimConfig struct {
+ SchedType string `json:"sched_type"`
+ BatchSize int `json:"batch_size"`
+ WarmupSteps int `json:"warmup_steps"`
+ TotalSteps int `json:"total_steps"`
+ AdamBetas1 float64 `json:"adam_betas1"`
+ AdamBetas2 float64 `json:"adam_betas2"`
+ WeightDecay float64 `json:"weight_decay"`
+ LearningRate float64 `json:"lr"`
+}
+
+type DilocoConfig struct {
+ InnerSteps int `json:"inner_steps"`
+}
+
+type Checkpoint struct {
+ Interval int `json:"interval"`
+ TopK int `json:"topk"`
+ Path string `json:"path"`
+}
+
+type TrainEnv struct {
+ TaskId string `json:"TASK_ID"`
+ NodeId string `json:"NODE_ID"`
+ StoreApiUrl string `json:"STORE_API_URL"`
+ GlobalAddr string `json:"GLOBAL_ADDR"`
+ GlobalPort string `json:"GLOBAL_PORT"`
+ GlobalRank string `json:"GLOBAL_RANK"`
+ GlobalUniqueID string `json:"GLOBAL_UNIQUE_ID"`
+ GlobalWorldSize string `json:"GLOBAL_WORLD_SIZE"`
+ BasePort string `json:"BASE_PORT"`
+}
+
+var devTrainConfig = TrainConfig{
+ Project: "1B-ft-xlam",
+ Name: "refactor test 3090",
+ Description: "3090 micro bs2",
+ Group: "base",
+ Tags: []string{"1x1", "no-diloco"},
+ Train: TrainParams{
+ MicroBatchSize: 2,
+ EvalInterval: 50,
+ },
+ Data: DataConfig{
+ SeqLength: 1024,
+ },
+ Optim: OptimConfig{
+ SchedType: "cosine",
+ BatchSize: 32,
+ WarmupSteps: 50,
+ TotalSteps: 6000,
+ AdamBetas1: 0.9,
+ AdamBetas2: 0.95,
+ WeightDecay: 0.1,
+ LearningRate: 5e-6,
+ },
+ Diloco: DilocoConfig{
+ InnerSteps: 50,
+ },
+ Ckpt: Checkpoint{
+ Interval: 1000,
+ TopK: 6,
+ Path: "outputs/1B_4x1-lr",
+ },
+}
+
+const (
+ defaultGlobalTrainingPort = "5565"
+ defaultTrainingBasePort = "10001"
+)
+
+func (api *Client) StartTraining(ctx context.Context, taskId uint64, participant string, nodeId string, masterNodeAddr string, rank int, worldSize int) error {
+ requestUrl, err := url.JoinPath(api.pocUrl, trainStartPath)
+ if err != nil {
+ return err
+ }
+
+ globalNodeId := training.GlobalNodeId{
+ Participant: participant,
+ LocalNodeId: nodeId,
+ }
+ trainEnv := TrainEnv{
+ TaskId: strconv.FormatUint(taskId, 10),
+ NodeId: globalNodeId.ToString(),
+ StoreApiUrl: api.mlGrpcCallbackAddress,
+ GlobalAddr: masterNodeAddr,
+ GlobalPort: defaultGlobalTrainingPort,
+ GlobalRank: strconv.Itoa(rank),
+ GlobalUniqueID: strconv.Itoa(rank),
+ GlobalWorldSize: strconv.Itoa(worldSize),
+ BasePort: defaultTrainingBasePort,
+ }
+ body := StartTraining{
+ TrainConfig: devTrainConfig,
+ TrainEnv: trainEnv,
+ }
+
+ logging.Info("Starting training with", types.Training, "trainEnv", trainEnv)
+ _, err = utils.SendPostJsonRequest(ctx, &api.client, requestUrl, body)
+ if err != nil {
+ return err
+ }
+
+ return nil
+}
+
+func (api *Client) GetTrainingStatus(ctx context.Context) error {
+ requestUrl, err := url.JoinPath(api.pocUrl, trainStartPath)
+ if err != nil {
+ return err
+ }
+
+ _, err = utils.SendGetRequest(ctx, &api.client, requestUrl)
+ if err != nil {
+ return err
+ }
+
+ return nil
+}
+
+func (api *Client) Stop(ctx context.Context) error {
+ requestUrl, err := url.JoinPath(api.pocUrl, stopPath)
+ if err != nil {
+ return err
+ }
+
+ _, err = utils.SendPostJsonRequest(ctx, &api.client, requestUrl, nil)
+ if err != nil {
+ return err
+ }
+
+ return nil
+}
+
+type MLNodeState string
+
+const (
+ MlNodeState_POW MLNodeState = "POW"
+ MlNodeState_INFERENCE MLNodeState = "INFERENCE"
+ MlNodeState_TRAIN MLNodeState = "TRAIN"
+ MlNodeState_STOPPED MLNodeState = "STOPPED"
+)
+
+type StateResponse struct {
+ State MLNodeState `json:"state"`
+}
+
+func (api *Client) NodeState(ctx context.Context) (*StateResponse, error) {
+ requestURL, err := url.JoinPath(api.pocUrl, nodeStatePath)
+ if err != nil {
+ return nil, err
+ }
+
+ resp, err := utils.SendGetRequest(ctx, &api.client, requestURL)
+ if err != nil {
+ return nil, err
+ }
+ defer resp.Body.Close()
+
+ if resp.StatusCode != http.StatusOK {
+ return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
+ }
+
+ var stateResp StateResponse
+ if err := json.NewDecoder(resp.Body).Decode(&stateResp); err != nil {
+ return nil, err
+ }
+
+ return &stateResp, nil
+}
+
+type PowState string
+
+const (
+ POW_IDLE PowState = "IDLE"
+ POW_NO_CONTROLLER PowState = "NOT_LOADED"
+ POW_LOADING PowState = "LOADING"
+ POW_GENERATING PowState = "GENERATING"
+ POW_VALIDATING PowState = "VALIDATING"
+ POW_STOPPED PowState = "STOPPED"
+ POW_MIXED PowState = "MIXED"
+)
+
+type PowStatusResponse struct {
+ Status PowState `json:"status"`
+ IsModelInitialized bool `json:"is_model_initialized"`
+}
+
+func (api *Client) GetPowStatus(ctx context.Context) (*PowStatusResponse, error) {
+ requestURL, err := url.JoinPath(api.pocUrl, powStatusPath)
+ if err != nil {
+ return nil, err
+ }
+
+ resp, err := utils.SendGetRequest(ctx, &api.client, requestURL)
+ if err != nil {
+ return nil, err
+ }
+ defer resp.Body.Close()
+
+ if resp.StatusCode != http.StatusOK {
+ return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
+ }
+
+ var powResp PowStatusResponse
+ if err := json.NewDecoder(resp.Body).Decode(&powResp); err != nil {
+ return nil, err
+ }
+
+ return &powResp, nil
+}
+
+func (api *Client) InferenceHealth(ctx context.Context) (bool, error) {
+ requestURL, err := url.JoinPath(api.inferenceUrl, "/health")
+ if err != nil {
+ return false, err
+ }
+
+ resp, err := utils.SendGetRequest(ctx, &api.client, requestURL)
+ if err != nil {
+ return false, err
+ }
+ defer resp.Body.Close()
+
+ if resp.StatusCode != http.StatusOK {
+ return false, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
+ }
+
+ return true, nil
+}
+
+type inferenceUpDto struct {
+ Model string `json:"model"`
+ Dtype string `json:"dtype"`
+ Args []string `json:"additional_args"`
+}
+
+func (api *Client) InferenceUp(ctx context.Context, model string, args []string) error {
+ inferenceUpUrl, err := url.JoinPath(api.pocUrl, inferenceUpPath)
+ if err != nil {
+ return err
+ }
+
+ dto := inferenceUpDto{
+ Model: model,
+ Dtype: "float16",
+ Args: args,
+ }
+
+ logging.Info("Sending inference/up request to node", types.PoC, "inferenceUpUrl", inferenceUpUrl, "body", dto)
+
+ _, err = utils.SendPostJsonRequest(ctx, &api.client, inferenceUpUrl, dto)
+ if err != nil {
+ logging.Error("Failed to send inference/up request", types.PoC, "error", err, "inferenceUpUrl", inferenceUpUrl, "inferenceUpDto", dto)
+ }
+ return err
+}
diff --git a/decentralized-api/mlnodeclient/client_factory.go b/decentralized-api/mlnodeclient/client_factory.go
new file mode 100644
index 000000000..2a8aad8ec
--- /dev/null
+++ b/decentralized-api/mlnodeclient/client_factory.go
@@ -0,0 +1,48 @@
+package mlnodeclient
+
+type ClientFactory interface {
+ CreateClient(pocUrl string, inferenceUrl string) MLNodeClient
+}
+
+type HttpClientFactory struct{}
+
+func (f *HttpClientFactory) CreateClient(pocUrl string, inferenceUrl string) MLNodeClient {
+ return NewNodeClient(pocUrl, inferenceUrl)
+}
+
+type MockClientFactory struct {
+ clients map[string]*MockClient
+}
+
+func NewMockClientFactory() *MockClientFactory {
+ return &MockClientFactory{
+ clients: make(map[string]*MockClient),
+ }
+}
+
+func (f *MockClientFactory) CreateClient(pocUrl string, inferenceUrl string) MLNodeClient {
+ // Use pocUrl as the key to identify nodes (it should be unique per node)
+ key := pocUrl
+ if client, exists := f.clients[key]; exists {
+ return client
+ }
+
+ // Create new mock client for this node
+ client := NewMockClient()
+ f.clients[key] = client
+ return client
+}
+
+func (f *MockClientFactory) GetClientForNode(pocUrl string) *MockClient {
+ return f.clients[pocUrl]
+}
+
+func (f *MockClientFactory) GetAllClients() map[string]*MockClient {
+ return f.clients
+}
+
+func (f *MockClientFactory) Reset() {
+ for _, client := range f.clients {
+ *client = *NewMockClient() // Reset the client state
+ }
+}
diff --git a/decentralized-api/mlnodeclient/errors.go b/decentralized-api/mlnodeclient/errors.go
new file mode 100644
index 000000000..786291521
--- /dev/null
+++ b/decentralized-api/mlnodeclient/errors.go
@@ -0,0 +1,28 @@
+package mlnodeclient
+
+import "fmt"
+
+// ErrAPINotImplemented indicates that the ML node doesn't support this API endpoint.
+// This typically happens when an older version of the ML node is running.
+// Can be checked with errors.Is(err, ErrAPINotImplemented)
+type ErrAPINotImplemented struct {
+ Endpoint string
+ StatusCode int
+}
+
+func (e *ErrAPINotImplemented) Error() string {
+ return fmt.Sprintf("API endpoint not implemented: %s (HTTP %d)", e.Endpoint, e.StatusCode)
+}
+
+func (e *ErrAPINotImplemented) Is(target error) bool {
+ _, ok := target.(*ErrAPINotImplemented)
+ return ok
+}
+
+// NewAPINotImplementedError creates a new ErrAPINotImplemented error
+func NewAPINotImplementedError(endpoint string, statusCode int) error {
+ return &ErrAPINotImplemented{
+ Endpoint: endpoint,
+ StatusCode: statusCode,
+ }
+}
diff --git a/decentralized-api/mlnodeclient/errors_test.go b/decentralized-api/mlnodeclient/errors_test.go
new file mode 100644
index 000000000..f3b5f80a8
--- /dev/null
+++ b/decentralized-api/mlnodeclient/errors_test.go
@@ -0,0 +1,66 @@
+package mlnodeclient
+
+import (
+ "errors"
+ "net/http"
+ "testing"
+)
+
+func TestErrAPINotImplemented(t *testing.T) {
+ t.Run("error message format", func(t *testing.T) {
+ err := NewAPINotImplementedError("/api/v1/test", http.StatusNotFound)
+ expected := "API endpoint not implemented: /api/v1/test (HTTP 404)"
+ if err.Error() != expected {
+ t.Errorf("expected error message %q, got %q", expected, err.Error())
+ }
+ })
+
+ t.Run("errors.Is comparison", func(t *testing.T) {
+ err1 := NewAPINotImplementedError("/api/v1/test", http.StatusNotFound)
+ err2 := &ErrAPINotImplemented{}
+
+ if !errors.Is(err1, err2) {
+ t.Error("expected errors.Is to return true for ErrAPINotImplemented types")
+ }
+ })
+
+ t.Run("type assertion", func(t *testing.T) {
+ err := NewAPINotImplementedError("/api/v1/test", http.StatusNotFound)
+
+ apiErr, ok := err.(*ErrAPINotImplemented)
+ if !ok {
+ t.Fatal("expected type assertion to succeed")
+ }
+
+ if apiErr.Endpoint != "/api/v1/test" {
+ t.Errorf("expected endpoint /api/v1/test, got %s", apiErr.Endpoint)
+ }
+ if apiErr.StatusCode != http.StatusNotFound {
+ t.Errorf("expected status code 404, got %d", apiErr.StatusCode)
+ }
+ })
+
+ t.Run("different status codes", func(t *testing.T) {
+ err404 := NewAPINotImplementedError("/api/v1/test", http.StatusNotFound)
+ err405 := NewAPINotImplementedError("/api/v1/test", http.StatusMethodNotAllowed)
+
+ apiErr404 := err404.(*ErrAPINotImplemented)
+ apiErr405 := err405.(*ErrAPINotImplemented)
+
+ if apiErr404.StatusCode != 404 {
+ t.Errorf("expected status code 404, got %d", apiErr404.StatusCode)
+ }
+ if apiErr405.StatusCode != 405 {
+ t.Errorf("expected status code 405, got %d", apiErr405.StatusCode)
+ }
+ })
+
+ t.Run("not equal to generic error", func(t *testing.T) {
+ apiErr := NewAPINotImplementedError("/api/v1/test", http.StatusNotFound)
+ genericErr := errors.New("some error")
+
+ if errors.Is(genericErr, apiErr) {
+ t.Error("expected errors.Is to return false for different error types")
+ }
+ })
+}
diff --git a/decentralized-api/mlnodeclient/gpu.go b/decentralized-api/mlnodeclient/gpu.go
new file mode 100644
index 000000000..5e4093aae
--- /dev/null
+++ b/decentralized-api/mlnodeclient/gpu.go
@@ -0,0 +1,78 @@
+package mlnodeclient
+
+import (
+ "context"
+ "encoding/json"
+ "fmt"
+ "net/http"
+ "net/url"
+
+ "decentralized-api/utils"
+)
+
+const (
+ gpuDevicesPath = "/api/v1/gpu/devices"
+ gpuDriverPath = "/api/v1/gpu/driver"
+)
+
+// GetGPUDevices retrieves information about all CUDA devices on the ML node.
+// Returns empty list if no GPUs are present or NVML is not initialized.
+// Returns ErrAPINotImplemented if the ML node doesn't support this endpoint.
+func (api *Client) GetGPUDevices(ctx context.Context) (*GPUDevicesResponse, error) {
+ requestURL, err := url.JoinPath(api.pocUrl, gpuDevicesPath)
+ if err != nil {
+ return nil, err
+ }
+
+ resp, err := utils.SendGetRequest(ctx, &api.client, requestURL)
+ if err != nil {
+ return nil, err
+ }
+ defer resp.Body.Close()
+
+ if resp.StatusCode == http.StatusNotFound || resp.StatusCode == http.StatusMethodNotAllowed {
+ return nil, NewAPINotImplementedError(gpuDevicesPath, resp.StatusCode)
+ }
+
+ if resp.StatusCode != http.StatusOK {
+ return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
+ }
+
+ var devicesResp GPUDevicesResponse
+ if err := json.NewDecoder(resp.Body).Decode(&devicesResp); err != nil {
+ return nil, err
+ }
+
+ return &devicesResp, nil
+}
+
+// GetGPUDriver retrieves CUDA driver version information from NVML.
+// Returns ErrAPINotImplemented if the ML node doesn't support this endpoint.
+// Returns error if NVML is not initialized or driver info cannot be retrieved.
+func (api *Client) GetGPUDriver(ctx context.Context) (*DriverInfo, error) {
+ requestURL, err := url.JoinPath(api.pocUrl, gpuDriverPath)
+ if err != nil {
+ return nil, err
+ }
+
+ resp, err := utils.SendGetRequest(ctx, &api.client, requestURL)
+ if err != nil {
+ return nil, err
+ }
+ defer resp.Body.Close()
+
+ if resp.StatusCode == http.StatusNotFound || resp.StatusCode == http.StatusMethodNotAllowed {
+ return nil, NewAPINotImplementedError(gpuDriverPath, resp.StatusCode)
+ }
+
+ if resp.StatusCode != http.StatusOK {
+ return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
+ }
+
+ var driverInfo DriverInfo
+ if err := json.NewDecoder(resp.Body).Decode(&driverInfo); err != nil {
+ return nil, err
+ }
+
+ return &driverInfo, nil
+}
diff --git a/decentralized-api/mlnodeclient/gpu_test.go b/decentralized-api/mlnodeclient/gpu_test.go
new file mode 100644
index 000000000..7b0247f66
--- /dev/null
+++ b/decentralized-api/mlnodeclient/gpu_test.go
@@ -0,0 +1,209 @@
+package mlnodeclient
+
+import (
+ "context"
+ "encoding/json"
+ "net/http"
+ "net/http/httptest"
+ "testing"
+)
+
+func TestClient_GetGPUDevices(t *testing.T) {
+ ctx := context.Background()
+
+ t.Run("successful response", func(t *testing.T) {
+ expectedResp := &GPUDevicesResponse{
+ Devices: []GPUDevice{
+ {
+ Index: 0,
+ Name: "NVIDIA A100-SXM4-40GB",
+ IsAvailable: true,
+ },
+ },
+ Count: 1,
+ }
+
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ if r.URL.Path != "/api/v1/gpu/devices" {
+ t.Errorf("expected path /api/v1/gpu/devices, got %s", r.URL.Path)
+ }
+ if r.Method != http.MethodGet {
+ t.Errorf("expected GET method, got %s", r.Method)
+ }
+
+ w.WriteHeader(http.StatusOK)
+ json.NewEncoder(w).Encode(expectedResp)
+ }))
+ defer server.Close()
+
+ client := NewNodeClient(server.URL, "")
+ resp, err := client.GetGPUDevices(ctx)
+
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if resp.Count != 1 {
+ t.Errorf("expected count 1, got %d", resp.Count)
+ }
+ if len(resp.Devices) != 1 {
+ t.Errorf("expected 1 device, got %d", len(resp.Devices))
+ }
+ if resp.Devices[0].Name != "NVIDIA A100-SXM4-40GB" {
+ t.Errorf("expected device name NVIDIA A100-SXM4-40GB, got %s", resp.Devices[0].Name)
+ }
+ })
+
+ t.Run("empty devices list", func(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ w.WriteHeader(http.StatusOK)
+ json.NewEncoder(w).Encode(&GPUDevicesResponse{
+ Devices: []GPUDevice{},
+ Count: 0,
+ })
+ }))
+ defer server.Close()
+
+ client := NewNodeClient(server.URL, "")
+ resp, err := client.GetGPUDevices(ctx)
+
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if resp.Count != 0 {
+ t.Errorf("expected count 0, got %d", resp.Count)
+ }
+ })
+
+ t.Run("API not implemented - 404", func(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ w.WriteHeader(http.StatusNotFound)
+ }))
+ defer server.Close()
+
+ client := NewNodeClient(server.URL, "")
+ _, err := client.GetGPUDevices(ctx)
+
+ if err == nil {
+ t.Fatal("expected error, got nil")
+ }
+
+ var apiErr *ErrAPINotImplemented
+ if !isErrAPINotImplemented(err) {
+ t.Errorf("expected ErrAPINotImplemented, got %T: %v", err, err)
+ } else {
+ apiErr = err.(*ErrAPINotImplemented)
+ if apiErr.StatusCode != http.StatusNotFound {
+ t.Errorf("expected status code 404, got %d", apiErr.StatusCode)
+ }
+ }
+ })
+
+ t.Run("API not implemented - 405", func(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ w.WriteHeader(http.StatusMethodNotAllowed)
+ }))
+ defer server.Close()
+
+ client := NewNodeClient(server.URL, "")
+ _, err := client.GetGPUDevices(ctx)
+
+ if err == nil {
+ t.Fatal("expected error, got nil")
+ }
+ if !isErrAPINotImplemented(err) {
+ t.Errorf("expected ErrAPINotImplemented, got %T: %v", err, err)
+ }
+ })
+
+ t.Run("server error", func(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ w.WriteHeader(http.StatusInternalServerError)
+ }))
+ defer server.Close()
+
+ client := NewNodeClient(server.URL, "")
+ _, err := client.GetGPUDevices(ctx)
+
+ if err == nil {
+ t.Fatal("expected error, got nil")
+ }
+ if isErrAPINotImplemented(err) {
+ t.Error("expected generic error, got ErrAPINotImplemented")
+ }
+ })
+}
+
+func TestClient_GetGPUDriver(t *testing.T) {
+ ctx := context.Background()
+
+ t.Run("successful response", func(t *testing.T) {
+ expectedResp := &DriverInfo{
+ DriverVersion: "535.104.05",
+ CudaDriverVersion: "12.2",
+ NvmlVersion: "12.535.104",
+ }
+
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ if r.URL.Path != "/api/v1/gpu/driver" {
+ t.Errorf("expected path /api/v1/gpu/driver, got %s", r.URL.Path)
+ }
+ if r.Method != http.MethodGet {
+ t.Errorf("expected GET method, got %s", r.Method)
+ }
+
+ w.WriteHeader(http.StatusOK)
+ json.NewEncoder(w).Encode(expectedResp)
+ }))
+ defer server.Close()
+
+ client := NewNodeClient(server.URL, "")
+ resp, err := client.GetGPUDriver(ctx)
+
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if resp.DriverVersion != "535.104.05" {
+ t.Errorf("expected driver version 535.104.05, got %s", resp.DriverVersion)
+ }
+ if resp.CudaDriverVersion != "12.2" {
+ t.Errorf("expected CUDA version 12.2, got %s", resp.CudaDriverVersion)
+ }
+ })
+
+ t.Run("API not implemented", func(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ w.WriteHeader(http.StatusNotFound)
+ }))
+ defer server.Close()
+
+ client := NewNodeClient(server.URL, "")
+ _, err := client.GetGPUDriver(ctx)
+
+ if err == nil {
+ t.Fatal("expected error, got nil")
+ }
+ if !isErrAPINotImplemented(err) {
+ t.Errorf("expected ErrAPINotImplemented, got %T: %v", err, err)
+ }
+ })
+
+ t.Run("service unavailable", func(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ w.WriteHeader(http.StatusServiceUnavailable)
+ }))
+ defer server.Close()
+
+ client := NewNodeClient(server.URL, "")
+ _, err := client.GetGPUDriver(ctx)
+
+ if err == nil {
+ t.Fatal("expected error, got nil")
+ }
+ })
+}
+
+// Helper function to check if error is ErrAPINotImplemented
+func isErrAPINotImplemented(err error) bool {
+ _, ok := err.(*ErrAPINotImplemented)
+ return ok
+}
diff --git a/decentralized-api/mlnodeclient/interface.go b/decentralized-api/mlnodeclient/interface.go
new file mode 100644
index 000000000..6167aeee4
--- /dev/null
+++ b/decentralized-api/mlnodeclient/interface.go
@@ -0,0 +1,38 @@
+package mlnodeclient
+
+import "context"
+
+// MLNodeClient defines the interface for interacting with ML nodes
+type MLNodeClient interface {
+ // Training operations
+ StartTraining(ctx context.Context, taskId uint64, participant string, nodeId string, masterNodeAddr string, rank int, worldSize int) error
+ GetTrainingStatus(ctx context.Context) error
+
+ // Node state operations
+ Stop(ctx context.Context) error
+ NodeState(ctx context.Context) (*StateResponse, error)
+
+ // PoC operations
+ GetPowStatus(ctx context.Context) (*PowStatusResponse, error)
+ InitGenerate(ctx context.Context, dto InitDto) error
+ InitValidate(ctx context.Context, dto InitDto) error
+ ValidateBatch(ctx context.Context, batch ProofBatch) error
+
+ // Inference operations
+ InferenceHealth(ctx context.Context) (bool, error)
+ InferenceUp(ctx context.Context, model string, args []string) error
+
+ // GPU operations
+ GetGPUDevices(ctx context.Context) (*GPUDevicesResponse, error)
+ GetGPUDriver(ctx context.Context) (*DriverInfo, error)
+
+ // Model management operations
+ CheckModelStatus(ctx context.Context, model Model) (*ModelStatusResponse, error)
+ DownloadModel(ctx context.Context, model Model) (*DownloadStartResponse, error)
+ DeleteModel(ctx context.Context, model Model) (*DeleteResponse, error)
+ ListModels(ctx context.Context) (*ModelListResponse, error)
+ GetDiskSpace(ctx context.Context) (*DiskSpaceInfo, error)
+}
+
+// Ensure Client implements MLNodeClient
+var _ MLNodeClient = (*Client)(nil)
diff --git a/decentralized-api/mlnodeclient/mock.go b/decentralized-api/mlnodeclient/mock.go
new file mode 100644
index 000000000..33f481d14
--- /dev/null
+++ b/decentralized-api/mlnodeclient/mock.go
@@ -0,0 +1,417 @@
+package mlnodeclient
+
+import (
+ "context"
+ "decentralized-api/logging"
+ "errors"
+ "sync"
+ "testing"
+
+ "github.com/productscience/inference/x/inference/types"
+)
+
+// MockClient is a mock implementation of MLNodeClient for testing
+type MockClient struct {
+ Mu sync.Mutex
+ // State tracking
+ CurrentState MLNodeState
+ PowStatus PowState
+ InferenceIsHealthy bool
+
+ // GPU state
+ GPUDevices []GPUDevice
+ DriverInfo *DriverInfo
+
+ // Model management state
+ CachedModels map[string]ModelListItem // key: hf_repo:hf_commit
+ DownloadingModels map[string]*DownloadProgress
+ DiskSpace *DiskSpaceInfo
+
+ // Error injection
+ StopError error
+ NodeStateError error
+ GetPowStatusError error
+ InitGenerateError error
+ InitValidateError error
+ ValiateBatchError error
+ InferenceHealthError error
+ InferenceUpError error
+ StartTrainingError error
+ GetGPUDevicesError error
+ GetGPUDriverError error
+ CheckModelStatusError error
+ DownloadModelError error
+ DeleteModelError error
+ ListModelsError error
+ GetDiskSpaceError error
+
+ // Call tracking
+ StopCalled int
+ NodeStateCalled int
+ GetPowStatusCalled int
+ InitGenerateCalled int
+ InitValidateCalled int
+ ValidateBatchCalled int
+ InferenceHealthCalled int
+ InferenceUpCalled int
+ StartTrainingCalled int
+ GetGPUDevicesCalled int
+ GetGPUDriverCalled int
+ CheckModelStatusCalled int
+ DownloadModelCalled int
+ DeleteModelCalled int
+ ListModelsCalled int
+ GetDiskSpaceCalled int
+
+ // Capture parameters
+ LastInitDto *InitDto
+ LastInitValidateDto *InitDto
+ LastValidateBatch ProofBatch
+ LastInferenceModel string
+ LastInferenceArgs []string
+ LastTrainingParams struct {
+ TaskId uint64
+ Participant string
+ NodeId string
+ MasterNodeAddr string
+ Rank int
+ WorldSize int
+ }
+ LastModelStatusCheck *Model
+ LastModelDownload *Model
+ LastModelDelete *Model
+}
+
+// NewMockClient creates a new mock client with default values
+func NewMockClient() *MockClient {
+ return &MockClient{
+ CurrentState: MlNodeState_STOPPED,
+ PowStatus: POW_STOPPED,
+ InferenceIsHealthy: false,
+ GPUDevices: []GPUDevice{},
+ CachedModels: make(map[string]ModelListItem),
+ DownloadingModels: make(map[string]*DownloadProgress),
+ }
+}
+
+func (m *MockClient) WithTryLock(t *testing.T, f func()) {
+ lock := m.Mu.TryLock()
+ if !lock {
+ t.Fatal("TryLock called more than once")
+ } else {
+ defer m.Mu.Unlock()
+ }
+
+ f()
+}
+
+func (m *MockClient) Stop(ctx context.Context) error {
+ m.Mu.Lock()
+ defer m.Mu.Unlock()
+ logging.Info("MockClient. Stop: called", types.Testing)
+ m.StopCalled++
+ if m.StopError != nil {
+ return m.StopError
+ }
+ m.CurrentState = MlNodeState_STOPPED
+ m.PowStatus = POW_STOPPED
+ m.InferenceIsHealthy = false
+ return nil
+}
+
+func (m *MockClient) NodeState(ctx context.Context) (*StateResponse, error) {
+ m.Mu.Lock()
+ defer m.Mu.Unlock()
+ m.NodeStateCalled++
+ if m.NodeStateError != nil {
+ return nil, m.NodeStateError
+ }
+ return &StateResponse{State: m.CurrentState}, nil
+}
+
+func (m *MockClient) GetPowStatus(ctx context.Context) (*PowStatusResponse, error) {
+ m.Mu.Lock()
+ defer m.Mu.Unlock()
+ m.GetPowStatusCalled++
+ if m.GetPowStatusError != nil {
+ return nil, m.GetPowStatusError
+ }
+ return &PowStatusResponse{
+ Status: m.PowStatus,
+ IsModelInitialized: m.PowStatus == POW_GENERATING,
+ }, nil
+}
+
+func (m *MockClient) InitGenerate(ctx context.Context, dto InitDto) error {
+ m.Mu.Lock()
+ defer m.Mu.Unlock()
+
+ if m.CurrentState != MlNodeState_STOPPED {
+ return errors.New("InitGenerate called with invalid state. Expected STOPPED. Actual: currentState =" + string(m.CurrentState))
+ }
+
+ logging.Info("MockClient. InitGenerate: called", types.Testing)
+ m.InitGenerateCalled++
+ m.LastInitDto = &dto
+ if m.InitGenerateError != nil {
+ return m.InitGenerateError
+ }
+ m.CurrentState = MlNodeState_POW
+ m.PowStatus = POW_GENERATING
+ return nil
+}
+
+func (m *MockClient) InitValidate(ctx context.Context, dto InitDto) error {
+ m.Mu.Lock()
+ defer m.Mu.Unlock()
+
+ if m.CurrentState != MlNodeState_POW ||
+ m.PowStatus != POW_GENERATING {
+ return errors.New("InitValidate called with invalid state. Expected MlNodeState_POW and POW_GENERATING. Actual: currentState = " + string(m.CurrentState) + ". powStatus =" + string(m.PowStatus))
+ }
+
+ logging.Info("MockClient. InitValidate: called", types.Testing)
+ m.InitValidateCalled++
+ m.LastInitValidateDto = &dto
+ if m.InitValidateError != nil {
+ return m.InitValidateError
+ }
+ m.CurrentState = MlNodeState_POW
+ m.PowStatus = POW_VALIDATING
+ return nil
+}
+
+func (m *MockClient) ValidateBatch(ctx context.Context, batch ProofBatch) error {
+ m.Mu.Lock()
+ defer m.Mu.Unlock()
+
+ if m.CurrentState != MlNodeState_POW ||
+ m.PowStatus != POW_VALIDATING {
+ return errors.New("ValidateBatch called with invalid state. Expected MlNodeState_POW and POW_VALIDATING. Actual: currentState = " + string(m.CurrentState) + ". powStatus =" + string(m.PowStatus))
+ }
+
+ m.ValidateBatchCalled++
+ m.LastValidateBatch = batch
+ if m.ValiateBatchError != nil {
+ return m.ValiateBatchError
+ }
+ m.CurrentState = MlNodeState_POW
+ m.PowStatus = POW_VALIDATING
+ return nil
+}
+
+func (m *MockClient) InferenceHealth(ctx context.Context) (bool, error) {
+ m.Mu.Lock()
+ defer m.Mu.Unlock()
+ m.InferenceHealthCalled++
+ if m.InferenceHealthError != nil {
+ return false, m.InferenceHealthError
+ }
+ return m.InferenceIsHealthy, nil
+}
+
+func (m *MockClient) InferenceUp(ctx context.Context, model string, args []string) error {
+ m.Mu.Lock()
+ defer m.Mu.Unlock()
+ m.InferenceUpCalled++
+ m.LastInferenceModel = model
+ m.LastInferenceArgs = args
+ if m.InferenceUpError != nil {
+ return m.InferenceUpError
+ }
+ m.CurrentState = MlNodeState_INFERENCE
+ m.InferenceIsHealthy = true
+ return nil
+}
+
+func (m *MockClient) StartTraining(ctx context.Context, taskId uint64, participant string, nodeId string, masterNodeAddr string, rank int, worldSize int) error {
+ m.Mu.Lock()
+ defer m.Mu.Unlock()
+ m.StartTrainingCalled++
+ m.LastTrainingParams.TaskId = taskId
+ m.LastTrainingParams.Participant = participant
+ m.LastTrainingParams.NodeId = nodeId
+ m.LastTrainingParams.MasterNodeAddr = masterNodeAddr
+ m.LastTrainingParams.Rank = rank
+ m.LastTrainingParams.WorldSize = worldSize
+ if m.StartTrainingError != nil {
+ return m.StartTrainingError
+ }
+ m.CurrentState = MlNodeState_TRAIN
+ return nil
+}
+
+func (m *MockClient) GetTrainingStatus(ctx context.Context) error {
+ m.Mu.Lock()
+ defer m.Mu.Unlock()
+ // Not implemented for now
+ return nil
+}
+
+// GPU operations
+
+func (m *MockClient) GetGPUDevices(ctx context.Context) (*GPUDevicesResponse, error) {
+ m.Mu.Lock()
+ defer m.Mu.Unlock()
+ m.GetGPUDevicesCalled++
+ if m.GetGPUDevicesError != nil {
+ return nil, m.GetGPUDevicesError
+ }
+ return &GPUDevicesResponse{
+ Devices: m.GPUDevices,
+ Count: len(m.GPUDevices),
+ }, nil
+}
+
+func (m *MockClient) GetGPUDriver(ctx context.Context) (*DriverInfo, error) {
+ m.Mu.Lock()
+ defer m.Mu.Unlock()
+ m.GetGPUDriverCalled++
+ if m.GetGPUDriverError != nil {
+ return nil, m.GetGPUDriverError
+ }
+ if m.DriverInfo == nil {
+ return &DriverInfo{
+ DriverVersion: "535.104.05",
+ CudaDriverVersion: "12.2",
+ NvmlVersion: "12.535.104",
+ }, nil
+ }
+ return m.DriverInfo, nil
+}
+
+// Model management operations
+
+func (m *MockClient) CheckModelStatus(ctx context.Context, model Model) (*ModelStatusResponse, error) {
+ m.Mu.Lock()
+ defer m.Mu.Unlock()
+ m.CheckModelStatusCalled++
+ m.LastModelStatusCheck = &model
+ if m.CheckModelStatusError != nil {
+ return nil, m.CheckModelStatusError
+ }
+
+ key := getModelKey(model)
+
+ // Check if downloading
+ if progress, ok := m.DownloadingModels[key]; ok {
+ return &ModelStatusResponse{
+ Model: model,
+ Status: ModelStatusDownloading,
+ Progress: progress,
+ }, nil
+ }
+
+ // Check if cached
+ if item, ok := m.CachedModels[key]; ok {
+ return &ModelStatusResponse{
+ Model: model,
+ Status: item.Status,
+ }, nil
+ }
+
+ // Not found
+ return &ModelStatusResponse{
+ Model: model,
+ Status: ModelStatusNotFound,
+ }, nil
+}
+
+func (m *MockClient) DownloadModel(ctx context.Context, model Model) (*DownloadStartResponse, error) {
+ m.Mu.Lock()
+ defer m.Mu.Unlock()
+ m.DownloadModelCalled++
+ m.LastModelDownload = &model
+ if m.DownloadModelError != nil {
+ return nil, m.DownloadModelError
+ }
+
+ key := getModelKey(model)
+
+ // Start download
+ m.DownloadingModels[key] = &DownloadProgress{
+ StartTime: float64(1728565234),
+ ElapsedSeconds: 0,
+ }
+
+ return &DownloadStartResponse{
+ TaskId: key,
+ Status: ModelStatusDownloading,
+ Model: model,
+ }, nil
+}
+
+func (m *MockClient) DeleteModel(ctx context.Context, model Model) (*DeleteResponse, error) {
+ m.Mu.Lock()
+ defer m.Mu.Unlock()
+ m.DeleteModelCalled++
+ m.LastModelDelete = &model
+ if m.DeleteModelError != nil {
+ return nil, m.DeleteModelError
+ }
+
+ key := getModelKey(model)
+ status := "deleted"
+
+ // Check if downloading and cancel
+ if _, ok := m.DownloadingModels[key]; ok {
+ delete(m.DownloadingModels, key)
+ status = "cancelled"
+ }
+
+ // Remove from cache
+ delete(m.CachedModels, key)
+
+ return &DeleteResponse{
+ Status: status,
+ Model: model,
+ }, nil
+}
+
+func (m *MockClient) ListModels(ctx context.Context) (*ModelListResponse, error) {
+ m.Mu.Lock()
+ defer m.Mu.Unlock()
+ m.ListModelsCalled++
+ if m.ListModelsError != nil {
+ return nil, m.ListModelsError
+ }
+
+ models := make([]ModelListItem, 0, len(m.CachedModels))
+ for _, item := range m.CachedModels {
+ models = append(models, item)
+ }
+
+ return &ModelListResponse{
+ Models: models,
+ }, nil
+}
+
+func (m *MockClient) GetDiskSpace(ctx context.Context) (*DiskSpaceInfo, error) {
+ m.Mu.Lock()
+ defer m.Mu.Unlock()
+ m.GetDiskSpaceCalled++
+ if m.GetDiskSpaceError != nil {
+ return nil, m.GetDiskSpaceError
+ }
+
+ if m.DiskSpace == nil {
+ return &DiskSpaceInfo{
+ CacheSizeGB: 13.0,
+ AvailableGB: 465.66,
+ CachePath: "/root/.cache/hub",
+ }, nil
+ }
+
+ return m.DiskSpace, nil
+}
+
+// Helper function to generate model key
+func getModelKey(model Model) string {
+ if model.HfCommit != nil && *model.HfCommit != "" {
+ return model.HfRepo + ":" + *model.HfCommit
+ }
+ return model.HfRepo + ":latest"
+}
+
+// Ensure MockClient implements MLNodeClient
+var _ MLNodeClient = (*MockClient)(nil)
diff --git a/decentralized-api/mlnodeclient/mock_test.go b/decentralized-api/mlnodeclient/mock_test.go
new file mode 100644
index 000000000..5f797f362
--- /dev/null
+++ b/decentralized-api/mlnodeclient/mock_test.go
@@ -0,0 +1,396 @@
+package mlnodeclient
+
+import (
+ "context"
+ "errors"
+ "testing"
+)
+
+func TestMockClient_GetGPUDevices(t *testing.T) {
+ ctx := context.Background()
+
+ t.Run("returns configured devices", func(t *testing.T) {
+ mock := NewMockClient()
+ mock.GPUDevices = []GPUDevice{
+ {Index: 0, Name: "NVIDIA A100", IsAvailable: true},
+ {Index: 1, Name: "NVIDIA V100", IsAvailable: true},
+ }
+
+ resp, err := mock.GetGPUDevices(ctx)
+
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if resp.Count != 2 {
+ t.Errorf("expected count 2, got %d", resp.Count)
+ }
+ if len(resp.Devices) != 2 {
+ t.Errorf("expected 2 devices, got %d", len(resp.Devices))
+ }
+ if mock.GetGPUDevicesCalled != 1 {
+ t.Errorf("expected GetGPUDevicesCalled to be 1, got %d", mock.GetGPUDevicesCalled)
+ }
+ })
+
+ t.Run("returns error when configured", func(t *testing.T) {
+ mock := NewMockClient()
+ mock.GetGPUDevicesError = errors.New("test error")
+
+ _, err := mock.GetGPUDevices(ctx)
+
+ if err == nil {
+ t.Fatal("expected error, got nil")
+ }
+ if err.Error() != "test error" {
+ t.Errorf("expected error 'test error', got %v", err)
+ }
+ })
+
+ t.Run("returns empty list by default", func(t *testing.T) {
+ mock := NewMockClient()
+
+ resp, err := mock.GetGPUDevices(ctx)
+
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if resp.Count != 0 {
+ t.Errorf("expected count 0, got %d", resp.Count)
+ }
+ })
+}
+
+func TestMockClient_GetGPUDriver(t *testing.T) {
+ ctx := context.Background()
+
+ t.Run("returns default driver info", func(t *testing.T) {
+ mock := NewMockClient()
+
+ resp, err := mock.GetGPUDriver(ctx)
+
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if resp.DriverVersion != "535.104.05" {
+ t.Errorf("expected driver version 535.104.05, got %s", resp.DriverVersion)
+ }
+ if mock.GetGPUDriverCalled != 1 {
+ t.Errorf("expected GetGPUDriverCalled to be 1, got %d", mock.GetGPUDriverCalled)
+ }
+ })
+
+ t.Run("returns configured driver info", func(t *testing.T) {
+ mock := NewMockClient()
+ mock.DriverInfo = &DriverInfo{
+ DriverVersion: "550.54.15",
+ CudaDriverVersion: "12.4",
+ NvmlVersion: "12.550.54",
+ }
+
+ resp, err := mock.GetGPUDriver(ctx)
+
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if resp.DriverVersion != "550.54.15" {
+ t.Errorf("expected driver version 550.54.15, got %s", resp.DriverVersion)
+ }
+ })
+
+ t.Run("returns error when configured", func(t *testing.T) {
+ mock := NewMockClient()
+ mock.GetGPUDriverError = errors.New("driver error")
+
+ _, err := mock.GetGPUDriver(ctx)
+
+ if err == nil {
+ t.Fatal("expected error, got nil")
+ }
+ })
+}
+
+func TestMockClient_CheckModelStatus(t *testing.T) {
+ ctx := context.Background()
+
+ t.Run("returns not found for unknown model", func(t *testing.T) {
+ mock := NewMockClient()
+ model := Model{HfRepo: "test/model", HfCommit: nil}
+
+ resp, err := mock.CheckModelStatus(ctx, model)
+
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if resp.Status != ModelStatusNotFound {
+ t.Errorf("expected status NOT_FOUND, got %s", resp.Status)
+ }
+ if mock.CheckModelStatusCalled != 1 {
+ t.Errorf("expected CheckModelStatusCalled to be 1, got %d", mock.CheckModelStatusCalled)
+ }
+ if mock.LastModelStatusCheck == nil {
+ t.Fatal("expected LastModelStatusCheck to be set")
+ }
+ if mock.LastModelStatusCheck.HfRepo != "test/model" {
+ t.Errorf("expected repo test/model, got %s", mock.LastModelStatusCheck.HfRepo)
+ }
+ })
+
+ t.Run("returns downloading status", func(t *testing.T) {
+ mock := NewMockClient()
+ model := Model{HfRepo: "test/model", HfCommit: nil}
+
+ mock.DownloadingModels["test/model:latest"] = &DownloadProgress{
+ StartTime: 1728565234.0,
+ ElapsedSeconds: 10.5,
+ }
+
+ resp, err := mock.CheckModelStatus(ctx, model)
+
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if resp.Status != ModelStatusDownloading {
+ t.Errorf("expected status DOWNLOADING, got %s", resp.Status)
+ }
+ if resp.Progress == nil {
+ t.Fatal("expected progress info")
+ }
+ })
+
+ t.Run("returns cached model status", func(t *testing.T) {
+ mock := NewMockClient()
+ model := Model{HfRepo: "test/model", HfCommit: nil}
+
+ mock.CachedModels["test/model:latest"] = ModelListItem{
+ Model: model,
+ Status: ModelStatusDownloaded,
+ }
+
+ resp, err := mock.CheckModelStatus(ctx, model)
+
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if resp.Status != ModelStatusDownloaded {
+ t.Errorf("expected status DOWNLOADED, got %s", resp.Status)
+ }
+ })
+}
+
+func TestMockClient_DownloadModel(t *testing.T) {
+ ctx := context.Background()
+
+ t.Run("starts download", func(t *testing.T) {
+ mock := NewMockClient()
+ model := Model{HfRepo: "test/model", HfCommit: nil}
+
+ resp, err := mock.DownloadModel(ctx, model)
+
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if resp.Status != ModelStatusDownloading {
+ t.Errorf("expected status DOWNLOADING, got %s", resp.Status)
+ }
+ if resp.TaskId != "test/model:latest" {
+ t.Errorf("expected task_id test/model:latest, got %s", resp.TaskId)
+ }
+ if mock.DownloadModelCalled != 1 {
+ t.Errorf("expected DownloadModelCalled to be 1, got %d", mock.DownloadModelCalled)
+ }
+ if _, exists := mock.DownloadingModels["test/model:latest"]; !exists {
+ t.Error("expected model to be added to DownloadingModels")
+ }
+ })
+
+ t.Run("handles specific commit", func(t *testing.T) {
+ mock := NewMockClient()
+ commit := "abc123"
+ model := Model{HfRepo: "test/model", HfCommit: &commit}
+
+ resp, err := mock.DownloadModel(ctx, model)
+
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if resp.TaskId != "test/model:abc123" {
+ t.Errorf("expected task_id test/model:abc123, got %s", resp.TaskId)
+ }
+ })
+
+ t.Run("returns error when configured", func(t *testing.T) {
+ mock := NewMockClient()
+ mock.DownloadModelError = errors.New("download error")
+ model := Model{HfRepo: "test/model"}
+
+ _, err := mock.DownloadModel(ctx, model)
+
+ if err == nil {
+ t.Fatal("expected error, got nil")
+ }
+ })
+}
+
+func TestMockClient_DeleteModel(t *testing.T) {
+ ctx := context.Background()
+
+ t.Run("deletes cached model", func(t *testing.T) {
+ mock := NewMockClient()
+ model := Model{HfRepo: "test/model", HfCommit: nil}
+
+ mock.CachedModels["test/model:latest"] = ModelListItem{
+ Model: model,
+ Status: ModelStatusDownloaded,
+ }
+
+ resp, err := mock.DeleteModel(ctx, model)
+
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if resp.Status != "deleted" {
+ t.Errorf("expected status deleted, got %s", resp.Status)
+ }
+ if _, exists := mock.CachedModels["test/model:latest"]; exists {
+ t.Error("expected model to be removed from cache")
+ }
+ if mock.DeleteModelCalled != 1 {
+ t.Errorf("expected DeleteModelCalled to be 1, got %d", mock.DeleteModelCalled)
+ }
+ })
+
+ t.Run("cancels downloading model", func(t *testing.T) {
+ mock := NewMockClient()
+ model := Model{HfRepo: "test/model", HfCommit: nil}
+
+ mock.DownloadingModels["test/model:latest"] = &DownloadProgress{
+ StartTime: 1728565234.0,
+ ElapsedSeconds: 10.0,
+ }
+
+ resp, err := mock.DeleteModel(ctx, model)
+
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if resp.Status != "cancelled" {
+ t.Errorf("expected status cancelled, got %s", resp.Status)
+ }
+ if _, exists := mock.DownloadingModels["test/model:latest"]; exists {
+ t.Error("expected model to be removed from downloading models")
+ }
+ })
+}
+
+func TestMockClient_ListModels(t *testing.T) {
+ ctx := context.Background()
+
+ t.Run("returns empty list by default", func(t *testing.T) {
+ mock := NewMockClient()
+
+ resp, err := mock.ListModels(ctx)
+
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if len(resp.Models) != 0 {
+ t.Errorf("expected 0 models, got %d", len(resp.Models))
+ }
+ if mock.ListModelsCalled != 1 {
+ t.Errorf("expected ListModelsCalled to be 1, got %d", mock.ListModelsCalled)
+ }
+ })
+
+ t.Run("returns cached models", func(t *testing.T) {
+ mock := NewMockClient()
+ model1 := Model{HfRepo: "test/model1", HfCommit: nil}
+ model2 := Model{HfRepo: "test/model2", HfCommit: nil}
+
+ mock.CachedModels["test/model1:latest"] = ModelListItem{
+ Model: model1,
+ Status: ModelStatusDownloaded,
+ }
+ mock.CachedModels["test/model2:latest"] = ModelListItem{
+ Model: model2,
+ Status: ModelStatusPartial,
+ }
+
+ resp, err := mock.ListModels(ctx)
+
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if len(resp.Models) != 2 {
+ t.Errorf("expected 2 models, got %d", len(resp.Models))
+ }
+ })
+}
+
+func TestMockClient_GetDiskSpace(t *testing.T) {
+ ctx := context.Background()
+
+ t.Run("returns default disk space", func(t *testing.T) {
+ mock := NewMockClient()
+
+ resp, err := mock.GetDiskSpace(ctx)
+
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if resp.CacheSizeGB != 13.0 {
+ t.Errorf("expected cache size 13.0, got %f", resp.CacheSizeGB)
+ }
+ if resp.AvailableGB != 465.66 {
+ t.Errorf("expected available 465.66, got %f", resp.AvailableGB)
+ }
+ if mock.GetDiskSpaceCalled != 1 {
+ t.Errorf("expected GetDiskSpaceCalled to be 1, got %d", mock.GetDiskSpaceCalled)
+ }
+ })
+
+ t.Run("returns configured disk space", func(t *testing.T) {
+ mock := NewMockClient()
+ mock.DiskSpace = &DiskSpaceInfo{
+ CacheSizeGB: 50.0,
+ AvailableGB: 100.0,
+ CachePath: "/custom/path",
+ }
+
+ resp, err := mock.GetDiskSpace(ctx)
+
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if resp.CacheSizeGB != 50.0 {
+ t.Errorf("expected cache size 50.0, got %f", resp.CacheSizeGB)
+ }
+ })
+}
+
+func TestGetModelKey(t *testing.T) {
+ t.Run("without commit", func(t *testing.T) {
+ model := Model{HfRepo: "test/model", HfCommit: nil}
+ key := getModelKey(model)
+ if key != "test/model:latest" {
+ t.Errorf("expected key test/model:latest, got %s", key)
+ }
+ })
+
+ t.Run("with commit", func(t *testing.T) {
+ commit := "abc123"
+ model := Model{HfRepo: "test/model", HfCommit: &commit}
+ key := getModelKey(model)
+ if key != "test/model:abc123" {
+ t.Errorf("expected key test/model:abc123, got %s", key)
+ }
+ })
+
+ t.Run("with empty commit string", func(t *testing.T) {
+ commit := ""
+ model := Model{HfRepo: "test/model", HfCommit: &commit}
+ key := getModelKey(model)
+ if key != "test/model:latest" {
+ t.Errorf("expected key test/model:latest, got %s", key)
+ }
+ })
+}
diff --git a/decentralized-api/mlnodeclient/models.go b/decentralized-api/mlnodeclient/models.go
new file mode 100644
index 000000000..f5b53fda4
--- /dev/null
+++ b/decentralized-api/mlnodeclient/models.go
@@ -0,0 +1,186 @@
+package mlnodeclient
+
+import (
+ "context"
+ "encoding/json"
+ "fmt"
+ "net/http"
+ "net/url"
+
+ "decentralized-api/utils"
+)
+
+const (
+ modelStatusPath = "/api/v1/models/status"
+ modelDownloadPath = "/api/v1/models/download"
+ modelDeletePath = "/api/v1/models"
+ modelListPath = "/api/v1/models/list"
+ modelSpacePath = "/api/v1/models/space"
+)
+
+// CheckModelStatus checks if a model exists in cache with verification.
+// Returns the current status of the model: DOWNLOADED, DOWNLOADING, NOT_FOUND, or PARTIAL.
+// Returns ErrAPINotImplemented if the ML node doesn't support this endpoint.
+func (api *Client) CheckModelStatus(ctx context.Context, model Model) (*ModelStatusResponse, error) {
+ requestURL, err := url.JoinPath(api.pocUrl, modelStatusPath)
+ if err != nil {
+ return nil, err
+ }
+
+ resp, err := utils.SendPostJsonRequest(ctx, &api.client, requestURL, model)
+ if err != nil {
+ return nil, err
+ }
+ defer resp.Body.Close()
+
+ if resp.StatusCode == http.StatusNotFound || resp.StatusCode == http.StatusMethodNotAllowed {
+ return nil, NewAPINotImplementedError(modelStatusPath, resp.StatusCode)
+ }
+
+ if resp.StatusCode != http.StatusOK {
+ return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
+ }
+
+ var statusResp ModelStatusResponse
+ if err := json.NewDecoder(resp.Body).Decode(&statusResp); err != nil {
+ return nil, err
+ }
+
+ return &statusResp, nil
+}
+
+// DownloadModel starts downloading a model asynchronously.
+// The download runs in the background and can be tracked using CheckModelStatus.
+// Returns 409 Conflict if model is already downloading.
+// Returns 429 Too Many Requests if concurrent download limit (3) is reached.
+// Returns ErrAPINotImplemented if the ML node doesn't support this endpoint.
+func (api *Client) DownloadModel(ctx context.Context, model Model) (*DownloadStartResponse, error) {
+ requestURL, err := url.JoinPath(api.pocUrl, modelDownloadPath)
+ if err != nil {
+ return nil, err
+ }
+
+ resp, err := utils.SendPostJsonRequest(ctx, &api.client, requestURL, model)
+ if err != nil {
+ return nil, err
+ }
+ defer resp.Body.Close()
+
+ if resp.StatusCode == http.StatusNotFound || resp.StatusCode == http.StatusMethodNotAllowed {
+ return nil, NewAPINotImplementedError(modelDownloadPath, resp.StatusCode)
+ }
+
+ if resp.StatusCode == http.StatusConflict {
+ return nil, fmt.Errorf("model is already downloading")
+ }
+
+ if resp.StatusCode == http.StatusTooManyRequests {
+ return nil, fmt.Errorf("maximum concurrent downloads reached")
+ }
+
+ if resp.StatusCode != http.StatusAccepted && resp.StatusCode != http.StatusOK {
+ return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
+ }
+
+ var downloadResp DownloadStartResponse
+ if err := json.NewDecoder(resp.Body).Decode(&downloadResp); err != nil {
+ return nil, err
+ }
+
+ return &downloadResp, nil
+}
+
+// DeleteModel deletes a model from cache or cancels an ongoing download.
+// If hf_commit is provided, only that specific revision is deleted.
+// If hf_commit is nil, all versions of the model are deleted.
+// Returns 404 if model is not found.
+// Returns ErrAPINotImplemented if the ML node doesn't support this endpoint.
+func (api *Client) DeleteModel(ctx context.Context, model Model) (*DeleteResponse, error) {
+ requestURL, err := url.JoinPath(api.pocUrl, modelDeletePath)
+ if err != nil {
+ return nil, err
+ }
+
+ resp, err := utils.SendDeleteJsonRequest(ctx, &api.client, requestURL, model)
+ if err != nil {
+ return nil, err
+ }
+ defer resp.Body.Close()
+
+ if resp.StatusCode == http.StatusNotFound || resp.StatusCode == http.StatusMethodNotAllowed {
+ return nil, NewAPINotImplementedError(modelDeletePath, resp.StatusCode)
+ }
+
+ if resp.StatusCode != http.StatusOK {
+ return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
+ }
+
+ var deleteResp DeleteResponse
+ if err := json.NewDecoder(resp.Body).Decode(&deleteResp); err != nil {
+ return nil, err
+ }
+
+ return &deleteResp, nil
+}
+
+// ListModels lists all models currently in the HuggingFace cache.
+// Returns all model revisions found in the cache directory with their status.
+// Returns ErrAPINotImplemented if the ML node doesn't support this endpoint.
+func (api *Client) ListModels(ctx context.Context) (*ModelListResponse, error) {
+ requestURL, err := url.JoinPath(api.pocUrl, modelListPath)
+ if err != nil {
+ return nil, err
+ }
+
+ resp, err := utils.SendGetRequest(ctx, &api.client, requestURL)
+ if err != nil {
+ return nil, err
+ }
+ defer resp.Body.Close()
+
+ if resp.StatusCode == http.StatusNotFound || resp.StatusCode == http.StatusMethodNotAllowed {
+ return nil, NewAPINotImplementedError(modelListPath, resp.StatusCode)
+ }
+
+ if resp.StatusCode != http.StatusOK {
+ return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
+ }
+
+ var listResp ModelListResponse
+ if err := json.NewDecoder(resp.Body).Decode(&listResp); err != nil {
+ return nil, err
+ }
+
+ return &listResp, nil
+}
+
+// GetDiskSpace retrieves information about disk space usage and availability.
+// Returns cache size, available disk space, and cache directory path.
+// Returns ErrAPINotImplemented if the ML node doesn't support this endpoint.
+func (api *Client) GetDiskSpace(ctx context.Context) (*DiskSpaceInfo, error) {
+ requestURL, err := url.JoinPath(api.pocUrl, modelSpacePath)
+ if err != nil {
+ return nil, err
+ }
+
+ resp, err := utils.SendGetRequest(ctx, &api.client, requestURL)
+ if err != nil {
+ return nil, err
+ }
+ defer resp.Body.Close()
+
+ if resp.StatusCode == http.StatusNotFound || resp.StatusCode == http.StatusMethodNotAllowed {
+ return nil, NewAPINotImplementedError(modelSpacePath, resp.StatusCode)
+ }
+
+ if resp.StatusCode != http.StatusOK {
+ return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
+ }
+
+ var spaceInfo DiskSpaceInfo
+ if err := json.NewDecoder(resp.Body).Decode(&spaceInfo); err != nil {
+ return nil, err
+ }
+
+ return &spaceInfo, nil
+}
diff --git a/decentralized-api/mlnodeclient/models_test.go b/decentralized-api/mlnodeclient/models_test.go
new file mode 100644
index 000000000..2a0f719e9
--- /dev/null
+++ b/decentralized-api/mlnodeclient/models_test.go
@@ -0,0 +1,480 @@
+package mlnodeclient
+
+import (
+ "context"
+ "encoding/json"
+ "io"
+ "net/http"
+ "net/http/httptest"
+ "testing"
+)
+
+func TestClient_CheckModelStatus(t *testing.T) {
+ ctx := context.Background()
+
+ t.Run("model downloaded", func(t *testing.T) {
+ model := Model{
+ HfRepo: "meta-llama/Llama-2-7b-hf",
+ HfCommit: nil,
+ }
+
+ expectedResp := &ModelStatusResponse{
+ Model: model,
+ Status: ModelStatusDownloaded,
+ }
+
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ if r.URL.Path != "/api/v1/models/status" {
+ t.Errorf("expected path /api/v1/models/status, got %s", r.URL.Path)
+ }
+ if r.Method != http.MethodPost {
+ t.Errorf("expected POST method, got %s", r.Method)
+ }
+
+ // Verify request body
+ body, _ := io.ReadAll(r.Body)
+ var reqModel Model
+ json.Unmarshal(body, &reqModel)
+ if reqModel.HfRepo != model.HfRepo {
+ t.Errorf("expected repo %s, got %s", model.HfRepo, reqModel.HfRepo)
+ }
+
+ w.WriteHeader(http.StatusOK)
+ json.NewEncoder(w).Encode(expectedResp)
+ }))
+ defer server.Close()
+
+ client := NewNodeClient(server.URL, "")
+ resp, err := client.CheckModelStatus(ctx, model)
+
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if resp.Status != ModelStatusDownloaded {
+ t.Errorf("expected status DOWNLOADED, got %s", resp.Status)
+ }
+ })
+
+ t.Run("model downloading with progress", func(t *testing.T) {
+ model := Model{
+ HfRepo: "meta-llama/Llama-2-7b-hf",
+ HfCommit: nil,
+ }
+
+ expectedResp := &ModelStatusResponse{
+ Model: model,
+ Status: ModelStatusDownloading,
+ Progress: &DownloadProgress{
+ StartTime: 1728565234.123,
+ ElapsedSeconds: 125.5,
+ },
+ }
+
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ w.WriteHeader(http.StatusOK)
+ json.NewEncoder(w).Encode(expectedResp)
+ }))
+ defer server.Close()
+
+ client := NewNodeClient(server.URL, "")
+ resp, err := client.CheckModelStatus(ctx, model)
+
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if resp.Status != ModelStatusDownloading {
+ t.Errorf("expected status DOWNLOADING, got %s", resp.Status)
+ }
+ if resp.Progress == nil {
+ t.Fatal("expected progress info, got nil")
+ }
+ if resp.Progress.ElapsedSeconds != 125.5 {
+ t.Errorf("expected elapsed 125.5, got %f", resp.Progress.ElapsedSeconds)
+ }
+ })
+
+ t.Run("model not found", func(t *testing.T) {
+ model := Model{
+ HfRepo: "unknown/model",
+ HfCommit: nil,
+ }
+
+ expectedResp := &ModelStatusResponse{
+ Model: model,
+ Status: ModelStatusNotFound,
+ }
+
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ w.WriteHeader(http.StatusOK)
+ json.NewEncoder(w).Encode(expectedResp)
+ }))
+ defer server.Close()
+
+ client := NewNodeClient(server.URL, "")
+ resp, err := client.CheckModelStatus(ctx, model)
+
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if resp.Status != ModelStatusNotFound {
+ t.Errorf("expected status NOT_FOUND, got %s", resp.Status)
+ }
+ })
+
+ t.Run("API not implemented", func(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ w.WriteHeader(http.StatusNotFound)
+ }))
+ defer server.Close()
+
+ client := NewNodeClient(server.URL, "")
+ model := Model{HfRepo: "test/model"}
+ _, err := client.CheckModelStatus(ctx, model)
+
+ if err == nil {
+ t.Fatal("expected error, got nil")
+ }
+ if !isErrAPINotImplemented(err) {
+ t.Errorf("expected ErrAPINotImplemented, got %T", err)
+ }
+ })
+}
+
+func TestClient_DownloadModel(t *testing.T) {
+ ctx := context.Background()
+
+ t.Run("successful download start", func(t *testing.T) {
+ model := Model{
+ HfRepo: "meta-llama/Llama-2-7b-hf",
+ HfCommit: nil,
+ }
+
+ expectedResp := &DownloadStartResponse{
+ TaskId: "meta-llama/Llama-2-7b-hf:latest",
+ Status: ModelStatusDownloading,
+ Model: model,
+ }
+
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ if r.URL.Path != "/api/v1/models/download" {
+ t.Errorf("expected path /api/v1/models/download, got %s", r.URL.Path)
+ }
+ if r.Method != http.MethodPost {
+ t.Errorf("expected POST method, got %s", r.Method)
+ }
+
+ w.WriteHeader(http.StatusAccepted)
+ json.NewEncoder(w).Encode(expectedResp)
+ }))
+ defer server.Close()
+
+ client := NewNodeClient(server.URL, "")
+ resp, err := client.DownloadModel(ctx, model)
+
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if resp.Status != ModelStatusDownloading {
+ t.Errorf("expected status DOWNLOADING, got %s", resp.Status)
+ }
+ if resp.TaskId != "meta-llama/Llama-2-7b-hf:latest" {
+ t.Errorf("expected task_id meta-llama/Llama-2-7b-hf:latest, got %s", resp.TaskId)
+ }
+ })
+
+ t.Run("already downloading - conflict", func(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ w.WriteHeader(http.StatusConflict)
+ }))
+ defer server.Close()
+
+ client := NewNodeClient(server.URL, "")
+ model := Model{HfRepo: "test/model"}
+ _, err := client.DownloadModel(ctx, model)
+
+ if err == nil {
+ t.Fatal("expected error, got nil")
+ }
+ if err.Error() != "model is already downloading" {
+ t.Errorf("unexpected error message: %v", err)
+ }
+ })
+
+ t.Run("too many requests", func(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ w.WriteHeader(http.StatusTooManyRequests)
+ }))
+ defer server.Close()
+
+ client := NewNodeClient(server.URL, "")
+ model := Model{HfRepo: "test/model"}
+ _, err := client.DownloadModel(ctx, model)
+
+ if err == nil {
+ t.Fatal("expected error, got nil")
+ }
+ if err.Error() != "maximum concurrent downloads reached" {
+ t.Errorf("unexpected error message: %v", err)
+ }
+ })
+
+ t.Run("API not implemented", func(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ w.WriteHeader(http.StatusNotFound)
+ }))
+ defer server.Close()
+
+ client := NewNodeClient(server.URL, "")
+ model := Model{HfRepo: "test/model"}
+ _, err := client.DownloadModel(ctx, model)
+
+ if err == nil {
+ t.Fatal("expected error, got nil")
+ }
+ if !isErrAPINotImplemented(err) {
+ t.Errorf("expected ErrAPINotImplemented, got %T", err)
+ }
+ })
+}
+
+func TestClient_DeleteModel(t *testing.T) {
+ ctx := context.Background()
+
+ t.Run("successful deletion", func(t *testing.T) {
+ model := Model{
+ HfRepo: "meta-llama/Llama-2-7b-hf",
+ HfCommit: nil,
+ }
+
+ expectedResp := &DeleteResponse{
+ Status: "deleted",
+ Model: model,
+ }
+
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ if r.URL.Path != "/api/v1/models" {
+ t.Errorf("expected path /api/v1/models, got %s", r.URL.Path)
+ }
+ if r.Method != http.MethodDelete {
+ t.Errorf("expected DELETE method, got %s", r.Method)
+ }
+
+ // Verify request body
+ body, _ := io.ReadAll(r.Body)
+ var reqModel Model
+ json.Unmarshal(body, &reqModel)
+ if reqModel.HfRepo != model.HfRepo {
+ t.Errorf("expected repo %s, got %s", model.HfRepo, reqModel.HfRepo)
+ }
+
+ w.WriteHeader(http.StatusOK)
+ json.NewEncoder(w).Encode(expectedResp)
+ }))
+ defer server.Close()
+
+ client := NewNodeClient(server.URL, "")
+ resp, err := client.DeleteModel(ctx, model)
+
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if resp.Status != "deleted" {
+ t.Errorf("expected status deleted, got %s", resp.Status)
+ }
+ })
+
+ t.Run("cancelled download", func(t *testing.T) {
+ model := Model{
+ HfRepo: "meta-llama/Llama-2-7b-hf",
+ HfCommit: nil,
+ }
+
+ expectedResp := &DeleteResponse{
+ Status: "cancelled",
+ Model: model,
+ }
+
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ w.WriteHeader(http.StatusOK)
+ json.NewEncoder(w).Encode(expectedResp)
+ }))
+ defer server.Close()
+
+ client := NewNodeClient(server.URL, "")
+ resp, err := client.DeleteModel(ctx, model)
+
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if resp.Status != "cancelled" {
+ t.Errorf("expected status cancelled, got %s", resp.Status)
+ }
+ })
+
+ t.Run("API not implemented", func(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ w.WriteHeader(http.StatusNotFound)
+ }))
+ defer server.Close()
+
+ client := NewNodeClient(server.URL, "")
+ model := Model{HfRepo: "test/model"}
+ _, err := client.DeleteModel(ctx, model)
+
+ if err == nil {
+ t.Fatal("expected error, got nil")
+ }
+ if !isErrAPINotImplemented(err) {
+ t.Errorf("expected ErrAPINotImplemented, got %T", err)
+ }
+ })
+}
+
+func TestClient_ListModels(t *testing.T) {
+ ctx := context.Background()
+
+ t.Run("successful list with models", func(t *testing.T) {
+ commit1 := "abc123"
+ expectedResp := &ModelListResponse{
+ Models: []ModelListItem{
+ {
+ Model: Model{
+ HfRepo: "meta-llama/Llama-2-7b-hf",
+ HfCommit: &commit1,
+ },
+ Status: ModelStatusDownloaded,
+ },
+ {
+ Model: Model{
+ HfRepo: "microsoft/phi-2",
+ HfCommit: nil,
+ },
+ Status: ModelStatusPartial,
+ },
+ },
+ }
+
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ if r.URL.Path != "/api/v1/models/list" {
+ t.Errorf("expected path /api/v1/models/list, got %s", r.URL.Path)
+ }
+ if r.Method != http.MethodGet {
+ t.Errorf("expected GET method, got %s", r.Method)
+ }
+
+ w.WriteHeader(http.StatusOK)
+ json.NewEncoder(w).Encode(expectedResp)
+ }))
+ defer server.Close()
+
+ client := NewNodeClient(server.URL, "")
+ resp, err := client.ListModels(ctx)
+
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if len(resp.Models) != 2 {
+ t.Errorf("expected 2 models, got %d", len(resp.Models))
+ }
+ if resp.Models[0].Status != ModelStatusDownloaded {
+ t.Errorf("expected first model status DOWNLOADED, got %s", resp.Models[0].Status)
+ }
+ })
+
+ t.Run("empty list", func(t *testing.T) {
+ expectedResp := &ModelListResponse{
+ Models: []ModelListItem{},
+ }
+
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ w.WriteHeader(http.StatusOK)
+ json.NewEncoder(w).Encode(expectedResp)
+ }))
+ defer server.Close()
+
+ client := NewNodeClient(server.URL, "")
+ resp, err := client.ListModels(ctx)
+
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if len(resp.Models) != 0 {
+ t.Errorf("expected 0 models, got %d", len(resp.Models))
+ }
+ })
+
+ t.Run("API not implemented", func(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ w.WriteHeader(http.StatusNotFound)
+ }))
+ defer server.Close()
+
+ client := NewNodeClient(server.URL, "")
+ _, err := client.ListModels(ctx)
+
+ if err == nil {
+ t.Fatal("expected error, got nil")
+ }
+ if !isErrAPINotImplemented(err) {
+ t.Errorf("expected ErrAPINotImplemented, got %T", err)
+ }
+ })
+}
+
+func TestClient_GetDiskSpace(t *testing.T) {
+ ctx := context.Background()
+
+ t.Run("successful response", func(t *testing.T) {
+ expectedResp := &DiskSpaceInfo{
+ CacheSizeGB: 13.0,
+ AvailableGB: 465.66,
+ CachePath: "/root/.cache/hub",
+ }
+
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ if r.URL.Path != "/api/v1/models/space" {
+ t.Errorf("expected path /api/v1/models/space, got %s", r.URL.Path)
+ }
+ if r.Method != http.MethodGet {
+ t.Errorf("expected GET method, got %s", r.Method)
+ }
+
+ w.WriteHeader(http.StatusOK)
+ json.NewEncoder(w).Encode(expectedResp)
+ }))
+ defer server.Close()
+
+ client := NewNodeClient(server.URL, "")
+ resp, err := client.GetDiskSpace(ctx)
+
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if resp.CacheSizeGB != 13.0 {
+ t.Errorf("expected cache size 13.0, got %f", resp.CacheSizeGB)
+ }
+ if resp.AvailableGB != 465.66 {
+ t.Errorf("expected available 465.66, got %f", resp.AvailableGB)
+ }
+ if resp.CachePath != "/root/.cache/hub" {
+ t.Errorf("expected cache path /root/.cache/hub, got %s", resp.CachePath)
+ }
+ })
+
+ t.Run("API not implemented", func(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ w.WriteHeader(http.StatusNotFound)
+ }))
+ defer server.Close()
+
+ client := NewNodeClient(server.URL, "")
+ _, err := client.GetDiskSpace(ctx)
+
+ if err == nil {
+ t.Fatal("expected error, got nil")
+ }
+ if !isErrAPINotImplemented(err) {
+ t.Errorf("expected ErrAPINotImplemented, got %T", err)
+ }
+ })
+}
diff --git a/decentralized-api/mlnodeclient/poc.go b/decentralized-api/mlnodeclient/poc.go
new file mode 100644
index 000000000..a53242f00
--- /dev/null
+++ b/decentralized-api/mlnodeclient/poc.go
@@ -0,0 +1,253 @@
+package mlnodeclient
+
+import (
+ "context"
+ "crypto/sha256"
+ "decentralized-api/utils"
+ "encoding/binary"
+ "fmt"
+ "math/rand"
+ "net/url"
+
+ "github.com/productscience/inference/testenv"
+)
+
+const (
+ InitGeneratePath = "/api/v1/pow/init/generate"
+ InitValidatePath = "/api/v1/pow/init/validate"
+ ValidateBatchPath = "/api/v1/pow/validate"
+
+ DefaultRTarget = 1.4013564660458173
+ DefaultBatchSize = 100
+ DefaultFraudThreshold = 1e-7
+)
+
+type InitDto struct {
+ BlockHash string `json:"block_hash"`
+ BlockHeight int64 `json:"block_height"`
+ PublicKey string `json:"public_key"`
+ BatchSize int `json:"batch_size"`
+ RTarget float64 `json:"r_target"`
+ FraudThreshold float64 `json:"fraud_threshold"`
+ Params *Params `json:"params"`
+ NodeNum uint64 `json:"node_id"`
+ TotalNodes int64 `json:"node_count"`
+ URL string `json:"url"`
+}
+
+func getNetworkParams() *Params {
+ if testenv.IsTestNet() {
+ return &TestNetParams
+ }
+ return &MainNetParams
+}
+
+func BuildInitDto(blockHeight int64, pubKey string, totalNodes int64, nodeNum uint64, blockHash, callbackUrl string) InitDto {
+ return InitDto{
+ BlockHeight: blockHeight,
+ BlockHash: blockHash,
+ PublicKey: pubKey,
+ BatchSize: DefaultBatchSize,
+ RTarget: DefaultRTarget,
+ FraudThreshold: DefaultFraudThreshold,
+ Params: getNetworkParams(),
+ URL: callbackUrl,
+ TotalNodes: totalNodes,
+ NodeNum: nodeNum,
+ }
+}
+
+type Params struct {
+ Dim int `json:"dim"`
+ NLayers int `json:"n_layers"`
+ NHeads int `json:"n_heads"`
+ NKVHeads int `json:"n_kv_heads"`
+ VocabSize int `json:"vocab_size"`
+ FFNDimMultiplier float64 `json:"ffn_dim_multiplier"`
+ MultipleOf int `json:"multiple_of"`
+ NormEps float64 `json:"norm_eps"`
+ RopeTheta int `json:"rope_theta"`
+ UseScaledRope bool `json:"use_scaled_rope"`
+ SeqLen int `json:"seq_len"`
+}
+
+var DefaultParams = Params{
+ Dim: 512,
+ NLayers: 64,
+ NHeads: 128,
+ NKVHeads: 128,
+ VocabSize: 8192,
+ FFNDimMultiplier: 16.0,
+ MultipleOf: 1024,
+ NormEps: 1e-05,
+ RopeTheta: 500000.0,
+ UseScaledRope: true,
+ SeqLen: 4,
+}
+
+var DevTestParams = Params{
+ Dim: 512,
+ NLayers: 16,
+ NHeads: 16,
+ NKVHeads: 16,
+ VocabSize: 8192,
+ FFNDimMultiplier: 1.3,
+ MultipleOf: 1024,
+ NormEps: 1e-05,
+ RopeTheta: 500000.0,
+ UseScaledRope: true,
+ SeqLen: 4,
+}
+
+var TestNetParams = Params{
+ Dim: 1024,
+ NLayers: 32,
+ NHeads: 32,
+ NKVHeads: 32,
+ VocabSize: 8196,
+ FFNDimMultiplier: 10.0,
+ MultipleOf: 2048, // 8*256
+ NormEps: 1e-5,
+ RopeTheta: 10000.0,
+ UseScaledRope: false,
+ SeqLen: 128,
+}
+
+var MainNetParams = Params{
+ Dim: 1792,
+ NLayers: 64,
+ NHeads: 64,
+ NKVHeads: 64,
+ VocabSize: 8196,
+ FFNDimMultiplier: 10.0,
+ MultipleOf: 4 * 2048,
+ NormEps: 1e-5,
+ RopeTheta: 10000.0,
+ UseScaledRope: false,
+ SeqLen: 256,
+}
+
+type ProofBatch struct {
+ PublicKey string `json:"public_key"`
+ BlockHash string `json:"block_hash"`
+ BlockHeight int64 `json:"block_height"`
+ Nonces []int64 `json:"nonces"`
+ Dist []float64 `json:"dist"`
+ NodeNum uint64 `json:"node_id"`
+}
+
+type ValidatedBatch struct {
+ ProofBatch // Inherits from ProofBatch
+
+ // New fields
+ ReceivedDist []float64 `json:"received_dist"`
+ RTarget float64 `json:"r_target"`
+ FraudThreshold float64 `json:"fraud_threshold"`
+ NInvalid int64 `json:"n_invalid"`
+ ProbabilityHonest float64 `json:"probability_honest"`
+ FraudDetected bool `json:"fraud_detected"`
+}
+
+// This sample doesn't have to be cryptographically secure as it's only used for sampling nonces to validate.
+// If it can't be reproduced on another machine, it's also not causing any harm as it's not validated on-chain.
+func (pb ProofBatch) SampleNoncesToValidate(
+ validatorPublicKey string,
+ nNonces int64,
+) ProofBatch {
+ totalNonces := int64(len(pb.Nonces))
+ if nNonces >= totalNonces {
+ return pb
+ }
+
+ nonceIndexes := deterministicSampleIndices(
+ validatorPublicKey,
+ pb.BlockHash,
+ pb.BlockHeight,
+ nNonces,
+ totalNonces,
+ )
+
+ sampledNonces := make([]int64, nNonces)
+ sampledDist := make([]float64, nNonces)
+
+ for i, idx := range nonceIndexes {
+ sampledNonces[i] = pb.Nonces[idx]
+ sampledDist[i] = pb.Dist[idx]
+ }
+
+ return ProofBatch{
+ PublicKey: pb.PublicKey,
+ BlockHash: pb.BlockHash,
+ BlockHeight: pb.BlockHeight,
+ Nonces: sampledNonces,
+ Dist: sampledDist,
+ }
+}
+
+func deterministicSampleIndices(
+ validatorPublicKey string,
+ blockHash string,
+ blockHeight int64,
+ nSamples int64,
+ totalItems int64,
+) []int {
+ if nSamples >= totalItems {
+ indices := make([]int, totalItems)
+ for i := int64(0); i < totalItems; i++ {
+ indices[i] = int(i)
+ }
+ return indices
+ }
+
+ seedInput := fmt.Sprintf("%s:%s:%d", validatorPublicKey, blockHash, blockHeight)
+ hash := sha256.Sum256([]byte(seedInput))
+ seed := int64(binary.BigEndian.Uint64(hash[:8]))
+
+ source := rand.NewSource(seed)
+ rng := rand.New(source)
+ indices := rng.Perm(int(totalItems))[:nSamples]
+
+ return indices
+}
+
+func (api *Client) InitGenerate(context context.Context, dto InitDto) error {
+ requestUrl, err := url.JoinPath(api.pocUrl, InitGeneratePath)
+ if err != nil {
+ return err
+ }
+
+ _, err = utils.SendPostJsonRequest(context, &api.client, requestUrl, dto)
+ if err != nil {
+ return err
+ }
+
+ return nil
+}
+
+func (api *Client) InitValidate(context context.Context, dto InitDto) error {
+ requestUrl, err := url.JoinPath(api.pocUrl, InitValidatePath)
+ if err != nil {
+ return err
+ }
+
+ _, err = utils.SendPostJsonRequest(context, &api.client, requestUrl, dto)
+ if err != nil {
+ return err
+ }
+
+ return nil
+}
+
+func (api *Client) ValidateBatch(context context.Context, batch ProofBatch) error {
+ requestUrl, err := url.JoinPath(api.pocUrl, ValidateBatchPath)
+ if err != nil {
+ return err
+ }
+
+ _, err = utils.SendPostJsonRequest(context, &api.client, requestUrl, batch)
+ if err != nil {
+ return err
+ }
+
+ return nil
+}
diff --git a/decentralized-api/mlnodeclient/types.go b/decentralized-api/mlnodeclient/types.go
new file mode 100644
index 000000000..09e31a6ac
--- /dev/null
+++ b/decentralized-api/mlnodeclient/types.go
@@ -0,0 +1,80 @@
+package mlnodeclient
+
+// GPU-related types
+
+type GPUDevice struct {
+ Index int `json:"index"`
+ Name string `json:"name"`
+ TotalMemoryMB *int `json:"total_memory_mb"`
+ FreeMemoryMB *int `json:"free_memory_mb"`
+ UsedMemoryMB *int `json:"used_memory_mb"`
+ UtilizationPercent *int `json:"utilization_percent"`
+ TemperatureC *int `json:"temperature_c"`
+ IsAvailable bool `json:"is_available"`
+ ErrorMessage *string `json:"error_message"`
+}
+
+type GPUDevicesResponse struct {
+ Devices []GPUDevice `json:"devices"`
+ Count int `json:"count"`
+}
+
+type DriverInfo struct {
+ DriverVersion string `json:"driver_version"`
+ CudaDriverVersion string `json:"cuda_driver_version"`
+ NvmlVersion string `json:"nvml_version"`
+}
+
+// Model management types
+
+type Model struct {
+ HfRepo string `json:"hf_repo"`
+ HfCommit *string `json:"hf_commit"`
+}
+
+type ModelStatus string
+
+const (
+ ModelStatusDownloaded ModelStatus = "DOWNLOADED"
+ ModelStatusDownloading ModelStatus = "DOWNLOADING"
+ ModelStatusNotFound ModelStatus = "NOT_FOUND"
+ ModelStatusPartial ModelStatus = "PARTIAL"
+)
+
+type DownloadProgress struct {
+ StartTime float64 `json:"start_time"`
+ ElapsedSeconds float64 `json:"elapsed_seconds"`
+}
+
+type ModelStatusResponse struct {
+ Model Model `json:"model"`
+ Status ModelStatus `json:"status"`
+ Progress *DownloadProgress `json:"progress"`
+ ErrorMessage *string `json:"error_message"`
+}
+
+type DownloadStartResponse struct {
+ TaskId string `json:"task_id"`
+ Status ModelStatus `json:"status"`
+ Model Model `json:"model"`
+}
+
+type DeleteResponse struct {
+ Status string `json:"status"`
+ Model Model `json:"model"`
+}
+
+type ModelListItem struct {
+ Model Model `json:"model"`
+ Status ModelStatus `json:"status"`
+}
+
+type ModelListResponse struct {
+ Models []ModelListItem `json:"models"`
+}
+
+type DiskSpaceInfo struct {
+ CacheSizeGB float64 `json:"cache_size_gb"`
+ AvailableGB float64 `json:"available_gb"`
+ CachePath string `json:"cache_path"`
+}
diff --git a/decentralized-api/participant/info_provider.go b/decentralized-api/participant/info_provider.go
new file mode 100644
index 000000000..a4aaa5c76
--- /dev/null
+++ b/decentralized-api/participant/info_provider.go
@@ -0,0 +1,34 @@
+package participant
+
+import (
+ "decentralized-api/cosmosclient"
+
+ "github.com/productscience/inference/x/inference/utils"
+)
+
+type CurrenParticipantInfo interface {
+ GetAddress() string
+ GetPubKey() string
+}
+
+type CosmosInfo struct {
+ Address string
+ PubKey string
+}
+
+func NewCurrentParticipantInfo(client cosmosclient.CosmosMessageClient) (*CosmosInfo, error) {
+ address := client.GetAccountAddress()
+
+ pubKey := client.GetAccountPubKey()
+ pubkeyString := utils.PubKeyToHexString(pubKey)
+
+ return &CosmosInfo{Address: address, PubKey: pubkeyString}, nil
+}
+
+func (c CosmosInfo) GetAddress() string {
+ return c.Address
+}
+
+func (c CosmosInfo) GetPubKey() string {
+ return c.PubKey
+}
diff --git a/decentralized-api/participant/participant_registration.go b/decentralized-api/participant/participant_registration.go
new file mode 100644
index 000000000..05b9d2e4d
--- /dev/null
+++ b/decentralized-api/participant/participant_registration.go
@@ -0,0 +1,202 @@
+package participant
+
+import (
+ "bytes"
+ "context"
+ "decentralized-api/apiconfig"
+ "decentralized-api/cosmosclient"
+ "decentralized-api/internal/server/public_entities"
+ "decentralized-api/logging"
+ "encoding/base64"
+ "encoding/json"
+ "fmt"
+ "net/http"
+ "net/url"
+ "os"
+ "strings"
+ "time"
+
+ "github.com/cometbft/cometbft/crypto"
+ rpcclient "github.com/cometbft/cometbft/rpc/client/http"
+ "github.com/productscience/inference/x/inference/types"
+)
+
+func participantExistsWithWait(recorder cosmosclient.CosmosMessageClient, chainNodeUrl string) (bool, error) {
+ client, err := cosmosclient.NewRpcClient(chainNodeUrl)
+ if err != nil {
+ return false, fmt.Errorf("failed to create tendermint RPC client: %w", err)
+ }
+ if err := waitForFirstBlock(client, 1*time.Minute); err != nil {
+ return false, fmt.Errorf("chain failed to start: %w", err)
+ }
+
+ return participantExists(recorder)
+}
+
+func participantExists(recorder cosmosclient.CosmosMessageClient) (bool, error) {
+ queryClient := recorder.NewInferenceQueryClient()
+ request := &types.QueryGetParticipantRequest{Index: recorder.GetAccountAddress()}
+
+ // TODO: check participant state, compute diff and update?
+ // Or implement some ways to periodically (or by request) update the participant state
+ response, err := queryClient.Participant(recorder.GetContext(), request)
+ if err != nil {
+ if strings.Contains(err.Error(), "code = NotFound") {
+ logging.Info("Participant does not exist", types.Participants, "Address", recorder.GetAccountAddress(), "err", err)
+ return false, nil
+ } else {
+ return false, err
+ }
+ }
+
+ _ = response
+
+ return true, nil
+}
+
+// An alternative could be to always submit a new participant
+//
+// and let the chain decide if it's a new or existing participant?
+//
+// Or if it's a genesis participant just submit it again if error is "block < 0"?
+func waitForFirstBlock(client *rpcclient.HTTP, timeout time.Duration) error {
+ ctx, cancel := context.WithTimeout(context.Background(), timeout)
+ defer cancel()
+
+ for {
+ select {
+ case <-ctx.Done():
+ return fmt.Errorf("timeout waiting for first block")
+ default:
+ status, err := client.Status(ctx)
+ if err != nil {
+ logging.Debug("Waiting for chain to start...", types.System, "error", err)
+ time.Sleep(1 * time.Second)
+ continue
+ }
+ if status.SyncInfo.LatestBlockHeight > 0 {
+ return nil
+ }
+ time.Sleep(1 * time.Second)
+ }
+ }
+}
+
+func RegisterParticipantIfNeeded(recorder cosmosclient.CosmosMessageClient, config *apiconfig.ConfigManager) error {
+ isTest := os.Getenv("TESTS") == "true"
+ if !isTest {
+ return nil
+ }
+
+ logging.Info("[TEST ONLY] Registering participant", types.Participants, "isTest", isTest)
+
+ if config.GetChainNodeConfig().IsGenesis {
+ // Genesis participants are pre-registered through the genesis ceremony process
+ // No need to register them again at runtime
+ logging.Info("Genesis participant registration disabled - participants are pre-registered in genesis", types.Participants)
+ return nil
+ } else {
+ return registerJoiningParticipant(recorder, config)
+ }
+}
+
+func registerJoiningParticipant(recorder cosmosclient.CosmosMessageClient, configManager *apiconfig.ConfigManager) error {
+ if exists, err := participantExistsWithWait(recorder, configManager.GetChainNodeConfig().Url); exists {
+ logging.Info("Participant already exists, skipping registration", types.Participants)
+ return nil
+ } else if err != nil {
+ return fmt.Errorf("Failed to check if participant exists: %w", err)
+ }
+
+ validatorKey, err := getValidatorKey(configManager.GetChainNodeConfig().Url)
+ if err != nil {
+ return err
+ }
+ validatorKeyString := keyToString(validatorKey)
+
+ workerKey, err := configManager.CreateWorkerKey()
+ if err != nil {
+ return fmt.Errorf("Failed to create worker key: %w", err)
+ }
+
+ address := recorder.GetAccountAddress()
+ pubKey := recorder.GetAccountPubKey()
+ pubKeyString := keyToStringFromBytes(pubKey.Bytes())
+
+ logging.Info(
+ "Registering joining participant",
+ types.Participants, "validatorKey", validatorKeyString,
+ "Url", configManager.GetApiConfig().PublicUrl,
+ "Address", address,
+ "PubKey", pubKeyString,
+ )
+
+ requestBody := public_entities.SubmitUnfundedNewParticipantDto{
+ Address: address,
+ Url: configManager.GetApiConfig().PublicUrl,
+ ValidatorKey: validatorKeyString,
+ PubKey: pubKeyString,
+ WorkerKey: workerKey,
+ }
+
+ requestUrl, err := url.JoinPath(configManager.GetChainNodeConfig().SeedApiUrl, "/v1/participants")
+ if err != nil {
+ return fmt.Errorf("failed to join URL path: %w", err)
+ }
+
+ jsonData, err := json.Marshal(requestBody)
+ if err != nil {
+ return fmt.Errorf("failed to marshal request body: %w", err)
+ }
+
+ req, err := http.NewRequest(http.MethodPost, requestUrl, bytes.NewBuffer(jsonData))
+ if err != nil {
+ return fmt.Errorf("failed to create HTTP request: %w", err)
+ }
+ req.Header.Set("Content-Type", "application/json")
+
+ logging.Info("Sending request to seed node", types.Participants, "url", requestUrl)
+
+ client := &http.Client{}
+ resp, err := client.Do(req)
+ if err != nil {
+ return fmt.Errorf("failed to send HTTP request: %w", err)
+ }
+ defer resp.Body.Close()
+
+ if resp.StatusCode != http.StatusOK {
+ return fmt.Errorf("received non-OK response: %s", resp.Status)
+ }
+ return nil
+}
+
+func keyToString(key crypto.PubKey) string {
+ if key == nil {
+ return ""
+ }
+ return keyToStringFromBytes(key.Bytes())
+}
+
+func keyToStringFromBytes(keyBytes []byte) string {
+ if keyBytes == nil {
+ return ""
+ }
+ return base64.StdEncoding.EncodeToString(keyBytes)
+}
+
+func getValidatorKey(chainNodeUrl string) (crypto.PubKey, error) {
+ // Get validator key through RPC
+ client, err := cosmosclient.NewRpcClient(chainNodeUrl)
+ if err != nil {
+ return nil, fmt.Errorf("failed to create tendermint RPC client: %w", err)
+ }
+
+ // Get validator info
+ result, err := client.Status(context.Background())
+ if err != nil {
+ return nil, fmt.Errorf("failed to get status from tendermint RPC client: %w", err)
+ }
+
+ validatorKey := result.ValidatorInfo.PubKey
+ return validatorKey, nil
+}
diff --git a/decentralized-api/scripts/init-docker.sh b/decentralized-api/scripts/init-docker.sh
new file mode 100644
index 000000000..7675d13f4
--- /dev/null
+++ b/decentralized-api/scripts/init-docker.sh
@@ -0,0 +1,104 @@
+#!/bin/sh
+set -e
+
+fail() {
+ echo "$1" >&2
+ if [ -n "${DEBUG-}" ]; then
+ tail -f /dev/null
+ else
+ exit 1
+ fi
+}
+
+if [ -z "${KEY_NAME-}" ]; then
+ echo "Error: KEY_NAME is required."
+ exit 1
+fi
+
+if [ "${CREATE_KEY:-false}" = "true" ]; then
+ echo "Creating account key: $KEY_NAME"
+
+ if command -v inferenced >/dev/null 2>&1; then
+ APP_NAME="inferenced"
+ else
+ APP_NAME="decentralized-api"
+ fi
+
+ $APP_NAME keys add "$KEY_NAME" \
+ --keyring-backend test \
+ --keyring-dir /root/.inference
+
+ ACCOUNT_PUBKEY=$($APP_NAME keys show "$KEY_NAME" --pubkey --keyring-backend test --keyring-dir /root/.inference | jq -r '.key')
+ export ACCOUNT_PUBKEY
+ echo "Generated ACCOUNT_PUBKEY: $ACCOUNT_PUBKEY"
+fi
+
+# If ACCOUNT_PUBKEY is not provided but CREATE_KEY=false, try to extract from existing key
+if [ -z "${ACCOUNT_PUBKEY-}" ]; then
+ echo "WARNING: ACCOUNT_PUBKEY not provided, attempting to extract from existing key: $KEY_NAME"
+ echo "WARNING: For production, explicitly provide ACCOUNT_PUBKEY or set CREATE_KEY=true"
+ sleep 20
+
+ export KEYRING_BACKEND="test"
+ # Check if the key exists
+ if inferenced keys show "$KEY_NAME" --keyring-backend $KEYRING_BACKEND --keyring-dir /root/.inference >/dev/null 2>&1; then
+ ACCOUNT_PUBKEY=$(inferenced keys show "$KEY_NAME" --pubkey --keyring-backend $KEYRING_BACKEND --keyring-dir /root/.inference | jq -r '.key')
+ export ACCOUNT_PUBKEY
+ echo "Extracted ACCOUNT_PUBKEY from existing key: $ACCOUNT_PUBKEY"
+ else
+ echo "Error: Key '$KEY_NAME' not found and ACCOUNT_PUBKEY not provided"
+ echo "Either set CREATE_KEY=true to create a new key, or provide ACCOUNT_PUBKEY, or ensure key '$KEY_NAME' exists"
+ exit 1
+ fi
+fi
+
+if [ -z "${ACCOUNT_PUBKEY-}" ]; then
+ echo "Error: ACCOUNT_PUBKEY is required."
+ exit 1
+fi
+
+if [ -z "$DAPI_API__POC_CALLBACK_URL" ]; then
+ echo "Error: DAPI_API__POC_CALLBACK_URL is required."
+ exit 1
+fi
+
+if [ -z "$DAPI_API__PUBLIC_URL" ]; then
+ echo "Error: DAPI_API__PUBLIC_URL is required."
+ exit 1
+fi
+
+mkdir -p /root/.dapi
+initial_config_file="/root/api-config.yaml"
+yaml_file="/root/.dapi/api-config.yaml"
+if [ ! -f "$yaml_file" ]; then
+ echo "Copying initial config file to $yaml_file"
+ cp "$initial_config_file" "$yaml_file"
+else
+ echo "Config file $yaml_file already exists"
+fi
+
+
+if [ -n "$NODE_HOST" ]; then
+ echo "Setting node address to http://$NODE_HOST:26657 in $yaml_file"
+ sed -i "s/url: .*:26657/url: http:\/\/$NODE_HOST:26657/" "$yaml_file"
+fi
+
+echo "Initial config (before env var merge)"
+cat "$yaml_file"
+
+echo "init for cosmovisor"
+mkdir -p /root/.dapi/data
+
+echo "init for nats"
+mkdir -p /root/.dapi/.nats
+
+cosmovisor init /usr/bin/decentralized-api || fail "Failed to initialize cosmovisor"
+
+if [ -n "${DEBUG-}" ]; then
+ echo "running cosmovisor in debug mode"
+ cosmovisor run || fail "Failed to start decentralized-api"
+else
+ echo "Running decentralized-api with cosmovisor"
+ exec cosmovisor run
+ echo "Decentralized API started successfully?"
+fi
\ No newline at end of file
diff --git a/decentralized-api/training/assigner.go b/decentralized-api/training/assigner.go
new file mode 100644
index 000000000..546c25505
--- /dev/null
+++ b/decentralized-api/training/assigner.go
@@ -0,0 +1,427 @@
+package training
+
+import (
+ "context"
+ "decentralized-api/cosmosclient"
+ "decentralized-api/logging"
+ "decentralized-api/utils"
+ "fmt"
+ "github.com/cometbft/cometbft/libs/rand"
+ "github.com/productscience/inference/api/inference/inference"
+ "github.com/productscience/inference/x/inference/keeper"
+ "github.com/productscience/inference/x/inference/types"
+ "log/slog"
+ "net/http"
+ "sort"
+ "time"
+)
+
+type Assigner struct {
+ cosmosClient cosmosclient.CosmosMessageClient
+ tendermintClient *cosmosclient.TendermintClient
+ ctx context.Context
+ task *taskToAssignState
+}
+
+type taskToAssignState struct {
+ task *types.TrainingTask
+}
+
+const logTag = "[training-task-assigner] "
+
+func NewAssigner(client cosmosclient.CosmosMessageClient, tendermintClient *cosmosclient.TendermintClient, ctx context.Context) *Assigner {
+ assigner := &Assigner{
+ cosmosClient: client,
+ tendermintClient: tendermintClient,
+ ctx: ctx,
+ task: nil,
+ }
+
+ // TODO: on startup do some queries to restore state (like tasks I was assigned)
+ go assigner.claimTasksForAssignment()
+
+ return assigner
+}
+
+func (a *Assigner) claimTasksForAssignment() {
+ ticker := time.NewTicker(10 * time.Second)
+ defer ticker.Stop()
+ for {
+ select {
+ case <-a.ctx.Done():
+ return
+ case <-ticker.C:
+ if a.task == nil {
+ a.tryClaimingTaskToAssign()
+ } else {
+ a.checkTaskIsStillClaimed()
+ }
+
+ // Task could be assigned in the "if" above, thus we're rechecking here
+ if a.task != nil {
+ a.assignTask(*a.task.task)
+ }
+ }
+ }
+}
+
+func (a *Assigner) tryClaimingTaskToAssign() {
+ chainStatus, err := a.tendermintClient.Status()
+ if err != nil {
+ slog.Error(logTag+"Failed to query chain status", "err", err)
+ }
+
+ if chainStatus.SyncInfo.CatchingUp {
+ slog.Info(logTag + "Node is catching up, skipping task query")
+ return
+ }
+
+ blockHeight := chainStatus.SyncInfo.LatestBlockHeight
+ queryClient := a.cosmosClient.NewInferenceQueryClient()
+
+ req := &types.QueryQueuedTrainingTasksRequest{}
+ resp, err := queryClient.QueuedTrainingTasks(a.cosmosClient.GetContext(), req)
+ if err != nil {
+ slog.Error(logTag+"Error querying for training tasks", "err", err)
+ return
+ }
+
+ task := a.chooseTrainingTask(resp.Tasks, blockHeight)
+ if task == nil {
+ // slog.Info(logTag + "No training tasks to claim for assignment")
+ return
+ }
+
+ msg := inference.MsgClaimTrainingTaskForAssignment{
+ TaskId: task.Id,
+ }
+
+ _, err = a.cosmosClient.ClaimTrainingTaskForAssignment(&msg)
+ if err != nil {
+ slog.Error(logTag+"Error claiming task for assignment", "err", err)
+ return
+ }
+
+ slog.Info(logTag+"Claimed task for assignment", "taskId", task.Id)
+ a.task = &taskToAssignState{
+ task: task,
+ }
+}
+
+func (a *Assigner) findAlreadyClaimedTask(tasks []*types.TrainingTask) *types.TrainingTask {
+ for _, task := range tasks {
+ if task.Assigner == a.cosmosClient.GetAccountAddress() {
+ return task
+ }
+ }
+ return nil
+}
+
+func (a *Assigner) chooseTrainingTask(tasks []*types.TrainingTask, currentBlockHeight int64) *types.TrainingTask {
+ // This check handles the case of the network node being restarted while the task was already claimed by it
+ taskAlreadyAssignedToMe := a.findAlreadyClaimedTask(tasks)
+ if taskAlreadyAssignedToMe != nil {
+ slog.Info(logTag+"Already claimed task found", "taskId", taskAlreadyAssignedToMe.Id)
+ return taskAlreadyAssignedToMe
+ }
+
+ unclaimedTasks := make([]*types.TrainingTask, 0)
+ for _, task := range tasks {
+ if task.AssignedAtBlockHeight == 0 && (task.Assigner == "" || (uint64(currentBlockHeight)-task.ClaimedByAssignerAtBlockHeight) > keeper.TrainingTaskAssignmentDeadline) {
+ unclaimedTasks = append(unclaimedTasks, task)
+ }
+ }
+
+ if len(unclaimedTasks) == 0 {
+ return nil
+ }
+
+ i := rand.Intn(len(unclaimedTasks))
+ return unclaimedTasks[i]
+}
+
+func (a *Assigner) assignTask(task types.TrainingTask) {
+ queryClient := a.cosmosClient.NewInferenceQueryClient()
+ participants, err := getParticipantsWithHardwareNodes(a.ctx, queryClient)
+ if err != nil {
+ slog.Error(logTag+"Error querying participants with hardware nodes", "err", err)
+ return
+ }
+
+ selectedParticipants, err := getParticipantListMatchingHardwareSpec(task.HardwareResources, participants)
+ if err != nil {
+ // FIXME: Returning and sleeping 60 more secs. Not sure if it's the best strategy
+ // We need to be able to distinguish between:
+ // a. "can't do because everyone's busy"
+ // vs
+ // b. "can't do because network doesn't have required hardware"
+ // And the treat them differently
+ // a. Retry, but when?
+ // b. Mark task as failed?
+ slog.Error(logTag+"Error picking task", "err", err)
+ return
+ }
+ slog.Info(logTag+"Selected participants", "participants", selectedParticipants)
+
+ httpClient := utils.NewHttpClient(120 * time.Second)
+ for _, p := range selectedParticipants {
+ participant, err := queryClient.Participant(a.ctx, &types.QueryGetParticipantRequest{Index: p.participant})
+ if err != nil {
+ slog.Error(logTag+"Error querying for participant", "participant", p.participant, "err", err)
+ return
+ }
+
+ err = confirmAvailability(httpClient, participant.Participant.InferenceUrl, task.Id, p.nodeIds)
+ if err != nil {
+ // FIXME: Returning and sleeping 60 more secs.
+ // Because by the next iteration chain state of hardware nodes may become up to date
+ // and we would select a different set of participants
+ slog.Error(logTag+"Error confirming availability", "participant", p.participant, "err", err)
+ return
+ }
+ }
+ slog.Info(logTag+"Confirmed availability for participants", "participants", selectedParticipants)
+
+ assignees := make([]*inference.TrainingTaskAssignee, len(selectedParticipants))
+ for i, p := range selectedParticipants {
+ assignees[i] = &inference.TrainingTaskAssignee{
+ Participant: p.participant,
+ NodeIds: p.nodeIds,
+ }
+ }
+ msg := &inference.MsgAssignTrainingTask{
+ TaskId: task.Id,
+ Assignees: assignees,
+ }
+ _, err = a.cosmosClient.AssignTrainingTask(msg)
+ if err != nil {
+ slog.Error(logTag+"Error sending assign task transaction", "err", err)
+ // TODO: what should we do? We need to know the reason, maybe someone else assigned it
+ // Get back here once you implement msg processing and understand what can go wrong here
+ } else {
+ slog.Info(logTag+"Assigned task", "taskId", task.Id)
+ a.task = nil
+ }
+}
+
+func (a *Assigner) checkTaskIsStillClaimed() {
+ if a.task == nil {
+ return
+ }
+
+ queryClient := a.cosmosClient.NewInferenceQueryClient()
+ req := &types.QueryTrainingTaskRequest{
+ Id: a.task.task.Id,
+ }
+ resp, err := queryClient.TrainingTask(a.cosmosClient.GetContext(), req)
+ if err != nil {
+ slog.Error(logTag+"Error querying for task", "taskId", a.task.task.Id, "err", err)
+ return
+ }
+
+ if resp.Task.Assigner != a.cosmosClient.GetAccountAddress() {
+ slog.Info(logTag+"Task is no longer claimed by me", "taskId", a.task.task.Id)
+ a.task = nil
+ }
+
+ if resp.Task.AssignedAtBlockHeight > 0 {
+ slog.Info(logTag+"Task is already assigned", "taskId", a.task.task.Id)
+ a.task = nil
+ }
+}
+
+type participantHardwareNodes struct {
+ participant string
+ weight int64
+ hardware *types.HardwareNodes
+}
+
+func getParticipantsWithHardwareNodes(ctx context.Context, queryClient types.QueryClient) (map[string]participantHardwareNodes, error) {
+ req := &types.QueryCurrentEpochGroupDataRequest{}
+ resp, err := queryClient.CurrentEpochGroupData(ctx, req)
+ if err != nil {
+ slog.Error(logTag+"Error querying for current epoch group data", "err", err)
+ return nil, err
+ }
+
+ participants := resp.EpochGroupData.ValidationWeights
+ slog.Info(logTag+"Participants", "participants", participants)
+
+ // FIXME: could be optimized if we queried only nodeIds of actual participants instead of ALL participants
+ // or maybe we should do some hardware nodeIds pruning
+ r := &types.QueryHardwareNodesAllRequest{}
+ hardwareNodes, err := queryClient.HardwareNodesAll(ctx, r)
+ if err != nil {
+ slog.Error(logTag+"Error querying for hardware nodeIds", "err", err)
+ return nil, err
+ }
+
+ hardwareNodesByParticipant := make(map[string]*types.HardwareNodes)
+ for _, nodes := range hardwareNodes.Nodes {
+ hardwareNodesByParticipant[nodes.Participant] = nodes
+ }
+
+ participantsWithHardware := make(map[string]participantHardwareNodes)
+ for _, participant := range participants {
+ address := participant.MemberAddress
+ participantsWithHardware[address] = participantHardwareNodes{
+ participant: address,
+ weight: participant.Weight,
+ hardware: hardwareNodesByParticipant[address],
+ }
+ }
+ slog.Info(logTag+"Participants with hardware nodes", "participants", participantsWithHardware)
+
+ return participantsWithHardware, nil
+}
+
+type selectedParticipant struct {
+ participant string
+ nodeIds []string
+}
+
+type candidateNode struct {
+ participant string
+ participantWeight int64
+ nodeId string
+ available map[string]uint32
+}
+
+// getParticipantListMatchingHardwareSpec returns a mapping from participant IDs to the list of node IDs
+// that, when combined, cover the task's hardware requirements. Returns an error if no such set exists.
+func getParticipantListMatchingHardwareSpec(
+ hardwareRequirements []*types.TrainingHardwareResources,
+ participants map[string]participantHardwareNodes,
+) ([]selectedParticipant, error) {
+ remaining := make(map[string]uint32)
+ for _, req := range hardwareRequirements {
+ remaining[req.Type] += req.Count
+ }
+ slog.Info(logTag+"Matching hardware requirements", "requirements", hardwareRequirements)
+
+ // Flatten the candidateNode pool: one candidateNode per available node.
+ var candidates []candidateNode
+ for _, p := range participants {
+ if p.hardware == nil {
+ continue
+ }
+ for _, node := range p.hardware.HardwareNodes {
+ if node.Status != types.HardwareNodeStatus_INFERENCE {
+ continue
+ }
+ avail := make(map[string]uint32)
+ for _, hw := range node.Hardware {
+ avail[hw.Type] += hw.Count
+ }
+ candidates = append(candidates, candidateNode{
+ participant: p.participant,
+ participantWeight: p.weight,
+ nodeId: node.LocalId,
+ available: avail,
+ })
+ }
+ }
+
+ // Sort candidates by participantWeight descending (higher participantWeight first)
+ sort.Slice(candidates, func(i, j int) bool {
+ return candidates[i].participantWeight > candidates[j].participantWeight
+ })
+ slog.Info(logTag+"Candidates", "candidates", candidates)
+
+ // We'll mark which candidates have been selected.
+ selected := make([]bool, len(candidates))
+
+ var selectedCandidates []candidateNode
+
+ // Greedy loop: try to cover the remaining requirements.
+ for {
+ allRequirementsMet := true
+ for _, req := range remaining {
+ if req > 0 {
+ allRequirementsMet = false
+ break
+ }
+ }
+ if allRequirementsMet {
+ break
+ }
+
+ bestCandidateIdx := findHighestContributingCandidate(candidates, selected, remaining)
+ if bestCandidateIdx == -1 {
+ return nil, fmt.Errorf(logTag + "insufficient hardware across nodeIds to satisfy task requirements")
+ }
+
+ // Select the best candidateNode and update the remaining requirements.
+ selected[bestCandidateIdx] = true
+ selectedCandidates = append(selectedCandidates, candidates[bestCandidateIdx])
+ bestCandidate := candidates[bestCandidateIdx]
+ for hwType, availCount := range bestCandidate.available {
+ if need, ok := remaining[hwType]; ok && need > 0 {
+ if availCount >= need {
+ remaining[hwType] = 0
+ } else {
+ remaining[hwType] = need - availCount
+ }
+ }
+ }
+ }
+
+ resultMap := make(map[string][]string)
+ for _, cand := range selectedCandidates {
+ resultMap[cand.participant] = append(resultMap[cand.participant], cand.nodeId)
+ }
+
+ result := make([]selectedParticipant, 0, len(resultMap))
+ for participant, nodes := range resultMap {
+ result = append(result, selectedParticipant{
+ participant: participant,
+ nodeIds: nodes,
+ })
+ }
+
+ return result, nil
+}
+
+func findHighestContributingCandidate(candidates []candidateNode, selected []bool, remaining map[string]uint32) int {
+ var bestCandidateIdx int = -1
+ var bestContribution uint32 = 0
+
+ for i, cand := range candidates {
+ if selected[i] {
+ continue
+ }
+ var contribution uint32 = 0
+ for hwType, availCount := range cand.available {
+ if need, ok := remaining[hwType]; ok && need > 0 {
+ if availCount < need {
+ contribution += availCount
+ } else {
+ contribution += need
+ }
+ }
+ }
+ // Update the best candidateNode if this one offers a higher contribution.
+ if contribution > bestContribution {
+ bestContribution = contribution
+ bestCandidateIdx = i
+ }
+ }
+
+ return bestCandidateIdx
+}
+
+type lockTrainingNodesDto struct {
+ TrainingTaskId uint64 `json:"training_task_id"`
+ NodeIds []string `json:"node_ids"`
+}
+
+func confirmAvailability(client *http.Client, participantUrl string, taskId uint64, nodeIds []string) error {
+ logging.Debug("confirmAvailability", types.Training, "participantUrl", participantUrl, "taskId", taskId, "nodeIds", nodeIds)
+ url := participantUrl + "/v1/training/lock-nodes"
+ payload := lockTrainingNodesDto{
+ TrainingTaskId: taskId,
+ NodeIds: nodeIds,
+ }
+ _, err := utils.SendPostJsonRequest(context.Background(), client, url, payload)
+ return err
+}
diff --git a/decentralized-api/training/assigner_test.go b/decentralized-api/training/assigner_test.go
new file mode 100644
index 000000000..5e92d9941
--- /dev/null
+++ b/decentralized-api/training/assigner_test.go
@@ -0,0 +1,9 @@
+package training_test
+
+import (
+ "testing"
+)
+
+func Test(t *testing.T) {
+
+}
diff --git a/decentralized-api/training/executor.go b/decentralized-api/training/executor.go
new file mode 100644
index 000000000..7da092c97
--- /dev/null
+++ b/decentralized-api/training/executor.go
@@ -0,0 +1,256 @@
+package training
+
+import (
+ "context"
+ "decentralized-api/broker"
+ "decentralized-api/cosmosclient"
+ "decentralized-api/logging"
+ "errors"
+ "github.com/productscience/inference/x/inference/types"
+ "log/slog"
+ "sort"
+ "time"
+)
+
+const logTagExecutor = "[training-task-executor] "
+
+type Executor struct {
+ broker *broker.Broker
+ cosmosClient cosmosclient.CosmosMessageClient
+ tasks map[uint64]struct{}
+ ctx context.Context
+}
+
+func NewExecutor(ctx context.Context, nodeBroker *broker.Broker, cosmosClient cosmosclient.CosmosMessageClient) *Executor {
+ e := &Executor{
+ broker: nodeBroker,
+ cosmosClient: cosmosClient,
+ tasks: make(map[uint64]struct{}),
+ ctx: ctx,
+ }
+
+ go e.checkStatusRoutine()
+
+ return e
+}
+
+func (e Executor) PreassignTask(taskId uint64, nodeIds []string) error {
+ command := broker.NewLockNodesForTrainingCommand(nodeIds)
+ err := e.broker.QueueMessage(command)
+ if err != nil {
+ return err
+ }
+
+ success := <-command.Response
+
+ if success {
+ e.tasks[taskId] = struct{}{}
+ return nil
+ } else {
+ return errors.New("failed to lock nodes")
+ }
+}
+
+func (e *Executor) ProcessTaskAssignedEvent(taskId uint64) {
+ logging.Info(logTagExecutor+"Processing task assigned event", types.Training, "taskId", taskId)
+ slog.Info(logTagExecutor+"Processing task assigned event", "taskId", taskId)
+ queryClient := e.cosmosClient.NewInferenceQueryClient()
+ req := types.QueryTrainingTaskRequest{Id: taskId}
+ resp, err := queryClient.TrainingTask(e.cosmosClient.GetContext(), &req)
+
+ if err != nil {
+ logging.Error(logTagExecutor+"Error fetching task", types.Training, "taskId", taskId, "error", err)
+ slog.Error(logTagExecutor+"Error fetching task", "taskId", taskId, "error", err)
+ return
+ }
+
+ if resp.Task.Assignees == nil {
+ logging.Error(logTagExecutor+"No assignees found for task", types.Training, "taskId", taskId)
+ slog.Error(logTagExecutor+"No assignees found for task", "taskId", taskId)
+ return
+ }
+
+ myNodes := make([]string, 0)
+ for _, a := range resp.Task.Assignees {
+ if a.Participant != e.cosmosClient.GetAccountAddress() {
+ continue
+ }
+ logging.Info(logTagExecutor+"Found task assigned to me", types.Training, "taskId", taskId)
+ slog.Info(logTagExecutor+"Found task assigned to me", "taskId", taskId)
+ for _, node := range a.NodeIds {
+ myNodes = append(myNodes, node)
+ }
+ }
+
+ if len(myNodes) == 0 {
+ logging.Info(logTagExecutor+"The task isn't assigned to me", types.Training, "taskId", taskId)
+ slog.Info(logTagExecutor+"The task isn't assigned to me", "taskId", taskId)
+ return
+ }
+
+ logging.Info(logTagExecutor+"The task is assigned to me", types.Training, "taskId", taskId, "nodes", myNodes)
+ slog.Info(logTagExecutor+"The task is assigned to me", "taskId", taskId, "nodes", myNodes)
+
+ rankedNodes, err := rankNodes(resp.Task)
+ if err != nil {
+ logging.Error(logTagExecutor+"Error ranking nodes", types.Training, "taskId", taskId, "error", err)
+ slog.Error(logTagExecutor+"Error ranking nodes", "taskId", taskId, "error", err)
+ return
+ }
+
+ masterNode, err := getMasterNode(e.ctx, rankedNodes, queryClient)
+ if err != nil {
+ logging.Error(logTagExecutor+"Error getting master node", types.Training, "taskId", taskId, "error", err)
+ slog.Error(logTagExecutor+"Error getting master node", "taskId", taskId, "error", err)
+ return
+ }
+
+ nodeRanks := make(map[string]int)
+ for i, n := range rankedNodes {
+ if n.participant == e.cosmosClient.GetAccountAddress() {
+ nodeRanks[n.nodeId] = i
+ }
+ }
+
+ logging.Info(logTagExecutor+"Starting training", types.Training, "taskId", taskId, "masterNode", masterNode.Host, "nodeRanks", nodeRanks, "worldSize", len(rankedNodes))
+ slog.Info(logTagExecutor+"Starting training", "taskId", taskId, "masterNode", masterNode.Host, "nodeRanks", nodeRanks, "worldSize", len(rankedNodes))
+ command := broker.NewStartTrainingCommand(
+ taskId,
+ masterNode.Host,
+ len(rankedNodes),
+ nodeRanks,
+ )
+ err = e.broker.QueueMessage(command)
+ if err != nil {
+ logging.Error(logTagExecutor+"Error starting training", types.Training, "taskId", taskId, "error", err)
+ slog.Error(logTagExecutor+"Error starting training", "taskId", taskId, "error", err)
+ return
+ }
+
+ success := <-command.Response
+ if success {
+ e.tasks[taskId] = struct{}{}
+ logging.Info(logTagExecutor+"Training started", types.Training, "taskId", taskId)
+ slog.Info(logTagExecutor+"Training started", "taskId", taskId)
+ } else {
+ logging.Error(logTagExecutor+"Error starting training", types.Training, "taskId", taskId)
+ slog.Error(logTagExecutor+"Error starting training", "taskId", taskId)
+ }
+}
+
+type nodeWithParticipant struct {
+ participant string
+ nodeId string
+}
+
+func rankNodes(task *types.TrainingTask) ([]nodeWithParticipant, error) {
+ if task == nil {
+ slog.Error(logTagExecutor + "No task found")
+ return nil, errors.New("no task found")
+ }
+
+ if task.Assignees == nil {
+ slog.Error(logTagExecutor+"No assignees found for task", "taskId", task.Id)
+ return nil, errors.New("no assignees found for task")
+ }
+
+ nodes := make([]nodeWithParticipant, 0)
+ for _, a := range task.Assignees {
+ for _, n := range a.NodeIds {
+ nodes = append(nodes, nodeWithParticipant{
+ participant: a.Participant,
+ nodeId: n,
+ })
+ }
+ }
+
+ sort.Slice(nodes, func(i, j int) bool {
+ if nodes[i].participant == nodes[j].participant {
+ return nodes[i].nodeId < nodes[j].nodeId
+ }
+ return nodes[i].participant < nodes[j].participant
+ })
+
+ return nodes, nil
+}
+
+func getMasterNode(ctx context.Context, rankedNodes []nodeWithParticipant, queryClient types.QueryClient) (*types.HardwareNode, error) {
+ if len(rankedNodes) == 0 {
+ slog.Error(logTagExecutor + "len(rankedNodes) is 0, can't pick master node")
+ return nil, errors.New("len(rankedNodes) is 0, can't pick master node")
+ }
+
+ resp, err := queryClient.HardwareNodes(ctx, &types.QueryHardwareNodesRequest{Participant: rankedNodes[0].participant})
+ if err != nil {
+ slog.Error(logTagExecutor+"Error fetching hardware nodes", "participant", rankedNodes[0].participant, "error", err)
+ return nil, err
+ }
+
+ for _, n := range resp.Nodes.HardwareNodes {
+ if n.LocalId == rankedNodes[0].nodeId {
+ return n, nil
+ }
+ }
+
+ slog.Error(logTagExecutor+"Master node not found", "participant", rankedNodes[0].participant, "nodeId", rankedNodes[0].nodeId, "response.Nodes", resp.Nodes)
+ return nil, errors.New("master node not found")
+}
+
+func (e *Executor) checkStatusRoutine() {
+ timer := time.NewTimer(60 * time.Second)
+ for {
+ select {
+ case <-e.ctx.Done():
+ return
+ case <-timer.C:
+ e.checkInProgressTasksOnChain()
+ e.checkStatus()
+ }
+ }
+}
+
+func (e *Executor) checkInProgressTasksOnChain() {
+ // 1. Get in progress tasks
+ queryClient := e.cosmosClient.NewInferenceQueryClient()
+ resp, err := queryClient.InProgressTrainingTasks(e.ctx, &types.QueryInProgressTrainingTasksRequest{})
+ if err != nil {
+ logging.Error(logTagExecutor+"Error fetching in progress tasks", types.Training, "error", err)
+ return
+ }
+
+ // 2. Filter tasks that are assigned to me
+ tasks := make([]*types.TrainingTask, 0)
+ for _, t := range resp.Tasks {
+ if t.Assignees == nil {
+ continue
+ }
+ for _, a := range t.Assignees {
+ if a.Participant == e.cosmosClient.GetAccountAddress() {
+ tasks = append(tasks, t)
+ break
+ }
+ }
+ }
+
+ // 3. For each task, check if it's already in the map
+ for _, t := range tasks {
+ if _, ok := e.tasks[t.Id]; !ok {
+ logging.Info(logTagExecutor+"Task not found in the set", types.Training, "taskId", t.Id)
+ // TODO: add a task to the map
+ // e.tasks[t.Id] = struct{}{}
+ } else {
+ logging.Info(logTagExecutor+"Task found in the set", types.Training, "taskId", t.Id)
+ }
+ }
+
+ // TODO: So here's the question:
+ // If task is absent in the map do we trigger it
+ // or
+ // do we have a separate routine that reads through the map each X seconds
+ // and just sends some check nodes are doing training command to the server
+ // I kind of like the option#2 more, because it's more resilient to failures
+}
+
+func (e *Executor) checkStatus() {
+ // TODO: the routine that goes over each task in the map and makes sure nodes are actually busy wit it
+}
diff --git a/decentralized-api/training/grpc_server.go b/decentralized-api/training/grpc_server.go
new file mode 100644
index 000000000..941f397d7
--- /dev/null
+++ b/decentralized-api/training/grpc_server.go
@@ -0,0 +1,233 @@
+package training
+
+import (
+ "context"
+ cosmosclient "decentralized-api/cosmosclient"
+ "decentralized-api/logging"
+
+ "github.com/productscience/inference/api/inference/inference"
+ "github.com/productscience/inference/x/inference/types"
+)
+
+type Server struct {
+ inference.UnimplementedNetworkNodeServiceServer
+ cosmosClient cosmosclient.CosmosMessageClient
+ executor *Executor
+}
+
+/*
+ grpcurl -plaintext \
+ localhost:9003 \
+ list
+
+ grpcurl -plaintext \
+ -d '{"run_id": "1", "record":{"key":"foo","value":"bar"}}' \
+ localhost:9003 \
+ inference.inference.NetworkNodeService/SetStoreRecord
+
+ grpcurl -plaintext \
+ -d '{"run_id": "1", "key":"foo"}' \
+ localhost:9003 \
+ inference.inference.NetworkNodeService/GetStoreRecord
+
+ grpcurl -plaintext \
+ -d '{"run_id": "1"}' \
+ localhost:9003 \
+ inference.inference.NetworkNodeService/ListStoreKeys
+*/
+func NewServer(cosmosClient cosmosclient.CosmosMessageClient, executor *Executor) *Server {
+ return &Server{
+ cosmosClient: cosmosClient,
+ executor: executor,
+ }
+}
+
+// Implement a few key methods first:
+
+func (s *Server) SetStoreRecord(ctx context.Context, req *inference.SetStoreRecordRequest) (*inference.SetStoreRecordResponse, error) {
+ if req.Record == nil {
+ return &inference.SetStoreRecordResponse{
+ Status: inference.StoreRecordStatusEnum_SET_RECORD_ERROR,
+ }, nil
+ }
+
+ logging.Info("SetStoreRecord called", types.Training, "key", req.Record.Key, "value", req.Record.Value)
+
+ msg := &inference.MsgSubmitTrainingKvRecord{
+ Creator: s.cosmosClient.GetAccountAddress(),
+ Participant: s.cosmosClient.GetAccountAddress(),
+ TaskId: req.RunId,
+ Key: req.Record.Key,
+ Value: req.Record.Value,
+ }
+ response := inference.MsgSubmitTrainingKvRecordResponse{}
+
+ err := s.cosmosClient.SendTransactionSyncNoRetry(msg, &response)
+ if err != nil {
+ logging.Error("Failed to send transaction", types.Training, "error", err)
+ return nil, err
+ }
+
+ logging.Info("MsgSubmitTrainingKvRecordResponse received", types.Training)
+
+ return &inference.SetStoreRecordResponse{
+ Status: inference.StoreRecordStatusEnum_SET_RECORD_OK,
+ }, nil
+}
+
+func (s *Server) GetStoreRecord(ctx context.Context, req *inference.GetStoreRecordRequest) (*inference.GetStoreRecordResponse, error) {
+ logging.Info("GetStoreRecord called", types.Training, "key", req.Key)
+
+ request := &types.QueryTrainingKvRecordRequest{
+ TaskId: req.RunId,
+ Key: req.Key,
+ }
+ queryClient := s.cosmosClient.NewInferenceQueryClient()
+ resp, err := queryClient.TrainingKvRecord(ctx, request)
+ if err != nil {
+ logging.Error("Failed to get training kv record", types.Training, "error", err)
+ return nil, err
+ }
+
+ logging.Info("GetStoreRecord response", types.Training, "record", resp.Record)
+
+ return &inference.GetStoreRecordResponse{
+ Record: &inference.Record{
+ Key: resp.Record.Key,
+ Value: resp.Record.Value,
+ },
+ }, nil
+}
+
+func (s *Server) ListStoreKeys(ctx context.Context, req *inference.StoreListKeysRequest) (*inference.StoreListKeysResponse, error) {
+ logging.Info("ListStoreKeys called", types.Training, "key")
+
+ queryClient := s.cosmosClient.NewInferenceQueryClient()
+ resp, err := queryClient.ListTrainingKvRecordKeys(ctx, &types.QueryListTrainingKvRecordKeysRequest{
+ TaskId: req.RunId,
+ })
+ if err != nil {
+ logging.Error("Failed to get training kv record keys", types.Training, "error", err)
+ return nil, err
+ }
+
+ return &inference.StoreListKeysResponse{
+ Keys: resp.Keys,
+ }, nil
+}
+
+func (s *Server) JoinTraining(ctx context.Context, req *inference.JoinTrainingRequest) (*inference.MLNodeTrainStatus, error) {
+ msg := inference.MsgJoinTraining{
+ Creator: s.cosmosClient.GetAccountAddress(),
+ Req: req,
+ }
+ resp := inference.MsgJoinTrainingResponse{}
+ err := s.cosmosClient.SendTransactionSyncNoRetry(&msg, &resp)
+ if err != nil {
+ logging.Error("Failed to send transaction", types.Training, "error", err)
+ return nil, err
+ }
+
+ return resp.Status, nil
+}
+
+func (s *Server) GetJoinTrainingStatus(ctx context.Context, req *inference.JoinTrainingRequest) (*inference.MLNodeTrainStatus, error) {
+ msg := inference.MsgJoinTrainingStatus{
+ Creator: s.cosmosClient.GetAccountAddress(),
+ Req: req,
+ }
+ resp := inference.MsgJoinTrainingStatusResponse{}
+ err := s.cosmosClient.SendTransactionSyncNoRetry(&msg, &resp)
+ if err != nil {
+ logging.Error("Failed to send transaction", types.Training, "error", err)
+ return nil, err
+ }
+
+ return resp.Status, nil
+}
+
+func (s *Server) SendHeartbeat(ctx context.Context, req *inference.HeartbeatRequest) (*inference.HeartbeatResponse, error) {
+ logging.Info("SendHeartbeat called", types.Training, "req", req)
+
+ // TODO: executor.Heartbeat(...)
+ // TODO: probably call it unconditionally. Even if transaction fails
+
+ msg := inference.MsgTrainingHeartbeat{
+ Creator: s.cosmosClient.GetAccountAddress(),
+ Req: req,
+ }
+ resp := inference.MsgTrainingHeartbeatResponse{}
+ err := s.cosmosClient.SendTransactionSyncNoRetry(&msg, &resp)
+ if err != nil {
+ logging.Error("Failed to send transaction", types.Training, "error", err)
+ return nil, err
+ }
+
+ return resp.Resp, nil
+}
+
+func (s *Server) GetAliveNodes(ctx context.Context, req *inference.GetAliveNodesRequest) (*inference.GetAliveNodesResponse, error) {
+ logging.Info("GetAliveNodes called", types.Training)
+
+ queryClient := s.cosmosClient.NewInferenceQueryClient()
+ queryReq := &types.QueryTrainingAliveNodesRequest{
+ Req: &types.GetAliveNodesRequest{
+ RunId: req.RunId,
+ OuterStep: req.OuterStep,
+ },
+ }
+
+ resp, err := queryClient.TrainingAliveNodes(ctx, queryReq)
+ if err != nil {
+ logging.Error("Failed to get alive nodes", types.Training, "error", err)
+ return nil, err
+ }
+
+ logging.Info("GetAliveNodes response", types.Training, "resp", resp)
+
+ return &inference.GetAliveNodesResponse{
+ AliveNodes: resp.Resp.AliveNodes,
+ }, nil
+}
+
+func (s *Server) SetBarrier(ctx context.Context, req *inference.SetBarrierRequest) (*inference.SetBarrierResponse, error) {
+ logging.Info("SetBarrier called", types.Training)
+
+ msg := inference.MsgSetBarrier{
+ Creator: s.cosmosClient.GetAccountAddress(),
+ Req: req,
+ }
+ resp := inference.MsgSetBarrierResponse{}
+ err := s.cosmosClient.SendTransactionSyncNoRetry(&msg, &resp)
+ if err != nil {
+ logging.Error("Failed to send transaction", types.Training, "error", err)
+ return nil, err
+ }
+ return resp.Resp, nil
+}
+
+func (s *Server) GetBarrierStatus(ctx context.Context, req *inference.GetBarrierStatusRequest) (*inference.GetBarrierStatusResponse, error) {
+ logging.Info("GetBarrierStatus called", types.Training)
+
+ queryClient := s.cosmosClient.NewInferenceQueryClient()
+ queryReq := &types.QueryTrainingBarrierRequest{
+ Req: &types.GetBarrierStatusRequest{
+ BarrierId: req.BarrierId,
+ RunId: req.RunId,
+ OuterStep: req.OuterStep,
+ },
+ }
+ resp, err := queryClient.TrainingBarrier(ctx, queryReq)
+ if err != nil {
+ logging.Error("Failed to get training barrier status", types.Training, "error", err)
+ return nil, err
+ }
+
+ logging.Info("GetBarrierStatus response", types.Training, "resp", resp)
+
+ return &inference.GetBarrierStatusResponse{
+ AllReady: resp.Resp.AllReady,
+ NotReady: resp.Resp.NotReady,
+ AliveNodes: resp.Resp.AliveNodes,
+ }, nil
+}
diff --git a/decentralized-api/upgrade/events.go b/decentralized-api/upgrade/events.go
new file mode 100644
index 000000000..c84361936
--- /dev/null
+++ b/decentralized-api/upgrade/events.go
@@ -0,0 +1,201 @@
+package upgrade
+
+import (
+ "decentralized-api/apiconfig"
+ "decentralized-api/cosmosclient"
+ "decentralized-api/internal/event_listener/chainevents"
+ "decentralized-api/logging"
+ "encoding/json"
+ "os"
+ "path/filepath"
+
+ "github.com/productscience/inference/x/inference/types"
+)
+
+func ProcessNewBlockEvent(
+ event *chainevents.JSONRPCResponse,
+ transactionRecorder cosmosclient.InferenceCosmosClient,
+ configManager *apiconfig.ConfigManager,
+) {
+ if event.Result.Data.Type != "tendermint/event/NewBlock" {
+ logging.Error("Expected tendermint/event/NewBlock event", types.Upgrades, "event", event.Result.Data.Type)
+ return
+ }
+
+ checkForPartialUpgradesScheduled(transactionRecorder, configManager)
+ checkForFullUpgradesScheduled(transactionRecorder, configManager)
+
+ checkForVersionSwitch(configManager)
+}
+
+func checkForPartialUpgradesScheduled(transactionRecorder cosmosclient.InferenceCosmosClient, configManager *apiconfig.ConfigManager) {
+ partialUpgrades, err := transactionRecorder.GetPartialUpgrades()
+ if err != nil {
+ logging.Error("Error getting partial upgrades", types.Upgrades, "error", err)
+ return
+ }
+ logging.Info("checkForPartialUpgrades. Partial upgrades", types.Upgrades, "partialUpgrades", partialUpgrades)
+ for _, upgrade := range partialUpgrades.PartialUpgrade {
+ // If Binaries are provided, we set everything
+ if upgrade.ApiBinariesJson != "" {
+ var planInfo UpgradeInfoInput
+ if err := json.Unmarshal([]byte(upgrade.ApiBinariesJson), &planInfo); err != nil {
+ logging.Error("Error unmarshalling upgrade plan info", types.Upgrades, "error", err)
+ continue
+ }
+ if planInfo.Binaries == nil || len(planInfo.Binaries) == 0 {
+ continue
+ }
+ if upgrade.Name == configManager.GetUpgradePlan().Name {
+ logging.Info("Upgrade already ready", types.Upgrades, "name", upgrade.Name)
+ continue
+ }
+ err = configManager.SetUpgradePlan(apiconfig.UpgradePlan{
+ Name: upgrade.Name,
+ Height: int64(upgrade.Height),
+ Binaries: planInfo.Binaries,
+ NodeVersion: planInfo.NodeVersion, // Store the known version
+ })
+ if err != nil {
+ logging.Error("Error setting upgrade with binaries", types.Upgrades, "error", err)
+ continue
+ }
+ continue
+ }
+ // If Binaries are not provided but NodeVersion is, we set the NodeVersion, ignoring conflicts
+ if upgrade.NodeVersion != "" {
+ err = configManager.SetUpgradePlan(apiconfig.UpgradePlan{
+ Name: upgrade.Name,
+ Height: int64(upgrade.Height),
+ NodeVersion: upgrade.NodeVersion,
+ })
+ if err != nil {
+ logging.Error("Error setting upgrade plan for node version", types.Upgrades, "error", err)
+ continue
+ }
+ continue
+ }
+ }
+}
+
+func checkForFullUpgradesScheduled(transactionRecorder cosmosclient.InferenceCosmosClient, configManager *apiconfig.ConfigManager) {
+ upgradePlan, err := transactionRecorder.GetUpgradePlan()
+ if err != nil {
+ logging.Error("Error getting upgrade plan", types.Upgrades, "error", err)
+ return
+ }
+
+ if upgradePlan != nil && upgradePlan.Plan != nil {
+ if upgradePlan.Plan.Name == configManager.GetUpgradePlan().Name {
+ logging.Info("Upgrade already ready", types.Upgrades, "name", upgradePlan.Plan.Name)
+ return
+ }
+ if upgradePlan.Plan.Info == "" {
+ logging.Error("Upgrade exists, no info for api binaries", types.Upgrades)
+ return
+ }
+ var planInfo UpgradeInfoInput
+ if err := json.Unmarshal([]byte(upgradePlan.Plan.Info), &planInfo); err != nil {
+ logging.Error("Error unmarshalling upgrade plan info", types.Upgrades, "error", err)
+ return
+ }
+ err = configManager.SetUpgradePlan(apiconfig.UpgradePlan{
+ Name: upgradePlan.Plan.Name,
+ Height: upgradePlan.Plan.Height,
+ Binaries: planInfo.Binaries,
+ NodeVersion: planInfo.NodeVersion,
+ })
+ if err != nil {
+ logging.Error("Error setting upgrade plan", types.Upgrades, "error", err)
+ return
+ }
+ }
+}
+
+func checkForVersionSwitch(configManager *apiconfig.ConfigManager) {
+ upgradePlan := configManager.GetUpgradePlan()
+
+ if upgradePlan.Name == "" || upgradePlan.NodeVersion == "" {
+ logging.Debug("checkForVersionSwitch. name or node version is empty", types.Upgrades, "upgradePlan", upgradePlan)
+ return
+ }
+
+ if configManager.GetHeight() >= upgradePlan.Height-1 {
+ logging.Info("checkForVersionSwitch. height reached for upgrade", types.Upgrades, "nodeVersion", upgradePlan.NodeVersion, "upgradeHeight", upgradePlan.Height)
+ oldVersion := configManager.GetCurrentNodeVersion()
+ if upgradePlan.NodeVersion != oldVersion {
+ err := configManager.SetCurrentNodeVersion(upgradePlan.NodeVersion)
+ if err != nil {
+ logging.Error("checkForVersionSwitch. Failed to update MLNode version in config", types.Upgrades, "error", err)
+ return
+ }
+ logging.Info("MLNode version updated during upgrade using known target version", types.Upgrades, "oldVersion", oldVersion, "newVersion", upgradePlan.NodeVersion)
+ if len(upgradePlan.Binaries) == 0 {
+ configManager.ClearUpgradePlan()
+ }
+ }
+ }
+}
+
+func CheckForUpgrade(configManager *apiconfig.ConfigManager) bool {
+ upgradePlan := configManager.GetUpgradePlan()
+ if upgradePlan.Name == "" {
+ logging.Warn("CheckForUpgrade. Websocket closed with no upgrade (name is empty)", types.Upgrades)
+ return false
+ }
+
+ successfullyUpgraded := false
+ if configManager.GetHeight() >= upgradePlan.Height-1 {
+ logging.Info("CheckForUpgrade. Upgrade height reached", types.Upgrades, "height", upgradePlan.Height)
+
+ checkForVersionSwitch(configManager)
+ if len(upgradePlan.Binaries) == 0 {
+ return successfullyUpgraded
+ }
+
+ // Write out upgrade-info.json
+ path := getUpgradeInfoPath()
+ upgradeInfo := UpgradeInfoOutput{
+ Binaries: upgradePlan.Binaries,
+ }
+
+ jsonData, err := json.Marshal(upgradeInfo)
+ if err != nil {
+ logging.Error("Error marshaling upgrade info to JSON", types.Upgrades, "error", err)
+ return false
+ }
+ output := UpgradeOutput{
+ Name: upgradePlan.Name,
+ // We add one, because the chain quits ON the upgrade height before it sends the new block event
+ Height: upgradePlan.Height - 1,
+ Info: string(jsonData),
+ }
+ jsonData, err = json.Marshal(output)
+ if err != nil {
+ logging.Error("Error marshaling output to JSON", types.Upgrades, "error", err)
+ return false
+ }
+
+ err = os.MkdirAll(filepath.Dir(path), os.ModePerm)
+ if err != nil {
+ logging.Error("Error creating output directory", types.Upgrades, "path", path, "error", err)
+ return false
+ }
+
+ err = os.WriteFile(path, jsonData, 0644)
+ if err != nil {
+ logging.Error("Error writing output to file", types.Upgrades, "path", path, "error", err)
+ return false
+ }
+ logging.Info("Upgrade output written to file, clearing upgrade plan", types.Upgrades, "path", path)
+ configManager.ClearUpgradePlan()
+ return true
+ }
+
+ logging.Warn("Websocket closed with no upgrade", types.Upgrades, "height", configManager.GetHeight(), "upgradeHeight", upgradePlan.Height)
+ return false
+}
+
+func getUpgradeInfoPath() string {
+ return "../data/upgrade-info.json"
+}
diff --git a/decentralized-api/upgrade/types.go b/decentralized-api/upgrade/types.go
new file mode 100644
index 000000000..0e96d500d
--- /dev/null
+++ b/decentralized-api/upgrade/types.go
@@ -0,0 +1,16 @@
+package upgrade
+
+type UpgradeOutput struct {
+ Name string `json:"name"`
+ Info string `json:"info"`
+ Height int64 `json:"height"`
+}
+
+type UpgradeInfoOutput struct {
+ Binaries map[string]string `json:"binaries"`
+}
+
+type UpgradeInfoInput struct {
+ Binaries map[string]string `json:"api_binaries"`
+ NodeVersion string `json:"node_version"`
+}
diff --git a/decentralized-api/utils/api_headers.go b/decentralized-api/utils/api_headers.go
new file mode 100644
index 000000000..79ee78935
--- /dev/null
+++ b/decentralized-api/utils/api_headers.go
@@ -0,0 +1,11 @@
+package utils
+
+const (
+ AuthorizationHeader = "Authorization"
+ XSeedHeader = "X-Seed"
+ XInferenceIdHeader = "X-Inference-Id"
+ XRequesterAddressHeader = "X-Requester-Address"
+ XTimestampHeader = "X-Timestamp"
+ XTransferAddressHeader = "X-Transfer-Address"
+ XTASignatureHeader = "X-TA-Signature"
+)
diff --git a/decentralized-api/utils/hashing.go b/decentralized-api/utils/hashing.go
new file mode 100644
index 000000000..5bbb0edab
--- /dev/null
+++ b/decentralized-api/utils/hashing.go
@@ -0,0 +1,73 @@
+package utils
+
+import (
+ "bytes"
+ "crypto/sha256"
+ "encoding/hex"
+ "encoding/json"
+ "sort"
+)
+
+// CanonicalizeJSON takes a JSON byte slice and returns a canonicalized JSON string
+func CanonicalizeJSON(jsonBytes []byte) (string, error) {
+ var jsonObj interface{}
+ if err := json.Unmarshal(jsonBytes, &jsonObj); err != nil {
+ return "", err
+ }
+ // add a random seed if it doesn't exist in jsonObj
+
+ buf := &bytes.Buffer{}
+ encoder := json.NewEncoder(buf)
+ encoder.SetIndent("", "")
+ encoder.SetEscapeHTML(false)
+
+ // Recursively sort keys and encode
+ if err := encodeCanonical(encoder, jsonObj); err != nil {
+ return "", err
+ }
+
+ return buf.String(), nil
+}
+
+// encodeCanonical encodes JSON ensuring that keys are sorted
+func encodeCanonical(encoder *json.Encoder, jsonObj interface{}) error {
+ switch v := jsonObj.(type) {
+ case map[string]interface{}:
+ // Sort keys
+ keys := make([]string, 0, len(v))
+ for k := range v {
+ keys = append(keys, k)
+ }
+ sort.Strings(keys)
+
+ // Create a sorted map
+ sortedMap := make(map[string]interface{}, len(v))
+ for _, k := range keys {
+ sortedMap[k] = v[k]
+ }
+
+ // Encode sorted map
+ if err := encoder.Encode(sortedMap); err != nil {
+ return err
+ }
+
+ case []interface{}:
+ // Encode array elements
+ if err := encoder.Encode(v); err != nil {
+ return err
+ }
+
+ default:
+ // Encode other types
+ if err := encoder.Encode(v); err != nil {
+ return err
+ }
+ }
+
+ return nil
+}
+
+func GenerateSHA256Hash(text string) string {
+ hash := sha256.Sum256([]byte(text))
+ return hex.EncodeToString(hash[:])
+}
diff --git a/decentralized-api/utils/http.go b/decentralized-api/utils/http.go
new file mode 100644
index 000000000..fdf1218b2
--- /dev/null
+++ b/decentralized-api/utils/http.go
@@ -0,0 +1,85 @@
+package utils
+
+import (
+ "bytes"
+ "context"
+ "decentralized-api/logging"
+ "encoding/json"
+ "net/http"
+ "time"
+
+ "github.com/productscience/inference/x/inference/types"
+)
+
+func NewHttpClient(timeout time.Duration) *http.Client {
+ return &http.Client{
+ Timeout: timeout,
+ }
+}
+
+func SendPostJsonRequest(ctx context.Context, client *http.Client, url string, payload any) (*http.Response, error) {
+ var req *http.Request
+ var err error
+
+ if payload == nil {
+ // Create a POST request with no body if payload is nil.
+ req, err = http.NewRequestWithContext(ctx, http.MethodPost, url, nil)
+ } else {
+ // Marshal the payload to JSON.
+ jsonData, err := json.Marshal(payload)
+ if err != nil {
+ return nil, err
+ }
+ req, err = http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewBuffer(jsonData))
+ }
+
+ if err != nil {
+ return nil, err
+ }
+ if req == nil {
+ logging.Error("SendPostJsonRequest. Failed to create HTTP request", types.Server, "url", url, "payload", payload)
+ return nil, err
+ }
+
+ return client.Do(req)
+}
+
+func SendGetRequest(ctx context.Context, client *http.Client, url string) (*http.Response, error) {
+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
+ if err != nil {
+ return nil, err
+ }
+
+ return client.Do(req)
+}
+
+func SendDeleteJsonRequest(ctx context.Context, client *http.Client, url string, payload any) (*http.Response, error) {
+ var req *http.Request
+ var err error
+
+ if payload == nil {
+ // Create a DELETE request with no body if payload is nil.
+ req, err = http.NewRequestWithContext(ctx, http.MethodDelete, url, nil)
+ } else {
+ // Marshal the payload to JSON.
+ jsonData, err := json.Marshal(payload)
+ if err != nil {
+ return nil, err
+ }
+ req, err = http.NewRequestWithContext(ctx, http.MethodDelete, url, bytes.NewBuffer(jsonData))
+ if err != nil {
+ return nil, err
+ }
+ req.Header.Set("Content-Type", "application/json")
+ }
+
+ if err != nil {
+ return nil, err
+ }
+ if req == nil {
+ logging.Error("SendDeleteJsonRequest. Failed to create HTTP request", types.Server, "url", url, "payload", payload)
+ return nil, err
+ }
+
+ return client.Do(req)
+}
diff --git a/decentralized-api/utils/pagination.go b/decentralized-api/utils/pagination.go
new file mode 100644
index 000000000..c8f90fe7f
--- /dev/null
+++ b/decentralized-api/utils/pagination.go
@@ -0,0 +1,35 @@
+package utils
+
+import (
+ "fmt"
+
+ "github.com/cosmos/cosmos-sdk/types/query"
+)
+
+func GetAllWithPagination[T any](
+ queryFunc func(*query.PageRequest) ([]T, *query.PageResponse, error),
+) ([]T, error) {
+ var allItems []T
+ var nextKey []byte
+
+ for {
+ req := &query.PageRequest{
+ Key: nextKey,
+ Limit: 1000,
+ }
+
+ items, pagination, err := queryFunc(req)
+ if err != nil {
+ return nil, fmt.Errorf("failed to fetch page (items so far: %d): %w", len(allItems), err)
+ }
+
+ allItems = append(allItems, items...)
+
+ if pagination == nil || len(pagination.NextKey) == 0 {
+ break
+ }
+ nextKey = pagination.NextKey
+ }
+
+ return allItems, nil
+}
diff --git a/decentralized-api/utils/pagination_test.go b/decentralized-api/utils/pagination_test.go
new file mode 100644
index 000000000..47f7a6bad
--- /dev/null
+++ b/decentralized-api/utils/pagination_test.go
@@ -0,0 +1,132 @@
+package utils
+
+import (
+ "fmt"
+ "testing"
+
+ "github.com/cosmos/cosmos-sdk/types/query"
+ "github.com/stretchr/testify/require"
+)
+
+func TestGetAllWithPagination_SinglePage(t *testing.T) {
+ // Mock data
+ testItems := []string{"item1", "item2", "item3"}
+
+ queryFunc := func(pageReq *query.PageRequest) ([]string, *query.PageResponse, error) {
+ require.NotNil(t, pageReq)
+ require.Equal(t, uint64(1000), pageReq.Limit)
+ require.Nil(t, pageReq.Key)
+
+ return testItems, &query.PageResponse{
+ NextKey: nil,
+ Total: uint64(len(testItems)),
+ }, nil
+ }
+
+ result, err := GetAllWithPagination(queryFunc)
+ require.NoError(t, err)
+ require.Equal(t, testItems, result)
+}
+
+func TestGetAllWithPagination_MultiplePages(t *testing.T) {
+ // Mock data split across pages
+ page1Items := []string{"item1", "item2"}
+ page2Items := []string{"item3", "item4"}
+ page3Items := []string{"item5"}
+
+ callCount := 0
+ queryFunc := func(pageReq *query.PageRequest) ([]string, *query.PageResponse, error) {
+ require.NotNil(t, pageReq)
+ require.Equal(t, uint64(1000), pageReq.Limit)
+
+ callCount++
+ switch callCount {
+ case 1:
+ require.Nil(t, pageReq.Key)
+ return page1Items, &query.PageResponse{
+ NextKey: []byte("key2"),
+ Total: 5,
+ }, nil
+ case 2:
+ require.Equal(t, []byte("key2"), pageReq.Key)
+ return page2Items, &query.PageResponse{
+ NextKey: []byte("key3"),
+ Total: 5,
+ }, nil
+ case 3:
+ require.Equal(t, []byte("key3"), pageReq.Key)
+ return page3Items, &query.PageResponse{
+ NextKey: nil,
+ Total: 5,
+ }, nil
+ default:
+ t.Fatalf("Unexpected call count: %d", callCount)
+ return nil, nil, nil
+ }
+ }
+
+ result, err := GetAllWithPagination(queryFunc)
+ require.NoError(t, err)
+ require.Equal(t, 3, callCount)
+
+ expected := append(page1Items, page2Items...)
+ expected = append(expected, page3Items...)
+ require.Equal(t, expected, result)
+}
+
+func TestGetAllWithPagination_ErrorHandling(t *testing.T) {
+ queryFunc := func(pageReq *query.PageRequest) ([]string, *query.PageResponse, error) {
+ return nil, nil, fmt.Errorf("query error")
+ }
+
+ result, err := GetAllWithPagination(queryFunc)
+ require.Error(t, err)
+ require.Contains(t, err.Error(), "failed to fetch page (items so far: 0)")
+ require.Contains(t, err.Error(), "query error")
+ require.Nil(t, result)
+}
+
+func TestGetAllWithPagination_ErrorOnSecondPage(t *testing.T) {
+ callCount := 0
+ queryFunc := func(pageReq *query.PageRequest) ([]string, *query.PageResponse, error) {
+ callCount++
+ if callCount == 1 {
+ return []string{"item1"}, &query.PageResponse{
+ NextKey: []byte("key2"),
+ Total: 2,
+ }, nil
+ }
+ return nil, nil, fmt.Errorf("second page error")
+ }
+
+ result, err := GetAllWithPagination(queryFunc)
+ require.Error(t, err)
+ require.Contains(t, err.Error(), "failed to fetch page (items so far: 1)")
+ require.Contains(t, err.Error(), "second page error")
+ require.Nil(t, result)
+}
+
+func TestGetAllWithPagination_EmptyResult(t *testing.T) {
+ queryFunc := func(pageReq *query.PageRequest) ([]string, *query.PageResponse, error) {
+ return []string{}, &query.PageResponse{
+ NextKey: nil,
+ Total: 0,
+ }, nil
+ }
+
+ result, err := GetAllWithPagination(queryFunc)
+ require.NoError(t, err)
+ require.Empty(t, result)
+}
+
+func TestGetAllWithPagination_NilPagination(t *testing.T) {
+ testItems := []string{"item1", "item2"}
+
+ queryFunc := func(pageReq *query.PageRequest) ([]string, *query.PageResponse, error) {
+ return testItems, nil, nil
+ }
+
+ result, err := GetAllWithPagination(queryFunc)
+ require.NoError(t, err)
+ require.Equal(t, testItems, result)
+}
diff --git a/deploy/join/config.env.template b/deploy/join/config.env.template
new file mode 100644
index 000000000..c8392a8f2
--- /dev/null
+++ b/deploy/join/config.env.template
@@ -0,0 +1,20 @@
+export KEY_NAME=
+export KEYRING_PASSWORD=
+export API_PORT=8000
+export API_SSL_PORT=8443
+export PUBLIC_URL=http://:
+export P2P_EXTERNAL_ADDRESS=tcp://:
+export ACCOUNT_PUBKEY=
+export NODE_CONFIG=./node-config.json
+export HF_HOME=/mnt/shared
+export SEED_API_URL=http://node2.gonka.ai:8000
+export SEED_NODE_RPC_URL=http://node2.gonka.ai:26657
+export SEED_NODE_P2P_URL=tcp://node2.gonka.ai:5000
+export DAPI_API__POC_CALLBACK_URL=http://api:9100
+export DAPI_CHAIN_NODE__URL=http://node:26657
+export DAPI_CHAIN_NODE__P2P_URL=http://node:26656
+export RPC_SERVER_URL_1=http://node1.gonka.ai:26657
+export RPC_SERVER_URL_2=http://node2.gonka.ai:26657
+export PORT=8080
+export INFERENCE_PORT=5050
+export KEYRING_BACKEND=file
\ No newline at end of file
diff --git a/deploy/join/docker-compose.mlnode.yml b/deploy/join/docker-compose.mlnode.yml
new file mode 100644
index 000000000..9dc8d895a
--- /dev/null
+++ b/deploy/join/docker-compose.mlnode.yml
@@ -0,0 +1,31 @@
+services:
+ mlnode-308:
+ # ghcr.io/product-science/mlnode:3.0.11-blackwell for Blackwell GPU (CUDA 12.8+)
+ image: ghcr.io/product-science/mlnode:3.0.11
+ hostname: mlnode-308
+ volumes:
+ - ${HF_HOME:-${HOME}/.cache}:/root/.cache
+ environment:
+ - HF_HOME=/root/.cache
+ - VLLM_ATTENTION_BACKEND=FLASHINFER
+ deploy:
+ resources:
+ reservations:
+ devices:
+ - driver: nvidia
+ count: all
+ capabilities: [gpu]
+ ipc: host
+ command: uvicorn api.app:app --host=0.0.0.0 --port=8080
+ restart: always
+
+ inference:
+ image: nginx:1.28.0
+ hostname: inference
+ ports:
+ - "${PORT:-8080}:8080"
+ - "${INFERENCE_PORT:-5050}:5000"
+ volumes:
+ - ./nginx.conf:/etc/nginx/nginx.conf:ro
+ restart: always
+
diff --git a/deploy/join/docker-compose.yml b/deploy/join/docker-compose.yml
new file mode 100644
index 000000000..1370017a9
--- /dev/null
+++ b/deploy/join/docker-compose.yml
@@ -0,0 +1,187 @@
+services:
+ tmkms:
+ image: ghcr.io/product-science/tmkms-softsign-with-keygen:0.2.5
+ container_name: tmkms
+ restart: unless-stopped
+ environment:
+ - VALIDATOR_LISTEN_ADDRESS=tcp://node:${TMKMS_PORT:-26658}
+ volumes:
+ - .tmkms:/root/.tmkms
+
+ node:
+ container_name: node
+ image: ghcr.io/product-science/inferenced:0.2.5
+ command: ["sh", "./init-docker.sh"]
+ volumes:
+ - .inference:/root/.inference
+ - ../../genesis/genesis.json:/root/genesis.json
+ environment:
+ - SEED_NODE_RPC_URL=${SEED_NODE_RPC_URL}
+ - SEED_NODE_P2P_URL=${SEED_NODE_P2P_URL}
+ - SNAPSHOT_INTERVAL=1000
+ - SNAPSHOT_KEEP_RECENT=5
+ - TRUSTED_BLOCK_PERIOD=${TRUSTED_BLOCK_PERIOD:-2000}
+ - KEY_NAME=${KEY_NAME}
+ - P2P_EXTERNAL_ADDRESS=${P2P_EXTERNAL_ADDRESS}
+ - CONFIG_p2p__allow_duplicate_ip=true
+ - CONFIG_p2p__handshake_timeout=30s
+ - CONFIG_p2p__dial_timeout=30s
+ - TMKMS_PORT=${TMKMS_PORT:-26658}
+ - SYNC_WITH_SNAPSHOTS=${SYNC_WITH_SNAPSHOTS:-true}
+ - RPC_SERVER_URL_1=${RPC_SERVER_URL_1}
+ - RPC_SERVER_URL_2=${RPC_SERVER_URL_2}
+ - REST_API_ACTIVE=true
+ - INIT_ONLY=false
+ - IS_GENESIS=false
+ - GENESIS_SEEDS=780e60b5defca577a160590e0bf51c6bb916d2c6@gonka.spv.re:5000,39ebfea6d2ab91e90c26cb702345cfa2f9bc611b@47.236.26.199:5000,645fbce2dedcc7166f4df7931d2c87ca5188b569@node2.gonka.ai:5000,6140f7090137d93c272ff5ccd863484d1592949d@node3.gonka.ai:5000,947a89a2d5f2af45cb7853f56be0bab8303ffce9@36.189.234.197:18027,78f3279bd30fe6f1b84a9c40c3b97bd74e575981@185.216.21.98:5000,d53a970a40231474fb4092ee64609b975d906085@47.236.19.22:15000,b7dd3863523d78cc5a7c56ddb786395fe49c954a@93.119.168.58:5000,b4ad5a33520ce10d0b7ed5193e2de71e2f1f7a51@36.189.234.237:17240,0772f16cc65cb4d19341b192bd7eba964f11d124@node1.gonka.ai:5000,4d63a0411a257669e794ff62f801550a8449d239@69.19.136.233:5000
+ ports:
+ - "5000:26656" #p2p
+ - "26657:26657" #rpc
+ expose:
+ - "${TMKMS_PORT:-26658}"
+ depends_on:
+ - tmkms
+ restart: always
+
+ api:
+ container_name: api
+ image: ghcr.io/product-science/api:0.2.5
+ volumes:
+ - .inference:/root/.inference
+ - .dapi:/root/.dapi
+ - ${NODE_CONFIG:-./node-config.json}:/root/node_config.json
+ depends_on:
+ - node
+ environment:
+ - KEY_NAME=${KEY_NAME}
+ - ACCOUNT_PUBKEY=${ACCOUNT_PUBKEY}
+ - KEYRING_BACKEND=file
+ - KEYRING_PASSWORD=${KEYRING_PASSWORD}
+ - DAPI_API__POC_CALLBACK_URL=${DAPI_API__POC_CALLBACK_URL}
+ - DAPI_API__PUBLIC_URL=${PUBLIC_URL}
+ - DAPI_CHAIN_NODE__SEED_API_URL=${SEED_API_URL}
+ - DAPI_CHAIN_NODE__URL=${DAPI_CHAIN_NODE__URL}
+ - DAPI_CHAIN_NODE__P2P_URL=${DAPI_CHAIN_NODE__P2P_URL}
+ - NODE_CONFIG_PATH=/root/node_config.json
+ - DAPI_API__PUBLIC_SERVER_PORT=9000
+ - DAPI_API__ML_SERVER_PORT=9100
+ - DAPI_API__ADMIN_SERVER_PORT=9200
+ ports:
+ - "9100:9100"
+ - "127.0.0.1:9200:9200"
+ restart: always
+
+ bridge:
+ container_name: bridge
+ image: ghcr.io/product-science/bridge:0.2.5
+ restart: unless-stopped
+ environment:
+ - GETH_DATA_DIR=/data/geth
+ - PRYSM_DATA_DIR=/data/prysm
+ - JWT_SECRET_PATH=/data/jwt/jwt.hex
+ - BRIDGE_POSTBLOCK=http://api:9200/admin/v1/bridge/block
+ - BRIDGE_GETADDRESSES=http://api:9000/v1/bridge/addresses
+ - BEACON_STATE_URL=https://beaconstate.ethstaker.cc/
+ - PERSISTENT_DB_DIR=/persistent-db
+ volumes:
+ - .inference-eth/geth:/data/geth
+ - .inference-eth/prysm:/data/prysm
+ - .inference-eth/jwt:/data/jwt
+ - .inference-eth/logs:/var/log
+ - .inference-eth/persistent-db:/persistent-db
+ depends_on:
+ - api
+
+ proxy:
+ container_name: proxy
+ image: ghcr.io/product-science/proxy:0.2.5
+ ports:
+ - "${API_PORT:-8000}:80"
+ - "${API_SSL_PORT:-8443}:443"
+ environment:
+ - NGINX_MODE=${NGINX_MODE:-http}
+ - SERVER_NAME=${SERVER_NAME:-}
+ - GONKA_API_PORT=9000
+ - CHAIN_RPC_PORT=26657
+ - CHAIN_API_PORT=1317
+ - CHAIN_GRPC_PORT=9090
+ - DASHBOARD_PORT=5173
+ # SSL enablement (entrypoint enables SSL if CERT_ISSUER_DOMAIN is set)
+ - CERT_ISSUER_DOMAIN=${CERT_ISSUER_DOMAIN:-}
+ - PROXY_ADD_NODE_PREFIX=${PROXY_ADD_NODE_PREFIX:-false}
+ # Optional: override proxy-ssl discovery
+ - PROXY_SSL_SERVICE_NAME=${PROXY_SSL_SERVICE_NAME:-proxy-ssl}
+ - PROXY_SSL_PORT=${PROXY_SSL_PORT:-8080}
+ volumes:
+ - ${SSL_CERT_SOURCE:-./secrets/nginx-ssl}:/etc/nginx/ssl
+ depends_on:
+ node:
+ condition: service_started
+ api:
+ condition: service_started
+ explorer:
+ condition: service_started
+ proxy-ssl:
+ condition: service_healthy
+ required: false
+ restart: unless-stopped
+ healthcheck:
+ test: ["CMD", "curl", "-f", "http://localhost/health"]
+ interval: 30s
+ timeout: 10s
+ retries: 3
+ start_period: 10s
+
+ proxy-ssl:
+ container_name: proxy-ssl
+ image: ghcr.io/product-science/proxy-ssl:0.2.5
+ profiles:
+ - ssl
+ environment:
+ # ACME Configuration
+ - ACME_ACCOUNT_EMAIL=${ACME_ACCOUNT_EMAIL:-}
+ - ACME_DNS_PROVIDER=${ACME_DNS_PROVIDER:-}
+
+ # Service Configuration
+ - CERT_ISSUER_DOMAIN=${CERT_ISSUER_DOMAIN:-}
+ - CERT_ISSUER_ALLOWED_SUBDOMAINS=${CERT_ISSUER_ALLOWED_SUBDOMAINS:-}
+ - CERT_ISSUER_JWT_SECRET=${CERT_ISSUER_JWT_SECRET:-}
+
+ # DNS Provider Configuration (if needed for your provider)
+ # AWS
+ - AWS_ACCESS_KEY_ID=${AWS_ACCESS_KEY_ID:-}
+ - AWS_SECRET_ACCESS_KEY=${AWS_SECRET_ACCESS_KEY:-}
+ - AWS_REGION=${AWS_REGION:-us-east-1}
+ # Cloudflare
+ - CF_DNS_API_TOKEN=${CF_DNS_API_TOKEN:-}
+ # Google Cloud
+ - GCE_PROJECT=${GCE_PROJECT:-}
+ - GCE_SERVICE_ACCOUNT_JSON_B64=${GCE_SERVICE_ACCOUNT_JSON_B64:-}
+ # Azure
+ - AZURE_CLIENT_ID=${AZURE_CLIENT_ID:-}
+ - AZURE_CLIENT_SECRET=${AZURE_CLIENT_SECRET:-}
+ - AZURE_SUBSCRIPTION_ID=${AZURE_SUBSCRIPTION_ID:-}
+ - AZURE_TENANT_ID=${AZURE_TENANT_ID:-}
+ # DigitalOcean
+ - DO_AUTH_TOKEN=${DO_AUTH_TOKEN:-}
+ # Hetzner
+ - HETZNER_API_KEY=${HETZNER_API_KEY:-}
+ volumes:
+ - ./secrets/nginx-ssl:/app/certs
+ - ./secrets/certbot:/app/data
+ restart: unless-stopped
+ healthcheck:
+ test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
+ interval: 30s
+ timeout: 5s
+ retries: 5
+ start_period: 10s
+
+ explorer:
+ container_name: explorer
+ image: ghcr.io/product-science/explorer:latest
+ expose:
+ - "5173"
+ restart: unless-stopped
+
+
diff --git a/deploy/join/nginx.conf b/deploy/join/nginx.conf
new file mode 100644
index 000000000..4cf515ffa
--- /dev/null
+++ b/deploy/join/nginx.conf
@@ -0,0 +1,70 @@
+events {}
+
+http {
+
+ resolver 127.0.0.11 valid=10s;
+ resolver_timeout 5s;
+
+ upstream mlnode_v308 {
+ zone mlnode_v308 64k;
+ server mlnode-308:8080 resolve;
+ }
+
+ server {
+ listen 8080;
+
+ # --- SETTINGS FOR UNLIMITED SIZE & TIMEOUT ---
+ client_max_body_size 0; # No limit on request body size
+ proxy_connect_timeout 24h; # Long timeout for connection
+ proxy_send_timeout 24h; # Long timeout for sending data
+ proxy_read_timeout 24h; # Long timeout for receiving data
+
+ # Route for the new version
+ location /v3.0.8/ {
+ proxy_pass http://mlnode_v308/;
+ proxy_set_header Host $host;
+ proxy_set_header X-Real-IP $remote_addr;
+ proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+ }
+
+ # Default route for backward compatibility
+ location / {
+ proxy_pass http://mlnode_v308/;
+ proxy_set_header Host $host;
+ proxy_set_header X-Real-IP $remote_addr;
+ proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+ }
+ }
+
+ upstream mlnode_v308_port5000 {
+ zone mlnode_v308_port5000 64k;
+ server mlnode-308:5000 resolve;
+ }
+
+ server {
+ # Temporary server block for backward compatibility when 2 ports are used
+ listen 5000;
+
+ # --- SETTINGS FOR UNLIMITED SIZE & TIMEOUT ---
+ client_max_body_size 0; # No limit on request body size
+ proxy_connect_timeout 24h; # Long timeout for connection
+ proxy_send_timeout 24h; # Long timeout for sending data
+ proxy_read_timeout 24h; # Long timeout for receiving data
+
+ # Route for the new version
+ location /v3.0.8/ {
+ proxy_pass http://mlnode_v308_port5000/;
+ proxy_set_header Host $host;
+ proxy_set_header X-Real-IP $remote_addr;
+ proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+ }
+
+ # Default route for backward compatibility
+ location / {
+ proxy_pass http://mlnode_v308_port5000/;
+ proxy_set_header Host $host;
+ proxy_set_header X-Real-IP $remote_addr;
+ proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+ }
+ }
+}
\ No newline at end of file
diff --git a/deploy/join/node-config-8x3080.json b/deploy/join/node-config-8x3080.json
new file mode 100644
index 000000000..b12ca17de
--- /dev/null
+++ b/deploy/join/node-config-8x3080.json
@@ -0,0 +1,21 @@
+[
+ {
+ "id": "node1",
+ "host": "inference",
+ "inference_port": 5000,
+ "poc_port": 8080,
+ "max_concurrent": 500,
+ "models": {
+ "Qwen/Qwen2.5-7B-Instruct": {
+ "args": [
+ "--quantization",
+ "fp8",
+ "--tensor-parallel-size",
+ "4",
+ "--pipeline-parallel-size",
+ "2"
+ ]
+ }
+ }
+ }
+]
\ No newline at end of file
diff --git a/deploy/join/node-config-qwq-4x3090.json b/deploy/join/node-config-qwq-4x3090.json
new file mode 100644
index 000000000..d30a2506a
--- /dev/null
+++ b/deploy/join/node-config-qwq-4x3090.json
@@ -0,0 +1,21 @@
+[
+ {
+ "id": "node1",
+ "host": "inference",
+ "inference_port": 5000,
+ "poc_port": 8080,
+ "max_concurrent": 500,
+ "models": {
+ "Qwen/QwQ-32B": {
+ "args": [
+ "--quantization",
+ "fp8",
+ "--tensor-parallel-size",
+ "4",
+ "--kv-cache-dtype",
+ "fp8"
+ ]
+ }
+ }
+ }
+]
\ No newline at end of file
diff --git a/deploy/join/node-config-qwq-8x3090.json b/deploy/join/node-config-qwq-8x3090.json
new file mode 100644
index 000000000..52564ef01
--- /dev/null
+++ b/deploy/join/node-config-qwq-8x3090.json
@@ -0,0 +1,23 @@
+[
+ {
+ "id": "node1",
+ "host": "inference",
+ "inference_port": 5000,
+ "poc_port": 8080,
+ "max_concurrent": 500,
+ "models": {
+ "Qwen/QwQ-32B": {
+ "args": [
+ "--quantization",
+ "fp8",
+ "--tensor-parallel-size",
+ "4",
+ "--pipeline-parallel-size",
+ "2",
+ "--kv-cache-dtype",
+ "fp8"
+ ]
+ }
+ }
+ }
+]
\ No newline at end of file
diff --git a/deploy/join/node-config-qwq.json b/deploy/join/node-config-qwq.json
new file mode 100644
index 000000000..ee3473d98
--- /dev/null
+++ b/deploy/join/node-config-qwq.json
@@ -0,0 +1,19 @@
+[
+ {
+ "id": "node1",
+ "host": "inference",
+ "inference_port": 5000,
+ "poc_port": 8080,
+ "max_concurrent": 500,
+ "models": {
+ "Qwen/QwQ-32B": {
+ "args": [
+ "--quantization",
+ "fp8",
+ "--kv-cache-dtype",
+ "fp8"
+ ]
+ }
+ }
+ }
+]
\ No newline at end of file
diff --git a/deploy/join/node-config.json b/deploy/join/node-config.json
new file mode 100644
index 000000000..0ca5c2c5e
--- /dev/null
+++ b/deploy/join/node-config.json
@@ -0,0 +1,19 @@
+[
+ {
+ "id": "node1",
+ "host": "inference",
+ "inference_port": 5000,
+ "poc_port": 8080,
+ "max_concurrent": 500,
+ "models": {
+ "Qwen/Qwen2.5-7B-Instruct": {
+ "args": [
+ "--quantization",
+ "fp8",
+ "--gpu-memory-utilization",
+ "0.9"
+ ]
+ }
+ }
+ }
+]
\ No newline at end of file
diff --git a/deploy/test/docker-compose.mlnode.yml b/deploy/test/docker-compose.mlnode.yml
new file mode 100644
index 000000000..d19a35b0a
--- /dev/null
+++ b/deploy/test/docker-compose.mlnode.yml
@@ -0,0 +1,52 @@
+services:
+ mlnode-308:
+ image: ghcr.io/product-science/mlnode:3.0.8
+ hostname: mlnode-308
+ volumes:
+ - ${HF_HOME:-${HOME}/.cache}:/root/.cache
+ environment:
+ - HF_HOME=/root/.cache
+ - VLLM_ATTENTION_BACKEND=FLASHINFER
+ - HF_HUB_OFFLINE=true
+ deploy:
+ resources:
+ reservations:
+ devices:
+ - driver: nvidia
+ count: all
+ capabilities: [gpu]
+ ipc: host
+ command: uvicorn api.app:app --host=0.0.0.0 --port=8080
+ restart: always
+
+ mlnode-309:
+ image: ghcr.io/product-science/mlnode:3.0.8
+ hostname: mlnode-309
+ volumes:
+ - ${HF_HOME:-${HOME}/.cache}:/root/.cache
+ environment:
+ - HF_HOME=/root/.cache
+ - VLLM_ATTENTION_BACKEND=FLASHINFER
+ - HF_HUB_OFFLINE=true
+ deploy:
+ resources:
+ reservations:
+ devices:
+ - driver: nvidia
+ count: all
+ capabilities: [gpu]
+ ipc: host
+ command: uvicorn api.app:app --host=0.0.0.0 --port=8080
+ restart: always
+
+
+ inference:
+ image: nginx:1.28.0
+ hostname: inference
+ ports:
+ - "${PORT:-8080}:8080"
+ - "${INFERENCE_PORT:-5050}:5000"
+ volumes:
+ - ./nginx.conf:/etc/nginx/nginx.conf:ro
+ restart: always
+
diff --git a/deploy/test/nginx.conf b/deploy/test/nginx.conf
new file mode 100644
index 000000000..0cfc49161
--- /dev/null
+++ b/deploy/test/nginx.conf
@@ -0,0 +1,87 @@
+events {}
+
+http {
+
+ upstream mlnode_v308 {
+ server mlnode-308:8080;
+ }
+
+ upstream mlnode_v309 {
+ server mlnode-309:8080;
+ }
+
+ server {
+ listen 8080;
+
+ # --- SETTINGS FOR UNLIMITED SIZE & TIMEOUT ---
+ client_max_body_size 0; # No limit on request body size
+ proxy_connect_timeout 24h; # Long timeout for connection
+ proxy_send_timeout 24h; # Long timeout for sending data
+ proxy_read_timeout 24h; # Long timeout for receiving data
+
+ # Route for the new version
+ location /v3.0.8/ {
+ proxy_pass http://mlnode_v308/;
+ proxy_set_header Host $host;
+ proxy_set_header X-Real-IP $remote_addr;
+ proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+ }
+
+ location /v3.0.9/ {
+ proxy_pass http://mlnode_v309/;
+ proxy_set_header Host $host;
+ proxy_set_header X-Real-IP $remote_addr;
+ proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+ }
+
+ # Default route for backward compatibility
+ location / {
+ proxy_pass http://mlnode_v308/;
+ proxy_set_header Host $host;
+ proxy_set_header X-Real-IP $remote_addr;
+ proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+ }
+ }
+
+ upstream mlnode_v308_port5000 {
+ server mlnode-308:5000;
+ }
+
+ upstream mlnode_v309_port5000 {
+ server mlnode-309:5000;
+ }
+
+ server {
+ # Temporary server block for backward compatibility when 2 ports are used
+ listen 5000;
+
+ # --- SETTINGS FOR UNLIMITED SIZE & TIMEOUT ---
+ client_max_body_size 0; # No limit on request body size
+ proxy_connect_timeout 24h; # Long timeout for connection
+ proxy_send_timeout 24h; # Long timeout for sending data
+ proxy_read_timeout 24h; # Long timeout for receiving data
+
+ # Route for the new version
+ location /v3.0.8/ {
+ proxy_pass http://mlnode_v308_port5000/;
+ proxy_set_header Host $host;
+ proxy_set_header X-Real-IP $remote_addr;
+ proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+ }
+
+ location /v3.0.9/ {
+ proxy_pass http://mlnode_v309_port5000/;
+ proxy_set_header Host $host;
+ proxy_set_header X-Real-IP $remote_addr;
+ proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+ }
+
+ # Default route for backward compatibility
+ location / {
+ proxy_pass http://mlnode_v308_port5000/;
+ proxy_set_header Host $host;
+ proxy_set_header X-Real-IP $remote_addr;
+ proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+ }
+ }
+}
\ No newline at end of file
diff --git a/dev_notes/build.md b/dev_notes/build.md
new file mode 100644
index 000000000..e4b6cd9ac
--- /dev/null
+++ b/dev_notes/build.md
@@ -0,0 +1,12 @@
+# Notes on build issues/fixes
+**Issue**
+
+Duing build, something like
+```aiignore
+17.20 google.golang.org/protobuf/internal/filedesc: /usr/local/go/pkg/tool/linux_amd64/compile: signal: illegal instruction
+```
+**Solution**
+
+Rerun the build
+
+-----
diff --git a/dev_notes/debugging_consensus_failure.md b/dev_notes/debugging_consensus_failure.md
new file mode 100644
index 000000000..378bfe6af
--- /dev/null
+++ b/dev_notes/debugging_consensus_failure.md
@@ -0,0 +1,38 @@
+# Debugging Consensus Failure
+A consensus failure will bring your test net to an absolute halt, with a message like this:
+```
+8:21AM ERR CONSENSUS FAILURE!!! err="+2/3 committed an invalid block: wrong Block.Header.AppHash. Expected EA8EB0F570057ACD72D1D6190A780F4B66419ED9AA7AB623BC2956168C9C5C3E, got 5CB2D60B9595359B3C55F87F3E571B2893944455BCF31357E5F2606E11E3FDB9" module=consensus stack="goroutine 242 [running]:
+runtime/debug.Stack()
+ /usr/local/go/src/runtime/debug/stack.go:26 +0x5e
+github.com/cometbft/cometbft/consensus.(*State).receiveRoutine.func2()
+...
+```
+
+It means that your nodes have calculated the state differently, and therefore have different hashes.
+
+**Be sure it's a wrong AppHash**. You can get other failures for when there is an error during the time you BUILD consensus, they will be a CONSENSUS FAILURE!!! but with different error messages.
+
+## Main Causes
+At present, there are two causes we have seen:
+### Randomness in state calculation
+All GUIDs, random numbers and anything else using randomness has to be calculated OUTSIDE chain state calculation. Any randomness in state calculations means consensus cannot be reached.
+### Go's map iteration order
+When iterating over a Go map, the order is **indeterminate**. It may be the same as another node, it MAY NOT. **This means any maps in your state will break your consensus**. It also means any iteration over maps that is **used** to generate lists or maps will ALSO break consensus.
+
+## Debugging
+It _should_ be pretty obvious when this happens, because you _just_ made some code changes and ran tests, and saw the failure. Then you smack your forehead, say "Oh yeah, don't use maps", and fix the issue.
+
+**However**, if you're not sure, you can debug the state:
+1. Note the block height of the failure.
+1. Exec into a container that's running the node.
+2. Run `inferenced export --height `.
+3. The state will be in json on stdout.
+4. Repeat this same process with other nodes
+
+Now you can compare the json (after formatting it) and you'll see where the states of each node differed. That should be enough to zero in on the issue.
+
+## Fixes
+1. **Don't use maps**. Use slices or arrays. If we *need* maps, we'll need to implement a deterministic map.
+2. **Don't use randomness** in state calculations. If you need randomness, it should be calculated outside of the state calculation. Passing it in from the API when creating a message, for example.
+3. **Don't use map iteration to generate lists or maps**. If you need to do this, you'll need to implement a deterministic map, or you'll need to iterate on a sorted list of keys.
+
diff --git a/dev_notes/ignite_cheat_sheet.md b/dev_notes/ignite_cheat_sheet.md
new file mode 100644
index 000000000..af2a5a854
--- /dev/null
+++ b/dev_notes/ignite_cheat_sheet.md
@@ -0,0 +1,41 @@
+# Ignite Cheat Sheet
+Some tips for how to use Cosmos Ignite to update and create things:
+
+## Add new store object:
+
+`ignite scaffold map participant reputation:int weight:int join_time:uint join_height:int last_inference_time:uint --index address --module inference --no-message`
+
+- **Be sure to include --no-message**, or else the store object will be modifiable simply by messages sent to the chain.
+- Prefer snake_case
+- Since address is added as an index, it doesn't need to be added as a field
+- You can have multiple fields as an index by using the --index parameter multiple times (`--index key1 --index key2`)
+
+## Add new message:
+`ignite scaffold message createGame black red --module checkers --response gameIndex`
+
+## Add new query:
+`ignite scaffold query getGameResult gameIndex --module checkers --response result`
+
+## Types that can be used in above CLI calls:
+
+| Type | Alias | Index | Code Type | Description |
+| ------------ | ------- | ----- | --------- | ------------------------------- |
+| string | - | yes | string | Text type |
+| array.string | strings | no | []string | List of text type |
+| bool | - | yes | bool | Boolean type |
+| int | - | yes | int32 | Integer type |
+| array.int | ints | no | []int32 | List of integers types |
+| uint | - | yes | uint64 | Unsigned integer type |
+| array.uint | uints | no | []uint64 | List of unsigned integers types |
+| coin | - | no | sdk.Coin | Cosmos SDK coin type |
+| array.coin | coins | no | sdk.Coins | List of Cosmos SDK coin types |
+| | | | | |
+
+
+## Modify existing store object:
+change the types in the `.proto` file for the store object and then run:
+`ignite generate proto-go`
+
+## Modify existing message:
+Change the types in `tx.proto` and then run:
+`ignite generate proto-go`
\ No newline at end of file
diff --git a/docs/consumer_setup.md b/docs/consumer_setup.md
new file mode 100644
index 000000000..f6185b491
--- /dev/null
+++ b/docs/consumer_setup.md
@@ -0,0 +1,161 @@
+
+
+---
+
+### **Step-by-Step Guide for Local Setup, Account Registration, and Sending Inference Requests**
+
+---
+
+### **Step 1: Install the `inferenced` Binary**
+
+Before starting, ensure you have the `inferenced` binary installed on your local machine. If you haven’t installed it yet, follow these steps:
+1. **Download the binary** from our official repository or website (link provided by your team).
+2. Make the binary executable by running:
+ ```bash
+ chmod +x inferenced
+ ```
+3. **Move it** to your path or use it from its current location:
+ ```bash
+ sudo mv inferenced /usr/local/bin/
+ ```
+
+Now, you should be ready to use `inferenced` from your terminal.
+
+---
+
+### **Step 2: Create a New Account Locally**
+
+To participate in the network, you need to create a local account. This will generate a public/private keypair and an account address.
+
+1. Run the following command to create a new account:
+ ```bash
+ inferenced keys add {{account_name}}
+ ```
+
+ - This will generate and display your **private key**, **public key**, and **account address**.
+ - **IMPORTANT:** Safely back up your private key (this is the only way to access your account and sign requests).
+
+2. You can verify your keys at any time using:
+ ```bash
+ inferenced keys list
+ ```
+
+3. Copy down your **public key** and **account address** from the output, as you’ll need them for the next step.
+
+---
+
+### **Step 3: Register Your Account and Get Test Tokens**
+
+Now that you have your account address and public key, you'll need to submit these to the API to get your account registered and receive some initial coins for making inference requests.
+
+1. Submit your public key and account address via the provided faucet API. Here’s an example using `curl`:
+
+ ```bash
+ curl -X POST https://api.yourchain.com/v1/participants \
+ -H "Content-Type: application/json" \
+ -d '{
+ "pub_key": "{{your_public_key}}",
+ "address": "{{your_account_address}}"
+ }'
+ ```
+
+ Replace `{{your_public_key}}` and `{{your_account_address}}` with the values generated in Step 2.
+
+1. The API will register your account and mint some initial tokens for you, which can be used for submitting inference requests. You’ll get a response confirming the successful registration and coin minting.
+2. You can verify you have been added and the amount of coin available by another request
+
+```bash
+curl -X GET https://api.yourchain.com/v1/participants/{{your_account_address}}
+```
+
+
+---
+
+### **Step 4: Prepare and Sign an Inference Request**
+
+Once your account is set up and funded, you can prepare an inference request, sign it locally using your private key, and then submit it to the inference API.
+
+1. **Prepare your request payload**. Save your request data to a file, for example `request_payload.json`. Here’s a sample of what the payload might look like:
+
+ ```json
+ {
+ "model": "your_model_name",
+ "data": "input_data_for_inference",
+ "parameters": {
+ "param1": "value1",
+ "param2": "value2"
+ }
+ }
+ ```
+
+2. **Sign the payload** using your private key:
+ ```bash
+ inferenced signature create --account-address {{your_account_address}} --file request_payload.json
+ ```
+
+ - Replace `{{your_account_address}}` with the address generated in Step 2.
+ - The `--file` flag should point to the file containing your request payload.
+ - This command will generate a **signature** based on the payload, which you will include in the next step.
+
+3. **Copy the output signature** from the command. This will be used when submitting your inference request to the API.
+
+---
+
+### **Step 5: Submit the Inference Request to the API**
+
+Now that you have signed your payload, you’re ready to submit the inference request to the API.
+
+1. Use the following `curl` command to submit your signed inference request:
+ ```bash
+ curl -X POST https://api.yourchain.com/v1/chat/completions \
+ -H "Content-Type: application/json" \
+ -H "Authorization: {{your_signature}}" \
+ -H "X-Requester-Address: {{your_account_address}}" \
+ --data-binary @request_payload.json
+ ```
+
+ - Replace `{{your_signature}}` with the signature you generated in Step 4.
+ - Replace `{{your_account_address}}` with the account address generated in Step 2.
+ - The `request_payload.json` file should contain your inference request data.
+
+2. The API will process the inference request, debit the necessary coins from your account, and return the inference result once complete.
+
+---
+
+### **Additional Commands for Key Management**
+
+Here are some additional commands you can use for managing your keys locally:
+
+- **List your keys**:
+ ```bash
+ inferenced keys list
+ ```
+
+- **Export your account’s public key**:
+ ```bash
+ inferenced keys show {{account_name}} --pubkey
+ ```
+
+- **Import an existing account**:
+ ```bash
+ inferenced keys add {{account_name}} --recover
+ ```
+
+- **Delete an account** (use with caution):
+ ```bash
+ inferenced keys delete {{account_name}}
+ ```
+
+- **Export your account’s private key** (use carefully!):
+ ```bash
+ inferenced keys export {{account_name}}
+ ```
+
+---
+
+### **Conclusion**
+
+These steps allow you to create and manage your account keys locally, register your account with the network, receive tokens, and sign inference request payloads. Once signed, you can submit those requests to the network for processing.
+
+This flow works entirely with the `inferenced` binary running locally and requires no direct interaction with the chain from the user’s local machine.
+
diff --git a/docs/cosmos_changes.md b/docs/cosmos_changes.md
new file mode 100644
index 000000000..f1ea2d8ee
--- /dev/null
+++ b/docs/cosmos_changes.md
@@ -0,0 +1,33 @@
+# Staking, Compute, and Slashing Module Changes
+
+This document describes the modifications made to the Cosmos SDK to support Gonka's Proof of Compute (PoC) consensus mechanism. These changes are published in our fork at: https://github.com/product-science/cosmos-sdk/tree/release/v0.53.x
+
+This set of changes introduces a significant overhaul of the `x/staking` module to disconnect it from real tokenomics. The primary goal is to base validator consensus power on an external "Proof of Compute" (PoC) metric, rather than on bonded tokens. This involves fundamental changes to staking, slashing, and bank logic.
+
+## Key Changes
+
+### 1. Staking Logic Override & "Compute Power"
+
+A new system based on "compute power" has been introduced, completely overriding the standard token-bonding staking logic.
+
+- **`x/staking/keeper/compute.go`**: This new file introduces `SetComputeValidators`, which is the primary entry point for managing the validator set. It takes a list of `ComputeResult` objects (containing a public key and power) and reconciles it with the current validator set.
+- **No Token Bonding**: The traditional mechanism of bonding tokens is entirely bypassed.
+ - In `x/staking/keeper/delegation.go`, the `Delegate` function now includes a check (`validator.Description.Details != "Created after Proof of Compute"`) to avoid moving tokens for these new compute-based validators.
+ - In `x/staking/keeper/val_state_change.go`, the logic to transfer tokens between the `bonded` and `not-bonded` pools has been removed.
+- **Manual `TotalBondedTokens`**: The `TotalBondedTokens` function in `x/staking/keeper/pool.go` no longer checks the bank module's balance. Instead, it manually iterates through all validators and sums their `Tokens` field to calculate the total bonded power.
+
+### 2. Power Calculation and Validator Updates
+
+- **`DefaultPowerReduction`**: This parameter in `types/staking.go` has been changed from `1,000,000` to `1`. This makes it so that any non-zero amount of tokens (representing compute power) translates to consensus power, accommodating a different power scale.
+- **Validator Power Indexing**: Logic in `x/staking/keeper/compute.go` now correctly manages the power index by explicitly calling `DeleteValidatorByPowerIndex` before setting the new power and calling `SetValidatorByPowerIndex`. This addresses issues with validator power updates in CometBFT.
+
+### 3. Slashing Mechanism Modified for Safe Hook Triggering
+
+- **Staking Module Made Safe**: The core `Slash` function in `x/staking/keeper/slash.go` has been modified to no longer burn tokens. Its purpose is now to reduce a validator's abstract "compute power" and to trigger hooks for other modules.
+- **Safe Hook Mechanism**: This two-part change ensures that when a validator is offline, the system can safely trigger the `BeforeValidatorSlashed` hook without causing a chain halt. This allows a separate collateral module to be reliably notified and to apply real financial penalties, while the staking module only manages consensus status and abstract power scores.
+
+### 4. Enhanced Logging
+
+- **Insufficient Funds**: The `subUnlockedCoins` function in `x/bank/keeper/send.go` has been updated with detailed logging, including a stack trace, to make debugging `ErrInsufficientFunds` errors easier.
+- **Validator Updates**: Extensive logging was added to the `ApplyAndReturnValidatorSetUpdates` function to trace the lifecycle of validators during state changes.
+- **Gas Costs**: The `gasCostPerIteration` in `x/group/keeper/msg_server.go` was set to `0` to remove gas costs for certain operations.
\ No newline at end of file
diff --git a/docs/gonka_poc.md b/docs/gonka_poc.md
new file mode 100644
index 000000000..b7d71a58b
--- /dev/null
+++ b/docs/gonka_poc.md
@@ -0,0 +1,224 @@
+# Gonka Proof of Compute (PoC) Design
+
+This document describes the complete Proof of Compute design and workflow in the Gonka network. The PoC system determines validator consensus power based on computational performance rather than token bonding, utilizing the Cosmos SDK modifications described in [cosmos_changes.md](cosmos_changes.md).
+
+## System Architecture
+
+The Gonka network consists of three main node types that work together to implement the PoC consensus mechanism:
+
+### 1. ML Nodes
+- **Purpose**: Execute machine learning computations for PoC generation and validation
+- **Location**: `mlnode/` package
+- **Key Components**:
+ - Proof generation workers using transformer models
+ - Batch validation capabilities
+ - REST API for external communication
+
+### 2. Decentralized API Nodes
+- **Purpose**: Orchestrate PoC operations and manage ML node coordination
+- **Location**: `decentralized-api/` package
+- **Key Components**:
+ - Node broker for ML node management
+ - PoC orchestrator for workflow coordination
+ - Chain phase tracker for epoch management
+
+### 3. Inference Chain Nodes
+- **Purpose**: Blockchain validators running the modified Cosmos SDK
+- **Location**: `inference-chain/` package
+- **Key Components**:
+ - PoC batch and validation message handlers
+ - Epoch management and validator set updates
+ - Integration with SetComputeValidators function
+
+## PoC Workflow Overview
+
+The PoC system operates in distinct stages within epochs. Each epoch represents a period where validators perform computational work to determine their voting power for the next validation period.
+
+### Epoch Structure
+
+Each epoch contains several distinct stages managed by the EpochContext in `inference-chain/x/inference/types/epoch_context.go`:
+
+1. **PoC Generation Stage**: ML nodes generate proof of compute batches
+2. **PoC Validation Stage**: Validators cross-validate submitted batches
+3. **PoC Validation End Stage**: Results are computed and new weights determined
+4. **Validator Set Update Stage**: New validators are activated with updated voting power
+
+## Detailed PoC Process
+
+### Stage 1: PoC Generation Initiation
+
+When the chain reaches the PoC start block height (determined by `IsStartOfPocStage` in EpochContext), the following occurs:
+
+**Chain Side (inference-chain/x/inference/module/module.go)**:
+- The `onStartOfPocStage` is triggered in the EndBlock handler
+- A new epoch is created via `CreateEpochGroup`
+- Old inference and PoC data is pruned based on configured thresholds
+
+**API Node Side (decentralized-api/internal/event_listener/new_block_dispatcher.go)**:
+- The OnNewBlockDispatcher detects the PoC start transition
+- The NodePoCOrchestrator receives a StartPoCEvent
+- Random seed is generated using the block height
+
+### Stage 2: ML Node PoC Generation
+
+**API Node Orchestration (decentralized-api/broker/node_worker_commands.go)**:
+- API node executes StartPoCNodeCommand for each managed ML node
+- Commands are dispatched through the broker's node worker system
+- Each ML node receives initialization parameters including block hash, public key, and callback URL
+
+**ML Node Computation (mlnode/packages/pow/src/pow/compute/)**:
+- ML nodes initialize transformer models using the distributed block hash as seed
+- Workers begin generating proof batches using the Compute class
+- Each batch contains nonces and distance calculations from model outputs
+- Generated batches are sent back to API nodes via callback mechanism
+
+**Batch Submission (decentralized-api/internal/server/mlnode/post_generated_batches_handler.go)**:
+- API node receives generated batches from ML nodes
+- Batches are converted to MsgSubmitPocBatch messages
+- Messages are submitted to the blockchain via the cosmos client
+
+### Stage 3: PoC Validation Phase
+
+When the validation stage begins (determined by `IsStartOfPoCValidationStage`):
+
+**Validation Initiation (decentralized-api/internal/poc/node_orchestrator.go)**:
+- The ValidateReceivedBatches function is triggered
+- API node queries all submitted PoC batches from the chain
+- Validation sampling is applied using deterministic nonce selection
+- ML nodes are switched to validation mode via InitValidateNodeCommand
+
+**ML Node Validation (mlnode/packages/pow/src/pow/compute/compute.py)**:
+- ML nodes receive batches to validate through the ValidateBatch API
+- The validate method re-generates proofs for given nonces
+- Validation results include fraud detection and statistical analysis
+- Results are sent back as MsgSubmitPocValidation messages
+
+### Stage 4: PoC Results Computation
+
+At the end of the validation stage (`IsEndOfPoCValidationStage`):
+
+**Weight Calculation (inference-chain/x/inference/module/chainvalidation.go)**:
+- The `ComputeNewWeights` function processes all submitted batches and validations
+- Current validator weights are retrieved from the active participants
+- PoC validation decisions are made using majority-based logic
+- Participants are accepted or rejected based on validation results from other validators
+
+**Validation Decision Logic**:
+- Each participant's submission is validated by other network participants
+- Acceptance requires valid validations from more than half of participants by weight
+- Rejection occurs if invalid validations exceed half of participants by weight
+- The decision incorporates fraud detection thresholds and statistical analysis
+
+### Stage 5: Validator Set Update
+
+During `IsSetNewValidatorsStage`:
+
+**Validator Power Updates (inference-chain/x/inference/module/module.go)**:
+- The system calls `SetComputeValidators` with computed results
+- This function is implemented in the modified Cosmos SDK staking module
+- New validator set is activated with voting power based on PoC results
+
+**Epoch Transition**:
+- The effective epoch index is updated to the upcoming epoch
+- Account settlements are performed for the previous epoch
+- Model assignments are made for participants in the new epoch
+- Active participants are registered for the next validation period
+
+## Power Systems and Usage Context
+
+The Gonka network operates with two distinct power systems that serve different purposes:
+
+### Staking Module Power (Consensus Power)
+This power is set via `SetComputeValidators` and is used for all Cosmos SDK native consensus and governance operations:
+
+**Use Cases**:
+- **Block Consensus**: Determines validator selection probability for block production in CometBFT
+- **Governance Voting**: Voting power for on-chain governance proposals
+- **Slashing**: Affects the magnitude of slashing penalties for validator misbehavior
+- **Validator Set**: Controls which validators are active in the consensus set
+- **Rewards Distribution**: Influences block rewards and commission distribution
+
+**Power Source**: Derived from PoC computational results and updated at the end of each epoch validation cycle.
+
+### EpochGroup Power (Internal Network Power)
+This power is recorded in EpochGroups and their subgroups, used for internal network operations during epochs:
+
+**Use Cases**:
+- **PoC Validation Decisions**: Determines weight in majority-based validation of other participants' PoC submissions
+- **Inference Work Allocation**: Controls how much inference work each participant receives
+- **Model Assignments**: Influences which models participants are assigned to serve
+- **Network Resource Distribution**: Affects allocation of computational resources within epochs
+- **Participant Selection**: Used in determining which participants advance to the next epoch
+
+**Power Source**: Based on historical PoC performance, preserved weights from previous epochs, and MLNode computational capacity.
+
+### Power Flow and Synchronization
+
+The two power systems are synchronized at specific points in the epoch lifecycle:
+
+1. **During Epoch**: EpochGroup power governs internal operations and PoC validation
+2. **At Epoch End**: PoC results are computed using EpochGroup weights for validation decisions
+3. **Validator Update**: Successful participants' power is transferred to the staking module via `SetComputeValidators`
+4. **New Epoch**: Updated consensus power becomes active while new EpochGroup power is established
+
+This dual-power architecture ensures that blockchain consensus remains stable and secure while allowing flexible resource allocation and validation during computational epochs.
+
+## Integration with Modified Cosmos SDK
+
+### SetComputeValidators Function
+
+The core integration point between PoC results and consensus is the `SetComputeValidators` function in the modified staking module:
+
+**Function Location**: Referenced in `inference-chain/x/inference/types/expected_keepers.go`
+**Purpose**: Updates validator voting power based on PoC computational results rather than bonded tokens
+
+**Process**:
+1. Receives ComputeResult objects containing public keys and computed power
+2. Reconciles new results with existing validator set
+3. Updates validator power indexing for CometBFT integration
+4. Manages validator transitions without token movement
+
+### Power Calculation Override
+
+**Traditional Staking**: Voting power = bonded tokens ÷ PowerReduction
+**PoC System**: Voting power = computed PoC score (with PowerReduction = 1)
+
+The modified system in `cosmos_changes.md` ensures:
+- No actual token bonding occurs for PoC-based validators
+- `TotalBondedTokens` is calculated by summing validator power scores
+- Slashing affects PoC scores rather than burning tokens
+- Hook mechanisms safely trigger collateral module penalties
+
+## Key Implementation Files
+
+### Chain-side PoC Management
+- `inference-chain/x/inference/module/module.go` - Main epoch and stage management
+- `inference-chain/x/inference/module/chainvalidation.go` - PoC validation logic
+- `inference-chain/x/inference/keeper/msg_server_submit_poc_batch.go` - Batch submission handler
+- `inference-chain/x/inference/keeper/msg_server_submit_poc_validation.go` - Validation submission handler
+
+### API Node Orchestration
+- `decentralized-api/internal/poc/node_orchestrator.go` - PoC workflow coordination
+- `decentralized-api/broker/node_worker_commands.go` - ML node command execution
+- `decentralized-api/internal/event_listener/new_block_dispatcher.go` - Chain event processing
+
+### ML Node Computation
+- `mlnode/packages/pow/src/pow/compute/compute.py` - Core PoC computation engine
+- `mlnode/packages/pow/src/pow/compute/worker.py` - Worker process management
+- `mlnode/packages/pow/src/pow/service/manager.py` - PoC service management
+
+## Epoch and Participant Management
+
+### Epoch Lifecycle
+- **Creation**: New epochs are created at PoC start via `CreateEpochGroup`
+- **Tracking**: Current, upcoming, and previous epochs are maintained separately
+- **Transitions**: Clean boundaries between epoch preparation and validator switching
+- **Storage**: Epoch data is stored using both sequential indices and PoC start block heights
+
+### Participant Selection
+- **Preservation**: Previous epoch participants with inference allocation are preserved
+- **Weight Calculation**: Total weight computed from MLNode PoC weights
+- **Model Assignment**: Participants receive model allocations for inference work
+- **Registration**: Top miners are registered based on PoC performance
+
+This design creates a robust computational consensus mechanism where validator voting power directly reflects demonstrated computational capability rather than economic stake, while maintaining the security and functionality of the underlying Cosmos SDK consensus engine.
\ No newline at end of file
diff --git a/docs/join_chain.md b/docs/join_chain.md
new file mode 100644
index 000000000..811418bc3
--- /dev/null
+++ b/docs/join_chain.md
@@ -0,0 +1,59 @@
+# Setting up your chain
+## Prerequisites
+
+### Dependencies
+
+You will need Docker installed to handle launching your containers
+
+### Files
+
+You will need two files to start:
+
+1. launch_chain.sh - this is the script that will launch your chain with parameters
+2. docker-compose-local.yml - This a docker-compose file for launching your chain locally, called by launch_chain.sh
+
+### config.env
+
+To start, you will need to create a file with the following environment variables:
+
+* KEY_NAME - A name for the key and for the two nodes (API and node) that will be created.
+* NODE_CONFIG - This is a path to a file that contains information about your inference nodes (see below)
+* ADD_ENDPOINT - This is the public url for an endpoint that is already in the chain, that will be used to add your account to the chain.
+* PORT - This is the local port that will be exposed for your API endpoint
+* PUBLIC_IP - This is the host you will use to expose your own endpoint. It will need to map ultimately to the API container created during this process.
+
+## NODE_CONFIG
+
+This is a json file that defines the endpoints of the inference servers that will actually serve inference requests for your node. The format is as follows:
+```
+[
+ {
+ "id": "uniqueNodeName",
+ "url": "http://35.76.234.56:8080/",
+ "max_concurrent": 10,
+ "models": [
+ "Qwen/Qwen2.5-7B-Instruct"
+ ]
+ }
+]
+```
+`max_concurrent` specifies how many requests can be handled by a given endpoint at a time. The API will balance all your requests between all endpoints you specify in this file
+
+
+## Launching
+
+Once you have created the config.env file with the right settings, you simply launch `./launch_chain.sh` - This will:
+
+1. Start your node, which will connect to the chain using seed nodes specified in the Docker image, and then add you as a participant in the network. It will take some time to catch up to the current chain height.
+2. Start your API, which will connect to your node and will be your main entry point, serving inference requests and allowing you to manage your nodes.
+
+## Customizing
+Your environment may differ, as to where you want to deploy or how. But you can use `launch_chain.sh` and `docker-compose-local.yml` as a starting point for your own deployment.
+
+The important points are:
+
+1. Using the Docker images contained in `docker-compose-local.yml` - these are the images that will be used to join the chain. They include all the necessary genesis state and seed nodes to join.
+2. {{Need to add info about sharing keys from the Node to the API, once we've made that remotely secure }}
+3. Each docker container will need a "KEY_NODE" set to use as the key and the main URL or the API.
+3. Adding inference nodes is done through the /v1/nodes/batch endpoint. You can see the call in `launch_chain.sh`
+4. To add your node to the network, you will still need the URL of a node that is already joined. `launch_chain.sh` shows how to get the data for the payload (by executing commands on the node) and how to structure it.
diff --git a/docs/manual-recover.md b/docs/manual-recover.md
new file mode 100644
index 000000000..1f3aa98ff
--- /dev/null
+++ b/docs/manual-recover.md
@@ -0,0 +1,48 @@
+Earlier today, Gonka Chain experienced a temporary chain halt triggered by a deterministic panic.
+- The incident did not cause a network partition, the state remains fully consistent
+- More than two-thirds of the network has already recovered and is operating normally
+- To resume block production, validators can perform a single-block rollback and upgrade to the patched binary
+
+Proposed fix: https://github.com/gonka-ai/gonka/pull/384
+
+Recovery Instructions
+
+1\ Stop the container (from gonka/deploy/join/ directory)
+```
+docker compose down node && sudo rm -rf .inference/data/upgrade-info.json
+```
+
+2\ Open the terminal of the container
+```shell
+source config.env && docker compose run -it node /bin/sh
+```
+
+3\ Rollback gonka blockchain one block back
+```
+inferenced rollback --home /root/.inference/
+```
+
+4\ Exit the container terminal
+```
+exit
+```
+
+5\ Download the new version of the chain node with the patch
+```shell
+wget -O inferenced https://github.com/gonka-ai/gonka/releases/download/release%2Fv0.2.3-patch3/inferenced
+
+sudo mkdir -p .inference/cosmovisor/upgrades/v0.2.3-patch3/bin/
+sudo cp inferenced .inference/cosmovisor/upgrades/v0.2.3-patch3/bin/inferenced
+sudo chmod +x .inference/cosmovisor/upgrades/v0.2.3-patch3/bin/inferenced
+sudo rm .inference/cosmovisor/current
+sudo ln -sf upgrades/v0.2.3-patch3 .inference/cosmovisor/current
+
+echo "699b26ee2212146406ed4fe336428bfc134aade5cf03c55ba5c4f7ebf3ca6c90 .inference/cosmovisor/current/bin/inferenced" | sudo sha256sum -c --status - && echo SUCCESS || echo FAILED
+```
+You should get SUCCESS in return
+
+6\ Start the updated node
+```shell
+source config.env && \
+ docker compose up node api proxy -d --no-deps --force-recreate
+```
\ No newline at end of file
diff --git a/docs/papers/Gonka_white_paper.pdf b/docs/papers/Gonka_white_paper.pdf
new file mode 100644
index 000000000..41dea5f7c
Binary files /dev/null and b/docs/papers/Gonka_white_paper.pdf differ
diff --git a/docs/papers/InferenceFlow.png b/docs/papers/InferenceFlow.png
new file mode 100644
index 000000000..468a00d2e
Binary files /dev/null and b/docs/papers/InferenceFlow.png differ
diff --git a/docs/prepare-upgrade-proposal.md b/docs/prepare-upgrade-proposal.md
new file mode 100644
index 000000000..b511bee9a
--- /dev/null
+++ b/docs/prepare-upgrade-proposal.md
@@ -0,0 +1,99 @@
+# Prepare and Test an Upgrade Proposal
+
+This document describes the process of preparing and reviewing an upgrade proposal on the Gonka chain. There are different types of upgrades:
+
+- full automatic upgrade of `api` and `node` binaries (on-chain, might break consensus)
+- partial upgrade of `api` or `node` binaries (on-chain, might break consensus)
+- semi-automatic upgrade of `mlnode` containers which include an automatic on-chain switch of version (on-chain, might break consensus)
+- off-chain upgrades of any containers (off-chain, doesn't break consensus, such an upgrade can be done asynchronously)
+
+This document focuses only on full on-chain upgrades. For more details on the overall upgrade strategy using Cosmovisor, see [the upgrade strategy document](./upgrades.md).
+
+## 1. Process
+
+The process consists of the following steps:
+
+- create a PR in the `gonka-ai` repo named "Upgrade Proposal vX.Y.Z"
+- get approval from a majority of active miners, and apply all requested edits
+- once the PR is approved, build and release the upgrade binaries and containers with version tag `vX.Y.Z` from the PR branch. **Do not merge the PR yet.**
+ - Run `make build-for-upgrade` from the repository root to build both `inferenced` and `decentralized-api` binaries
+ - Binaries are published to `public-html/v2/inferenced/` and `public-html/v2/dapi/` with checksums automatically generated
+ - Build and push Docker containers for all services with the version tag
+ - Create a GitHub release (example: https://github.com/gonka-ai/gonka/releases/tag/release%2Fv0.2.3)
+- submit the on-chain upgrade proposal with `./inferenced tx upgrade software-upgrade vX.Y.Z` and include links to the released binaries in the upgrade info JSON. The proposed upgrade height should be at least a couple of hours from the PoC phase. The governance proposal requires a deposit. See [the upgrade strategy document](./upgrades.md) for a full command example.
+- attach the static GitHub link to `proposals/governance-artifacts/update-vX.Y.Z/README.md` as metadata to the on-chain proposal using `--metadata "https://github.com/gonka-ai/gonka/blob//proposals/governance-artifacts/update-vX.Y.Z/README.md"`
+- get votes from the majority of miners
+- if voting finishes and there is approval by consensus, the upgrade is applied automatically
+- after a successful on-chain upgrade, merge the PR. This ensures the `main` branch is not in an inconsistent state where container versions do not match the on-chain binary versions.
+
+
+Each upgrade proposal should start with a PR named "Upgrade Proposal vX.Y.Z". The PR should contain:
+
+- all proposed changes
+- incremented `ConsensusVersion` in each modified module's `module.go` file
+- migrations for all incremented versions registered in `inference-chain/app/upgrades.go:registerMigrations`. If no migrations are needed, an empty migration should still be created to track that the module version has been processed
+- an upgrade handler created in `inference-chain/app/upgrades/vX_Y_Z` and registered in `inference-chain/app/upgrades.go:setupUpgradeHandlers`
+- container image versions in `deploy/join/docker-compose.yml` set to `X.Y.Z`
+- a description of the proposal in `proposals/governance-artifacts/update-vX.Y.Z/README.md` and in the PR description
+
+
+If an upgrade proposal has multiple independent features, they should be split into different commits. For clarity, structure the PR description with clear sections. Here is a recommended structure:
+
+> ## Example PR Description
+>
+> ### Upgrade Plan
+>
+> This section should describe:
+> - Which components are part of the on-chain upgrade and which can be updated off-chain asynchronously.
+> - Any manual steps required for participants. It should be very clear if existing participants need to take action or if changes only affect new participants.
+>
+> ### Testing
+>
+> This section should describe:
+> - How this upgrade proposal was tested and how it can be reproduced.
+> - A confirmation that all checks from the `Testing at TestNet` section below have passed successfully.
+>
+> ### Risks
+>
+> - Any risks or changes in behavior after this upgrade should be documented here. If there are no known risks, this should be stated explicitly.
+>
+> ### Changes
+>
+> This section should provide:
+> - A high-level summary of what the upgrade introduces.
+> - A detailed description for every commit that introduces major changes, ideally with commit hashes. For example:
+>
+> #### Feature X (``)
+>
+> A brief description of the feature and the changes it introduces.
+
+Upgrade proposals must not require changes to the base container. Binaries downloaded by `cosmovisor` must have all required files.
+
+
+## 2. Testing
+
+Before review starts, the upgrade proposal should pass the following checks:
+
+- All Unit Tests pass (`make local-build` locally or `.github/workflows/verify.yml` in CI/CD)
+- All Integration Tests pass (`.github/workflows/integration.yml` in CI/CD or `make run-tests` locally)
+- The upgrade process from the current Gonka Chain version has been tested successfully multiple times on TestNet
+- The migration process is tested on a fresh export of Gonka MainNet state in a test environment
+
+
+### Testing at TestNet
+
+The TestNet is described in `test-net-cloud/nebius/README.md` and can be quickly redeployed in case of failures. All cold keys are available directly on TestNet's servers.
+
+The process of proposing and voting on TestNet exactly matches the process on MainNet.
+
+As TestNet might be re-created quite often, each test should be started by executing a couple of hundred inference requests to make testing closer to the real chain state.
+
+Then the process is:
+
+- schedule an upgrade in the middle of an epoch
+- vote for the upgrade
+- check that the upgrade is applied successfully and the new binaries are used
+- check that the chain successfully serves and validates inference after the upgrade
+- check that all active participants from the epoch with the upgrade were rewarded for this epoch
+- check that the next PoC phase after the upgrade was successful and all active participants successfully passed it
+- check that the testnet works without any problem for several next epochs after the upgrade and every node is rewarded
\ No newline at end of file
diff --git a/docs/prepare_join_image.md b/docs/prepare_join_image.md
new file mode 100644
index 000000000..ab875bf8c
--- /dev/null
+++ b/docs/prepare_join_image.md
@@ -0,0 +1,22 @@
+
+# Preparing the join docker images
+The gist of this can be found in `test2.sh`, but here are the steps:
+
+1. Build the genesis docker image, using the Makefile command build-genesis.
+1. This will use DockerfileGenesis to build the image.
+1. The image, when launched in a container, will run `init-docker-genesis.sh`, which will:
+ 1. Initialize the genesis node with the correct settings.
+ 1. Create and add a genesis account.
+ 1. Launch the chain
+1. Now build the api docker image, using the Makefile `build-docker` in `decentralized-api`
+1. Launch the api docker image, being sure that KEY_NAME is set to "genesis"
+1. Now you can use files generated by the genesis node to create files in `./inference-chain/build`:
+ 1. `genesis.json` - this is found on the docker container at `/root/.inference/config`
+ 1. `inferenced` - this is the executable built by the Makefile, it should already be in `./inference-chain/build`
+ 1. `config.env` - This has two important values:
+ 1. SEEDS - This is the address of the genesis node (at a minimum), in the format of {{node_id}}@{{node-ip-address}}:{{port}}
+ 1. The node_id is retrieved by running `inferenced tendermint show-node-id`
+ 1. The ip address needs to be a public URL or IP address.
+ 1. The port is usually 26656
+ 1. ADD_ENDPOINT - This is the address of the API for the genesis node, which you launched previously. Again, this will need to be available publicly on the internet.
+
diff --git a/docs/specs/genesistransfer/genesistransfer-cli-guide.md b/docs/specs/genesistransfer/genesistransfer-cli-guide.md
new file mode 100644
index 000000000..0fd8c53bd
--- /dev/null
+++ b/docs/specs/genesistransfer/genesistransfer-cli-guide.md
@@ -0,0 +1,52 @@
+# Genesis Transfer CLI Reference
+
+## Query Commands
+
+```bash
+# Check transfer status
+inferenced query genesistransfer transfer-status [genesis-address]
+
+# Check transfer eligibility
+inferenced query genesistransfer transfer-eligibility [genesis-address]
+
+# List transfer history
+inferenced query genesistransfer transfer-history
+
+# View module parameters
+inferenced query genesistransfer params
+
+# View allowed accounts (if whitelist enabled)
+inferenced query genesistransfer allowed-accounts
+```
+
+## Transaction Commands
+
+```bash
+# Transfer ownership (must be signed by genesis account owner)
+inferenced tx genesistransfer transfer-ownership [genesis-address] [recipient-address] \
+ --from [genesis-account-key] \
+ --gas 2000000 \
+ --yes
+```
+
+## Command Examples
+
+```bash
+# Complete transfer workflow
+inferenced query genesistransfer transfer-eligibility gonka1genesis...
+inferenced tx genesistransfer transfer-ownership gonka1genesis... gonka1recipient... \
+ --from genesis-key --gas 2000000 --yes
+inferenced query genesistransfer transfer-status gonka1genesis...
+
+# Check account balances
+inferenced query bank balances gonka1genesis...
+inferenced query bank balances gonka1recipient...
+
+# Batch transfer script
+for account in gonka1genesis1... gonka1genesis2...; do
+ inferenced tx genesistransfer transfer-ownership $account gonka1recipient... \
+ --from genesis-key --gas 2000000 --yes
+done
+```
+
+See the deployment guide for configuration and integration details.
\ No newline at end of file
diff --git a/docs/specs/genesistransfer/genesistransfer-deployment.md b/docs/specs/genesistransfer/genesistransfer-deployment.md
new file mode 100644
index 000000000..bcfebd084
--- /dev/null
+++ b/docs/specs/genesistransfer/genesistransfer-deployment.md
@@ -0,0 +1,84 @@
+# Genesis Account Ownership Transfer - Deployment Guide
+
+## Overview
+
+This guide covers deploying and using the genesis account ownership transfer system. The module enables secure, atomic transfer of genesis accounts including all liquid balances and vesting schedules from placeholder accounts to their intended recipients.
+
+## Prerequisites
+
+- Active blockchain network with the genesistransfer module enabled
+- Private keys for genesis accounts that need to be transferred
+- CLI access to the blockchain node
+
+## Basic Usage
+
+### 1. Check Transfer Eligibility
+
+Before transferring, verify the account is eligible:
+
+```bash
+# Check if genesis account can be transferred
+inferenced query genesistransfer transfer-eligibility [genesis-address]
+
+# Check current transfer status
+inferenced query genesistransfer transfer-status [genesis-address]
+```
+
+### 2. Execute Ownership Transfer
+
+Transfer complete ownership of a genesis account:
+
+```bash
+# Transfer ownership (must be signed by genesis account owner)
+inferenced tx genesistransfer transfer-ownership [genesis-address] [recipient-address] \
+ --from [genesis-account-key-name] \
+ --gas 2000000 \
+ --yes
+```
+
+**Important**: The transaction must be signed by the genesis account owner (the account being transferred from).
+
+### 3. Verify Transfer Completion
+
+After transfer, verify it completed successfully:
+
+```bash
+# Check transfer status
+inferenced query genesistransfer transfer-status [genesis-address]
+
+# View transfer history
+inferenced query genesistransfer transfer-history
+
+# Check recipient received the assets
+inferenced query bank balances [recipient-address]
+```
+
+## Module Configuration
+
+### Parameters
+
+```bash
+# View current module parameters
+inferenced query genesistransfer params
+```
+
+### Account Whitelist (Optional)
+
+If account restrictions are enabled:
+
+```bash
+# Check which accounts are allowed to transfer
+inferenced query genesistransfer allowed-accounts
+```
+
+## Security Considerations
+
+### Key Management
+- **Genesis Account Keys**: Must be securely stored until transfer completion
+- **One-Time Transfer**: Each genesis account can only be transferred once
+- **Irreversible**: Transfers cannot be undone once completed
+
+### Validation
+- **Address Verification**: Double-check recipient addresses before transfer
+- **Balance Confirmation**: Verify expected balances before and after transfer
+- **Vesting Preservation**: Vesting schedules transfer intact with original timelines
diff --git a/docs/specs/inference-validation-flow.md b/docs/specs/inference-validation-flow.md
new file mode 100644
index 000000000..fbb8f4add
--- /dev/null
+++ b/docs/specs/inference-validation-flow.md
@@ -0,0 +1,69 @@
+## Inference Validation Flow with Secret Seeds
+
+### Overview of the Validation Process
+
+The validation system uses a sophisticated secret seed mechanism to ensure fair and unpredictable validator assignment while maintaining verifiable accountability. Here's the complete flow:
+
+### Phase 1: Secret Seed Generation and Private Decision Making
+
+**Seed Generation:**
+Each API node generates and maintains its own private random seed for each epoch using `createNewSeed` in `decentralized-api/internal/poc/random_seed.go`. This seed is kept secret in the local configuration and used for private decision-making.
+
+**Private Validation Selection:**
+When inferences complete, API nodes use their current private seed to determine which inferences they should validate:
+
+1. **SampleInferenceToValidate**: The `InferenceValidator` calls this function with a list of finished inference IDs
+2. **Private Calculation**: Using `s.configManager.GetCurrentSeed().Seed`, each validator runs the `ShouldValidate` algorithm locally with their secret seed
+3. **Deterministic Selection**: The combination of the secret seed, inference ID, and validator's model-specific power produces a consistent decision of whether to validate each inference
+4. **Validation Execution**: Validators immediately perform verification for inferences they're selected to validate
+
+**Critical Point**: At this stage, the seed is private - other participants cannot predict or verify which inferences a validator should validate.
+
+### Phase 2: Validation Result Publication
+
+**Immediate Publication:**
+When validators complete verification, they immediately publish their results via `MsgValidation` transactions to the blockchain. These validation results are public and recorded in the `EpochGroupValidations` structure.
+
+**No Seed Verification Yet:**
+During this phase, there's no verification of whether the validator was actually supposed to validate the inference - the system accepts validation results from any eligible validator for the model.
+
+### Phase 3: Seed Revelation and Claim Verification
+
+**Seed Revelation:**
+At the end of each epoch during the claim rewards stage, validators reveal their previously secret seed when submitting `MsgClaimRewards` transactions. The seed that was private during validation decision-making now becomes public.
+
+**Retroactive Validation Check:**
+The blockchain performs comprehensive verification in `getMustBeValidatedInferences`:
+
+1. **Reconstruct Required Validations**: Using the now-revealed seed, the system re-runs the exact same `ShouldValidate` calculation that the validator used privately
+2. **Compare Expected vs Actual**: The system checks whether the validator performed validation for exactly the inferences they were supposed to validate based on their seed
+3. **Enforce Compliance**: If any required validations are missing, the claim is rejected with `ErrValidationsMissed`
+
+**Seed Signature Verification:**
+The system also verifies that the revealed seed is authentic using cryptographic signatures in `validateSeedSignature`, ensuring validators cannot retroactively choose favorable seeds.
+
+### Security and Integrity Mechanisms
+
+**Prevents Gaming:**
+- Validators cannot predict which inferences they'll need to validate until they've already committed to their seed
+- Retroactive verification ensures validators cannot selectively skip difficult validations
+- Model-specific weight calculations prevent validators from avoiding certain models
+
+**Cryptographic Accountability:**
+- Seeds are cryptographically signed when generated, preventing post-hoc manipulation
+- The deterministic `ShouldValidate` function ensures the same seed always produces the same validation requirements
+- Public verification during claims provides transparent accountability
+
+**Model-Specific Enforcement:**
+- Validation requirements are calculated using model-specific power within the appropriate subgroup
+- Only validators supporting the inference's model are eligible for validation assignment
+- Cross-model validation assignments are prevented by the weight map filtering
+
+### Implementation Timeline
+
+**Current Epoch**: Private seed-based decision making
+**Validation Phase**: Public validation result publication
+**Next Epoch Transition**: Seed revelation and retroactive verification
+**Reward Distribution**: Only compliant validators receive rewards
+
+This system ensures both unpredictable validator assignment (due to secret seeds) and verifiable compliance (through retroactive checking), creating a robust validation mechanism that's difficult to game while maintaining transparency and accountability.
diff --git a/docs/specs/restrictions/restrictions-cli-guide.md b/docs/specs/restrictions/restrictions-cli-guide.md
new file mode 100644
index 000000000..0396668a7
--- /dev/null
+++ b/docs/specs/restrictions/restrictions-cli-guide.md
@@ -0,0 +1,45 @@
+# Transfer Restrictions CLI Reference
+
+## Query Commands
+
+```bash
+# Check current restriction status
+inferenced query restrictions transfer-restriction-status
+
+# List emergency exemptions
+inferenced query restrictions transfer-exemptions
+
+# Check exemption usage for account
+inferenced query restrictions exemption-usage [exemption-id] [account-address]
+```
+
+## Transaction Commands
+
+```bash
+# Execute emergency transfer (if exemption exists)
+inferenced tx restrictions execute-emergency-transfer \
+ [exemption-id] [from-address] [to-address] [amount] [denom] \
+ --from [key-name] --gas 300000
+```
+
+## Command Examples
+
+```bash
+# Check if restrictions are active
+inferenced query restrictions transfer-restriction-status
+
+# Example output:
+# {
+# "is_active": true,
+# "restriction_end_block": "1555000",
+# "current_block_height": "125000",
+# "remaining_blocks": "1430000"
+# }
+
+# Execute emergency transfer
+inferenced tx restrictions execute-emergency-transfer \
+ emergency-001 gonka1from... gonka1to... 1000 ugonka \
+ --from from-key --gas 300000 --yes
+```
+
+See the deployment guide for configuration and integration details.
\ No newline at end of file
diff --git a/docs/specs/restrictions/restrictions-deployment.md b/docs/specs/restrictions/restrictions-deployment.md
new file mode 100644
index 000000000..28f1fda89
--- /dev/null
+++ b/docs/specs/restrictions/restrictions-deployment.md
@@ -0,0 +1,79 @@
+# Transfer Restrictions Deployment Guide
+
+## Overview
+
+The Transfer Restrictions module provides temporary restrictions on user-to-user transfers during bootstrap periods while preserving essential network operations (gas payments, staking, governance, inference fees).
+
+## Configuration
+
+### Genesis Configuration
+
+**For Production Networks**: Set restriction end block in genesis.json:
+
+```json
+{
+ "app_state": {
+ "restrictions": {
+ "params": {
+ "restriction_end_block": "1555000"
+ }
+ }
+ }
+}
+```
+
+**For Testing/Testnet**: Default `restriction_end_block: 0` (no restrictions)
+
+### Timeline
+
+- **Recommended Duration**: 90 days (~1,555,000 blocks at 5s block time)
+- **Automatic Lifting**: Restrictions automatically end at configured block height
+- **No Manual Intervention**: System self-manages restriction lifecycle
+
+## What's Restricted vs Allowed
+
+### ✅ **Always Allowed**
+- Gas fee payments
+- Staking operations (delegate, undelegate, redelegate)
+- Governance operations (deposits, voting)
+- Inference service payments
+- Module reward distributions
+- All module-to-account transfers
+
+### ❌ **Restricted During Bootstrap**
+- Direct user-to-user transfers
+- Peer-to-peer trading
+- Speculative transfers
+
+## Emergency Exemptions
+
+If emergency transfers are needed during restriction period:
+
+1. **Create Governance Proposal** to add exemption template
+2. **Users Execute** transfers matching approved templates
+
+```bash
+# Check available exemptions
+inferenced query restrictions transfer-exemptions
+
+# Execute emergency transfer (if exemption exists)
+inferenced tx restrictions execute-emergency-transfer [exemption-id] [from] [to] [amount] [denom] --from [key]
+```
+
+## Monitoring
+
+```bash
+# Check current status
+inferenced query restrictions transfer-restriction-status
+
+# View exemption usage
+inferenced query restrictions exemption-usage [exemption-id] [account]
+```
+
+## Timeline Management
+
+- **Current Status**: Check remaining blocks until restrictions lift
+- **Governance Override**: Can modify end block via parameter change proposal
+- **Early Termination**: Set end block to current height to disable immediately
+
+The module automatically handles all restriction lifecycle management with zero manual intervention required.
\ No newline at end of file
diff --git a/docs/tokenomics.md b/docs/tokenomics.md
new file mode 100644
index 000000000..71eba7da6
--- /dev/null
+++ b/docs/tokenomics.md
@@ -0,0 +1,170 @@
+# Tokenomics
+
+This document outlines the tokenomics of the project, explaining how fees are charged, and how rewards are distributed to participants.
+
+## Fees
+
+Fees are an essential part of the ecosystem, ensuring that the network is compensated for the computational resources used.
+
+### Fee Calculation based on Units of Compute
+
+When a user sends an inference request, the fee for request is determined by the potential computational cost of the request, which is based on the number of tokens in the prompt and the maximum number of tokens that can be in the completion. Based on the actual number of tokens processed: the tokens in the user's prompt and the tokens generated in the completion. This ensures users only pay for what they use.
+
+The calculation is based on a more nuanced concept of "Units of Compute":
+
+1. **Unit of Compute**: This is an abstract representation of the computational resources required for an inference task.
+
+2. **Units of Compute per Token**: Each AI model has a specific `UnitsOfComputePerToken` value. This value, set when the model is registered on the chain, represents how many Units of Compute are consumed for each token processed by that model.
+
+3. **Unit of Compute Price**: The price for a single Unit of Compute is dynamic and is determined by the network participants. In each epoch, participants can submit proposals for the price. The final `UnitOfComputePrice` is a weighted median of all valid proposals for that epoch. This logic can be seen in `inference-chain/x/inference/epochgroup/unit_of_compute_price.go`.
+
+The final fee for an inference request is calculated by multiplying these three factors together:
+
+`Final Fee = (Prompt Tokens + Actual Completion Tokens) * UnitsOfComputePerToken * UnitOfComputePrice`
+
+To ensure network providers are guaranteed payment, an amount covering the maximum possible cost is held in escrow when a request is initiated. This process is explained in the next section. The final cost calculation happens in the `CalculateCost` function within `inference-chain/x/inference/calculations/inference_state.go`.
+
+*Note: The current implementation in `CalculateCost` and `CalculateEscrow` appears to use a constant `PerTokenCost` for simplicity, but the underlying architecture is designed for the dynamic, model-specific pricing described above.*
+
+### The Escrow and Refund Mechanism
+
+It is important to understand that an initial amount, calculated using the user-defined `Max Completion Tokens`, is held in **escrow**. This is a crucial mechanism to ensure fairness for both users and network participants.
+
+1. **Initial Escrow**: Before any on-chain transaction, the `decentralized-api` first verifies that the user has sufficient funds to cover the maximum possible cost of the request. This check can be seen in `decentralized-api/internal/server/public/post_chat_handler.go`. If the check passes, an amount is placed in escrow on the blockchain to guarantee payment to the provider. The on-chain escrow calculation can be found in `CalculateEscrow` in `inference-chain/x/inference/calculations/inference_state.go`.
+
+2. **Final Settlement and Refund**: After the inference request is completed, the system calculates the **Actual Cost** based on the *actual* number of tokens generated (as shown in the formula above). The provider is paid this `ActualCost` from the escrowed amount. Any remaining funds are immediately **refunded** to the user.
+
+This two-step process ensures that users are only charged for the computational resources they actually consume, while providers are protected against unfunded requests.
+
+### Blockchain Transaction Fees
+
+Unlike many other blockchains, this network does not charge separate fees (i.e., "gas") for submitting transactions. The configuration, as seen in `decentralized-api/cosmosclient/cosmosclient.go`, sets transaction fees to zero.
+
+The economic model is focused on the fees for the core service—AI inference—rather than on generic transaction processing. This simplifies the experience for users, who only need to be concerned with the cost of their inference requests.
+
+## Rewards
+
+Participants who contribute to the network by running inference nodes are rewarded with newly minted coins.
+
+### Reward Components
+
+After each epoch, participants can claim their rewards. The rewards consist of two parts:
+
+1. **Work Coins:** These are the fees that were put into escrow by the users who made the inference requests.
+2. **Reward Coins:** These are newly minted coins created through a subsidy mechanism to incentivize network participation.
+
+The process of claiming rewards and the distribution of work and reward coins are handled in `inference-chain/x/inference/keeper/msg_server_claim_rewards.go`. The minting of new reward coins is done by the `MintRewardCoins` function in `inference-chain/x/inference/keeper/payment_handler.go`.
+
+### Subsidy Mechanism
+
+The number of **Reward Coins** minted in each epoch is not fixed; it is determined by a **Subsidy Mechanism**. This mechanism calculates the total amount of new coins to create based on the total work performed by all participants in that epoch.
+
+This system is designed to incentivize participation, especially in the early stages of the network, and it gradually reduces the number of new coins over time. The specific logic for this calculation can be found in `inference-chain/x/inference/keeper/accountsettle.go`.
+
+### Distribution of Rewards
+
+Both **Work Coins** and **Reward Coins** are distributed to participants at the end of each epoch. However, they are distributed differently:
+
+* **Work Coins Distribution**: The distribution of Work Coins is straightforward. Each participant receives the exact amount of fees that they have accumulated for the inference tasks they processed during the epoch. These are the funds that were held in escrow.
+
+* **Reward Coins Distribution**: Reward Coins are distributed proportionally among all contributing participants. The system first calculates the total amount of work done by all participants in an epoch. Then, each participant receives a share of the total Reward Coins that is directly proportional to their contribution to the total work.
+
+This dual reward system ensures that participants are compensated directly for the tasks they perform (Work Coins) and also receive a share of the network's growth and success (Reward Coins). The logic for calculating these amounts for each participant is in the `getSettleAmount` function within `inference-chain/x/inference/keeper/accountsettle.go`.
+
+### Top Miner Rewards
+
+In addition to the regular rewards and subsidies, there are special rewards for the top miners in the network. These rewards are designed to incentivize high-performing and reliable participants. The criteria for being a top miner and the distribution of these rewards are defined in `inference-chain/x/inference/keeper/top_miner_calculations.go`.
+
+## Collateral System
+
+The network implements a collateral system that strengthens security by ensuring participants with significant network influence have a direct financial stake in the network's integrity. This system was introduced as part of Tokenomics V2 to create accountability and prevent malicious behavior.
+
+### Participant Weight and Collateral
+
+Network participants earn "weight" through Proof of Compute activities (work done, nonces delivered, etc.). This weight influences their role in governance processes, such as unit of compute price calculation. The collateral system introduces a hybrid model that combines:
+
+1. **Base Weight**: A portion of potential weight granted unconditionally (default 20%)
+2. **Collateral-Eligible Weight**: Additional weight that must be backed by deposited collateral (remaining 80%)
+
+### Grace Period
+
+To encourage early adoption, there is an initial grace period (default 180 epochs) during which no collateral is required. During this period, all potential weight is granted unconditionally. After the grace period ends, the collateral requirements become active.
+
+### Managing Collateral
+
+Participants can interact with the collateral system through two main operations:
+
+- **Deposit Collateral**: Transfer tokens from spendable balance to be held as collateral
+- **Withdraw Collateral**: Initiate return of collateral (subject to unbonding period)
+
+Withdrawals are not immediate - they enter an "unbonding queue" for a configurable period (default 1 epoch) before being released. This ensures collateral remains slashable even after withdrawal is initiated.
+
+### Slashing Conditions
+
+Collateral can be "slashed" (seized and burned) under specific conditions:
+
+1. **Malicious Behavior**: When a participant is marked as `INVALID` due to consistently incorrect work (default 20% slash)
+2. **Downtime**: When a participant fails to meet participation requirements in an epoch (default 10% slash)
+3. **Consensus Faults**: When the associated validator commits consensus-level violations
+
+Slashing is applied proportionally to both active collateral and any collateral in the unbonding queue.
+
+### Integration with Consensus
+
+The collateral system integrates with the underlying Cosmos SDK staking module through hooks, ensuring that consensus-level penalties (validator slashing, jailing) are reflected in the application-specific collateral system.
+
+*For detailed technical specifications, see the [Collateral Proposal](../proposals/tokenomics-v2/collateral.md).*
+
+## Reward Vesting
+
+To better align long-term incentives of network participants with sustained growth and stability, the network implements a reward vesting system. This ensures that newly distributed rewards are released gradually over time rather than immediately.
+
+### Vesting Mechanism
+
+All newly distributed rewards are routed through a dedicated vesting system:
+
+- **Work Coins**: Fees from user requests, subject to configurable vesting periods
+- **Reward Coins**: Newly minted subsidies, subject to configurable vesting periods
+- **Top Miner Rewards**: Special high-performer rewards, subject to configurable vesting periods
+
+### Vesting Schedule
+
+Each participant maintains a personal vesting schedule - essentially an array where each element represents tokens unlocking in a specific epoch. When new rewards are earned:
+
+1. The reward amount is divided evenly across the vesting period
+2. Any remainder from division is added to the first epoch for precision
+3. Amounts are aggregated into existing schedule elements to maintain efficiency
+
+### Vesting Periods
+
+The system supports different vesting periods for different reward types:
+
+- `WorkVestingPeriod`: Controls vesting for work coins (default 0, configurable via governance)
+- `RewardVestingPeriod`: Controls vesting for reward subsidies (default 0, configurable via governance)
+- `TopMinerVestingPeriod`: Controls vesting for top miner rewards (default 0, configurable via governance)
+
+In production environments, these are typically configured to 180 epochs (~180 days) to encourage long-term participation.
+
+### Token Unlocking
+
+Vested tokens are automatically unlocked once per epoch:
+
+1. The system processes each participant's vesting schedule
+2. Tokens from the oldest vesting entry are transferred to the participant's spendable balance
+3. The processed entry is removed from the schedule
+4. Empty schedules are cleaned up to prevent state bloat
+
+This creates a predictable, automated release of vested tokens synchronized with the network's epoch lifecycle.
+
+### Querying Vesting Status
+
+Participants can query their vesting status to see:
+- Total amount currently vesting
+- Detailed breakdown of future unlock schedule
+- Historical information about released tokens
+
+*For detailed technical specifications, see the [Vesting Proposal](../proposals/tokenomics-v2/vesting.md).*
+
+## Token Supply
+
+The initial total supply of the native coin and its distribution are defined in the `DefaultGenesisOnlyParams` function in `inference-chain/x/inference/types/params.go`. This includes the allocation for the originator, top reward amount, pre-programmed sale amount, and standard reward amount.
diff --git a/docs/transactions_with_retry.md b/docs/transactions_with_retry.md
new file mode 100644
index 000000000..e69de29bb
diff --git a/docs/upgrades.md b/docs/upgrades.md
new file mode 100644
index 000000000..a6f6e3a47
--- /dev/null
+++ b/docs/upgrades.md
@@ -0,0 +1,118 @@
+# Upgrade Strategy for Cosmos Blockchain App Using Cosmovisor
+
+## Overview
+Our upgrade strategy for the Cosmos blockchain app relies on **Cosmovisor**, a widely used tool in Cosmos environments. Cosmovisor acts as a wrapper around application binaries, monitoring chain events and managing upgrades automatically.
+
+### How Cosmovisor Works:
+1. **Event Monitoring**: Cosmovisor listens for chain events and checks the `upgrade-info.json` file in the data directory.
+2. **Upgrade Detection**: When the app exits, Cosmovisor reads the `upgrade-info.json` file for details such as:
+ - Upgrade name
+ - Target chain height
+ - URL for the new binaries
+3. **Binary Download**: It fetches the specified binaries and relaunches the app using the new binaries with the same arguments.
+
+This approach is central to our strategy for managing application binaries.
+
+---
+
+## Special Considerations
+
+### Dual Binary Management
+Since our system includes two binaries (chain app and decentralized API), we needed to adapt the process for seamless upgrades:
+
+1. **Build Process**:
+ - Use the `build-for-upgrade` target in the makefiles for both the chain and API.
+ - The process generates a build using Docker, captures the output, and packages it into a zip file.
+ - The files are published to the directories `public_html/v2/dapi` for the decentralized API and `public_html/v2/inferenced` for the chain binary.
+ - The SHA of each build is printed to use in the URL.
+
+2. **Governance Proposal**:
+ - A governance proposal includes the JSON information about binaries and their SHA.
+ - The proposal is submitted and voted on.
+ - Once approved, the upgrade details are added to `upgrade-info.json`. Cosmovisor downloads and installs the upgrade.
+
+3. **Scalability Considerations**:
+ - The binaries must be hosted in a manner that supports a high volume of simultaneous downloads during the upgrade process.
+
+---
+
+## Upgrade Workflow
+
+1. **Chain-Specific Upgrade Handlers**:
+ - Add the actual upgrade handler to the chain to manage data migrations or other state updates.
+ - Look in the `inference-chain/app/upgrades` folder and the `inference-chain/app/upgrades.go` file for examples
+ - Key elements include:
+ - Constants defining the upgrade name (in `constants.go`).
+ - A `CreateUpgradeHandler` function.
+ - Invocation in `setupUpgradeHandlers` (found in `upgrades.go`).
+ - If the upgrade changes the data in the state, increment `ConsensusVersion` in `module.go`
+
+2. **Build the Binaries**:
+ - Generate and publish binaries with the `build-for-upgrade` Makefile target.
+ - Ensure appropriate versioning and SHAs.
+ - Document the changes clearly.
+
+3. **Submit Governance Proposal**:
+ - Include upgrade details such as binaries, SHAs, and hosting URLs.
+ Example command line to submit:
+ ```
+ inferenced tx upgrade software-upgrade v0.0.2test --title v0.0.2test --upgrade-height 74 --upgrade-info {"binaries":{"linux/amd64":"http://binary-server/v2/inferenced/inferenced.zip?checksum=sha256:32620280f4b6abe013e97a521ae48f1c6915c78a51cc6661c51c429951fe6032"},"api_binaries":{"linux/amd64":"http://binary-server/v2/dapi/decentralized-api.zip?checksum=sha256:06ba4bb537ce5e139edbd4ffdac5d68acc5e5bc1da89b4989f12c5fe1919118b"}} --summary For testing --deposit 100000icoin --from cosmos1jz6smxmljlr4yqymf7lw5qcfuvw700w2g663vp --keyring-backend test --chain-id=prod-sim --keyring-dir=/root/.inference --yes --broadcast-mode sync --output json
+ ```
+
+4. **Promote the Proposal**:
+ - Allow stakeholders to test the binaries.
+ - Provide documentation and tools for validating and describing the changes.
+
+5. **Monitor the Rollout**:
+ - Upon governance approval, the upgrade will be scheduled for the `upgrade-height`
+ - Monitor the network disruption during rollout as nodes update simultaneously and download the binaries.
+
+---
+## Upgrading Data in the Chain
+The recommended approach for upgrading data is illustrated in PR 84:
+
+https://github.com/gonka-ai/gonka/pull/84
+
+#### Summary:
+1. Copy the unmodified .proto files for the data you are changing. Rename them with a V1 in front (or V2 if there is already a V1)
+2. Change the original proto files to whatever new format we want
+3. Write a custom getter for the OLD values (V1)
+4. Register a change handler that gets the old values and then writes the new ones. This may involve:
+ 1. Converting values from one type to another
+ 2. Dropping fields
+ 3. Adding new fields and coming up with a decent default value
+ 4. Any other necessary change, as long as the new values can be derived from old ones.
+
+---
+## Testing the Upgrade Mechanism (not specific upgrades)
+Testing is semi-automated, with plans for further automation.
+
+### Steps:
+1. Update `constants.go`:
+ - Set the version to `v0.0.1-test`.
+2. Build and launch the app. (locally, as you would for Testermint)
+3. Update the version to `v0.0.2-test` in `constants.go`.
+4. Rebuild using `build-for-upgrade`.
+ - Outputs are stored in the correct directory, and SHAs are output during the build.
+5. Run `submit upgrade` test:
+ - Change the SHAs in the Testermint test.
+ - Run tests to ensure successful version upgrades.
+
+---
+## Testing the Upgrade Mechanism (for specific upgrades)
+Testing is similar to above, but with several additional steps:
+1. You will need TWO branches synced to your local machine: One for the new version you are migrating to, one for the commit to upgrade FROM.
+2. Make the changes in the new branch and write the upgrade handler per instructions above.
+3. Make sure the new binaries will pass the tests in the new branch
+3. Build the new binaries using `build-for-upgrade`. (both in decentralized-api and inference-chain)
+4. Copy the new binaries (zip files) to the OLD binares directory (public-html/v2/dapi and public-html/v2/inferenced)
+4. In the OLD branch open the `submit upgrade` Testermint test, make sure the parameters and SHA match the NEW branch values.
+5. Launch the chain in the OLD branch
+6. Run the submit upgrade test.
+7. If it passes, run `make build-docker` in the NEW branch, to ensure the image matches the new binaries.
+8. Run tests needed to verify the upgrade went well (will depend on the upgrade). Be careful not to run tests that will reboot the chain.
+## Key Notes
+- **Upgrade Handlers**: Each upgrade requires a tailored handler for any necessary migrations.
+- **Documentation**: Ensure clear communication of changes and steps for stakeholders.
+- **Scalability**: Account for possible high traffic during binary downloads.
+
diff --git a/docs/voting.md b/docs/voting.md
new file mode 100644
index 000000000..99700bdb1
--- /dev/null
+++ b/docs/voting.md
@@ -0,0 +1,80 @@
+# Voting
+Voting has two levels. Governance voting and operational voting.
+
+### Governance Voting
+This is voting for changing the "big" parameters, such as inflation rate, rewards and punishments for bad inferences, length of Epochs, etc. Voting period is likely to be days.
+
+It is not implemented yet. We plan to use the x/gov module from the Cosmos SDK.
+
+
+### Operational Voting
+Operational voting is voting on short-lived proposals when something seems wrong. Voting period is minutes. For example:
+
+1. An inference does not appear to be using the right model or parameters
+2. A PoC does not appear to be valid
+3. ?
+
+This is implemented for inference validation, and will be implemented for PoC validation shortly. It leverages the x/group module, with the results of each PoC creating a new group with the weights from the period.
+
+### Diagram
+Below is a Mermaid diagram of the inference validation voting process:
+
+```mermaid
+flowchart TD
+ start(["Validator receives event: Inference finished"])
+ decision1{"Should Validator validate?"}
+ validation["Validator validates inference"]
+ resultMsg["Validator sends result message to chain"]
+ chainLogic{"Chain logic determines result"}
+ validatedStatus["Inference marked as VALIDATED"]
+ votingStatus["Inference moved to VOTING status"]
+ proposals["Two proposals created:
+ - Invalidate
+ - Revalidate"]
+ notifyNetwork["Network notified for confirm validation"]
+ networkValidation["Network members validate inference"]
+ networkMsg["Network members send validation result to chain"]
+ voteDecision{"Chain logic determines result"}
+ invalidateMsg["Chain sends InvalidateInference message"]
+ revalidateMsg["Chain sends RevalidateInference message"]
+ validated["Member Validated Inference"]
+ invalidated["Member Invalidated Inference"]
+ noVoteOnInvalidated["Vote No on Invalidation"]
+ noVoteOnRevalidated["Vote No on Revalidation"]
+ yesVoteOnInvalidated["Vote Yes on Invalidation"]
+ yesVoteOnRevalidation["Vote Yes on Revalidation"]
+ revalidateDecision{"Yes votes for revalidate > 50%?"}
+ invalidateDecision{"Yes votes for invalidate > 50%?"}
+ finalValidated("Inference marked as VALIDATED")
+ finalInvalidated("Inference marked as INVALIDATED")
+ finalIgnored["Inference will not be validated or invalidated"]
+ %% Decision paths
+ start --> decision1
+ decision1 -->|Yes| validation
+ decision1 -->|No| finalIgnored
+ validation --> resultMsg
+ resultMsg --> chainLogic
+ chainLogic -->|Validated| validatedStatus
+ chainLogic -->|Invalidated| votingStatus
+ votingStatus --> proposals
+ proposals --> notifyNetwork
+ notifyNetwork --> networkValidation
+ networkValidation --> networkMsg
+ networkMsg --> voteDecision
+ voteDecision --> |Validated| validated
+ voteDecision --> |Invalidated| invalidated
+ validated --> noVoteOnInvalidated
+ validated --> yesVoteOnRevalidation
+ invalidated --> yesVoteOnInvalidated
+ invalidated --> noVoteOnRevalidated
+ noVoteOnInvalidated --> networkValidation
+ noVoteOnRevalidated --> networkValidation
+ yesVoteOnInvalidated --> invalidateDecision
+ yesVoteOnRevalidation --> revalidateDecision
+ invalidateDecision --> |No| networkValidation
+ revalidateDecision --> |No| networkValidation
+ invalidateDecision --> |Yes| invalidateMsg
+ revalidateDecision --> |Yes| revalidateMsg
+ invalidateMsg --> finalInvalidated
+ revalidateMsg --> finalValidated
+```
diff --git a/genesis/README.md b/genesis/README.md
new file mode 100644
index 000000000..8aabf704c
--- /dev/null
+++ b/genesis/README.md
@@ -0,0 +1,328 @@
+# Gonka Genesis Ceremony
+
+The genesis ceremony is a coordinated process to bootstrap the Gonka blockchain with a pre-defined set of initial validators and an agreed-upon genesis.json file.
+This ceremony is important because it establishes the network's foundational security, ensures fair participation among validators, and creates a verifiable starting point for the blockchain.
+
+## Overview
+
+The ceremony is a transparent and auditable process managed entirely through GitHub Pull Requests (PRs). The core workflow is straightforward:
+
+- Participants (Validators) submit information and offline transaction files (GENTX and GENPARTICIPANT) via PRs
+- The Coordinator aggregates and verifies these inputs to publish the final, agreed `genesis.json` with a scheduled `genesis_time` and recorded hash.
+- Validators verify that the file is produced correctly and launch their nodes
+
+The ceremony proceeds through clearly defined phases to produce an auditable, shared `genesis.json`. All collaboration happens via GitHub PRs for full transparency and accountability.
+
+
+This process is guided by several key principles:
+
+- **Transparency and Auditability:** Using GitHub PRs for all submissions creates a public, verifiable record of the entire process from start to finish.
+
+- **Decentralized Launch:** The ceremony ensures the network begins with an agreed-upon set of independent validators, establishing decentralization from block zero.
+
+- **Verifiable State:** The final genesis.json hash is recorded, allowing every participant to confirm they are starting from the exact same initial state.
+
+- **Consensus:** The process guarantees that all initial validators have reviewed and accepted the genesis state before the network goes live.
+
+## Prerequisites
+
+Before participating in the ceremony, each participant (validator) must:
+
+1. **Fork** [the Gonka Repository](https://github.com/gonka-ai/gonka/) to your GitHub account
+
+2. **Choose a participant (validator) name** and create your validator directory:
+ ```bash
+ cp -r genesis/validators/template genesis/validators/
+ ```
+ This directory will be used for sharing information and transactions during the ceremony.
+
+3. **Follow the local setup portion of the Quickstart Guide**. Before the ceremony, you must complete the local machine setup as described in the [Gonka Quickstart](https://gonka.ai/participant/quickstart) guide. This includes installing the `inferenced` CLI, creating your Account Cold Key, and pulling the Docker images. **Stop** after pulling the images and do not launch the services; the ceremony process replaces the server-side setup and on-chain transactions with an offline, PR-based workflow.
+
+4. Confirm readiness:
+ - `inferenced` CLI is installed locally and your Account Cold Key is created
+ - Containers are pulled, models downloaded, and environment variables (`config.env`) are configured
+
+
+## Ceremony Process
+
+The ceremony follows a 5-phase process, replacing the on-chain registration steps from `quickstart.md` with an offline, PR-based workflow. All transaction files are generated locally and submitted for aggregation by the Coordinator.
+
+- **Phase 1 [Validators]**: Prepare Keys and initial server setup; open PR with validator information (including node ID, ML operational address, and consensus pubkey)
+- **Phase 2 [Coordinator]**: Aggregate validator info and publish `genesis.json` draft for review
+- **Phase 3 [Validators]**: Generate offline `GENTX` and `GENPARTICIPANT` files from the draft; open PR with files
+- **Phase 4 [Coordinator]**: Verify and collect transactions, patch `genesis.json`, set `genesis_time`
+- **Phase 5 [Validators]**: Retrieve final `genesis.json`, verify hash, and launch nodes before `genesis_time`
+
+### Deploy Scripts
+
+To simplify the process, the deploy scripts for the Ceremony will be in [/deploy/join](/deploy/join) directory of [the Gonka Repository](https://github.com/gonka-ai/gonka/).
+The deploy scripts are the same as the standard join flow from `quickstart.md`. During the ceremony, the Coordinator will adjust the following environment variables to enable genesis-specific behavior:
+
+- `INIT_ONLY` — initialize data directories and prepare configs without starting the full stack
+- `GENESIS_SEEDS` — seed node address list used for initial P2P connectivity at launch
+- `IS_GENESIS` — toggle genesis-only paths (e.g., hash verification, bootstrap behavior) in compose/scripts
+
+Location: these variables are set by the Coordinator in `deploy/join/docker-compose.yml`. Validators should not change them.
+
+Once **Phase 5** is finished and the chain has launched, the variables above are removed from the repo by the Coordinator as they're not required further.
+
+Working directory: run all `docker compose` commands from `deploy/join` (change directory first), or pass `-f deploy/join/docker-compose.yml` explicitly when running from the repository root.
+
+### 1. [Validators]: Prepare Keys and Initial Server Setup
+
+This phase mirrors the key generation steps in `quickstart.md`, but all setup is performed offline to generate files for the ceremony. The Account Key (Cold) was already created during the quickstart; the following steps will guide you through generating the ML Operational Key (Warm) on your server.
+
+#### 1.1 [Local] Confirm Account Cold Key (from Quickstart)
+The Account Cold Key was created during `quickstart.md`. You can view its information with:
+```bash
+./inferenced keys list --keyring-backend file
+```
+
+**Example output:**
+```
+Enter keyring passphrase (attempt 1/3):
+- address: gonka1eq4f5p32ewkekf9rv5f0qjsa0xaepckmgl85kr
+ name: "gonka-account-key"
+ pubkey: '{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"A4U3G2eY46mwhWx7ZXieT+LetPJhG0jHNuVCQB6wgBZK"}'
+ type: local
+```
+
+#### 1.2 [Server]: Initialize Node and Get Node ID
+```bash
+docker compose run --rm node
+```
+
+**Example output:**
+```
+51a9df752b60f565fe061a115b6494782447dc1f
+```
+
+
+#### 1.3 [Server]: Extract Consensus Public Key
+Start the `tmkms` service to generate the consensus key, then extract the public key.
+```bash
+docker compose up -d tmkms && docker compose run --rm --entrypoint /bin/sh tmkms -c "tmkms-pubkey"
+```
+
+**Example output:**
+```
+/wTVavYr5OCiVssIT3Gc5nsfIH0lP1Rqn/zeQtq4CvQ=
+```
+
+#### 1.4 [Server]: Generate ML Operational Key
+
+Create the warm key inside the `api` container using the `file` keyring backend (required for programmatic access). The key will be stored in a persistent volume mapped to `/root/.inference` of the container:
+
+Note: `$KEY_NAME` and `$KEYRING_PASSWORD` are defined in Quickstart `config.env`.
+```bash
+docker compose run --rm --no-deps -it api /bin/sh
+```
+
+Inside the container, create the ML operational key:
+```bash
+printf '%s\n%s\n' "$KEYRING_PASSWORD" "$KEYRING_PASSWORD" | inferenced keys add "$KEY_NAME" --keyring-backend file
+```
+
+**Example output:**
+```
+~ # printf '%s\n%s\n' "$KEYRING_PASSWORD" "$KEYRING_PASSWORD" | inferenced keys add "$KEY_NAME" --keyring-backend file
+
+- address: gonka1gyz2agg5yx49gy2z4qpsz9826t6s9xev6tkehw
+ name: node-702105
+ pubkey: '{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"Ao8VPh5U5XQBcJ6qxAIwBbhF/3UPZEwzZ9H/qbIA6ipj"}'
+ type: local
+
+
+**Important** write this mnemonic phrase in a safe place.
+It is the only way to recover your account if you ever forget your password.
+
+again plastic athlete arrow first measure danger drastic wolf coyote work memory already inmate sorry path tackle custom write result west tray rabbit jeans
+```
+
+#### 1.5 [Local]: Prepare PR with validator information
+Create or update `genesis/validators//README.md` with the following fields. Use values collected above and from Quickstart.
+
+```markdown
+Account Public Key:
+Node ID:
+ML Operational Address:
+Consensus Public Key:
+P2P_EXTERNAL_ADDRESS:
+```
+
+#### 1.6 Create Pull Request
+
+Submit a PR to [the Gonka Repository](https://github.com/gonka-ai/gonka/) with your validator information. Include a clear title like "Add validator: " and ensure all required fields are populated in your README.md file.
+
+### 2. [Coordinator]: Genesis Draft Preparation
+
+The coordinator will:
+- Review and merge all validator PRs from Phase 1
+- Prepare the initial `genesis.json` draft which includes all Account Addresses and place it in `genesis/genesis-draft.json`
+- Announce the availability of the draft to all participants
+
+### 3. [Validators]: GENTX and GENPARTICIPANT Generation
+
+This phase involves generating the necessary transaction files for chain initialization. These transactions include:
+
+- `MsgCreateValidator` - Creates your validator on the chain
+- `MsgSubmitNewParticipant` - Registers your node as a network participant
+
+The gentx command requires the following variables from previous steps:
+
+- `` - name of Account Cold Key in local registry (e.g., "gonka-account-key" from Quickstart)
+- `` - the validator name chosen in the Prerequisites section
+- `` - address of ML Operational Key from step 1.4
+- `$PUBLIC_URL` - environment variable with public URL from Quickstart's `config.env`
+- `` - consensus public key from step 1.3
+- `` - node ID from step 1.2
+
+This custom `gentx` command automatically creates the required `authz` grants from your Account Key to your ML Operational Key, simplifying the setup process.
+
+Before generating files, you must copy the draft `genesis/genesis-draft.json` into the `config` directory where your Account Cold Key is stored. This allows the `gentx` command to access your key and validate the transaction against the correct chain configuration.
+
+The default home directory for `inferenced` is `~/.inference`. If you created your key there, use the following command:
+
+```bash
+cp ./genesis/genesis-draft.json ~/.inference/config/genesis.json
+```
+
+*If you specified a custom home directory with the `--home` flag when creating your key, be sure to use that same directory for the `gentx` command by providing the `--home` flag again.*
+
+#### [Local]: Create GENTX and GENPARTICIPANT Files
+
+The `1nicoin` value represents an artificial consensus weight for the genesis transaction. The real validator weight will be determined during the first Proof of Compute (PoC) phase.
+
+```bash
+./inferenced genesis gentx \
+ --keyring-backend file \
+ 1nicoin \
+ --moniker \
+ --pubkey \
+ --ml-operational-address \
+ --url $PUBLIC_URL \
+ --chain-id gonka-mainnet \
+ --node-id
+```
+
+**Example output:**
+```
+./inferenced genesis gentx \
+ --home ./702121 \
+ --keyring-backend file \
+ 702121 1nicoin \
+ --pubkey eNrjtkSXzfE18jq3lqvpu/i1iIog9SN+kqR2Wsa6fSM= \
+ --ml-operational-address gonka13xplq68fws3uvs8m7ej2ed5ack9hzpc68fwvex \
+ --url http://36.189.234.237:19238 \
+ --moniker "mynode-702121" --chain-id gonka-mainnet \
+ --node-id 149d25924b9a6676448aea716864c31775645459
+Enter keyring passphrase (attempt 1/3):
+Classic genesis transaction written to "702121/config/gentx/gentx-149d25924b9a6676448aea716864c31775645459.json"
+Genparticipant transaction written to "702121/config/genparticipant/genparticipant-149d25924b9a6676448aea716864c31775645459.json"
+```
+
+#### [Local]: Submit Generated Files
+
+Copy the generated files to your validator directory and create a PR:
+
+1. Copy files to your validator directory:
+
+ ```bash
+ cp ~/.inference/config/gentx/gentx-.json genesis/validators//
+ cp ~/.inference/config/genparticipant/genparticipant-.json genesis/validators//
+ ```
+
+2. Create a PR with the following files:
+
+ - `genesis/validators//gentx-.json`
+ - `genesis/validators//genparticipant-.json`
+
+Use a clear PR title like "Add gentx files for validator: ".
+
+
+### 4. [Coordinator]: Final Genesis Preparation
+
+Once all validators have submitted their transaction files, the Coordinator begins constructing the official `genesis.json`. This critical step ensures all initial participants are correctly included in the blockchain's state from the very first block.
+
+The process involves two main commands:
+1. **Collecting Genesis Transactions**: The `collect-gentxs` command gathers all `gentx-.json` files, validates them, and incorporates them into `genesis.json` to populate the initial validator set.
+2. **Patching Participant Data**: The `patch-genesis` command processes the `genparticipant-.json` files, verifying their signatures and patching the initial state to include all registered participants.
+
+After merging all transactions, the Coordinator sets the `genesis_time` to a future timestamp, ensuring all validators have enough time to prepare for a synchronized launch.
+
+Finally, the Coordinator commits the official `genesis.json` to the `genesis/` directory. The hash of this commit is then embedded into the source code to ensure all nodes start from the same verified state.
+
+#### [Coordinator Local]: Collect Genesis Transactions
+
+```bash
+./inferenced genesis collect-gentxs --gentx-dir gentxs
+```
+
+#### [Coordinator]: Process Participant Registrations
+
+```bash
+./inferenced genesis patch-genesis --genparticipant-dir genparticipants
+```
+
+#### [Coordinator]: Configure Network Seeds
+
+The Coordinator configures the initial network peering by setting the `GENESIS_SEEDS` variable in `deploy/join/docker-compose.yml`. This variable is a comma-separated list of validator node addresses, constructed using the `Node ID` and `P2P_EXTERNAL_ADDRESS` provided by each validator in their respective `README.md` files.
+
+Example format: `@,@,...`
+
+Additionally, the Coordinator sets `INIT_ONLY` to `false`, which allows the nodes to fully start up and connect to the network at launch time instead of just initializing their data directories.
+
+### 5. [Validators]: Chain Launch
+
+With the final `genesis.json` published, validators must verify that it is produced correctly and prepare their nodes to launch at the specified `genesis_time`. The blockchain will begin producing blocks at exactly this moment.
+
+#### 5.1 [Server]: Update and Launch
+
+These steps should be performed on your validator server.
+
+1. **Pull Latest Configuration**
+
+ Pull the latest changes from the repository to get the final `genesis.json` and seed node configuration.
+ ```bash
+ git pull
+ ```
+
+2. **Update Container Images**
+
+ From the `deploy/join` directory, pull the latest Docker container images. The node image is built with the final genesis hash for verification.
+ ```bash
+ source config.env
+ docker compose -f docker-compose.yml -f docker-compose.mlnode.yml pull
+ ```
+
+3. **Launch Your Validator**
+
+ Finally, start all services.
+ ```bash
+ docker compose -f docker-compose.yml -f docker-compose.mlnode.yml up -d
+ ```
+
+#### 5.2 [Server]: Verify Launch Status
+
+After launching, monitor your node's logs to confirm it is waiting for the genesis time:
+
+```bash
+docker compose logs node -f
+```
+
+Look for a message similar to this:
+```
+INF Genesis time is in the future. Sleeping until then... genTime=2025-08-14T09:13:39Z module=server
+```
+
+**Important Notes:**
+- The `api` container may restart several times before the `node` container is fully operational
+- Once the genesis time passes, you should see block production messages in the logs
+
+### 6. [Coordinator]: Post-Launch Cleanup
+
+Remove genesis-specific variables from docker-compose.yml configuration files to transition to normal operation mode.
+
+## Troubleshooting
+
+For additional support, consult the [Quickstart Guide](https://gonka.ai/participant/quickstart) or join the community Discord.
diff --git a/genesis/founders_ledger.json b/genesis/founders_ledger.json
new file mode 100644
index 000000000..c6fc293ae
--- /dev/null
+++ b/genesis/founders_ledger.json
@@ -0,0 +1,44 @@
+gonka18299ldv2cym0gh5spmm6yncv3at3qgn0t7km5w 100,470,678,000,000,000
+gonka16fdw9ve0xj5yy42asg85wgykr4y4kw2l37rkfp 2,400,000,000,000,000
+gonka1dtvqtnq6fjvetajs25kuc9f3944fctveuukxpx 800,000,000,000,000
+gonka1k4rnc2e9upscac85tkjwa43wr6kqpfyqcmdwej 800,000,000,000,000
+gonka1s7jy6fajstlxzhtxgqmdh4a2cgq26uxcu7jptk 800,000,000,000,000
+gonka1rusnaafgmk0h464fthswch3pzh0zzpsegrda09 320,000,000,000,000
+gonka12tz8qs5kxjp6qsdgj2u3rzx009z2qf6hjrwrrl 320,000,000,000,000
+gonka1n7ph0qezwcr666kp6tesylw4eqnyqwd0g76u7d 320,000,000,000,000
+gonka1ld2e89rhfmdlke69m444jcd99h7fra4whksdk4 320,000,000,000,000
+gonka1a0rh2dej6lrnj5zkx005f5jrxem0tpdh4cpcmg 160,000,000,000,000
+gonka18qmj244rxzt3274357jd2mp45tv8n4508g29r8 160,000,000,000,000
+gonka1v86vj8e8eqd3gk5zlf9zawrg0w7c7tfa7x9k25 160,000,000,000,000
+gonka108eh38a2pelplqz2lh3ujjnvk7ucdylql6gfmg 160,000,000,000,000
+gonka1cpxpnskkf6hlpldu76tya7d53rklnjlqu4uars 80,000,000,000,000
+gonka17u7kemct38fx3cuj2yh0x5j2fd9zxkuwkes6q7 15,000,000,000,000,000
+gonka1th0qvf05sqdd09p9rgq69nlchw5xzpc3ddply8 4,800,001,000,000,000
+gonka1pq9r54md9zrd9xqyxx9f3h7as9kfgnp2c0ucat 40,000,000,000,000,000
+gonka1gvx5swzrur89kg5r0z5jn9a0krvmhvzx3f2fea 3,613,884,000,000,000
+gonka1x29n95z989ycxymqw60w56dpz7kcdxpp8w8y6x 722,777,000,000,000
+gonka1327uf364ql39e63fax5n8t8y5e8lag4xjl7e49 722,777,000,000,000
+gonka1tyfdmaulndss4wqpxr24e8reytj03aw338sphz 8,673,322,000,000,000
+gonka1akmamql0z9vnd48tfw3d75zexu3dswqcawtnxa 361,388,000,000,000
+gonka13t3cvaeke9z5vlwps3z7eyp9uj98z2xkt02352 361,388,000,000,000
+gonka19cw7kkrkdcxkxmkz56hjatfwrunn79fsyvfky5 110,044,000,000,000
+gonka1689695npe7amwyunaaj9dwz58v8n7cgkw5emn4 34,381,000,000,000
+gonka1fxls283es0m7cymxky9xuml9x74flfjhkfrz4q 7,163,000,000,000
+gonka179nv57lqeana9nvgeul8twegj58ccrd2hm5uzc 144,555,000,000,000
+gonka1ucl3pfq6sy9ggxuxahvjhm52hgl3qu4wg46hsk 72,278,000,000,000
+gonka1jle7z5mmfczkvy76gvsxud6kjryzhr8c3cpyal 361,388,000,000,000
+gonka1xn25n0hphw8tkfg6r3hjvh8d6nerpzqjpql3nx 72,278,000,000,000
+gonka1z5a69mz9gzhphf4eu6yznzru2la0em89xutepm 72,278,000,000,000
+gonka1lrwu2czkxwaadqnvsttfa5uvc6mshv8wjd3wyz 144,555,000,000,000
+gonka1469wnu47q925a4ekazp09tx9k5phyj2nv67jv3 144,555,000,000,000
+gonka1h78hmsvknwp86qzu9xftv9znwga7u0sjghmz20 1,445,554,000,000,000
+gonka1qm66c5gqyew27nefdknspf2x5nwvetsk80zvay 361,388,000,000,000
+gonka1qgstmj6k2xwx5p8s2p0ch2qd32lkgegqkcsljs 36,074,000,000,000
+gonka1g02qwpgju9xu8lwtqpgrzfqrj7x45tnnhgh3xz 72,278,000,000,000
+gonka1clvs7fyag6zjkpnvapjj6m0jn38mgsn63tdnhc 180,629,000,000,000
+gonka18weyd0tlmtvnn47c0fqg0p8jj3q6s2hz3w67nc 36,074,000,000,000
+gonka1l4z4swg3e0pf937qm08u0cnkszss34kpe32y52 361,388,000,000,000
+gonka10k4rmsg3e9xrmm2my9dp6lal4nxlenck9uur39 3,252,496,000,000,000
+gonka1vthfz8j7gkeu04jx2ju6akcyv6s9apc497x2e3 722,777,000,000,000
+gonka19xcrqllduyr6ur3l5ldln4qj0jfpaqfx20280q 10,841,652,000,000,000
+
diff --git a/genesis/genesis-draft-no-accounts.json b/genesis/genesis-draft-no-accounts.json
new file mode 100644
index 000000000..2fdadfa4e
--- /dev/null
+++ b/genesis/genesis-draft-no-accounts.json
@@ -0,0 +1,617 @@
+{
+ "app_name": "inferenced",
+ "app_version": "50e0a6c3",
+ "genesis_time": "2025-08-21T20:48:23.205041299Z",
+ "chain_id": "gonka-mainnet",
+ "initial_height": 1,
+ "app_hash": null,
+ "app_state": {
+ "06-solomachine": null,
+ "07-tendermint": null,
+ "auth": {
+ "params": {
+ "max_memo_characters": "256",
+ "tx_sig_limit": "7",
+ "tx_size_cost_per_byte": "10",
+ "sig_verify_cost_ed25519": "590",
+ "sig_verify_cost_secp256k1": "1000"
+ },
+ "accounts": [
+ {
+ "@type": "/cosmos.auth.v1beta1.ModuleAccount",
+ "name": "distribution",
+ "base_account": {
+ "address": "gonka1jv65s3grqf6v6jl3dp4t6c9t9rk99cd8h2rzwa",
+ "pub_key": null,
+ "account_number": "0",
+ "sequence": "0"
+ },
+ "permissions": []
+ }
+ ]
+ },
+ "authz": {
+ "authorization": []
+ },
+ "bank": {
+ "params": {
+ "send_enabled": [],
+ "default_send_enabled": true
+ },
+ "balances": [
+ {
+ "address": "gonka1jv65s3grqf6v6jl3dp4t6c9t9rk99cd8h2rzwa",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "120000000000000000"
+ }
+ ]
+ }
+ ],
+ "supply": [
+ {
+ "denom": "ngonka",
+ "amount": "120000000000000000"
+ }
+ ],
+ "denom_metadata": [
+ {
+ "description": "Coins for the Gonka network.",
+ "base": "ngonka",
+ "display": "ngonka",
+ "name": "Gonka",
+ "symbol": "GNK",
+ "denom_units": [
+ {
+ "denom": "ngonka",
+ "exponent": 0,
+ "aliases": [
+ "nanogonka"
+ ]
+ },
+ {
+ "denom": "ugonka",
+ "exponent": 3,
+ "aliases": [
+ "microgonka"
+ ]
+ },
+ {
+ "denom": "mgonka",
+ "exponent": 6,
+ "aliases": [
+ "milligonka"
+ ]
+ },
+ {
+ "denom": "gonka",
+ "exponent": 9,
+ "aliases": []
+ }
+ ]
+ }
+ ],
+ "send_enabled": []
+ },
+ "bls": {
+ "params": {
+ "i_total_slots": 100,
+ "t_slots_degree_offset": 50,
+ "dealing_phase_duration_blocks": "5",
+ "verification_phase_duration_blocks": "3",
+ "signing_deadline_blocks": "10"
+ },
+ "active_epoch_id": "0"
+ },
+ "bookkeeper": {
+ "params": {}
+ },
+ "capability": {
+ "index": "1",
+ "owners": []
+ },
+ "circuit": {
+ "account_permissions": [],
+ "disabled_type_urls": []
+ },
+ "collateral": {
+ "params": {
+ "unbonding_period_epochs": "1"
+ },
+ "collateral_balance_list": [],
+ "unbonding_collateral_list": [],
+ "jailed_participant_list": []
+ },
+ "consensus": null,
+ "crisis": {
+ "constant_fee": {
+ "denom": "ngonka",
+ "amount": "1000"
+ }
+ },
+ "distribution": {
+ "params": {
+ "community_tax": "0.020000000000000000",
+ "base_proposer_reward": "0.000000000000000000",
+ "bonus_proposer_reward": "0.000000000000000000",
+ "withdraw_addr_enabled": true
+ },
+ "fee_pool": {
+ "community_pool": [{ "denom": "ngonka", "amount": "120000000000000000.000000000000000000" }]
+ },
+ "delegator_withdraw_infos": [],
+ "previous_proposer": "",
+ "outstanding_rewards": [],
+ "validator_accumulated_commissions": [],
+ "validator_historical_rewards": [],
+ "validator_current_rewards": [],
+ "delegator_starting_infos": [],
+ "validator_slash_events": []
+ },
+ "evidence": {
+ "evidence": []
+ },
+ "feegrant": {
+ "allowances": []
+ },
+ "feeibc": {
+ "identified_fees": [],
+ "fee_enabled_channels": [],
+ "registered_payees": [],
+ "registered_counterparty_payees": [],
+ "forward_relayers": []
+ },
+ "genesistransfer": {
+ "params": {
+ "allowed_accounts": [],
+ "restrict_to_list": false
+ },
+ "transfer_records": []
+ },
+ "genutil": {
+ "gen_txs": []
+ },
+ "gov": {
+ "starting_proposal_id": "1",
+ "deposits": [],
+ "votes": [],
+ "proposals": [],
+ "deposit_params": null,
+ "voting_params": null,
+ "tally_params": null,
+ "params": {
+ "min_deposit": [
+ {
+ "denom": "ngonka",
+ "amount": "25_000_000"
+ }
+ ],
+ "max_deposit_period": "172800s",
+ "voting_period": "48h0m0s",
+ "quorum": "0.334000000000000000",
+ "threshold": "0.500000000000000000",
+ "veto_threshold": "0.334000000000000000",
+ "min_initial_deposit_ratio": "0.000000000000000000",
+ "proposal_cancel_ratio": "0.500000000000000000",
+ "proposal_cancel_dest": "",
+ "expedited_voting_period": "12h0m0s",
+ "expedited_threshold": "0.667000000000000000",
+ "expedited_min_deposit": [
+ {
+ "denom": "ngonka",
+ "amount": "50_000_000"
+ }
+ ],
+ "burn_vote_quorum": false,
+ "burn_proposal_deposit_prevote": false,
+ "burn_vote_veto": true,
+ "min_deposit_ratio": "0.010000000000000000"
+ },
+ "constitution": ""
+ },
+ "group": {
+ "group_seq": "0",
+ "groups": [],
+ "group_members": [],
+ "group_policy_seq": "0",
+ "group_policies": [],
+ "proposal_seq": "0",
+ "proposals": [],
+ "votes": []
+ },
+ "ibc": {
+ "client_genesis": {
+ "clients": [],
+ "clients_consensus": [],
+ "clients_metadata": [],
+ "params": {
+ "allowed_clients": [
+ "*"
+ ]
+ },
+ "create_localhost": false,
+ "next_client_sequence": "0"
+ },
+ "connection_genesis": {
+ "connections": [],
+ "client_connection_paths": [],
+ "next_connection_sequence": "0",
+ "params": {
+ "max_expected_time_per_block": "30000000000"
+ }
+ },
+ "channel_genesis": {
+ "channels": [],
+ "acknowledgements": [],
+ "commitments": [],
+ "receipts": [],
+ "send_sequences": [],
+ "recv_sequences": [],
+ "ack_sequences": [],
+ "next_channel_sequence": "0",
+ "params": {
+ "upgrade_timeout": {
+ "height": {
+ "revision_number": "0",
+ "revision_height": "0"
+ },
+ "timestamp": "600000000000"
+ }
+ }
+ }
+ },
+ "inference": {
+ "params": {
+ "epoch_params": {
+ "epoch_length": "17280",
+ "epoch_multiplier": "1",
+ "epoch_shift": "16980",
+ "default_unit_of_compute_price": "100",
+ "poc_stage_duration": "60",
+ "poc_exchange_duration": "5",
+ "poc_validation_delay": "5",
+ "poc_validation_duration": "20",
+ "set_new_validators_delay": "120",
+ "inference_validation_cutoff": "80",
+ "inference_pruning_epoch_threshold": "2"
+ },
+ "validation_params": {
+ "false_positive_rate": {
+ "value": "5",
+ "exponent": -2
+ },
+ "min_ramp_up_measurements": 10,
+ "pass_value": {
+ "value": "99",
+ "exponent": -2
+ },
+ "min_validation_average": {
+ "value": "1",
+ "exponent": -2
+ },
+ "max_validation_average": {
+ "value": "1",
+ "exponent": 0
+ },
+ "expiration_blocks": "20",
+ "epochs_to_max": "30",
+ "full_validation_traffic_cutoff": "10000",
+ "min_validation_halfway": {
+ "value": "5",
+ "exponent": -2
+ },
+ "min_validation_traffic_cutoff": "100",
+ "miss_percentage_cutoff": {
+ "value": "1",
+ "exponent": -2
+ },
+ "miss_requests_penalty": {
+ "value": "1",
+ "exponent": 0
+ },
+ "timestamp_expiration": "60",
+ "timestamp_advance": "30",
+ "estimated_limits_per_block_kb": "0"
+ },
+ "poc_params": {
+ "default_difficulty": 5,
+ "validation_sample_size": 200,
+ "poc_data_pruning_epoch_threshold": "1"
+ },
+ "tokenomics_params": {
+ "subsidy_reduction_interval": {
+ "value": "5",
+ "exponent": -2
+ },
+ "subsidy_reduction_amount": {
+ "value": "2",
+ "exponent": -1
+ },
+ "current_subsidy_percentage": {
+ "value": "9",
+ "exponent": -1
+ },
+ "top_reward_allowed_failure": {
+ "value": "1",
+ "exponent": -1
+ },
+ "top_miner_poc_qualification": "10",
+ "work_vesting_period": "0",
+ "reward_vesting_period": "0",
+ "top_miner_vesting_period": "0"
+ },
+ "collateral_params": {
+ "slash_fraction_invalid": {
+ "value": "2",
+ "exponent": -1
+ },
+ "slash_fraction_downtime": {
+ "value": "1",
+ "exponent": -1
+ },
+ "downtime_missed_percentage_threshold": {
+ "value": "5",
+ "exponent": -2
+ },
+ "grace_period_end_epoch": "180",
+ "base_weight_ratio": {
+ "value": "2",
+ "exponent": -1
+ },
+ "collateral_per_weight_unit": {
+ "value": "1",
+ "exponent": 0
+ }
+ },
+ "bitcoin_reward_params": {
+ "use_bitcoin_rewards": true,
+ "initial_epoch_reward": "285000000000000",
+ "decay_rate": {
+ "value": "-475",
+ "exponent": -6
+ },
+ "genesis_epoch": "1",
+ "utilization_bonus_factor": {
+ "value": "5",
+ "exponent": -1
+ },
+ "full_coverage_bonus_factor": {
+ "value": "12",
+ "exponent": -1
+ },
+ "partial_coverage_bonus_factor": {
+ "value": "1",
+ "exponent": -1
+ }
+ },
+ "dynamic_pricing_params": {
+ "stability_zone_lower_bound": {
+ "value": "4",
+ "exponent": -1
+ },
+ "stability_zone_upper_bound": {
+ "value": "6",
+ "exponent": -1
+ },
+ "price_elasticity": {
+ "value": "5",
+ "exponent": -2
+ },
+ "utilization_window_duration": "60",
+ "min_per_token_price": "1",
+ "base_per_token_price": "100",
+ "grace_period_end_epoch": "90",
+ "grace_period_per_token_price": "0"
+ },
+ "bandwidth_limits_params": {
+ "estimated_limits_per_block_kb": "10752",
+ "kb_per_input_token": {
+ "value": "23",
+ "exponent": "-4"
+ },
+ "kb_per_output_token": {
+ "value": "64",
+ "exponent": "-2"
+ }
+ }
+ },
+ "genesis_only_params": {
+ "total_supply": "1000000000000000000",
+ "originator_supply": "160000000000000000",
+ "top_reward_amount": "120000000000000000",
+ "standard_reward_amount": "600000000000000000",
+ "pre_programmed_sale_amount": "120000000000000000",
+ "top_rewards": 3,
+ "supply_denom": "ngonka",
+ "top_reward_period": "31536000",
+ "top_reward_payouts": "12",
+ "top_reward_payouts_per_miner": "4",
+ "top_reward_max_duration": "126144000",
+ "max_individual_power_percentage": {
+ "value": "25",
+ "exponent": -2
+ },
+ "genesis_guardian_enabled": true,
+ "genesis_guardian_network_maturity_threshold": "2000000",
+ "genesis_guardian_multiplier": {
+ "value": "52",
+ "exponent": -2
+ },
+ "genesis_guardian_addresses": []
+ },
+ "model_list": [
+ {
+ "proposed_by": "genesis",
+ "id": "Qwen/QwQ-32B",
+ "units_of_compute_per_token": "1000",
+ "hf_repo": "Qwen/QwQ-32B",
+ "hf_commit": "976055f8c83f394f35dbd3ab09a285a984907bd0",
+ "model_args": [
+ "--quantization",
+ "fp8",
+ "--kv-cache-dtype",
+ "fp8"
+ ],
+ "v_ram": "80",
+ "throughput_per_nonce": "1000",
+ "validation_threshold": {
+ "value": "98",
+ "exponent": -2
+ }
+ },
+ {
+ "proposed_by": "genesis",
+ "id": "Qwen/Qwen2.5-7B-Instruct",
+ "units_of_compute_per_token": "100",
+ "hf_repo": "Qwen/Qwen2.5-7B-Instruct",
+ "hf_commit": "a09a35458c702b33eeacc393d103063234e8bc28",
+ "model_args": [
+ "--quantization",
+ "fp8"
+ ],
+ "v_ram": "24",
+ "throughput_per_nonce": "10000",
+ "validation_threshold": {
+ "value": "98",
+ "exponent": -2
+ }
+ }
+ ],
+ "cosm_wasm_params": {
+ "cw20_code": "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",
+ "cw20_code_id": "0"
+ },
+ "participant_list": []
+ },
+ "interchainaccounts": {
+ "controller_genesis_state": {
+ "active_channels": [],
+ "interchain_accounts": [],
+ "ports": [],
+ "params": {
+ "controller_enabled": true
+ }
+ },
+ "host_genesis_state": {
+ "active_channels": [],
+ "interchain_accounts": [],
+ "port": "icahost",
+ "params": {
+ "host_enabled": true,
+ "allow_messages": [
+ "*"
+ ]
+ }
+ }
+ },
+ "mint": {
+ "minter": {
+ "inflation": "0.130000000000000000",
+ "annual_provisions": "0.000000000000000000"
+ },
+ "params": {
+ "mint_denom": "ngonka",
+ "inflation_rate_change": "0.130000000000000000",
+ "inflation_max": "0.200000000000000000",
+ "inflation_min": "0.070000000000000000",
+ "goal_bonded": "0.670000000000000000",
+ "blocks_per_year": "6311520"
+ }
+ },
+ "nft": {
+ "classes": [],
+ "entries": []
+ },
+ "params": null,
+ "restrictions": {
+ "params": {
+ "restriction_end_block": "1555000",
+ "emergency_transfer_exemptions": [],
+ "exemption_usage_tracking": []
+ }
+ },
+ "runtime": null,
+ "slashing": {
+ "params": {
+ "signed_blocks_window": "100",
+ "min_signed_per_window": "0.500000000000000000",
+ "downtime_jail_duration": "600s",
+ "slash_fraction_double_sign": "0.050000000000000000",
+ "slash_fraction_downtime": "0.010000000000000000"
+ },
+ "signing_infos": [],
+ "missed_blocks": []
+ },
+ "staking": {
+ "params": {
+ "unbonding_time": "1814400s",
+ "max_validators": 100,
+ "max_entries": 7,
+ "historical_entries": 10000,
+ "bond_denom": "ngonka",
+ "min_commission_rate": "0.000000000000000000"
+ },
+ "last_total_power": "0",
+ "last_validator_powers": [],
+ "validators": [],
+ "delegations": [],
+ "unbonding_delegations": [],
+ "redelegations": [],
+ "exported": false
+ },
+ "streamvesting": {
+ "params": {
+ "reward_vesting_period": "180"
+ },
+ "vesting_schedule_list": []
+ },
+ "transfer": {
+ "port_id": "transfer",
+ "denom_traces": [],
+ "params": {
+ "send_enabled": true,
+ "receive_enabled": true
+ },
+ "total_escrowed": []
+ },
+ "upgrade": {},
+ "vesting": {},
+ "wasm": {
+ "params": {
+ "code_upload_access": {
+ "permission": "Everybody",
+ "addresses": []
+ },
+ "instantiate_default_permission": "Everybody"
+ },
+ "codes": [],
+ "contracts": [],
+ "sequences": []
+ }
+ },
+ "consensus": {
+ "params": {
+ "block": {
+ "max_bytes": "22020096",
+ "max_gas": "-1"
+ },
+ "evidence": {
+ "max_age_num_blocks": "100000",
+ "max_age_duration": "172800000000000",
+ "max_bytes": "1048576"
+ },
+ "validator": {
+ "pub_key_types": [
+ "ed25519"
+ ]
+ },
+ "version": {
+ "app": "0"
+ },
+ "abci": {
+ "vote_extensions_enable_height": "0"
+ }
+ }
+ }
+}
diff --git a/genesis/genesis-draft.json b/genesis/genesis-draft.json
new file mode 100644
index 000000000..fb1d62418
--- /dev/null
+++ b/genesis/genesis-draft.json
@@ -0,0 +1,2094 @@
+{
+ "app_name": "inferenced",
+ "app_version": "50e0a6c3",
+ "genesis_time": "2025-08-21T20:48:23.205041299Z",
+ "chain_id": "gonka-mainnet",
+ "initial_height": 1,
+ "app_hash": null,
+ "app_state": {
+ "06-solomachine": null,
+ "07-tendermint": null,
+ "auth": {
+ "params": {
+ "max_memo_characters": "256",
+ "tx_sig_limit": "7",
+ "tx_size_cost_per_byte": "10",
+ "sig_verify_cost_ed25519": "590",
+ "sig_verify_cost_secp256k1": "1000"
+ },
+ "accounts": [
+ {
+ "@type": "/cosmos.auth.v1beta1.ModuleAccount",
+ "base_account": {
+ "address": "gonka1jv65s3grqf6v6jl3dp4t6c9t9rk99cd8h2rzwa",
+ "pub_key": null,
+ "account_number": "0",
+ "sequence": "0"
+ },
+ "name": "distribution",
+ "permissions": []
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka18299ldv2cym0gh5spmm6yncv3at3qgn0t7km5w",
+ "pub_key": null,
+ "account_number": "1",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "100470678000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka16fdw9ve0xj5yy42asg85wgykr4y4kw2l37rkfp",
+ "pub_key": null,
+ "account_number": "2",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "2400000000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1dtvqtnq6fjvetajs25kuc9f3944fctveuukxpx",
+ "pub_key": null,
+ "account_number": "3",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "800000000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1k4rnc2e9upscac85tkjwa43wr6kqpfyqcmdwej",
+ "pub_key": null,
+ "account_number": "4",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "800000000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1s7jy6fajstlxzhtxgqmdh4a2cgq26uxcu7jptk",
+ "pub_key": null,
+ "account_number": "5",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "800000000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1rusnaafgmk0h464fthswch3pzh0zzpsegrda09",
+ "pub_key": null,
+ "account_number": "6",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "320000000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka12tz8qs5kxjp6qsdgj2u3rzx009z2qf6hjrwrrl",
+ "pub_key": null,
+ "account_number": "7",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "320000000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1n7ph0qezwcr666kp6tesylw4eqnyqwd0g76u7d",
+ "pub_key": null,
+ "account_number": "8",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "320000000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1ld2e89rhfmdlke69m444jcd99h7fra4whksdk4",
+ "pub_key": null,
+ "account_number": "9",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "320000000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1a0rh2dej6lrnj5zkx005f5jrxem0tpdh4cpcmg",
+ "pub_key": null,
+ "account_number": "10",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "160000000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka18qmj244rxzt3274357jd2mp45tv8n4508g29r8",
+ "pub_key": null,
+ "account_number": "11",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "160000000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1v86vj8e8eqd3gk5zlf9zawrg0w7c7tfa7x9k25",
+ "pub_key": null,
+ "account_number": "12",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "160000000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka108eh38a2pelplqz2lh3ujjnvk7ucdylql6gfmg",
+ "pub_key": null,
+ "account_number": "13",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "160000000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1cpxpnskkf6hlpldu76tya7d53rklnjlqu4uars",
+ "pub_key": null,
+ "account_number": "14",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "80000000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka17u7kemct38fx3cuj2yh0x5j2fd9zxkuwkes6q7",
+ "pub_key": null,
+ "account_number": "15",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "15000000000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1th0qvf05sqdd09p9rgq69nlchw5xzpc3ddply8",
+ "pub_key": null,
+ "account_number": "16",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "4800001000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1pq9r54md9zrd9xqyxx9f3h7as9kfgnp2c0ucat",
+ "pub_key": null,
+ "account_number": "17",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "40000000000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1gvx5swzrur89kg5r0z5jn9a0krvmhvzx3f2fea",
+ "pub_key": null,
+ "account_number": "18",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "3613884000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1x29n95z989ycxymqw60w56dpz7kcdxpp8w8y6x",
+ "pub_key": null,
+ "account_number": "19",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "722777000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1327uf364ql39e63fax5n8t8y5e8lag4xjl7e49",
+ "pub_key": null,
+ "account_number": "20",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "722777000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1tyfdmaulndss4wqpxr24e8reytj03aw338sphz",
+ "pub_key": null,
+ "account_number": "21",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "8673322000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1akmamql0z9vnd48tfw3d75zexu3dswqcawtnxa",
+ "pub_key": null,
+ "account_number": "22",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "361388000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka13t3cvaeke9z5vlwps3z7eyp9uj98z2xkt02352",
+ "pub_key": null,
+ "account_number": "23",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "361388000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka19cw7kkrkdcxkxmkz56hjatfwrunn79fsyvfky5",
+ "pub_key": null,
+ "account_number": "24",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "110044000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1689695npe7amwyunaaj9dwz58v8n7cgkw5emn4",
+ "pub_key": null,
+ "account_number": "25",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "34381000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1fxls283es0m7cymxky9xuml9x74flfjhkfrz4q",
+ "pub_key": null,
+ "account_number": "26",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "7163000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka179nv57lqeana9nvgeul8twegj58ccrd2hm5uzc",
+ "pub_key": null,
+ "account_number": "27",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "144555000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1ucl3pfq6sy9ggxuxahvjhm52hgl3qu4wg46hsk",
+ "pub_key": null,
+ "account_number": "28",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "72278000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1jle7z5mmfczkvy76gvsxud6kjryzhr8c3cpyal",
+ "pub_key": null,
+ "account_number": "29",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "361388000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1xn25n0hphw8tkfg6r3hjvh8d6nerpzqjpql3nx",
+ "pub_key": null,
+ "account_number": "30",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "72278000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1z5a69mz9gzhphf4eu6yznzru2la0em89xutepm",
+ "pub_key": null,
+ "account_number": "31",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "72278000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1lrwu2czkxwaadqnvsttfa5uvc6mshv8wjd3wyz",
+ "pub_key": null,
+ "account_number": "32",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "144555000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1469wnu47q925a4ekazp09tx9k5phyj2nv67jv3",
+ "pub_key": null,
+ "account_number": "33",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "144555000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1h78hmsvknwp86qzu9xftv9znwga7u0sjghmz20",
+ "pub_key": null,
+ "account_number": "34",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "1445554000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1qm66c5gqyew27nefdknspf2x5nwvetsk80zvay",
+ "pub_key": null,
+ "account_number": "35",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "361388000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1qgstmj6k2xwx5p8s2p0ch2qd32lkgegqkcsljs",
+ "pub_key": null,
+ "account_number": "36",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "36074000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1g02qwpgju9xu8lwtqpgrzfqrj7x45tnnhgh3xz",
+ "pub_key": null,
+ "account_number": "37",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "72278000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1clvs7fyag6zjkpnvapjj6m0jn38mgsn63tdnhc",
+ "pub_key": null,
+ "account_number": "38",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "180629000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka18weyd0tlmtvnn47c0fqg0p8jj3q6s2hz3w67nc",
+ "pub_key": null,
+ "account_number": "39",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "36074000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1l4z4swg3e0pf937qm08u0cnkszss34kpe32y52",
+ "pub_key": null,
+ "account_number": "40",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "361388000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka10k4rmsg3e9xrmm2my9dp6lal4nxlenck9uur39",
+ "pub_key": null,
+ "account_number": "41",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "3252496000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1vthfz8j7gkeu04jx2ju6akcyv6s9apc497x2e3",
+ "pub_key": null,
+ "account_number": "42",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "722777000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka19xcrqllduyr6ur3l5ldln4qj0jfpaqfx20280q",
+ "pub_key": null,
+ "account_number": "43",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "10841652000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.auth.v1beta1.BaseAccount",
+ "address": "gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6",
+ "pub_key": null,
+ "account_number": "44",
+ "sequence": "0"
+ },
+ {
+ "@type": "/cosmos.auth.v1beta1.BaseAccount",
+ "address": "gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p",
+ "pub_key": null,
+ "account_number": "45",
+ "sequence": "0"
+ },
+ {
+ "@type": "/cosmos.auth.v1beta1.BaseAccount",
+ "address": "gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp",
+ "pub_key": null,
+ "account_number": "46",
+ "sequence": "0"
+ },
+ {
+ "@type": "/cosmos.auth.v1beta1.BaseAccount",
+ "address": "gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5",
+ "pub_key": null,
+ "account_number": "47",
+ "sequence": "0"
+ },
+ {
+ "@type": "/cosmos.auth.v1beta1.BaseAccount",
+ "address": "gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq",
+ "pub_key": null,
+ "account_number": "48",
+ "sequence": "0"
+ },
+ {
+ "@type": "/cosmos.auth.v1beta1.BaseAccount",
+ "address": "gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk",
+ "pub_key": null,
+ "account_number": "49",
+ "sequence": "0"
+ },
+ {
+ "@type": "/cosmos.auth.v1beta1.BaseAccount",
+ "address": "gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m",
+ "pub_key": null,
+ "account_number": "50",
+ "sequence": "0"
+ },
+ {
+ "@type": "/cosmos.auth.v1beta1.BaseAccount",
+ "address": "gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u",
+ "pub_key": null,
+ "account_number": "51",
+ "sequence": "0"
+ },
+ {
+ "@type": "/cosmos.auth.v1beta1.BaseAccount",
+ "address": "gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje",
+ "pub_key": null,
+ "account_number": "52",
+ "sequence": "0"
+ },
+ {
+ "@type": "/cosmos.auth.v1beta1.BaseAccount",
+ "address": "gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le",
+ "pub_key": null,
+ "account_number": "53",
+ "sequence": "0"
+ },
+ {
+ "@type": "/cosmos.auth.v1beta1.BaseAccount",
+ "address": "gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5",
+ "pub_key": null,
+ "account_number": "54",
+ "sequence": "0"
+ }
+ ]
+ },
+ "authz": {
+ "authorization": []
+ },
+ "bank": {
+ "params": {
+ "send_enabled": [],
+ "default_send_enabled": true
+ },
+ "balances": [
+ {
+ "address": "gonka1qgstmj6k2xwx5p8s2p0ch2qd32lkgegqkcsljs",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "36074000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1qm66c5gqyew27nefdknspf2x5nwvetsk80zvay",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "361388000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1pq9r54md9zrd9xqyxx9f3h7as9kfgnp2c0ucat",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "40000000000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "1"
+ }
+ ]
+ },
+ {
+ "address": "gonka1z5a69mz9gzhphf4eu6yznzru2la0em89xutepm",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "72278000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "1"
+ }
+ ]
+ },
+ {
+ "address": "gonka1rusnaafgmk0h464fthswch3pzh0zzpsegrda09",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "320000000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "1"
+ }
+ ]
+ },
+ {
+ "address": "gonka19xcrqllduyr6ur3l5ldln4qj0jfpaqfx20280q",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "10841652000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "1"
+ }
+ ]
+ },
+ {
+ "address": "gonka19cw7kkrkdcxkxmkz56hjatfwrunn79fsyvfky5",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "110044000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1x29n95z989ycxymqw60w56dpz7kcdxpp8w8y6x",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "722777000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1xn25n0hphw8tkfg6r3hjvh8d6nerpzqjpql3nx",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "72278000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka18qmj244rxzt3274357jd2mp45tv8n4508g29r8",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "160000000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka18299ldv2cym0gh5spmm6yncv3at3qgn0t7km5w",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "100470678000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka18weyd0tlmtvnn47c0fqg0p8jj3q6s2hz3w67nc",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "36074000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1gvx5swzrur89kg5r0z5jn9a0krvmhvzx3f2fea",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "3613884000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1g02qwpgju9xu8lwtqpgrzfqrj7x45tnnhgh3xz",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "72278000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1fxls283es0m7cymxky9xuml9x74flfjhkfrz4q",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "7163000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka12tz8qs5kxjp6qsdgj2u3rzx009z2qf6hjrwrrl",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "320000000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1tyfdmaulndss4wqpxr24e8reytj03aw338sphz",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "8673322000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1th0qvf05sqdd09p9rgq69nlchw5xzpc3ddply8",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "4800001000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1v86vj8e8eqd3gk5zlf9zawrg0w7c7tfa7x9k25",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "160000000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1vthfz8j7gkeu04jx2ju6akcyv6s9apc497x2e3",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "722777000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "1"
+ }
+ ]
+ },
+ {
+ "address": "gonka1dtvqtnq6fjvetajs25kuc9f3944fctveuukxpx",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "800000000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "1"
+ }
+ ]
+ },
+ {
+ "address": "gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "1"
+ }
+ ]
+ },
+ {
+ "address": "gonka108eh38a2pelplqz2lh3ujjnvk7ucdylql6gfmg",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "160000000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka10k4rmsg3e9xrmm2my9dp6lal4nxlenck9uur39",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "3252496000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1s7jy6fajstlxzhtxgqmdh4a2cgq26uxcu7jptk",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "800000000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1327uf364ql39e63fax5n8t8y5e8lag4xjl7e49",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "722777000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka13t3cvaeke9z5vlwps3z7eyp9uj98z2xkt02352",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "361388000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1jv65s3grqf6v6jl3dp4t6c9t9rk99cd8h2rzwa",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "120000000000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1jle7z5mmfczkvy76gvsxud6kjryzhr8c3cpyal",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "361388000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1n7ph0qezwcr666kp6tesylw4eqnyqwd0g76u7d",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "320000000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "1"
+ }
+ ]
+ },
+ {
+ "address": "gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "1"
+ }
+ ]
+ },
+ {
+ "address": "gonka1469wnu47q925a4ekazp09tx9k5phyj2nv67jv3",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "144555000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "1"
+ }
+ ]
+ },
+ {
+ "address": "gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "1"
+ }
+ ]
+ },
+ {
+ "address": "gonka1k4rnc2e9upscac85tkjwa43wr6kqpfyqcmdwej",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "800000000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1h78hmsvknwp86qzu9xftv9znwga7u0sjghmz20",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "1445554000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1cpxpnskkf6hlpldu76tya7d53rklnjlqu4uars",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "80000000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1clvs7fyag6zjkpnvapjj6m0jn38mgsn63tdnhc",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "180629000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1689695npe7amwyunaaj9dwz58v8n7cgkw5emn4",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "34381000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka16fdw9ve0xj5yy42asg85wgykr4y4kw2l37rkfp",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "2400000000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1ucl3pfq6sy9ggxuxahvjhm52hgl3qu4wg46hsk",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "72278000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1a0rh2dej6lrnj5zkx005f5jrxem0tpdh4cpcmg",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "160000000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1akmamql0z9vnd48tfw3d75zexu3dswqcawtnxa",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "361388000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka179nv57lqeana9nvgeul8twegj58ccrd2hm5uzc",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "144555000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka17u7kemct38fx3cuj2yh0x5j2fd9zxkuwkes6q7",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "15000000000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1lrwu2czkxwaadqnvsttfa5uvc6mshv8wjd3wyz",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "144555000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1ld2e89rhfmdlke69m444jcd99h7fra4whksdk4",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "320000000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1l4z4swg3e0pf937qm08u0cnkszss34kpe32y52",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "361388000000000"
+ }
+ ]
+ }
+ ],
+ "supply": [
+ {
+ "denom": "ngonka",
+ "amount": "320000000000000011"
+ }
+ ],
+ "denom_metadata": [
+ {
+ "description": "Coins for the Gonka network.",
+ "denom_units": [
+ {
+ "denom": "ngonka",
+ "exponent": 0,
+ "aliases": [
+ "nanogonka"
+ ]
+ },
+ {
+ "denom": "ugonka",
+ "exponent": 3,
+ "aliases": [
+ "microgonka"
+ ]
+ },
+ {
+ "denom": "mgonka",
+ "exponent": 6,
+ "aliases": [
+ "milligonka"
+ ]
+ },
+ {
+ "denom": "gonka",
+ "exponent": 9,
+ "aliases": []
+ }
+ ],
+ "base": "ngonka",
+ "display": "ngonka",
+ "name": "Gonka",
+ "symbol": "GNK",
+ "uri": "",
+ "uri_hash": ""
+ }
+ ],
+ "send_enabled": []
+ },
+ "bls": {
+ "params": {
+ "i_total_slots": 100,
+ "t_slots_degree_offset": 50,
+ "dealing_phase_duration_blocks": "5",
+ "verification_phase_duration_blocks": "3",
+ "signing_deadline_blocks": "10"
+ },
+ "active_epoch_id": "0"
+ },
+ "bookkeeper": {
+ "params": {}
+ },
+ "capability": {
+ "index": "1",
+ "owners": []
+ },
+ "circuit": {
+ "account_permissions": [],
+ "disabled_type_urls": []
+ },
+ "collateral": {
+ "params": {
+ "unbonding_period_epochs": "1"
+ },
+ "collateral_balance_list": [],
+ "unbonding_collateral_list": [],
+ "jailed_participant_list": []
+ },
+ "consensus": null,
+ "crisis": {
+ "constant_fee": {
+ "denom": "ngonka",
+ "amount": "1000"
+ }
+ },
+ "distribution": {
+ "params": {
+ "community_tax": "0.020000000000000000",
+ "base_proposer_reward": "0.000000000000000000",
+ "bonus_proposer_reward": "0.000000000000000000",
+ "withdraw_addr_enabled": true
+ },
+ "fee_pool": {
+ "community_pool": [
+ {
+ "denom": "ngonka",
+ "amount": "120000000000000000.000000000000000000"
+ }
+ ]
+ },
+ "delegator_withdraw_infos": [],
+ "previous_proposer": "",
+ "outstanding_rewards": [],
+ "validator_accumulated_commissions": [],
+ "validator_historical_rewards": [],
+ "validator_current_rewards": [],
+ "delegator_starting_infos": [],
+ "validator_slash_events": []
+ },
+ "evidence": {
+ "evidence": []
+ },
+ "feegrant": {
+ "allowances": []
+ },
+ "feeibc": {
+ "identified_fees": [],
+ "fee_enabled_channels": [],
+ "registered_payees": [],
+ "registered_counterparty_payees": [],
+ "forward_relayers": []
+ },
+ "genesistransfer": {
+ "params": {
+ "allowed_accounts": [],
+ "restrict_to_list": false
+ },
+ "transfer_records": []
+ },
+ "genutil": {
+ "gen_txs": []
+ },
+ "gov": {
+ "starting_proposal_id": "1",
+ "deposits": [],
+ "votes": [],
+ "proposals": [],
+ "deposit_params": null,
+ "voting_params": null,
+ "tally_params": null,
+ "params": {
+ "min_deposit": [
+ {
+ "denom": "ngonka",
+ "amount": "25_000_000"
+ }
+ ],
+ "max_deposit_period": "172800s",
+ "voting_period": "48h0m0s",
+ "quorum": "0.334000000000000000",
+ "threshold": "0.500000000000000000",
+ "veto_threshold": "0.334000000000000000",
+ "min_initial_deposit_ratio": "0.000000000000000000",
+ "proposal_cancel_ratio": "0.500000000000000000",
+ "proposal_cancel_dest": "",
+ "expedited_voting_period": "12h0m0s",
+ "expedited_threshold": "0.667000000000000000",
+ "expedited_min_deposit": [
+ {
+ "denom": "ngonka",
+ "amount": "50_000_000"
+ }
+ ],
+ "burn_vote_quorum": false,
+ "burn_proposal_deposit_prevote": false,
+ "burn_vote_veto": true,
+ "min_deposit_ratio": "0.010000000000000000"
+ },
+ "constitution": ""
+ },
+ "group": {
+ "group_seq": "0",
+ "groups": [],
+ "group_members": [],
+ "group_policy_seq": "0",
+ "group_policies": [],
+ "proposal_seq": "0",
+ "proposals": [],
+ "votes": []
+ },
+ "ibc": {
+ "client_genesis": {
+ "clients": [],
+ "clients_consensus": [],
+ "clients_metadata": [],
+ "params": {
+ "allowed_clients": [
+ "*"
+ ]
+ },
+ "create_localhost": false,
+ "next_client_sequence": "0"
+ },
+ "connection_genesis": {
+ "connections": [],
+ "client_connection_paths": [],
+ "next_connection_sequence": "0",
+ "params": {
+ "max_expected_time_per_block": "30000000000"
+ }
+ },
+ "channel_genesis": {
+ "channels": [],
+ "acknowledgements": [],
+ "commitments": [],
+ "receipts": [],
+ "send_sequences": [],
+ "recv_sequences": [],
+ "ack_sequences": [],
+ "next_channel_sequence": "0",
+ "params": {
+ "upgrade_timeout": {
+ "height": {
+ "revision_number": "0",
+ "revision_height": "0"
+ },
+ "timestamp": "600000000000"
+ }
+ }
+ }
+ },
+ "inference": {
+ "params": {
+ "epoch_params": {
+ "epoch_length": "17280",
+ "epoch_multiplier": "1",
+ "epoch_shift": "16980",
+ "default_unit_of_compute_price": "100",
+ "poc_stage_duration": "60",
+ "poc_exchange_duration": "5",
+ "poc_validation_delay": "5",
+ "poc_validation_duration": "20",
+ "set_new_validators_delay": "120",
+ "inference_validation_cutoff": "80",
+ "inference_pruning_epoch_threshold": "2"
+ },
+ "validation_params": {
+ "false_positive_rate": {
+ "value": "5",
+ "exponent": -2
+ },
+ "min_ramp_up_measurements": 10,
+ "pass_value": {
+ "value": "99",
+ "exponent": -2
+ },
+ "min_validation_average": {
+ "value": "1",
+ "exponent": -2
+ },
+ "max_validation_average": {
+ "value": "1",
+ "exponent": 0
+ },
+ "expiration_blocks": "20",
+ "epochs_to_max": "30",
+ "full_validation_traffic_cutoff": "10000",
+ "min_validation_halfway": {
+ "value": "5",
+ "exponent": -2
+ },
+ "min_validation_traffic_cutoff": "100",
+ "miss_percentage_cutoff": {
+ "value": "1",
+ "exponent": -2
+ },
+ "miss_requests_penalty": {
+ "value": "1",
+ "exponent": 0
+ },
+ "timestamp_expiration": "60",
+ "timestamp_advance": "30",
+ "estimated_limits_per_block_kb": "0"
+ },
+ "poc_params": {
+ "default_difficulty": 5,
+ "validation_sample_size": 200,
+ "poc_data_pruning_epoch_threshold": "1"
+ },
+ "tokenomics_params": {
+ "subsidy_reduction_interval": {
+ "value": "5",
+ "exponent": -2
+ },
+ "subsidy_reduction_amount": {
+ "value": "2",
+ "exponent": -1
+ },
+ "current_subsidy_percentage": {
+ "value": "9",
+ "exponent": -1
+ },
+ "top_reward_allowed_failure": {
+ "value": "1",
+ "exponent": -1
+ },
+ "top_miner_poc_qualification": "10",
+ "work_vesting_period": "180",
+ "reward_vesting_period": "180",
+ "top_miner_vesting_period": "180"
+ },
+ "collateral_params": {
+ "slash_fraction_invalid": {
+ "value": "2",
+ "exponent": -1
+ },
+ "slash_fraction_downtime": {
+ "value": "1",
+ "exponent": -1
+ },
+ "downtime_missed_percentage_threshold": {
+ "value": "5",
+ "exponent": -2
+ },
+ "grace_period_end_epoch": "180",
+ "base_weight_ratio": {
+ "value": "2",
+ "exponent": -1
+ },
+ "collateral_per_weight_unit": {
+ "value": "42",
+ "exponent": -1
+ }
+ },
+ "bitcoin_reward_params": {
+ "use_bitcoin_rewards": true,
+ "initial_epoch_reward": "323000000000000",
+ "decay_rate": {
+ "value": "-475",
+ "exponent": -6
+ },
+ "genesis_epoch": "1",
+ "utilization_bonus_factor": {
+ "value": "5",
+ "exponent": -1
+ },
+ "full_coverage_bonus_factor": {
+ "value": "12",
+ "exponent": -1
+ },
+ "partial_coverage_bonus_factor": {
+ "value": "1",
+ "exponent": -1
+ }
+ },
+ "dynamic_pricing_params": {
+ "stability_zone_lower_bound": {
+ "value": "4",
+ "exponent": -1
+ },
+ "stability_zone_upper_bound": {
+ "value": "6",
+ "exponent": -1
+ },
+ "price_elasticity": {
+ "value": "5",
+ "exponent": -2
+ },
+ "utilization_window_duration": "60",
+ "min_per_token_price": "1",
+ "base_per_token_price": "100",
+ "grace_period_end_epoch": "90",
+ "grace_period_per_token_price": "0"
+ },
+ "bandwidth_limits_params": {
+ "estimated_limits_per_block_kb": "10752",
+ "kb_per_input_token": {
+ "value": "23",
+ "exponent": "-4"
+ },
+ "kb_per_output_token": {
+ "value": "64",
+ "exponent": "-2"
+ }
+ }
+ },
+ "genesis_only_params": {
+ "total_supply": "1000000000000000000",
+ "originator_supply": "200000000000000000",
+ "top_reward_amount": "0",
+ "standard_reward_amount": "680000000000000000",
+ "pre_programmed_sale_amount": "120000000000000000",
+ "top_rewards": 3,
+ "supply_denom": "ngonka",
+ "top_reward_period": "31536000",
+ "top_reward_payouts": "12",
+ "top_reward_payouts_per_miner": "4",
+ "top_reward_max_duration": "126144000",
+ "max_individual_power_percentage": {
+ "value": "25",
+ "exponent": -2
+ },
+ "genesis_guardian_enabled": true,
+ "genesis_guardian_network_maturity_threshold": "2000000",
+ "genesis_guardian_multiplier": {
+ "value": "52",
+ "exponent": -2
+ },
+ "genesis_guardian_addresses": [
+ "gonkavaloper1y2a9p56kv044327uycmqdexl7zs82fs5lyang5",
+ "gonkavaloper1dkl4mah5erqggvhqkpc8j3qs5tyuetgdc59d0v",
+ "gonkavaloper1kx9mca3xm8u8ypzfuhmxey66u0ufxhs70mtf0e"
+ ]
+ },
+ "model_list": [
+ {
+ "proposed_by": "genesis",
+ "id": "Qwen/QwQ-32B",
+ "units_of_compute_per_token": "1000",
+ "hf_repo": "Qwen/QwQ-32B",
+ "hf_commit": "976055f8c83f394f35dbd3ab09a285a984907bd0",
+ "model_args": [
+ "--quantization",
+ "fp8",
+ "--kv-cache-dtype",
+ "fp8"
+ ],
+ "v_ram": "80",
+ "throughput_per_nonce": "1000",
+ "validation_threshold": {
+ "value": "98",
+ "exponent": -2
+ }
+ },
+ {
+ "proposed_by": "genesis",
+ "id": "Qwen/Qwen2.5-7B-Instruct",
+ "units_of_compute_per_token": "100",
+ "hf_repo": "Qwen/Qwen2.5-7B-Instruct",
+ "hf_commit": "a09a35458c702b33eeacc393d103063234e8bc28",
+ "model_args": [
+ "--quantization",
+ "fp8"
+ ],
+ "v_ram": "24",
+ "throughput_per_nonce": "10000",
+ "validation_threshold": {
+ "value": "98",
+ "exponent": -2
+ }
+ }
+ ],
+ "cosm_wasm_params": {
+ "cw20_code": "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",
+ "cw20_code_id": "0"
+ },
+ "participant_list": []
+ },
+ "interchainaccounts": {
+ "controller_genesis_state": {
+ "active_channels": [],
+ "interchain_accounts": [],
+ "ports": [],
+ "params": {
+ "controller_enabled": true
+ }
+ },
+ "host_genesis_state": {
+ "active_channels": [],
+ "interchain_accounts": [],
+ "port": "icahost",
+ "params": {
+ "host_enabled": true,
+ "allow_messages": [
+ "*"
+ ]
+ }
+ }
+ },
+ "mint": {
+ "minter": {
+ "inflation": "0.130000000000000000",
+ "annual_provisions": "0.000000000000000000"
+ },
+ "params": {
+ "mint_denom": "ngonka",
+ "inflation_rate_change": "0.130000000000000000",
+ "inflation_max": "0.200000000000000000",
+ "inflation_min": "0.070000000000000000",
+ "goal_bonded": "0.670000000000000000",
+ "blocks_per_year": "6311520"
+ }
+ },
+ "nft": {
+ "classes": [],
+ "entries": []
+ },
+ "params": null,
+ "restrictions": {
+ "params": {
+ "restriction_end_block": "1555000",
+ "emergency_transfer_exemptions": [],
+ "exemption_usage_tracking": []
+ }
+ },
+ "runtime": null,
+ "slashing": {
+ "params": {
+ "signed_blocks_window": "100",
+ "min_signed_per_window": "0.500000000000000000",
+ "downtime_jail_duration": "600s",
+ "slash_fraction_double_sign": "0.050000000000000000",
+ "slash_fraction_downtime": "0.010000000000000000"
+ },
+ "signing_infos": [],
+ "missed_blocks": []
+ },
+ "staking": {
+ "params": {
+ "unbonding_time": "1814400s",
+ "max_validators": 100,
+ "max_entries": 7,
+ "historical_entries": 10000,
+ "bond_denom": "ngonka",
+ "min_commission_rate": "0.000000000000000000"
+ },
+ "last_total_power": "0",
+ "last_validator_powers": [],
+ "validators": [],
+ "delegations": [],
+ "unbonding_delegations": [],
+ "redelegations": [],
+ "exported": false
+ },
+ "streamvesting": {
+ "params": {
+ "reward_vesting_period": "180"
+ },
+ "vesting_schedule_list": []
+ },
+ "transfer": {
+ "port_id": "transfer",
+ "denom_traces": [],
+ "params": {
+ "send_enabled": true,
+ "receive_enabled": true
+ },
+ "total_escrowed": []
+ },
+ "upgrade": {},
+ "vesting": {},
+ "wasm": {
+ "params": {
+ "code_upload_access": {
+ "permission": "Everybody",
+ "addresses": []
+ },
+ "instantiate_default_permission": "Everybody"
+ },
+ "codes": [],
+ "contracts": [],
+ "sequences": []
+ }
+ },
+ "consensus": {
+ "params": {
+ "block": {
+ "max_bytes": "22020096",
+ "max_gas": "-1"
+ },
+ "evidence": {
+ "max_age_num_blocks": "100000",
+ "max_age_duration": "172800000000000",
+ "max_bytes": "1048576"
+ },
+ "validator": {
+ "pub_key_types": [
+ "ed25519"
+ ]
+ },
+ "version": {
+ "app": "0"
+ },
+ "abci": {
+ "vote_extensions_enable_height": "0"
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/genesis/genesis-overrides.json b/genesis/genesis-overrides.json
new file mode 100644
index 000000000..d668adfab
--- /dev/null
+++ b/genesis/genesis-overrides.json
@@ -0,0 +1,97 @@
+{
+ "app_state": {
+ "gov": {
+ "params": {
+ "voting_period": "48h0m0s",
+ "quorum": "0.334000000000000000",
+ "min_deposit": [
+ {
+ "denom": "ngonka",
+ "amount": "25_000_000"
+ }
+ ],
+ "expedited_voting_period": "12h0m0s",
+ "expedited_min_deposit": [
+ {
+ "denom": "ngonka",
+ "amount": "50_000_000"
+ }
+ ]
+ }
+ },
+ "inference": {
+ "params": {
+ "epoch_params": {
+ "epoch_length": "17280",
+ "epoch_multiplier": "1",
+ "epoch_shift": "16980",
+ "poc_stage_duration": "60",
+ "poc_exchange_duration": "5",
+ "poc_validation_delay": "5",
+ "poc_validation_duration": "20",
+ "set_new_validators_delay": "120",
+ "inference_validation_cutoff": "80",
+ "default_unit_of_compute_price": "100"
+ },
+ "bandwidth_limits_params": {
+ "estimated_limits_per_block_kb": "10752",
+ "kb_per_input_token": {
+ "value": "23",
+ "exponent": "-4"
+ },
+ "kb_per_output_token": {
+ "value": "64",
+ "exponent": "-2"
+ }
+ }
+ },
+ "model_list": [
+ {
+ "proposed_by": "genesis",
+ "id": "Qwen/QwQ-32B",
+ "units_of_compute_per_token": "1000",
+ "hf_repo": "Qwen/QwQ-32B",
+ "hf_commit": "976055f8c83f394f35dbd3ab09a285a984907bd0",
+ "model_args": [
+ "--quantization",
+ "fp8",
+ "--kv-cache-dtype",
+ "fp8"
+ ],
+ "v_ram": "80",
+ "throughput_per_nonce": "1000",
+ "validation_threshold": {
+ "value": "98",
+ "exponent": -2
+ }
+ },
+ {
+ "proposed_by": "genesis",
+ "id": "Qwen/Qwen2.5-7B-Instruct",
+ "units_of_compute_per_token": "100",
+ "hf_repo": "Qwen/Qwen2.5-7B-Instruct",
+ "hf_commit": "a09a35458c702b33eeacc393d103063234e8bc28",
+ "model_args": [
+ "--quantization",
+ "fp8"
+ ],
+ "v_ram": "24",
+ "throughput_per_nonce": "10000",
+ "validation_threshold": {
+ "value": "98",
+ "exponent": -2
+ }
+ }
+ ],
+ "genesis_only_params": {
+ "total_supply": "1000000000000000000",
+ "originator_supply": "160000000000000000",
+ "top_reward_amount": "120000000000000000",
+ "standard_reward_amount": "600000000000000000",
+ "pre_programmed_sale_amount": "120000000000000000",
+ "top_rewards": 3,
+ "supply_denom": "ngonka"
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/genesis/genesis.json b/genesis/genesis.json
new file mode 100644
index 000000000..9df68bef5
--- /dev/null
+++ b/genesis/genesis.json
@@ -0,0 +1,5474 @@
+{
+ "app_name": "inferenced",
+ "app_version": "50e0a6c3",
+ "genesis_time": "2025-08-22T08:42:00.713839000Z",
+ "chain_id": "gonka-mainnet",
+ "initial_height": 1,
+ "app_hash": null,
+ "app_state": {
+ "06-solomachine": null,
+ "07-tendermint": null,
+ "auth": {
+ "params": {
+ "max_memo_characters": "256",
+ "tx_sig_limit": "7",
+ "tx_size_cost_per_byte": "10",
+ "sig_verify_cost_ed25519": "590",
+ "sig_verify_cost_secp256k1": "1000"
+ },
+ "accounts": [
+ {
+ "@type": "/cosmos.auth.v1beta1.ModuleAccount",
+ "base_account": {
+ "address": "gonka1jv65s3grqf6v6jl3dp4t6c9t9rk99cd8h2rzwa",
+ "pub_key": null,
+ "account_number": "0",
+ "sequence": "0"
+ },
+ "name": "distribution",
+ "permissions": []
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka18299ldv2cym0gh5spmm6yncv3at3qgn0t7km5w",
+ "pub_key": null,
+ "account_number": "1",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "100470678000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka16fdw9ve0xj5yy42asg85wgykr4y4kw2l37rkfp",
+ "pub_key": null,
+ "account_number": "2",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "2400000000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1dtvqtnq6fjvetajs25kuc9f3944fctveuukxpx",
+ "pub_key": null,
+ "account_number": "3",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "800000000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1k4rnc2e9upscac85tkjwa43wr6kqpfyqcmdwej",
+ "pub_key": null,
+ "account_number": "4",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "800000000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1s7jy6fajstlxzhtxgqmdh4a2cgq26uxcu7jptk",
+ "pub_key": null,
+ "account_number": "5",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "800000000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1rusnaafgmk0h464fthswch3pzh0zzpsegrda09",
+ "pub_key": null,
+ "account_number": "6",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "320000000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka12tz8qs5kxjp6qsdgj2u3rzx009z2qf6hjrwrrl",
+ "pub_key": null,
+ "account_number": "7",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "320000000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1n7ph0qezwcr666kp6tesylw4eqnyqwd0g76u7d",
+ "pub_key": null,
+ "account_number": "8",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "320000000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1ld2e89rhfmdlke69m444jcd99h7fra4whksdk4",
+ "pub_key": null,
+ "account_number": "9",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "320000000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1a0rh2dej6lrnj5zkx005f5jrxem0tpdh4cpcmg",
+ "pub_key": null,
+ "account_number": "10",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "160000000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka18qmj244rxzt3274357jd2mp45tv8n4508g29r8",
+ "pub_key": null,
+ "account_number": "11",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "160000000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1v86vj8e8eqd3gk5zlf9zawrg0w7c7tfa7x9k25",
+ "pub_key": null,
+ "account_number": "12",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "160000000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka108eh38a2pelplqz2lh3ujjnvk7ucdylql6gfmg",
+ "pub_key": null,
+ "account_number": "13",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "160000000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1cpxpnskkf6hlpldu76tya7d53rklnjlqu4uars",
+ "pub_key": null,
+ "account_number": "14",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "80000000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka17u7kemct38fx3cuj2yh0x5j2fd9zxkuwkes6q7",
+ "pub_key": null,
+ "account_number": "15",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "15000000000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1th0qvf05sqdd09p9rgq69nlchw5xzpc3ddply8",
+ "pub_key": null,
+ "account_number": "16",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "4800001000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1pq9r54md9zrd9xqyxx9f3h7as9kfgnp2c0ucat",
+ "pub_key": null,
+ "account_number": "17",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "40000000000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1gvx5swzrur89kg5r0z5jn9a0krvmhvzx3f2fea",
+ "pub_key": null,
+ "account_number": "18",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "3613884000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1x29n95z989ycxymqw60w56dpz7kcdxpp8w8y6x",
+ "pub_key": null,
+ "account_number": "19",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "722777000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1327uf364ql39e63fax5n8t8y5e8lag4xjl7e49",
+ "pub_key": null,
+ "account_number": "20",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "722777000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1tyfdmaulndss4wqpxr24e8reytj03aw338sphz",
+ "pub_key": null,
+ "account_number": "21",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "8673322000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1akmamql0z9vnd48tfw3d75zexu3dswqcawtnxa",
+ "pub_key": null,
+ "account_number": "22",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "361388000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka13t3cvaeke9z5vlwps3z7eyp9uj98z2xkt02352",
+ "pub_key": null,
+ "account_number": "23",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "361388000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka19cw7kkrkdcxkxmkz56hjatfwrunn79fsyvfky5",
+ "pub_key": null,
+ "account_number": "24",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "110044000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1689695npe7amwyunaaj9dwz58v8n7cgkw5emn4",
+ "pub_key": null,
+ "account_number": "25",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "34381000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1fxls283es0m7cymxky9xuml9x74flfjhkfrz4q",
+ "pub_key": null,
+ "account_number": "26",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "7163000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka179nv57lqeana9nvgeul8twegj58ccrd2hm5uzc",
+ "pub_key": null,
+ "account_number": "27",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "144555000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1ucl3pfq6sy9ggxuxahvjhm52hgl3qu4wg46hsk",
+ "pub_key": null,
+ "account_number": "28",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "72278000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1jle7z5mmfczkvy76gvsxud6kjryzhr8c3cpyal",
+ "pub_key": null,
+ "account_number": "29",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "361388000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1xn25n0hphw8tkfg6r3hjvh8d6nerpzqjpql3nx",
+ "pub_key": null,
+ "account_number": "30",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "72278000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1z5a69mz9gzhphf4eu6yznzru2la0em89xutepm",
+ "pub_key": null,
+ "account_number": "31",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "72278000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1lrwu2czkxwaadqnvsttfa5uvc6mshv8wjd3wyz",
+ "pub_key": null,
+ "account_number": "32",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "144555000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1469wnu47q925a4ekazp09tx9k5phyj2nv67jv3",
+ "pub_key": null,
+ "account_number": "33",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "144555000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1h78hmsvknwp86qzu9xftv9znwga7u0sjghmz20",
+ "pub_key": null,
+ "account_number": "34",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "1445554000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1qm66c5gqyew27nefdknspf2x5nwvetsk80zvay",
+ "pub_key": null,
+ "account_number": "35",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "361388000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1qgstmj6k2xwx5p8s2p0ch2qd32lkgegqkcsljs",
+ "pub_key": null,
+ "account_number": "36",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "36074000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1g02qwpgju9xu8lwtqpgrzfqrj7x45tnnhgh3xz",
+ "pub_key": null,
+ "account_number": "37",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "72278000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1clvs7fyag6zjkpnvapjj6m0jn38mgsn63tdnhc",
+ "pub_key": null,
+ "account_number": "38",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "180629000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka18weyd0tlmtvnn47c0fqg0p8jj3q6s2hz3w67nc",
+ "pub_key": null,
+ "account_number": "39",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "36074000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1l4z4swg3e0pf937qm08u0cnkszss34kpe32y52",
+ "pub_key": null,
+ "account_number": "40",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "361388000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka10k4rmsg3e9xrmm2my9dp6lal4nxlenck9uur39",
+ "pub_key": null,
+ "account_number": "41",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "3252496000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka1vthfz8j7gkeu04jx2ju6akcyv6s9apc497x2e3",
+ "pub_key": null,
+ "account_number": "42",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "722777000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.vesting.v1beta1.ContinuousVestingAccount",
+ "base_vesting_account": {
+ "base_account": {
+ "address": "gonka19xcrqllduyr6ur3l5ldln4qj0jfpaqfx20280q",
+ "pub_key": null,
+ "account_number": "43",
+ "sequence": "0"
+ },
+ "original_vesting": [
+ {
+ "denom": "ngonka",
+ "amount": "10841652000000000"
+ }
+ ],
+ "delegated_free": [],
+ "delegated_vesting": [],
+ "end_time": "1881894000"
+ },
+ "start_time": "1755750000"
+ },
+ {
+ "@type": "/cosmos.auth.v1beta1.BaseAccount",
+ "address": "gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6",
+ "pub_key": null,
+ "account_number": "44",
+ "sequence": "0"
+ },
+ {
+ "@type": "/cosmos.auth.v1beta1.BaseAccount",
+ "address": "gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p",
+ "pub_key": null,
+ "account_number": "45",
+ "sequence": "0"
+ },
+ {
+ "@type": "/cosmos.auth.v1beta1.BaseAccount",
+ "address": "gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp",
+ "pub_key": null,
+ "account_number": "46",
+ "sequence": "0"
+ },
+ {
+ "@type": "/cosmos.auth.v1beta1.BaseAccount",
+ "address": "gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5",
+ "pub_key": null,
+ "account_number": "47",
+ "sequence": "0"
+ },
+ {
+ "@type": "/cosmos.auth.v1beta1.BaseAccount",
+ "address": "gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq",
+ "pub_key": null,
+ "account_number": "48",
+ "sequence": "0"
+ },
+ {
+ "@type": "/cosmos.auth.v1beta1.BaseAccount",
+ "address": "gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk",
+ "pub_key": null,
+ "account_number": "49",
+ "sequence": "0"
+ },
+ {
+ "@type": "/cosmos.auth.v1beta1.BaseAccount",
+ "address": "gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m",
+ "pub_key": null,
+ "account_number": "50",
+ "sequence": "0"
+ },
+ {
+ "@type": "/cosmos.auth.v1beta1.BaseAccount",
+ "address": "gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u",
+ "pub_key": null,
+ "account_number": "51",
+ "sequence": "0"
+ },
+ {
+ "@type": "/cosmos.auth.v1beta1.BaseAccount",
+ "address": "gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje",
+ "pub_key": null,
+ "account_number": "52",
+ "sequence": "0"
+ },
+ {
+ "@type": "/cosmos.auth.v1beta1.BaseAccount",
+ "address": "gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le",
+ "pub_key": null,
+ "account_number": "53",
+ "sequence": "0"
+ },
+ {
+ "@type": "/cosmos.auth.v1beta1.BaseAccount",
+ "address": "gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5",
+ "pub_key": null,
+ "account_number": "54",
+ "sequence": "0"
+ },
+ {
+ "@type": "/cosmos.auth.v1beta1.BaseAccount",
+ "account_number": "55",
+ "address": "gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz",
+ "pub_key": null,
+ "sequence": "0"
+ },
+ {
+ "@type": "/cosmos.auth.v1beta1.BaseAccount",
+ "account_number": "56",
+ "address": "gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs",
+ "pub_key": null,
+ "sequence": "0"
+ },
+ {
+ "@type": "/cosmos.auth.v1beta1.BaseAccount",
+ "account_number": "57",
+ "address": "gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd",
+ "pub_key": null,
+ "sequence": "0"
+ },
+ {
+ "@type": "/cosmos.auth.v1beta1.BaseAccount",
+ "account_number": "58",
+ "address": "gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej",
+ "pub_key": null,
+ "sequence": "0"
+ },
+ {
+ "@type": "/cosmos.auth.v1beta1.BaseAccount",
+ "account_number": "59",
+ "address": "gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5",
+ "pub_key": null,
+ "sequence": "0"
+ },
+ {
+ "@type": "/cosmos.auth.v1beta1.BaseAccount",
+ "account_number": "60",
+ "address": "gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt",
+ "pub_key": null,
+ "sequence": "0"
+ },
+ {
+ "@type": "/cosmos.auth.v1beta1.BaseAccount",
+ "account_number": "61",
+ "address": "gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t",
+ "pub_key": null,
+ "sequence": "0"
+ },
+ {
+ "@type": "/cosmos.auth.v1beta1.BaseAccount",
+ "account_number": "62",
+ "address": "gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d",
+ "pub_key": null,
+ "sequence": "0"
+ },
+ {
+ "@type": "/cosmos.auth.v1beta1.BaseAccount",
+ "account_number": "63",
+ "address": "gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc",
+ "pub_key": null,
+ "sequence": "0"
+ },
+ {
+ "@type": "/cosmos.auth.v1beta1.BaseAccount",
+ "account_number": "64",
+ "address": "gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p",
+ "pub_key": null,
+ "sequence": "0"
+ },
+ {
+ "@type": "/cosmos.auth.v1beta1.BaseAccount",
+ "account_number": "65",
+ "address": "gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z",
+ "pub_key": null,
+ "sequence": "0"
+ }
+ ]
+ },
+ "authz": {
+ "authorization": [
+ {
+ "granter": "gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le",
+ "grantee": "gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgStartInference"
+ },
+ "expiration": "2026-08-22T06:31:44Z"
+ },
+ {
+ "granter": "gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le",
+ "grantee": "gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgFinishInference"
+ },
+ "expiration": "2026-08-22T06:31:44Z"
+ },
+ {
+ "granter": "gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le",
+ "grantee": "gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgClaimRewards"
+ },
+ "expiration": "2026-08-22T06:31:44Z"
+ },
+ {
+ "granter": "gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le",
+ "grantee": "gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgValidation"
+ },
+ "expiration": "2026-08-22T06:31:44Z"
+ },
+ {
+ "granter": "gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le",
+ "grantee": "gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitPocBatch"
+ },
+ "expiration": "2026-08-22T06:31:44Z"
+ },
+ {
+ "granter": "gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le",
+ "grantee": "gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitPocValidation"
+ },
+ "expiration": "2026-08-22T06:31:44Z"
+ },
+ {
+ "granter": "gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le",
+ "grantee": "gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitSeed"
+ },
+ "expiration": "2026-08-22T06:31:44Z"
+ },
+ {
+ "granter": "gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le",
+ "grantee": "gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgBridgeExchange"
+ },
+ "expiration": "2026-08-22T06:31:44Z"
+ },
+ {
+ "granter": "gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le",
+ "grantee": "gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitTrainingKvRecord"
+ },
+ "expiration": "2026-08-22T06:31:44Z"
+ },
+ {
+ "granter": "gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le",
+ "grantee": "gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgJoinTraining"
+ },
+ "expiration": "2026-08-22T06:31:44Z"
+ },
+ {
+ "granter": "gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le",
+ "grantee": "gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgJoinTrainingStatus"
+ },
+ "expiration": "2026-08-22T06:31:44Z"
+ },
+ {
+ "granter": "gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le",
+ "grantee": "gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgTrainingHeartbeat"
+ },
+ "expiration": "2026-08-22T06:31:44Z"
+ },
+ {
+ "granter": "gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le",
+ "grantee": "gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSetBarrier"
+ },
+ "expiration": "2026-08-22T06:31:44Z"
+ },
+ {
+ "granter": "gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le",
+ "grantee": "gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgClaimTrainingTaskForAssignment"
+ },
+ "expiration": "2026-08-22T06:31:44Z"
+ },
+ {
+ "granter": "gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le",
+ "grantee": "gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgAssignTrainingTask"
+ },
+ "expiration": "2026-08-22T06:31:44Z"
+ },
+ {
+ "granter": "gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le",
+ "grantee": "gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitNewUnfundedParticipant"
+ },
+ "expiration": "2026-08-22T06:31:44Z"
+ },
+ {
+ "granter": "gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le",
+ "grantee": "gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitNewParticipant"
+ },
+ "expiration": "2026-08-22T06:31:44Z"
+ },
+ {
+ "granter": "gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le",
+ "grantee": "gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitHardwareDiff"
+ },
+ "expiration": "2026-08-22T06:31:44Z"
+ },
+ {
+ "granter": "gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le",
+ "grantee": "gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgInvalidateInference"
+ },
+ "expiration": "2026-08-22T06:31:44Z"
+ },
+ {
+ "granter": "gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le",
+ "grantee": "gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgRevalidateInference"
+ },
+ "expiration": "2026-08-22T06:31:44Z"
+ },
+ {
+ "granter": "gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le",
+ "grantee": "gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitDealerPart"
+ },
+ "expiration": "2026-08-22T06:31:44Z"
+ },
+ {
+ "granter": "gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le",
+ "grantee": "gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitVerificationVector"
+ },
+ "expiration": "2026-08-22T06:31:44Z"
+ },
+ {
+ "granter": "gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le",
+ "grantee": "gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgRequestThresholdSignature"
+ },
+ "expiration": "2026-08-22T06:31:44Z"
+ },
+ {
+ "granter": "gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le",
+ "grantee": "gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitPartialSignature"
+ },
+ "expiration": "2026-08-22T06:31:44Z"
+ },
+ {
+ "granter": "gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le",
+ "grantee": "gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitGroupKeyValidationSignature"
+ },
+ "expiration": "2026-08-22T06:31:44Z"
+ },
+ {
+ "granter": "gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p",
+ "grantee": "gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgStartInference"
+ },
+ "expiration": "2026-08-22T06:57:49Z"
+ },
+ {
+ "granter": "gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p",
+ "grantee": "gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgFinishInference"
+ },
+ "expiration": "2026-08-22T06:57:49Z"
+ },
+ {
+ "granter": "gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p",
+ "grantee": "gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgClaimRewards"
+ },
+ "expiration": "2026-08-22T06:57:49Z"
+ },
+ {
+ "granter": "gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p",
+ "grantee": "gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgValidation"
+ },
+ "expiration": "2026-08-22T06:57:49Z"
+ },
+ {
+ "granter": "gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p",
+ "grantee": "gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitPocBatch"
+ },
+ "expiration": "2026-08-22T06:57:49Z"
+ },
+ {
+ "granter": "gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p",
+ "grantee": "gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitPocValidation"
+ },
+ "expiration": "2026-08-22T06:57:49Z"
+ },
+ {
+ "granter": "gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p",
+ "grantee": "gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitSeed"
+ },
+ "expiration": "2026-08-22T06:57:49Z"
+ },
+ {
+ "granter": "gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p",
+ "grantee": "gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgBridgeExchange"
+ },
+ "expiration": "2026-08-22T06:57:49Z"
+ },
+ {
+ "granter": "gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p",
+ "grantee": "gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitTrainingKvRecord"
+ },
+ "expiration": "2026-08-22T06:57:49Z"
+ },
+ {
+ "granter": "gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p",
+ "grantee": "gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgJoinTraining"
+ },
+ "expiration": "2026-08-22T06:57:49Z"
+ },
+ {
+ "granter": "gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p",
+ "grantee": "gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgJoinTrainingStatus"
+ },
+ "expiration": "2026-08-22T06:57:49Z"
+ },
+ {
+ "granter": "gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p",
+ "grantee": "gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgTrainingHeartbeat"
+ },
+ "expiration": "2026-08-22T06:57:49Z"
+ },
+ {
+ "granter": "gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p",
+ "grantee": "gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSetBarrier"
+ },
+ "expiration": "2026-08-22T06:57:49Z"
+ },
+ {
+ "granter": "gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p",
+ "grantee": "gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgClaimTrainingTaskForAssignment"
+ },
+ "expiration": "2026-08-22T06:57:49Z"
+ },
+ {
+ "granter": "gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p",
+ "grantee": "gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgAssignTrainingTask"
+ },
+ "expiration": "2026-08-22T06:57:49Z"
+ },
+ {
+ "granter": "gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p",
+ "grantee": "gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitNewUnfundedParticipant"
+ },
+ "expiration": "2026-08-22T06:57:49Z"
+ },
+ {
+ "granter": "gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p",
+ "grantee": "gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitNewParticipant"
+ },
+ "expiration": "2026-08-22T06:57:49Z"
+ },
+ {
+ "granter": "gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p",
+ "grantee": "gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitHardwareDiff"
+ },
+ "expiration": "2026-08-22T06:57:49Z"
+ },
+ {
+ "granter": "gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p",
+ "grantee": "gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgInvalidateInference"
+ },
+ "expiration": "2026-08-22T06:57:49Z"
+ },
+ {
+ "granter": "gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p",
+ "grantee": "gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgRevalidateInference"
+ },
+ "expiration": "2026-08-22T06:57:49Z"
+ },
+ {
+ "granter": "gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p",
+ "grantee": "gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitDealerPart"
+ },
+ "expiration": "2026-08-22T06:57:49Z"
+ },
+ {
+ "granter": "gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p",
+ "grantee": "gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitVerificationVector"
+ },
+ "expiration": "2026-08-22T06:57:49Z"
+ },
+ {
+ "granter": "gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p",
+ "grantee": "gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgRequestThresholdSignature"
+ },
+ "expiration": "2026-08-22T06:57:49Z"
+ },
+ {
+ "granter": "gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p",
+ "grantee": "gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitPartialSignature"
+ },
+ "expiration": "2026-08-22T06:57:49Z"
+ },
+ {
+ "granter": "gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p",
+ "grantee": "gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitGroupKeyValidationSignature"
+ },
+ "expiration": "2026-08-22T06:57:49Z"
+ },
+ {
+ "granter": "gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5",
+ "grantee": "gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgStartInference"
+ },
+ "expiration": "2026-08-22T06:35:18Z"
+ },
+ {
+ "granter": "gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5",
+ "grantee": "gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgFinishInference"
+ },
+ "expiration": "2026-08-22T06:35:18Z"
+ },
+ {
+ "granter": "gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5",
+ "grantee": "gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgClaimRewards"
+ },
+ "expiration": "2026-08-22T06:35:18Z"
+ },
+ {
+ "granter": "gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5",
+ "grantee": "gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgValidation"
+ },
+ "expiration": "2026-08-22T06:35:18Z"
+ },
+ {
+ "granter": "gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5",
+ "grantee": "gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitPocBatch"
+ },
+ "expiration": "2026-08-22T06:35:18Z"
+ },
+ {
+ "granter": "gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5",
+ "grantee": "gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitPocValidation"
+ },
+ "expiration": "2026-08-22T06:35:18Z"
+ },
+ {
+ "granter": "gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5",
+ "grantee": "gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitSeed"
+ },
+ "expiration": "2026-08-22T06:35:18Z"
+ },
+ {
+ "granter": "gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5",
+ "grantee": "gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgBridgeExchange"
+ },
+ "expiration": "2026-08-22T06:35:18Z"
+ },
+ {
+ "granter": "gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5",
+ "grantee": "gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitTrainingKvRecord"
+ },
+ "expiration": "2026-08-22T06:35:18Z"
+ },
+ {
+ "granter": "gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5",
+ "grantee": "gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgJoinTraining"
+ },
+ "expiration": "2026-08-22T06:35:18Z"
+ },
+ {
+ "granter": "gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5",
+ "grantee": "gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgJoinTrainingStatus"
+ },
+ "expiration": "2026-08-22T06:35:18Z"
+ },
+ {
+ "granter": "gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5",
+ "grantee": "gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgTrainingHeartbeat"
+ },
+ "expiration": "2026-08-22T06:35:18Z"
+ },
+ {
+ "granter": "gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5",
+ "grantee": "gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSetBarrier"
+ },
+ "expiration": "2026-08-22T06:35:18Z"
+ },
+ {
+ "granter": "gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5",
+ "grantee": "gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgClaimTrainingTaskForAssignment"
+ },
+ "expiration": "2026-08-22T06:35:18Z"
+ },
+ {
+ "granter": "gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5",
+ "grantee": "gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgAssignTrainingTask"
+ },
+ "expiration": "2026-08-22T06:35:18Z"
+ },
+ {
+ "granter": "gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5",
+ "grantee": "gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitNewUnfundedParticipant"
+ },
+ "expiration": "2026-08-22T06:35:18Z"
+ },
+ {
+ "granter": "gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5",
+ "grantee": "gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitNewParticipant"
+ },
+ "expiration": "2026-08-22T06:35:18Z"
+ },
+ {
+ "granter": "gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5",
+ "grantee": "gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitHardwareDiff"
+ },
+ "expiration": "2026-08-22T06:35:18Z"
+ },
+ {
+ "granter": "gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5",
+ "grantee": "gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgInvalidateInference"
+ },
+ "expiration": "2026-08-22T06:35:18Z"
+ },
+ {
+ "granter": "gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5",
+ "grantee": "gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgRevalidateInference"
+ },
+ "expiration": "2026-08-22T06:35:18Z"
+ },
+ {
+ "granter": "gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5",
+ "grantee": "gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitDealerPart"
+ },
+ "expiration": "2026-08-22T06:35:18Z"
+ },
+ {
+ "granter": "gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5",
+ "grantee": "gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitVerificationVector"
+ },
+ "expiration": "2026-08-22T06:35:18Z"
+ },
+ {
+ "granter": "gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5",
+ "grantee": "gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgRequestThresholdSignature"
+ },
+ "expiration": "2026-08-22T06:35:18Z"
+ },
+ {
+ "granter": "gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5",
+ "grantee": "gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitPartialSignature"
+ },
+ "expiration": "2026-08-22T06:35:18Z"
+ },
+ {
+ "granter": "gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5",
+ "grantee": "gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitGroupKeyValidationSignature"
+ },
+ "expiration": "2026-08-22T06:35:18Z"
+ },
+ {
+ "granter": "gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5",
+ "grantee": "gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgStartInference"
+ },
+ "expiration": "2026-08-22T06:33:56Z"
+ },
+ {
+ "granter": "gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5",
+ "grantee": "gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgFinishInference"
+ },
+ "expiration": "2026-08-22T06:33:56Z"
+ },
+ {
+ "granter": "gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5",
+ "grantee": "gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgClaimRewards"
+ },
+ "expiration": "2026-08-22T06:33:56Z"
+ },
+ {
+ "granter": "gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5",
+ "grantee": "gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgValidation"
+ },
+ "expiration": "2026-08-22T06:33:56Z"
+ },
+ {
+ "granter": "gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5",
+ "grantee": "gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitPocBatch"
+ },
+ "expiration": "2026-08-22T06:33:56Z"
+ },
+ {
+ "granter": "gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5",
+ "grantee": "gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitPocValidation"
+ },
+ "expiration": "2026-08-22T06:33:56Z"
+ },
+ {
+ "granter": "gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5",
+ "grantee": "gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitSeed"
+ },
+ "expiration": "2026-08-22T06:33:56Z"
+ },
+ {
+ "granter": "gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5",
+ "grantee": "gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgBridgeExchange"
+ },
+ "expiration": "2026-08-22T06:33:56Z"
+ },
+ {
+ "granter": "gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5",
+ "grantee": "gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitTrainingKvRecord"
+ },
+ "expiration": "2026-08-22T06:33:56Z"
+ },
+ {
+ "granter": "gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5",
+ "grantee": "gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgJoinTraining"
+ },
+ "expiration": "2026-08-22T06:33:56Z"
+ },
+ {
+ "granter": "gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5",
+ "grantee": "gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgJoinTrainingStatus"
+ },
+ "expiration": "2026-08-22T06:33:56Z"
+ },
+ {
+ "granter": "gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5",
+ "grantee": "gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgTrainingHeartbeat"
+ },
+ "expiration": "2026-08-22T06:33:56Z"
+ },
+ {
+ "granter": "gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5",
+ "grantee": "gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSetBarrier"
+ },
+ "expiration": "2026-08-22T06:33:56Z"
+ },
+ {
+ "granter": "gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5",
+ "grantee": "gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgClaimTrainingTaskForAssignment"
+ },
+ "expiration": "2026-08-22T06:33:56Z"
+ },
+ {
+ "granter": "gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5",
+ "grantee": "gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgAssignTrainingTask"
+ },
+ "expiration": "2026-08-22T06:33:56Z"
+ },
+ {
+ "granter": "gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5",
+ "grantee": "gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitNewUnfundedParticipant"
+ },
+ "expiration": "2026-08-22T06:33:56Z"
+ },
+ {
+ "granter": "gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5",
+ "grantee": "gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitNewParticipant"
+ },
+ "expiration": "2026-08-22T06:33:56Z"
+ },
+ {
+ "granter": "gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5",
+ "grantee": "gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitHardwareDiff"
+ },
+ "expiration": "2026-08-22T06:33:56Z"
+ },
+ {
+ "granter": "gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5",
+ "grantee": "gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgInvalidateInference"
+ },
+ "expiration": "2026-08-22T06:33:56Z"
+ },
+ {
+ "granter": "gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5",
+ "grantee": "gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgRevalidateInference"
+ },
+ "expiration": "2026-08-22T06:33:56Z"
+ },
+ {
+ "granter": "gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5",
+ "grantee": "gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitDealerPart"
+ },
+ "expiration": "2026-08-22T06:33:56Z"
+ },
+ {
+ "granter": "gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5",
+ "grantee": "gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitVerificationVector"
+ },
+ "expiration": "2026-08-22T06:33:56Z"
+ },
+ {
+ "granter": "gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5",
+ "grantee": "gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgRequestThresholdSignature"
+ },
+ "expiration": "2026-08-22T06:33:56Z"
+ },
+ {
+ "granter": "gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5",
+ "grantee": "gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitPartialSignature"
+ },
+ "expiration": "2026-08-22T06:33:56Z"
+ },
+ {
+ "granter": "gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5",
+ "grantee": "gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitGroupKeyValidationSignature"
+ },
+ "expiration": "2026-08-22T06:33:56Z"
+ },
+ {
+ "granter": "gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp",
+ "grantee": "gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgStartInference"
+ },
+ "expiration": "2026-08-22T06:32:32Z"
+ },
+ {
+ "granter": "gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp",
+ "grantee": "gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgFinishInference"
+ },
+ "expiration": "2026-08-22T06:32:32Z"
+ },
+ {
+ "granter": "gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp",
+ "grantee": "gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgClaimRewards"
+ },
+ "expiration": "2026-08-22T06:32:32Z"
+ },
+ {
+ "granter": "gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp",
+ "grantee": "gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgValidation"
+ },
+ "expiration": "2026-08-22T06:32:32Z"
+ },
+ {
+ "granter": "gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp",
+ "grantee": "gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitPocBatch"
+ },
+ "expiration": "2026-08-22T06:32:32Z"
+ },
+ {
+ "granter": "gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp",
+ "grantee": "gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitPocValidation"
+ },
+ "expiration": "2026-08-22T06:32:32Z"
+ },
+ {
+ "granter": "gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp",
+ "grantee": "gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitSeed"
+ },
+ "expiration": "2026-08-22T06:32:32Z"
+ },
+ {
+ "granter": "gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp",
+ "grantee": "gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgBridgeExchange"
+ },
+ "expiration": "2026-08-22T06:32:32Z"
+ },
+ {
+ "granter": "gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp",
+ "grantee": "gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitTrainingKvRecord"
+ },
+ "expiration": "2026-08-22T06:32:32Z"
+ },
+ {
+ "granter": "gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp",
+ "grantee": "gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgJoinTraining"
+ },
+ "expiration": "2026-08-22T06:32:32Z"
+ },
+ {
+ "granter": "gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp",
+ "grantee": "gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgJoinTrainingStatus"
+ },
+ "expiration": "2026-08-22T06:32:32Z"
+ },
+ {
+ "granter": "gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp",
+ "grantee": "gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgTrainingHeartbeat"
+ },
+ "expiration": "2026-08-22T06:32:32Z"
+ },
+ {
+ "granter": "gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp",
+ "grantee": "gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSetBarrier"
+ },
+ "expiration": "2026-08-22T06:32:32Z"
+ },
+ {
+ "granter": "gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp",
+ "grantee": "gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgClaimTrainingTaskForAssignment"
+ },
+ "expiration": "2026-08-22T06:32:32Z"
+ },
+ {
+ "granter": "gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp",
+ "grantee": "gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgAssignTrainingTask"
+ },
+ "expiration": "2026-08-22T06:32:32Z"
+ },
+ {
+ "granter": "gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp",
+ "grantee": "gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitNewUnfundedParticipant"
+ },
+ "expiration": "2026-08-22T06:32:32Z"
+ },
+ {
+ "granter": "gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp",
+ "grantee": "gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitNewParticipant"
+ },
+ "expiration": "2026-08-22T06:32:32Z"
+ },
+ {
+ "granter": "gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp",
+ "grantee": "gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitHardwareDiff"
+ },
+ "expiration": "2026-08-22T06:32:32Z"
+ },
+ {
+ "granter": "gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp",
+ "grantee": "gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgInvalidateInference"
+ },
+ "expiration": "2026-08-22T06:32:32Z"
+ },
+ {
+ "granter": "gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp",
+ "grantee": "gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgRevalidateInference"
+ },
+ "expiration": "2026-08-22T06:32:32Z"
+ },
+ {
+ "granter": "gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp",
+ "grantee": "gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitDealerPart"
+ },
+ "expiration": "2026-08-22T06:32:32Z"
+ },
+ {
+ "granter": "gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp",
+ "grantee": "gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitVerificationVector"
+ },
+ "expiration": "2026-08-22T06:32:32Z"
+ },
+ {
+ "granter": "gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp",
+ "grantee": "gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgRequestThresholdSignature"
+ },
+ "expiration": "2026-08-22T06:32:32Z"
+ },
+ {
+ "granter": "gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp",
+ "grantee": "gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitPartialSignature"
+ },
+ "expiration": "2026-08-22T06:32:32Z"
+ },
+ {
+ "granter": "gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp",
+ "grantee": "gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitGroupKeyValidationSignature"
+ },
+ "expiration": "2026-08-22T06:32:32Z"
+ },
+ {
+ "granter": "gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6",
+ "grantee": "gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgStartInference"
+ },
+ "expiration": "2026-08-22T06:28:04Z"
+ },
+ {
+ "granter": "gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6",
+ "grantee": "gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgFinishInference"
+ },
+ "expiration": "2026-08-22T06:28:04Z"
+ },
+ {
+ "granter": "gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6",
+ "grantee": "gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgClaimRewards"
+ },
+ "expiration": "2026-08-22T06:28:04Z"
+ },
+ {
+ "granter": "gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6",
+ "grantee": "gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgValidation"
+ },
+ "expiration": "2026-08-22T06:28:04Z"
+ },
+ {
+ "granter": "gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6",
+ "grantee": "gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitPocBatch"
+ },
+ "expiration": "2026-08-22T06:28:04Z"
+ },
+ {
+ "granter": "gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6",
+ "grantee": "gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitPocValidation"
+ },
+ "expiration": "2026-08-22T06:28:04Z"
+ },
+ {
+ "granter": "gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6",
+ "grantee": "gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitSeed"
+ },
+ "expiration": "2026-08-22T06:28:04Z"
+ },
+ {
+ "granter": "gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6",
+ "grantee": "gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgBridgeExchange"
+ },
+ "expiration": "2026-08-22T06:28:04Z"
+ },
+ {
+ "granter": "gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6",
+ "grantee": "gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitTrainingKvRecord"
+ },
+ "expiration": "2026-08-22T06:28:04Z"
+ },
+ {
+ "granter": "gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6",
+ "grantee": "gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgJoinTraining"
+ },
+ "expiration": "2026-08-22T06:28:04Z"
+ },
+ {
+ "granter": "gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6",
+ "grantee": "gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgJoinTrainingStatus"
+ },
+ "expiration": "2026-08-22T06:28:04Z"
+ },
+ {
+ "granter": "gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6",
+ "grantee": "gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgTrainingHeartbeat"
+ },
+ "expiration": "2026-08-22T06:28:04Z"
+ },
+ {
+ "granter": "gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6",
+ "grantee": "gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSetBarrier"
+ },
+ "expiration": "2026-08-22T06:28:04Z"
+ },
+ {
+ "granter": "gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6",
+ "grantee": "gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgClaimTrainingTaskForAssignment"
+ },
+ "expiration": "2026-08-22T06:28:04Z"
+ },
+ {
+ "granter": "gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6",
+ "grantee": "gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgAssignTrainingTask"
+ },
+ "expiration": "2026-08-22T06:28:04Z"
+ },
+ {
+ "granter": "gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6",
+ "grantee": "gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitNewUnfundedParticipant"
+ },
+ "expiration": "2026-08-22T06:28:04Z"
+ },
+ {
+ "granter": "gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6",
+ "grantee": "gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitNewParticipant"
+ },
+ "expiration": "2026-08-22T06:28:04Z"
+ },
+ {
+ "granter": "gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6",
+ "grantee": "gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitHardwareDiff"
+ },
+ "expiration": "2026-08-22T06:28:04Z"
+ },
+ {
+ "granter": "gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6",
+ "grantee": "gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgInvalidateInference"
+ },
+ "expiration": "2026-08-22T06:28:04Z"
+ },
+ {
+ "granter": "gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6",
+ "grantee": "gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgRevalidateInference"
+ },
+ "expiration": "2026-08-22T06:28:04Z"
+ },
+ {
+ "granter": "gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6",
+ "grantee": "gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitDealerPart"
+ },
+ "expiration": "2026-08-22T06:28:04Z"
+ },
+ {
+ "granter": "gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6",
+ "grantee": "gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitVerificationVector"
+ },
+ "expiration": "2026-08-22T06:28:04Z"
+ },
+ {
+ "granter": "gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6",
+ "grantee": "gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgRequestThresholdSignature"
+ },
+ "expiration": "2026-08-22T06:28:04Z"
+ },
+ {
+ "granter": "gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6",
+ "grantee": "gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitPartialSignature"
+ },
+ "expiration": "2026-08-22T06:28:04Z"
+ },
+ {
+ "granter": "gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6",
+ "grantee": "gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitGroupKeyValidationSignature"
+ },
+ "expiration": "2026-08-22T06:28:04Z"
+ },
+ {
+ "granter": "gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk",
+ "grantee": "gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgStartInference"
+ },
+ "expiration": "2026-08-22T06:31:51Z"
+ },
+ {
+ "granter": "gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk",
+ "grantee": "gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgFinishInference"
+ },
+ "expiration": "2026-08-22T06:31:51Z"
+ },
+ {
+ "granter": "gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk",
+ "grantee": "gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgClaimRewards"
+ },
+ "expiration": "2026-08-22T06:31:51Z"
+ },
+ {
+ "granter": "gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk",
+ "grantee": "gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgValidation"
+ },
+ "expiration": "2026-08-22T06:31:51Z"
+ },
+ {
+ "granter": "gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk",
+ "grantee": "gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitPocBatch"
+ },
+ "expiration": "2026-08-22T06:31:51Z"
+ },
+ {
+ "granter": "gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk",
+ "grantee": "gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitPocValidation"
+ },
+ "expiration": "2026-08-22T06:31:51Z"
+ },
+ {
+ "granter": "gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk",
+ "grantee": "gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitSeed"
+ },
+ "expiration": "2026-08-22T06:31:51Z"
+ },
+ {
+ "granter": "gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk",
+ "grantee": "gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgBridgeExchange"
+ },
+ "expiration": "2026-08-22T06:31:51Z"
+ },
+ {
+ "granter": "gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk",
+ "grantee": "gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitTrainingKvRecord"
+ },
+ "expiration": "2026-08-22T06:31:51Z"
+ },
+ {
+ "granter": "gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk",
+ "grantee": "gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgJoinTraining"
+ },
+ "expiration": "2026-08-22T06:31:51Z"
+ },
+ {
+ "granter": "gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk",
+ "grantee": "gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgJoinTrainingStatus"
+ },
+ "expiration": "2026-08-22T06:31:51Z"
+ },
+ {
+ "granter": "gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk",
+ "grantee": "gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgTrainingHeartbeat"
+ },
+ "expiration": "2026-08-22T06:31:51Z"
+ },
+ {
+ "granter": "gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk",
+ "grantee": "gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSetBarrier"
+ },
+ "expiration": "2026-08-22T06:31:51Z"
+ },
+ {
+ "granter": "gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk",
+ "grantee": "gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgClaimTrainingTaskForAssignment"
+ },
+ "expiration": "2026-08-22T06:31:51Z"
+ },
+ {
+ "granter": "gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk",
+ "grantee": "gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgAssignTrainingTask"
+ },
+ "expiration": "2026-08-22T06:31:51Z"
+ },
+ {
+ "granter": "gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk",
+ "grantee": "gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitNewUnfundedParticipant"
+ },
+ "expiration": "2026-08-22T06:31:51Z"
+ },
+ {
+ "granter": "gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk",
+ "grantee": "gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitNewParticipant"
+ },
+ "expiration": "2026-08-22T06:31:51Z"
+ },
+ {
+ "granter": "gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk",
+ "grantee": "gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitHardwareDiff"
+ },
+ "expiration": "2026-08-22T06:31:51Z"
+ },
+ {
+ "granter": "gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk",
+ "grantee": "gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgInvalidateInference"
+ },
+ "expiration": "2026-08-22T06:31:51Z"
+ },
+ {
+ "granter": "gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk",
+ "grantee": "gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgRevalidateInference"
+ },
+ "expiration": "2026-08-22T06:31:51Z"
+ },
+ {
+ "granter": "gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk",
+ "grantee": "gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitDealerPart"
+ },
+ "expiration": "2026-08-22T06:31:51Z"
+ },
+ {
+ "granter": "gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk",
+ "grantee": "gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitVerificationVector"
+ },
+ "expiration": "2026-08-22T06:31:51Z"
+ },
+ {
+ "granter": "gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk",
+ "grantee": "gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgRequestThresholdSignature"
+ },
+ "expiration": "2026-08-22T06:31:51Z"
+ },
+ {
+ "granter": "gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk",
+ "grantee": "gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitPartialSignature"
+ },
+ "expiration": "2026-08-22T06:31:51Z"
+ },
+ {
+ "granter": "gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk",
+ "grantee": "gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitGroupKeyValidationSignature"
+ },
+ "expiration": "2026-08-22T06:31:51Z"
+ },
+ {
+ "granter": "gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq",
+ "grantee": "gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgStartInference"
+ },
+ "expiration": "2026-08-22T06:56:11Z"
+ },
+ {
+ "granter": "gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq",
+ "grantee": "gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgFinishInference"
+ },
+ "expiration": "2026-08-22T06:56:11Z"
+ },
+ {
+ "granter": "gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq",
+ "grantee": "gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgClaimRewards"
+ },
+ "expiration": "2026-08-22T06:56:11Z"
+ },
+ {
+ "granter": "gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq",
+ "grantee": "gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgValidation"
+ },
+ "expiration": "2026-08-22T06:56:11Z"
+ },
+ {
+ "granter": "gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq",
+ "grantee": "gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitPocBatch"
+ },
+ "expiration": "2026-08-22T06:56:11Z"
+ },
+ {
+ "granter": "gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq",
+ "grantee": "gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitPocValidation"
+ },
+ "expiration": "2026-08-22T06:56:11Z"
+ },
+ {
+ "granter": "gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq",
+ "grantee": "gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitSeed"
+ },
+ "expiration": "2026-08-22T06:56:11Z"
+ },
+ {
+ "granter": "gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq",
+ "grantee": "gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgBridgeExchange"
+ },
+ "expiration": "2026-08-22T06:56:11Z"
+ },
+ {
+ "granter": "gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq",
+ "grantee": "gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitTrainingKvRecord"
+ },
+ "expiration": "2026-08-22T06:56:11Z"
+ },
+ {
+ "granter": "gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq",
+ "grantee": "gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgJoinTraining"
+ },
+ "expiration": "2026-08-22T06:56:11Z"
+ },
+ {
+ "granter": "gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq",
+ "grantee": "gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgJoinTrainingStatus"
+ },
+ "expiration": "2026-08-22T06:56:11Z"
+ },
+ {
+ "granter": "gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq",
+ "grantee": "gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgTrainingHeartbeat"
+ },
+ "expiration": "2026-08-22T06:56:11Z"
+ },
+ {
+ "granter": "gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq",
+ "grantee": "gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSetBarrier"
+ },
+ "expiration": "2026-08-22T06:56:11Z"
+ },
+ {
+ "granter": "gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq",
+ "grantee": "gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgClaimTrainingTaskForAssignment"
+ },
+ "expiration": "2026-08-22T06:56:11Z"
+ },
+ {
+ "granter": "gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq",
+ "grantee": "gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgAssignTrainingTask"
+ },
+ "expiration": "2026-08-22T06:56:11Z"
+ },
+ {
+ "granter": "gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq",
+ "grantee": "gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitNewUnfundedParticipant"
+ },
+ "expiration": "2026-08-22T06:56:11Z"
+ },
+ {
+ "granter": "gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq",
+ "grantee": "gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitNewParticipant"
+ },
+ "expiration": "2026-08-22T06:56:11Z"
+ },
+ {
+ "granter": "gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq",
+ "grantee": "gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitHardwareDiff"
+ },
+ "expiration": "2026-08-22T06:56:11Z"
+ },
+ {
+ "granter": "gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq",
+ "grantee": "gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgInvalidateInference"
+ },
+ "expiration": "2026-08-22T06:56:11Z"
+ },
+ {
+ "granter": "gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq",
+ "grantee": "gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgRevalidateInference"
+ },
+ "expiration": "2026-08-22T06:56:11Z"
+ },
+ {
+ "granter": "gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq",
+ "grantee": "gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitDealerPart"
+ },
+ "expiration": "2026-08-22T06:56:11Z"
+ },
+ {
+ "granter": "gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq",
+ "grantee": "gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitVerificationVector"
+ },
+ "expiration": "2026-08-22T06:56:11Z"
+ },
+ {
+ "granter": "gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq",
+ "grantee": "gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgRequestThresholdSignature"
+ },
+ "expiration": "2026-08-22T06:56:11Z"
+ },
+ {
+ "granter": "gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq",
+ "grantee": "gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitPartialSignature"
+ },
+ "expiration": "2026-08-22T06:56:11Z"
+ },
+ {
+ "granter": "gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq",
+ "grantee": "gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitGroupKeyValidationSignature"
+ },
+ "expiration": "2026-08-22T06:56:11Z"
+ },
+ {
+ "granter": "gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje",
+ "grantee": "gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgStartInference"
+ },
+ "expiration": "2026-08-22T06:51:05Z"
+ },
+ {
+ "granter": "gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje",
+ "grantee": "gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgFinishInference"
+ },
+ "expiration": "2026-08-22T06:51:05Z"
+ },
+ {
+ "granter": "gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje",
+ "grantee": "gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgClaimRewards"
+ },
+ "expiration": "2026-08-22T06:51:05Z"
+ },
+ {
+ "granter": "gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje",
+ "grantee": "gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgValidation"
+ },
+ "expiration": "2026-08-22T06:51:05Z"
+ },
+ {
+ "granter": "gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje",
+ "grantee": "gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitPocBatch"
+ },
+ "expiration": "2026-08-22T06:51:05Z"
+ },
+ {
+ "granter": "gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje",
+ "grantee": "gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitPocValidation"
+ },
+ "expiration": "2026-08-22T06:51:05Z"
+ },
+ {
+ "granter": "gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje",
+ "grantee": "gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitSeed"
+ },
+ "expiration": "2026-08-22T06:51:05Z"
+ },
+ {
+ "granter": "gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje",
+ "grantee": "gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgBridgeExchange"
+ },
+ "expiration": "2026-08-22T06:51:05Z"
+ },
+ {
+ "granter": "gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje",
+ "grantee": "gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitTrainingKvRecord"
+ },
+ "expiration": "2026-08-22T06:51:05Z"
+ },
+ {
+ "granter": "gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje",
+ "grantee": "gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgJoinTraining"
+ },
+ "expiration": "2026-08-22T06:51:05Z"
+ },
+ {
+ "granter": "gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje",
+ "grantee": "gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgJoinTrainingStatus"
+ },
+ "expiration": "2026-08-22T06:51:05Z"
+ },
+ {
+ "granter": "gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje",
+ "grantee": "gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgTrainingHeartbeat"
+ },
+ "expiration": "2026-08-22T06:51:05Z"
+ },
+ {
+ "granter": "gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje",
+ "grantee": "gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSetBarrier"
+ },
+ "expiration": "2026-08-22T06:51:05Z"
+ },
+ {
+ "granter": "gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje",
+ "grantee": "gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgClaimTrainingTaskForAssignment"
+ },
+ "expiration": "2026-08-22T06:51:05Z"
+ },
+ {
+ "granter": "gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje",
+ "grantee": "gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgAssignTrainingTask"
+ },
+ "expiration": "2026-08-22T06:51:05Z"
+ },
+ {
+ "granter": "gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje",
+ "grantee": "gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitNewUnfundedParticipant"
+ },
+ "expiration": "2026-08-22T06:51:05Z"
+ },
+ {
+ "granter": "gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje",
+ "grantee": "gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitNewParticipant"
+ },
+ "expiration": "2026-08-22T06:51:05Z"
+ },
+ {
+ "granter": "gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje",
+ "grantee": "gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitHardwareDiff"
+ },
+ "expiration": "2026-08-22T06:51:05Z"
+ },
+ {
+ "granter": "gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje",
+ "grantee": "gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgInvalidateInference"
+ },
+ "expiration": "2026-08-22T06:51:05Z"
+ },
+ {
+ "granter": "gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje",
+ "grantee": "gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgRevalidateInference"
+ },
+ "expiration": "2026-08-22T06:51:05Z"
+ },
+ {
+ "granter": "gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje",
+ "grantee": "gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitDealerPart"
+ },
+ "expiration": "2026-08-22T06:51:05Z"
+ },
+ {
+ "granter": "gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje",
+ "grantee": "gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitVerificationVector"
+ },
+ "expiration": "2026-08-22T06:51:05Z"
+ },
+ {
+ "granter": "gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje",
+ "grantee": "gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgRequestThresholdSignature"
+ },
+ "expiration": "2026-08-22T06:51:05Z"
+ },
+ {
+ "granter": "gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje",
+ "grantee": "gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitPartialSignature"
+ },
+ "expiration": "2026-08-22T06:51:05Z"
+ },
+ {
+ "granter": "gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje",
+ "grantee": "gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitGroupKeyValidationSignature"
+ },
+ "expiration": "2026-08-22T06:51:05Z"
+ },
+ {
+ "granter": "gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u",
+ "grantee": "gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgStartInference"
+ },
+ "expiration": "2026-08-22T07:21:13Z"
+ },
+ {
+ "granter": "gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u",
+ "grantee": "gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgFinishInference"
+ },
+ "expiration": "2026-08-22T07:21:13Z"
+ },
+ {
+ "granter": "gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u",
+ "grantee": "gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgClaimRewards"
+ },
+ "expiration": "2026-08-22T07:21:13Z"
+ },
+ {
+ "granter": "gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u",
+ "grantee": "gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgValidation"
+ },
+ "expiration": "2026-08-22T07:21:13Z"
+ },
+ {
+ "granter": "gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u",
+ "grantee": "gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitPocBatch"
+ },
+ "expiration": "2026-08-22T07:21:13Z"
+ },
+ {
+ "granter": "gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u",
+ "grantee": "gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitPocValidation"
+ },
+ "expiration": "2026-08-22T07:21:13Z"
+ },
+ {
+ "granter": "gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u",
+ "grantee": "gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitSeed"
+ },
+ "expiration": "2026-08-22T07:21:13Z"
+ },
+ {
+ "granter": "gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u",
+ "grantee": "gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgBridgeExchange"
+ },
+ "expiration": "2026-08-22T07:21:13Z"
+ },
+ {
+ "granter": "gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u",
+ "grantee": "gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitTrainingKvRecord"
+ },
+ "expiration": "2026-08-22T07:21:13Z"
+ },
+ {
+ "granter": "gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u",
+ "grantee": "gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgJoinTraining"
+ },
+ "expiration": "2026-08-22T07:21:13Z"
+ },
+ {
+ "granter": "gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u",
+ "grantee": "gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgJoinTrainingStatus"
+ },
+ "expiration": "2026-08-22T07:21:13Z"
+ },
+ {
+ "granter": "gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u",
+ "grantee": "gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgTrainingHeartbeat"
+ },
+ "expiration": "2026-08-22T07:21:13Z"
+ },
+ {
+ "granter": "gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u",
+ "grantee": "gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSetBarrier"
+ },
+ "expiration": "2026-08-22T07:21:13Z"
+ },
+ {
+ "granter": "gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u",
+ "grantee": "gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgClaimTrainingTaskForAssignment"
+ },
+ "expiration": "2026-08-22T07:21:13Z"
+ },
+ {
+ "granter": "gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u",
+ "grantee": "gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgAssignTrainingTask"
+ },
+ "expiration": "2026-08-22T07:21:13Z"
+ },
+ {
+ "granter": "gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u",
+ "grantee": "gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitNewUnfundedParticipant"
+ },
+ "expiration": "2026-08-22T07:21:13Z"
+ },
+ {
+ "granter": "gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u",
+ "grantee": "gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitNewParticipant"
+ },
+ "expiration": "2026-08-22T07:21:13Z"
+ },
+ {
+ "granter": "gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u",
+ "grantee": "gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitHardwareDiff"
+ },
+ "expiration": "2026-08-22T07:21:13Z"
+ },
+ {
+ "granter": "gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u",
+ "grantee": "gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgInvalidateInference"
+ },
+ "expiration": "2026-08-22T07:21:13Z"
+ },
+ {
+ "granter": "gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u",
+ "grantee": "gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgRevalidateInference"
+ },
+ "expiration": "2026-08-22T07:21:13Z"
+ },
+ {
+ "granter": "gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u",
+ "grantee": "gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitDealerPart"
+ },
+ "expiration": "2026-08-22T07:21:13Z"
+ },
+ {
+ "granter": "gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u",
+ "grantee": "gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitVerificationVector"
+ },
+ "expiration": "2026-08-22T07:21:13Z"
+ },
+ {
+ "granter": "gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u",
+ "grantee": "gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgRequestThresholdSignature"
+ },
+ "expiration": "2026-08-22T07:21:13Z"
+ },
+ {
+ "granter": "gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u",
+ "grantee": "gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitPartialSignature"
+ },
+ "expiration": "2026-08-22T07:21:13Z"
+ },
+ {
+ "granter": "gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u",
+ "grantee": "gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitGroupKeyValidationSignature"
+ },
+ "expiration": "2026-08-22T07:21:13Z"
+ },
+ {
+ "granter": "gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m",
+ "grantee": "gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgStartInference"
+ },
+ "expiration": "2026-08-22T06:59:50Z"
+ },
+ {
+ "granter": "gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m",
+ "grantee": "gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgFinishInference"
+ },
+ "expiration": "2026-08-22T06:59:50Z"
+ },
+ {
+ "granter": "gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m",
+ "grantee": "gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgClaimRewards"
+ },
+ "expiration": "2026-08-22T06:59:50Z"
+ },
+ {
+ "granter": "gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m",
+ "grantee": "gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgValidation"
+ },
+ "expiration": "2026-08-22T06:59:50Z"
+ },
+ {
+ "granter": "gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m",
+ "grantee": "gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitPocBatch"
+ },
+ "expiration": "2026-08-22T06:59:50Z"
+ },
+ {
+ "granter": "gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m",
+ "grantee": "gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitPocValidation"
+ },
+ "expiration": "2026-08-22T06:59:50Z"
+ },
+ {
+ "granter": "gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m",
+ "grantee": "gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitSeed"
+ },
+ "expiration": "2026-08-22T06:59:50Z"
+ },
+ {
+ "granter": "gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m",
+ "grantee": "gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgBridgeExchange"
+ },
+ "expiration": "2026-08-22T06:59:50Z"
+ },
+ {
+ "granter": "gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m",
+ "grantee": "gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitTrainingKvRecord"
+ },
+ "expiration": "2026-08-22T06:59:50Z"
+ },
+ {
+ "granter": "gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m",
+ "grantee": "gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgJoinTraining"
+ },
+ "expiration": "2026-08-22T06:59:50Z"
+ },
+ {
+ "granter": "gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m",
+ "grantee": "gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgJoinTrainingStatus"
+ },
+ "expiration": "2026-08-22T06:59:50Z"
+ },
+ {
+ "granter": "gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m",
+ "grantee": "gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgTrainingHeartbeat"
+ },
+ "expiration": "2026-08-22T06:59:50Z"
+ },
+ {
+ "granter": "gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m",
+ "grantee": "gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSetBarrier"
+ },
+ "expiration": "2026-08-22T06:59:50Z"
+ },
+ {
+ "granter": "gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m",
+ "grantee": "gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgClaimTrainingTaskForAssignment"
+ },
+ "expiration": "2026-08-22T06:59:50Z"
+ },
+ {
+ "granter": "gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m",
+ "grantee": "gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgAssignTrainingTask"
+ },
+ "expiration": "2026-08-22T06:59:50Z"
+ },
+ {
+ "granter": "gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m",
+ "grantee": "gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitNewUnfundedParticipant"
+ },
+ "expiration": "2026-08-22T06:59:50Z"
+ },
+ {
+ "granter": "gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m",
+ "grantee": "gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitNewParticipant"
+ },
+ "expiration": "2026-08-22T06:59:50Z"
+ },
+ {
+ "granter": "gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m",
+ "grantee": "gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgSubmitHardwareDiff"
+ },
+ "expiration": "2026-08-22T06:59:50Z"
+ },
+ {
+ "granter": "gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m",
+ "grantee": "gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgInvalidateInference"
+ },
+ "expiration": "2026-08-22T06:59:50Z"
+ },
+ {
+ "granter": "gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m",
+ "grantee": "gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.inference.MsgRevalidateInference"
+ },
+ "expiration": "2026-08-22T06:59:50Z"
+ },
+ {
+ "granter": "gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m",
+ "grantee": "gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitDealerPart"
+ },
+ "expiration": "2026-08-22T06:59:50Z"
+ },
+ {
+ "granter": "gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m",
+ "grantee": "gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitVerificationVector"
+ },
+ "expiration": "2026-08-22T06:59:50Z"
+ },
+ {
+ "granter": "gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m",
+ "grantee": "gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgRequestThresholdSignature"
+ },
+ "expiration": "2026-08-22T06:59:50Z"
+ },
+ {
+ "granter": "gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m",
+ "grantee": "gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitPartialSignature"
+ },
+ "expiration": "2026-08-22T06:59:50Z"
+ },
+ {
+ "granter": "gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m",
+ "grantee": "gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z",
+ "authorization": {
+ "@type": "/cosmos.authz.v1beta1.GenericAuthorization",
+ "msg": "/inference.bls.MsgSubmitGroupKeyValidationSignature"
+ },
+ "expiration": "2026-08-22T06:59:50Z"
+ }
+ ]
+ },
+ "bank": {
+ "params": {
+ "send_enabled": [],
+ "default_send_enabled": true
+ },
+ "balances": [
+ {
+ "address": "gonka1qgstmj6k2xwx5p8s2p0ch2qd32lkgegqkcsljs",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "36074000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1qm66c5gqyew27nefdknspf2x5nwvetsk80zvay",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "361388000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1pq9r54md9zrd9xqyxx9f3h7as9kfgnp2c0ucat",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "40000000000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "1"
+ }
+ ]
+ },
+ {
+ "address": "gonka1z5a69mz9gzhphf4eu6yznzru2la0em89xutepm",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "72278000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "1"
+ }
+ ]
+ },
+ {
+ "address": "gonka1rusnaafgmk0h464fthswch3pzh0zzpsegrda09",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "320000000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "1"
+ }
+ ]
+ },
+ {
+ "address": "gonka19xcrqllduyr6ur3l5ldln4qj0jfpaqfx20280q",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "10841652000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "1"
+ }
+ ]
+ },
+ {
+ "address": "gonka19cw7kkrkdcxkxmkz56hjatfwrunn79fsyvfky5",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "110044000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1x29n95z989ycxymqw60w56dpz7kcdxpp8w8y6x",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "722777000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1xn25n0hphw8tkfg6r3hjvh8d6nerpzqjpql3nx",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "72278000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka18qmj244rxzt3274357jd2mp45tv8n4508g29r8",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "160000000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka18299ldv2cym0gh5spmm6yncv3at3qgn0t7km5w",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "100470678000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka18weyd0tlmtvnn47c0fqg0p8jj3q6s2hz3w67nc",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "36074000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1gvx5swzrur89kg5r0z5jn9a0krvmhvzx3f2fea",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "3613884000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1g02qwpgju9xu8lwtqpgrzfqrj7x45tnnhgh3xz",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "72278000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1fxls283es0m7cymxky9xuml9x74flfjhkfrz4q",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "7163000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka12tz8qs5kxjp6qsdgj2u3rzx009z2qf6hjrwrrl",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "320000000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1tyfdmaulndss4wqpxr24e8reytj03aw338sphz",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "8673322000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1th0qvf05sqdd09p9rgq69nlchw5xzpc3ddply8",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "4800001000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1v86vj8e8eqd3gk5zlf9zawrg0w7c7tfa7x9k25",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "160000000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1vthfz8j7gkeu04jx2ju6akcyv6s9apc497x2e3",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "722777000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "1"
+ }
+ ]
+ },
+ {
+ "address": "gonka1dtvqtnq6fjvetajs25kuc9f3944fctveuukxpx",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "800000000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "1"
+ }
+ ]
+ },
+ {
+ "address": "gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "1"
+ }
+ ]
+ },
+ {
+ "address": "gonka108eh38a2pelplqz2lh3ujjnvk7ucdylql6gfmg",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "160000000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka10k4rmsg3e9xrmm2my9dp6lal4nxlenck9uur39",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "3252496000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1s7jy6fajstlxzhtxgqmdh4a2cgq26uxcu7jptk",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "800000000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1327uf364ql39e63fax5n8t8y5e8lag4xjl7e49",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "722777000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka13t3cvaeke9z5vlwps3z7eyp9uj98z2xkt02352",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "361388000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1jv65s3grqf6v6jl3dp4t6c9t9rk99cd8h2rzwa",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "120000000000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1jle7z5mmfczkvy76gvsxud6kjryzhr8c3cpyal",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "361388000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1n7ph0qezwcr666kp6tesylw4eqnyqwd0g76u7d",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "320000000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "1"
+ }
+ ]
+ },
+ {
+ "address": "gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "1"
+ }
+ ]
+ },
+ {
+ "address": "gonka1469wnu47q925a4ekazp09tx9k5phyj2nv67jv3",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "144555000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "1"
+ }
+ ]
+ },
+ {
+ "address": "gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "1"
+ }
+ ]
+ },
+ {
+ "address": "gonka1k4rnc2e9upscac85tkjwa43wr6kqpfyqcmdwej",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "800000000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1h78hmsvknwp86qzu9xftv9znwga7u0sjghmz20",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "1445554000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1cpxpnskkf6hlpldu76tya7d53rklnjlqu4uars",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "80000000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1clvs7fyag6zjkpnvapjj6m0jn38mgsn63tdnhc",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "180629000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1689695npe7amwyunaaj9dwz58v8n7cgkw5emn4",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "34381000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka16fdw9ve0xj5yy42asg85wgykr4y4kw2l37rkfp",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "2400000000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1ucl3pfq6sy9ggxuxahvjhm52hgl3qu4wg46hsk",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "72278000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1a0rh2dej6lrnj5zkx005f5jrxem0tpdh4cpcmg",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "160000000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1akmamql0z9vnd48tfw3d75zexu3dswqcawtnxa",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "361388000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka179nv57lqeana9nvgeul8twegj58ccrd2hm5uzc",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "144555000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka17u7kemct38fx3cuj2yh0x5j2fd9zxkuwkes6q7",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "15000000000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1lrwu2czkxwaadqnvsttfa5uvc6mshv8wjd3wyz",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "144555000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1ld2e89rhfmdlke69m444jcd99h7fra4whksdk4",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "320000000000000"
+ }
+ ]
+ },
+ {
+ "address": "gonka1l4z4swg3e0pf937qm08u0cnkszss34kpe32y52",
+ "coins": [
+ {
+ "denom": "ngonka",
+ "amount": "361388000000000"
+ }
+ ]
+ }
+ ],
+ "supply": [
+ {
+ "denom": "ngonka",
+ "amount": "320000000000000011"
+ }
+ ],
+ "denom_metadata": [
+ {
+ "description": "Coins for the Gonka network.",
+ "denom_units": [
+ {
+ "denom": "ngonka",
+ "exponent": 0,
+ "aliases": [
+ "nanogonka"
+ ]
+ },
+ {
+ "denom": "ugonka",
+ "exponent": 3,
+ "aliases": [
+ "microgonka"
+ ]
+ },
+ {
+ "denom": "mgonka",
+ "exponent": 6,
+ "aliases": [
+ "milligonka"
+ ]
+ },
+ {
+ "denom": "gonka",
+ "exponent": 9,
+ "aliases": []
+ }
+ ],
+ "base": "ngonka",
+ "display": "ngonka",
+ "name": "Gonka",
+ "symbol": "GNK",
+ "uri": "",
+ "uri_hash": ""
+ }
+ ],
+ "send_enabled": []
+ },
+ "bls": {
+ "params": {
+ "i_total_slots": 100,
+ "t_slots_degree_offset": 50,
+ "dealing_phase_duration_blocks": "5",
+ "verification_phase_duration_blocks": "3",
+ "signing_deadline_blocks": "10"
+ },
+ "active_epoch_id": "0"
+ },
+ "bookkeeper": {
+ "params": {}
+ },
+ "capability": {
+ "index": "1",
+ "owners": []
+ },
+ "circuit": {
+ "account_permissions": [],
+ "disabled_type_urls": []
+ },
+ "collateral": {
+ "params": {
+ "unbonding_period_epochs": "1"
+ },
+ "collateral_balance_list": [],
+ "unbonding_collateral_list": [],
+ "jailed_participant_list": []
+ },
+ "consensus": null,
+ "crisis": {
+ "constant_fee": {
+ "denom": "ngonka",
+ "amount": "1000"
+ }
+ },
+ "distribution": {
+ "params": {
+ "community_tax": "0.020000000000000000",
+ "base_proposer_reward": "0.000000000000000000",
+ "bonus_proposer_reward": "0.000000000000000000",
+ "withdraw_addr_enabled": true
+ },
+ "fee_pool": {
+ "community_pool": [
+ {
+ "denom": "ngonka",
+ "amount": "120000000000000000.000000000000000000"
+ }
+ ]
+ },
+ "delegator_withdraw_infos": [],
+ "previous_proposer": "",
+ "outstanding_rewards": [],
+ "validator_accumulated_commissions": [],
+ "validator_historical_rewards": [],
+ "validator_current_rewards": [],
+ "delegator_starting_infos": [],
+ "validator_slash_events": []
+ },
+ "evidence": {
+ "evidence": []
+ },
+ "feegrant": {
+ "allowances": []
+ },
+ "feeibc": {
+ "identified_fees": [],
+ "fee_enabled_channels": [],
+ "registered_payees": [],
+ "registered_counterparty_payees": [],
+ "forward_relayers": []
+ },
+ "genesistransfer": {
+ "params": {
+ "allowed_accounts": [],
+ "restrict_to_list": false
+ },
+ "transfer_records": []
+ },
+ "genutil": {
+ "gen_txs": [
+ {
+ "body": {
+ "messages": [
+ {
+ "@type": "/cosmos.staking.v1beta1.MsgCreateValidator",
+ "description": {
+ "moniker": "gonka-1",
+ "identity": "",
+ "website": "",
+ "security_contact": "",
+ "details": ""
+ },
+ "commission": {
+ "rate": "0.100000000000000000",
+ "max_rate": "0.200000000000000000",
+ "max_change_rate": "0.010000000000000000"
+ },
+ "min_self_delegation": "1",
+ "delegator_address": "",
+ "validator_address": "gonkavaloper1y2a9p56kv044327uycmqdexl7zs82fs5lyang5",
+ "pubkey": {
+ "@type": "/cosmos.crypto.ed25519.PubKey",
+ "key": "OPwcpfQYOoWDuHKYivRVq5jxrELH0moP5qdznvj3Dps="
+ },
+ "value": {
+ "denom": "ngonka",
+ "amount": "1"
+ }
+ }
+ ],
+ "memo": "",
+ "timeout_height": "0",
+ "unordered": false,
+ "timeout_timestamp": null,
+ "extension_options": [],
+ "non_critical_extension_options": []
+ },
+ "auth_info": {
+ "signer_infos": [
+ {
+ "public_key": {
+ "@type": "/cosmos.crypto.secp256k1.PubKey",
+ "key": "A/EHY6CWbAH8evT5gRDSJdsTMmtQQLQspeRT32La8cX8"
+ },
+ "mode_info": {
+ "single": {
+ "mode": "SIGN_MODE_DIRECT"
+ }
+ },
+ "sequence": "0"
+ }
+ ],
+ "fee": {
+ "amount": [],
+ "gas_limit": "200000",
+ "payer": "",
+ "granter": ""
+ },
+ "tip": null
+ },
+ "signatures": [
+ "4krCJCFCfs/P16R323TN45+546TYAVdf/Rg2F/f0dA8ItrRi+tj5x/TLPibcWZlAGL2nYT02/AGhbFnWfiUQ9A=="
+ ]
+ },
+ {
+ "body": {
+ "messages": [
+ {
+ "@type": "/cosmos.staking.v1beta1.MsgCreateValidator",
+ "description": {
+ "moniker": "node-6ali-01",
+ "identity": "",
+ "website": "",
+ "security_contact": "",
+ "details": ""
+ },
+ "commission": {
+ "rate": "0.100000000000000000",
+ "max_rate": "0.200000000000000000",
+ "max_change_rate": "0.010000000000000000"
+ },
+ "min_self_delegation": "1",
+ "delegator_address": "",
+ "validator_address": "gonkavaloper1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgs9xqav",
+ "pubkey": {
+ "@type": "/cosmos.crypto.ed25519.PubKey",
+ "key": "5QYFI0kdyBPrcld3FfOwoZdynfwN5li0qUbg3zwFK4I="
+ },
+ "value": {
+ "denom": "ngonka",
+ "amount": "1"
+ }
+ }
+ ],
+ "memo": "",
+ "timeout_height": "0",
+ "unordered": false,
+ "timeout_timestamp": null,
+ "extension_options": [],
+ "non_critical_extension_options": []
+ },
+ "auth_info": {
+ "signer_infos": [
+ {
+ "public_key": {
+ "@type": "/cosmos.crypto.secp256k1.PubKey",
+ "key": "A1uX2Pz8eBXxc/m3VXOglAv/UTo/YvkDA1hAqL4rUUyp"
+ },
+ "mode_info": {
+ "single": {
+ "mode": "SIGN_MODE_DIRECT"
+ }
+ },
+ "sequence": "0"
+ }
+ ],
+ "fee": {
+ "amount": [],
+ "gas_limit": "200000",
+ "payer": "",
+ "granter": ""
+ },
+ "tip": null
+ },
+ "signatures": [
+ "4O/GI5Q3lFDGH5Fn5RIlX1gbnQyffl4Rx9RPKOfnq9w2Jt0c/bu90184fsOj5uhllBiMhPX4RJnY94b8SYsSag=="
+ ]
+ },
+ {
+ "body": {
+ "messages": [
+ {
+ "@type": "/cosmos.staking.v1beta1.MsgCreateValidator",
+ "description": {
+ "moniker": "gonka-gid-001",
+ "identity": "",
+ "website": "",
+ "security_contact": "",
+ "details": ""
+ },
+ "commission": {
+ "rate": "0.100000000000000000",
+ "max_rate": "0.200000000000000000",
+ "max_change_rate": "0.010000000000000000"
+ },
+ "min_self_delegation": "1",
+ "delegator_address": "",
+ "validator_address": "gonkavaloper1r90m7wlp95zz92eqltys77xyyqkcmz72lc73me",
+ "pubkey": {
+ "@type": "/cosmos.crypto.ed25519.PubKey",
+ "key": "WDLSFDAjM9OGUER2hmpFivYbaZiXNl8/+2Vq61Z/dDc="
+ },
+ "value": {
+ "denom": "ngonka",
+ "amount": "1"
+ }
+ }
+ ],
+ "memo": "",
+ "timeout_height": "0",
+ "unordered": false,
+ "timeout_timestamp": null,
+ "extension_options": [],
+ "non_critical_extension_options": []
+ },
+ "auth_info": {
+ "signer_infos": [
+ {
+ "public_key": {
+ "@type": "/cosmos.crypto.secp256k1.PubKey",
+ "key": "Ar8WnJJJs/wRe8YM7+p50eC9akdOPuqeuRsIfos4W4wR"
+ },
+ "mode_info": {
+ "single": {
+ "mode": "SIGN_MODE_DIRECT"
+ }
+ },
+ "sequence": "0"
+ }
+ ],
+ "fee": {
+ "amount": [],
+ "gas_limit": "200000",
+ "payer": "",
+ "granter": ""
+ },
+ "tip": null
+ },
+ "signatures": [
+ "QfMnGJ5NKPhH7ubZc0ImJjPwA+DamRFw/I3QWivPQwpmh9N19OltzMgZX9OCWOfDLWc1crVqe/aa+xWRo5xUkQ=="
+ ]
+ },
+ {
+ "body": {
+ "messages": [
+ {
+ "@type": "/cosmos.staking.v1beta1.MsgCreateValidator",
+ "description": {
+ "moniker": "gonka-3",
+ "identity": "",
+ "website": "",
+ "security_contact": "",
+ "details": ""
+ },
+ "commission": {
+ "rate": "0.100000000000000000",
+ "max_rate": "0.200000000000000000",
+ "max_change_rate": "0.010000000000000000"
+ },
+ "min_self_delegation": "1",
+ "delegator_address": "",
+ "validator_address": "gonkavaloper1kx9mca3xm8u8ypzfuhmxey66u0ufxhs70mtf0e",
+ "pubkey": {
+ "@type": "/cosmos.crypto.ed25519.PubKey",
+ "key": "FODVOcIY8RNoGA7WsiNSL6YQ8N4/A5Ox1IyXgc/FmE0="
+ },
+ "value": {
+ "denom": "ngonka",
+ "amount": "1"
+ }
+ }
+ ],
+ "memo": "",
+ "timeout_height": "0",
+ "unordered": false,
+ "timeout_timestamp": null,
+ "extension_options": [],
+ "non_critical_extension_options": []
+ },
+ "auth_info": {
+ "signer_infos": [
+ {
+ "public_key": {
+ "@type": "/cosmos.crypto.secp256k1.PubKey",
+ "key": "A+yokzwLbyIn2jzTirjONexkP36AYMv6RxDXMrbCnJzR"
+ },
+ "mode_info": {
+ "single": {
+ "mode": "SIGN_MODE_DIRECT"
+ }
+ },
+ "sequence": "0"
+ }
+ ],
+ "fee": {
+ "amount": [],
+ "gas_limit": "200000",
+ "payer": "",
+ "granter": ""
+ },
+ "tip": null
+ },
+ "signatures": [
+ "WBNogY6fLiWm8KNV3NEQC2GFsHHzJypZiEyozQCmmMoV8uYs0oGtM2OpjLXpy6XfZRhaPx49AcZ6zaEsr/OnNQ=="
+ ]
+ },
+ {
+ "body": {
+ "messages": [
+ {
+ "@type": "/cosmos.staking.v1beta1.MsgCreateValidator",
+ "description": {
+ "moniker": "gonka-2",
+ "identity": "",
+ "website": "",
+ "security_contact": "",
+ "details": ""
+ },
+ "commission": {
+ "rate": "0.100000000000000000",
+ "max_rate": "0.200000000000000000",
+ "max_change_rate": "0.010000000000000000"
+ },
+ "min_self_delegation": "1",
+ "delegator_address": "",
+ "validator_address": "gonkavaloper1dkl4mah5erqggvhqkpc8j3qs5tyuetgdc59d0v",
+ "pubkey": {
+ "@type": "/cosmos.crypto.ed25519.PubKey",
+ "key": "YHtcky8VaH0qQNhYJkN61RPf83oKWsCPXdaewvDEYLo="
+ },
+ "value": {
+ "denom": "ngonka",
+ "amount": "1"
+ }
+ }
+ ],
+ "memo": "",
+ "timeout_height": "0",
+ "unordered": false,
+ "timeout_timestamp": null,
+ "extension_options": [],
+ "non_critical_extension_options": []
+ },
+ "auth_info": {
+ "signer_infos": [
+ {
+ "public_key": {
+ "@type": "/cosmos.crypto.secp256k1.PubKey",
+ "key": "A9CX2rkp0YxVAvKW2bv4nXEU12UEnw/gHjQND1tPWCoY"
+ },
+ "mode_info": {
+ "single": {
+ "mode": "SIGN_MODE_DIRECT"
+ }
+ },
+ "sequence": "0"
+ }
+ ],
+ "fee": {
+ "amount": [],
+ "gas_limit": "200000",
+ "payer": "",
+ "granter": ""
+ },
+ "tip": null
+ },
+ "signatures": [
+ "AuGp4kCjGBpRqv5VOkAIRZcQWcqST9+D/x7z0n5i0tM2TFo/YaWr8G/Y3ZvoqYr8YxcUIKUM6ASKPV8JbxfZdA=="
+ ]
+ },
+ {
+ "body": {
+ "messages": [
+ {
+ "@type": "/cosmos.staking.v1beta1.MsgCreateValidator",
+ "description": {
+ "moniker": "spvre",
+ "identity": "",
+ "website": "",
+ "security_contact": "",
+ "details": ""
+ },
+ "commission": {
+ "rate": "0.100000000000000000",
+ "max_rate": "0.200000000000000000",
+ "max_change_rate": "0.010000000000000000"
+ },
+ "min_self_delegation": "1",
+ "delegator_address": "",
+ "validator_address": "gonkavaloper19fpma3577v3fnk8nxjkvg442ss8hvglxjqe94h",
+ "pubkey": {
+ "@type": "/cosmos.crypto.ed25519.PubKey",
+ "key": "pM9MGrvN6zoLAuA6SKndq2GT/AY8b9tr8PodsnmV4Bk="
+ },
+ "value": {
+ "denom": "ngonka",
+ "amount": "1"
+ }
+ }
+ ],
+ "memo": "",
+ "timeout_height": "0",
+ "unordered": false,
+ "timeout_timestamp": null,
+ "extension_options": [],
+ "non_critical_extension_options": []
+ },
+ "auth_info": {
+ "signer_infos": [
+ {
+ "public_key": {
+ "@type": "/cosmos.crypto.secp256k1.PubKey",
+ "key": "Auz6M2noPEepwz55meXHhx3hNGpjIglMiBXXXkQ+yOV9"
+ },
+ "mode_info": {
+ "single": {
+ "mode": "SIGN_MODE_DIRECT"
+ }
+ },
+ "sequence": "0"
+ }
+ ],
+ "fee": {
+ "amount": [],
+ "gas_limit": "200000",
+ "payer": "",
+ "granter": ""
+ },
+ "tip": null
+ },
+ "signatures": [
+ "2yGlYQV9TAT31CUHCZ4qBQsTt158Ha9g49rRX/2XnF0H2q27fuV5QLSwXE8tYeN0HThIE+3/BaNTLMPC0zIuHw=="
+ ]
+ },
+ {
+ "body": {
+ "messages": [
+ {
+ "@type": "/cosmos.staking.v1beta1.MsgCreateValidator",
+ "description": {
+ "moniker": "gonka-hy-001",
+ "identity": "",
+ "website": "",
+ "security_contact": "",
+ "details": ""
+ },
+ "commission": {
+ "rate": "0.100000000000000000",
+ "max_rate": "0.200000000000000000",
+ "max_change_rate": "0.010000000000000000"
+ },
+ "min_self_delegation": "1",
+ "delegator_address": "",
+ "validator_address": "gonkavaloper1ktl3kkn9l68c9amanu8u4868mcjmtsr5hgnu9m",
+ "pubkey": {
+ "@type": "/cosmos.crypto.ed25519.PubKey",
+ "key": "jFC9XywnI7hzIEQ1kmSQf8Q1iuqy861P7vBrqa3LQxs="
+ },
+ "value": {
+ "denom": "ngonka",
+ "amount": "1"
+ }
+ }
+ ],
+ "memo": "",
+ "timeout_height": "0",
+ "unordered": false,
+ "timeout_timestamp": null,
+ "extension_options": [],
+ "non_critical_extension_options": []
+ },
+ "auth_info": {
+ "signer_infos": [
+ {
+ "public_key": {
+ "@type": "/cosmos.crypto.secp256k1.PubKey",
+ "key": "AxbqG2vVhIHEJ375h/B+ei4HiQeboZF6EujXGVvBoLYg"
+ },
+ "mode_info": {
+ "single": {
+ "mode": "SIGN_MODE_DIRECT"
+ }
+ },
+ "sequence": "0"
+ }
+ ],
+ "fee": {
+ "amount": [],
+ "gas_limit": "200000",
+ "payer": "",
+ "granter": ""
+ },
+ "tip": null
+ },
+ "signatures": [
+ "ZrDl/LG3aQwylhd/8Z5MamhDUt5h+3kT+BWLCGXet75iKZeMsmy5IE2TdLPmKLtdK1OFw3t2fN1P6bRIJ4QOVw=="
+ ]
+ },
+ {
+ "body": {
+ "messages": [
+ {
+ "@type": "/cosmos.staking.v1beta1.MsgCreateValidator",
+ "description": {
+ "moniker": "node-201081",
+ "identity": "",
+ "website": "",
+ "security_contact": "",
+ "details": ""
+ },
+ "commission": {
+ "rate": "0.100000000000000000",
+ "max_rate": "0.200000000000000000",
+ "max_change_rate": "0.010000000000000000"
+ },
+ "min_self_delegation": "1",
+ "delegator_address": "",
+ "validator_address": "gonkavaloper15p7s7w2hx0y8095lddd4ummm2y0kwpwlwk7g2d",
+ "pubkey": {
+ "@type": "/cosmos.crypto.ed25519.PubKey",
+ "key": "BUWZfCeWI3O+UXcmCbnjacmi0RY0PzX/8aJKdy3rP48="
+ },
+ "value": {
+ "denom": "ngonka",
+ "amount": "1"
+ }
+ }
+ ],
+ "memo": "",
+ "timeout_height": "0",
+ "unordered": false,
+ "timeout_timestamp": null,
+ "extension_options": [],
+ "non_critical_extension_options": []
+ },
+ "auth_info": {
+ "signer_infos": [
+ {
+ "public_key": {
+ "@type": "/cosmos.crypto.secp256k1.PubKey",
+ "key": "AxNmIzNd3iKvSzHcLXVNVsg5+N7sL0Nh0DAgozogvH28"
+ },
+ "mode_info": {
+ "single": {
+ "mode": "SIGN_MODE_DIRECT"
+ }
+ },
+ "sequence": "0"
+ }
+ ],
+ "fee": {
+ "amount": [],
+ "gas_limit": "200000",
+ "payer": "",
+ "granter": ""
+ },
+ "tip": null
+ },
+ "signatures": [
+ "HVuMF7qaSsUMKKsAnG7DXpqKNs8t/WSgIO8ebRdZEkxAKvdyn4e1/d7JWIDrkgA1CHsyGoVEd5YPt66Wvvj/fw=="
+ ]
+ },
+ {
+ "body": {
+ "messages": [
+ {
+ "@type": "/cosmos.staking.v1beta1.MsgCreateValidator",
+ "description": {
+ "moniker": "node-710122",
+ "identity": "",
+ "website": "",
+ "security_contact": "",
+ "details": ""
+ },
+ "commission": {
+ "rate": "0.100000000000000000",
+ "max_rate": "0.200000000000000000",
+ "max_change_rate": "0.010000000000000000"
+ },
+ "min_self_delegation": "1",
+ "delegator_address": "",
+ "validator_address": "gonkavaloper1vhprg9epy683xghp8ddtdlw2y9cycecm86yv95",
+ "pubkey": {
+ "@type": "/cosmos.crypto.ed25519.PubKey",
+ "key": "2ykmApZ4pfSMfoREBUDu/vImEYlOym8ymVWOw2wcMQo="
+ },
+ "value": {
+ "denom": "ngonka",
+ "amount": "1"
+ }
+ }
+ ],
+ "memo": "",
+ "timeout_height": "0",
+ "unordered": false,
+ "timeout_timestamp": null,
+ "extension_options": [],
+ "non_critical_extension_options": []
+ },
+ "auth_info": {
+ "signer_infos": [
+ {
+ "public_key": {
+ "@type": "/cosmos.crypto.secp256k1.PubKey",
+ "key": "AuTi5Ju0Qh5ITZFyxLxnvi69jG5j6+/rEtypPo/jilCj"
+ },
+ "mode_info": {
+ "single": {
+ "mode": "SIGN_MODE_DIRECT"
+ }
+ },
+ "sequence": "0"
+ }
+ ],
+ "fee": {
+ "amount": [],
+ "gas_limit": "200000",
+ "payer": "",
+ "granter": ""
+ },
+ "tip": null
+ },
+ "signatures": [
+ "odw4zBxs5YtqjxMvcKJWSMlni9QnaRt3YuDigvC77EwEqZI9S7eX2tvMuE6ztMSFX46gOEsTVEO19GazkJgINg=="
+ ]
+ },
+ {
+ "body": {
+ "messages": [
+ {
+ "@type": "/cosmos.staking.v1beta1.MsgCreateValidator",
+ "description": {
+ "moniker": "gcore",
+ "identity": "",
+ "website": "",
+ "security_contact": "",
+ "details": ""
+ },
+ "commission": {
+ "rate": "0.100000000000000000",
+ "max_rate": "0.200000000000000000",
+ "max_change_rate": "0.010000000000000000"
+ },
+ "min_self_delegation": "1",
+ "delegator_address": "",
+ "validator_address": "gonkavaloper1n7njfqnq7z64efe7xma23zu78xex93e0fl2na3",
+ "pubkey": {
+ "@type": "/cosmos.crypto.ed25519.PubKey",
+ "key": "6BfEgtpNGORi05A9+XTF7yquvV7BKqfOOWcwpD3A8oU="
+ },
+ "value": {
+ "denom": "ngonka",
+ "amount": "1"
+ }
+ }
+ ],
+ "memo": "",
+ "timeout_height": "0",
+ "unordered": false,
+ "timeout_timestamp": null,
+ "extension_options": [],
+ "non_critical_extension_options": []
+ },
+ "auth_info": {
+ "signer_infos": [
+ {
+ "public_key": {
+ "@type": "/cosmos.crypto.secp256k1.PubKey",
+ "key": "A626Hdn4JBkuep77PVki26ndO6Onbqb//LghjauM8+lA"
+ },
+ "mode_info": {
+ "single": {
+ "mode": "SIGN_MODE_DIRECT"
+ }
+ },
+ "sequence": "0"
+ }
+ ],
+ "fee": {
+ "amount": [],
+ "gas_limit": "200000",
+ "payer": "",
+ "granter": ""
+ },
+ "tip": null
+ },
+ "signatures": [
+ "VfDeU1UkaYOhen5YKHlW7pFcBWK4GvLp1pxbXIkrZjk6qyJHTbKsLv49eootB2Pb9k4EkTsIGe//HQZ6ig5kvg=="
+ ]
+ },
+ {
+ "body": {
+ "messages": [
+ {
+ "@type": "/cosmos.staking.v1beta1.MsgCreateValidator",
+ "description": {
+ "moniker": "node-6ali-02",
+ "identity": "",
+ "website": "",
+ "security_contact": "",
+ "details": ""
+ },
+ "commission": {
+ "rate": "0.100000000000000000",
+ "max_rate": "0.200000000000000000",
+ "max_change_rate": "0.010000000000000000"
+ },
+ "min_self_delegation": "1",
+ "delegator_address": "",
+ "validator_address": "gonkavaloper1p2lhgng7tcqju7emk989s5fpdr7k2c3e26xddk",
+ "pubkey": {
+ "@type": "/cosmos.crypto.ed25519.PubKey",
+ "key": "LLqBxOz+vD3p7sQsdEhBfrFH2QFMjy3fMasB9yBGSqs="
+ },
+ "value": {
+ "denom": "ngonka",
+ "amount": "1"
+ }
+ }
+ ],
+ "memo": "",
+ "timeout_height": "0",
+ "unordered": false,
+ "timeout_timestamp": null,
+ "extension_options": [],
+ "non_critical_extension_options": []
+ },
+ "auth_info": {
+ "signer_infos": [
+ {
+ "public_key": {
+ "@type": "/cosmos.crypto.secp256k1.PubKey",
+ "key": "ApNB0x1fYdt0m1eUwiMgJjMfsuiUMlu+TqkiSO2S73iC"
+ },
+ "mode_info": {
+ "single": {
+ "mode": "SIGN_MODE_DIRECT"
+ }
+ },
+ "sequence": "0"
+ }
+ ],
+ "fee": {
+ "amount": [],
+ "gas_limit": "200000",
+ "payer": "",
+ "granter": ""
+ },
+ "tip": null
+ },
+ "signatures": [
+ "3x+0Ok78uDwhKtTFWjszcv4sYiJzTvXbPj1grJcQDeU7lv041ocAMuUWOuh1/RZX7AZKXPznpE1xYldDPYVx6w=="
+ ]
+ }
+ ]
+ },
+ "gov": {
+ "starting_proposal_id": "1",
+ "deposits": [],
+ "votes": [],
+ "proposals": [],
+ "deposit_params": null,
+ "voting_params": null,
+ "tally_params": null,
+ "params": {
+ "min_deposit": [
+ {
+ "denom": "ngonka",
+ "amount": "25_000_000"
+ }
+ ],
+ "max_deposit_period": "172800s",
+ "voting_period": "48h0m0s",
+ "quorum": "0.334000000000000000",
+ "threshold": "0.500000000000000000",
+ "veto_threshold": "0.334000000000000000",
+ "min_initial_deposit_ratio": "0.000000000000000000",
+ "proposal_cancel_ratio": "0.500000000000000000",
+ "proposal_cancel_dest": "",
+ "expedited_voting_period": "12h0m0s",
+ "expedited_threshold": "0.667000000000000000",
+ "expedited_min_deposit": [
+ {
+ "denom": "ngonka",
+ "amount": "50_000_000"
+ }
+ ],
+ "burn_vote_quorum": false,
+ "burn_proposal_deposit_prevote": false,
+ "burn_vote_veto": true,
+ "min_deposit_ratio": "0.010000000000000000"
+ },
+ "constitution": ""
+ },
+ "group": {
+ "group_seq": "0",
+ "groups": [],
+ "group_members": [],
+ "group_policy_seq": "0",
+ "group_policies": [],
+ "proposal_seq": "0",
+ "proposals": [],
+ "votes": []
+ },
+ "ibc": {
+ "client_genesis": {
+ "clients": [],
+ "clients_consensus": [],
+ "clients_metadata": [],
+ "params": {
+ "allowed_clients": [
+ "*"
+ ]
+ },
+ "create_localhost": false,
+ "next_client_sequence": "0"
+ },
+ "connection_genesis": {
+ "connections": [],
+ "client_connection_paths": [],
+ "next_connection_sequence": "0",
+ "params": {
+ "max_expected_time_per_block": "30000000000"
+ }
+ },
+ "channel_genesis": {
+ "channels": [],
+ "acknowledgements": [],
+ "commitments": [],
+ "receipts": [],
+ "send_sequences": [],
+ "recv_sequences": [],
+ "ack_sequences": [],
+ "next_channel_sequence": "0",
+ "params": {
+ "upgrade_timeout": {
+ "height": {
+ "revision_number": "0",
+ "revision_height": "0"
+ },
+ "timestamp": "600000000000"
+ }
+ }
+ }
+ },
+ "inference": {
+ "params": {
+ "epoch_params": {
+ "epoch_length": "17280",
+ "epoch_multiplier": "1",
+ "epoch_shift": "16980",
+ "default_unit_of_compute_price": "100",
+ "poc_stage_duration": "60",
+ "poc_exchange_duration": "5",
+ "poc_validation_delay": "5",
+ "poc_validation_duration": "20",
+ "set_new_validators_delay": "120",
+ "inference_validation_cutoff": "80",
+ "inference_pruning_epoch_threshold": "2"
+ },
+ "validation_params": {
+ "false_positive_rate": {
+ "value": "5",
+ "exponent": -2
+ },
+ "min_ramp_up_measurements": 10,
+ "pass_value": {
+ "value": "99",
+ "exponent": -2
+ },
+ "min_validation_average": {
+ "value": "1",
+ "exponent": -2
+ },
+ "max_validation_average": {
+ "value": "1",
+ "exponent": 0
+ },
+ "expiration_blocks": "20",
+ "epochs_to_max": "30",
+ "full_validation_traffic_cutoff": "10000",
+ "min_validation_halfway": {
+ "value": "5",
+ "exponent": -2
+ },
+ "min_validation_traffic_cutoff": "100",
+ "miss_percentage_cutoff": {
+ "value": "1",
+ "exponent": -2
+ },
+ "miss_requests_penalty": {
+ "value": "1",
+ "exponent": 0
+ },
+ "timestamp_expiration": "60",
+ "timestamp_advance": "30",
+ "estimated_limits_per_block_kb": "0"
+ },
+ "poc_params": {
+ "default_difficulty": 5,
+ "validation_sample_size": 200,
+ "poc_data_pruning_epoch_threshold": "1"
+ },
+ "tokenomics_params": {
+ "subsidy_reduction_interval": {
+ "value": "5",
+ "exponent": -2
+ },
+ "subsidy_reduction_amount": {
+ "value": "2",
+ "exponent": -1
+ },
+ "current_subsidy_percentage": {
+ "value": "9",
+ "exponent": -1
+ },
+ "top_reward_allowed_failure": {
+ "value": "1",
+ "exponent": -1
+ },
+ "top_miner_poc_qualification": "10",
+ "work_vesting_period": "180",
+ "reward_vesting_period": "180",
+ "top_miner_vesting_period": "180"
+ },
+ "collateral_params": {
+ "slash_fraction_invalid": {
+ "value": "2",
+ "exponent": -1
+ },
+ "slash_fraction_downtime": {
+ "value": "1",
+ "exponent": -1
+ },
+ "downtime_missed_percentage_threshold": {
+ "value": "5",
+ "exponent": -2
+ },
+ "grace_period_end_epoch": "180",
+ "base_weight_ratio": {
+ "value": "2",
+ "exponent": -1
+ },
+ "collateral_per_weight_unit": {
+ "value": "42",
+ "exponent": -1
+ }
+ },
+ "bitcoin_reward_params": {
+ "use_bitcoin_rewards": true,
+ "initial_epoch_reward": "323000000000000",
+ "decay_rate": {
+ "value": "-475",
+ "exponent": -6
+ },
+ "genesis_epoch": "1",
+ "utilization_bonus_factor": {
+ "value": "5",
+ "exponent": -1
+ },
+ "full_coverage_bonus_factor": {
+ "value": "12",
+ "exponent": -1
+ },
+ "partial_coverage_bonus_factor": {
+ "value": "1",
+ "exponent": -1
+ }
+ },
+ "dynamic_pricing_params": {
+ "stability_zone_lower_bound": {
+ "value": "4",
+ "exponent": -1
+ },
+ "stability_zone_upper_bound": {
+ "value": "6",
+ "exponent": -1
+ },
+ "price_elasticity": {
+ "value": "5",
+ "exponent": -2
+ },
+ "utilization_window_duration": "60",
+ "min_per_token_price": "1",
+ "base_per_token_price": "100",
+ "grace_period_end_epoch": "90",
+ "grace_period_per_token_price": "0"
+ },
+ "bandwidth_limits_params": {
+ "estimated_limits_per_block_kb": "10752",
+ "kb_per_input_token": {
+ "value": "23",
+ "exponent": "-4"
+ },
+ "kb_per_output_token": {
+ "value": "64",
+ "exponent": "-2"
+ }
+ }
+ },
+ "genesis_only_params": {
+ "total_supply": "1000000000000000000",
+ "originator_supply": "200000000000000000",
+ "top_reward_amount": "0",
+ "standard_reward_amount": "680000000000000000",
+ "pre_programmed_sale_amount": "120000000000000000",
+ "top_rewards": 3,
+ "supply_denom": "ngonka",
+ "top_reward_period": "31536000",
+ "top_reward_payouts": "12",
+ "top_reward_payouts_per_miner": "4",
+ "top_reward_max_duration": "126144000",
+ "max_individual_power_percentage": {
+ "value": "25",
+ "exponent": -2
+ },
+ "genesis_guardian_enabled": true,
+ "genesis_guardian_network_maturity_threshold": "2000000",
+ "genesis_guardian_multiplier": {
+ "value": "52",
+ "exponent": -2
+ },
+ "genesis_guardian_addresses": [
+ "gonkavaloper1y2a9p56kv044327uycmqdexl7zs82fs5lyang5",
+ "gonkavaloper1dkl4mah5erqggvhqkpc8j3qs5tyuetgdc59d0v",
+ "gonkavaloper1kx9mca3xm8u8ypzfuhmxey66u0ufxhs70mtf0e"
+ ]
+ },
+ "model_list": [
+ {
+ "proposed_by": "genesis",
+ "id": "Qwen/QwQ-32B",
+ "units_of_compute_per_token": "1000",
+ "hf_repo": "Qwen/QwQ-32B",
+ "hf_commit": "976055f8c83f394f35dbd3ab09a285a984907bd0",
+ "model_args": [
+ "--quantization",
+ "fp8",
+ "--kv-cache-dtype",
+ "fp8"
+ ],
+ "v_ram": "80",
+ "throughput_per_nonce": "1000",
+ "validation_threshold": {
+ "value": "98",
+ "exponent": -2
+ }
+ },
+ {
+ "proposed_by": "genesis",
+ "id": "Qwen/Qwen2.5-7B-Instruct",
+ "units_of_compute_per_token": "100",
+ "hf_repo": "Qwen/Qwen2.5-7B-Instruct",
+ "hf_commit": "a09a35458c702b33eeacc393d103063234e8bc28",
+ "model_args": [
+ "--quantization",
+ "fp8"
+ ],
+ "v_ram": "24",
+ "throughput_per_nonce": "10000",
+ "validation_threshold": {
+ "value": "98",
+ "exponent": -2
+ }
+ }
+ ],
+ "cosm_wasm_params": {
+ "cw20_code": "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",
+ "cw20_code_id": "0"
+ },
+ "participant_list": [
+ {
+ "index": "gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le",
+ "address": "gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le",
+ "weight": 1,
+ "join_time": 1755848273,
+ "last_inference_time": 1755848273,
+ "inference_url": "http://node1.gonka.ai:8000",
+ "status": 1,
+ "validator_key": "OPwcpfQYOoWDuHKYivRVq5jxrELH0moP5qdznvj3Dps=",
+ "current_epoch_stats": {}
+ },
+ {
+ "index": "gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p",
+ "address": "gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p",
+ "weight": 1,
+ "join_time": 1755848273,
+ "last_inference_time": 1755848273,
+ "inference_url": "http://47.236.26.199:8000",
+ "status": 1,
+ "validator_key": "5QYFI0kdyBPrcld3FfOwoZdynfwN5li0qUbg3zwFK4I=",
+ "current_epoch_stats": {}
+ },
+ {
+ "index": "gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5",
+ "address": "gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5",
+ "weight": 1,
+ "join_time": 1755848273,
+ "last_inference_time": 1755848273,
+ "inference_url": "http://69.19.136.233:8000",
+ "status": 1,
+ "validator_key": "WDLSFDAjM9OGUER2hmpFivYbaZiXNl8/+2Vq61Z/dDc=",
+ "current_epoch_stats": {}
+ },
+ {
+ "index": "gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5",
+ "address": "gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5",
+ "weight": 1,
+ "join_time": 1755848273,
+ "last_inference_time": 1755848273,
+ "inference_url": "http://node3.gonka.ai:8000",
+ "status": 1,
+ "validator_key": "FODVOcIY8RNoGA7WsiNSL6YQ8N4/A5Ox1IyXgc/FmE0=",
+ "current_epoch_stats": {}
+ },
+ {
+ "index": "gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp",
+ "address": "gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp",
+ "weight": 1,
+ "join_time": 1755848273,
+ "last_inference_time": 1755848273,
+ "inference_url": "http://node2.gonka.ai:8000",
+ "status": 1,
+ "validator_key": "YHtcky8VaH0qQNhYJkN61RPf83oKWsCPXdaewvDEYLo=",
+ "current_epoch_stats": {}
+ },
+ {
+ "index": "gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6",
+ "address": "gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6",
+ "weight": 1,
+ "join_time": 1755848273,
+ "last_inference_time": 1755848273,
+ "inference_url": "http://gonka.spv.re:8000",
+ "status": 1,
+ "validator_key": "pM9MGrvN6zoLAuA6SKndq2GT/AY8b9tr8PodsnmV4Bk=",
+ "current_epoch_stats": {}
+ },
+ {
+ "index": "gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk",
+ "address": "gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk",
+ "weight": 1,
+ "join_time": 1755848273,
+ "last_inference_time": 1755848273,
+ "inference_url": "http://185.216.21.98:8000",
+ "status": 1,
+ "validator_key": "jFC9XywnI7hzIEQ1kmSQf8Q1iuqy861P7vBrqa3LQxs=",
+ "current_epoch_stats": {}
+ },
+ {
+ "index": "gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq",
+ "address": "gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq",
+ "weight": 1,
+ "join_time": 1755848273,
+ "last_inference_time": 1755848273,
+ "inference_url": "http://36.189.234.197:18026",
+ "status": 1,
+ "validator_key": "BUWZfCeWI3O+UXcmCbnjacmi0RY0PzX/8aJKdy3rP48=",
+ "current_epoch_stats": {}
+ },
+ {
+ "index": "gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje",
+ "address": "gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje",
+ "weight": 1,
+ "join_time": 1755848273,
+ "last_inference_time": 1755848273,
+ "inference_url": "http://36.189.234.237:17241",
+ "status": 1,
+ "validator_key": "2ykmApZ4pfSMfoREBUDu/vImEYlOym8ymVWOw2wcMQo=",
+ "current_epoch_stats": {}
+ },
+ {
+ "index": "gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u",
+ "address": "gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u",
+ "weight": 1,
+ "join_time": 1755848273,
+ "last_inference_time": 1755848273,
+ "inference_url": "http://93.119.168.58:8000",
+ "status": 1,
+ "validator_key": "6BfEgtpNGORi05A9+XTF7yquvV7BKqfOOWcwpD3A8oU=",
+ "current_epoch_stats": {}
+ },
+ {
+ "index": "gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m",
+ "address": "gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m",
+ "weight": 1,
+ "join_time": 1755848273,
+ "last_inference_time": 1755848273,
+ "inference_url": "http://47.236.19.22:18000",
+ "status": 1,
+ "validator_key": "LLqBxOz+vD3p7sQsdEhBfrFH2QFMjy3fMasB9yBGSqs=",
+ "current_epoch_stats": {}
+ }
+ ]
+ },
+ "interchainaccounts": {
+ "controller_genesis_state": {
+ "active_channels": [],
+ "interchain_accounts": [],
+ "ports": [],
+ "params": {
+ "controller_enabled": true
+ }
+ },
+ "host_genesis_state": {
+ "active_channels": [],
+ "interchain_accounts": [],
+ "port": "icahost",
+ "params": {
+ "host_enabled": true,
+ "allow_messages": [
+ "*"
+ ]
+ }
+ }
+ },
+ "mint": {
+ "minter": {
+ "inflation": "0.130000000000000000",
+ "annual_provisions": "0.000000000000000000"
+ },
+ "params": {
+ "mint_denom": "ngonka",
+ "inflation_rate_change": "0.130000000000000000",
+ "inflation_max": "0.200000000000000000",
+ "inflation_min": "0.070000000000000000",
+ "goal_bonded": "0.670000000000000000",
+ "blocks_per_year": "6311520"
+ }
+ },
+ "nft": {
+ "classes": [],
+ "entries": []
+ },
+ "params": null,
+ "restrictions": {
+ "params": {
+ "restriction_end_block": "1555000",
+ "emergency_transfer_exemptions": [],
+ "exemption_usage_tracking": []
+ }
+ },
+ "runtime": null,
+ "slashing": {
+ "params": {
+ "signed_blocks_window": "100",
+ "min_signed_per_window": "0.500000000000000000",
+ "downtime_jail_duration": "600s",
+ "slash_fraction_double_sign": "0.050000000000000000",
+ "slash_fraction_downtime": "0.010000000000000000"
+ },
+ "signing_infos": [],
+ "missed_blocks": []
+ },
+ "staking": {
+ "params": {
+ "unbonding_time": "1814400s",
+ "max_validators": 100,
+ "max_entries": 7,
+ "historical_entries": 10000,
+ "bond_denom": "ngonka",
+ "min_commission_rate": "0.000000000000000000"
+ },
+ "last_total_power": "0",
+ "last_validator_powers": [],
+ "validators": [],
+ "delegations": [],
+ "unbonding_delegations": [],
+ "redelegations": [],
+ "exported": false
+ },
+ "streamvesting": {
+ "params": {
+ "reward_vesting_period": "180"
+ },
+ "vesting_schedule_list": []
+ },
+ "transfer": {
+ "port_id": "transfer",
+ "denom_traces": [],
+ "params": {
+ "send_enabled": true,
+ "receive_enabled": true
+ },
+ "total_escrowed": []
+ },
+ "upgrade": {},
+ "vesting": {},
+ "wasm": {
+ "params": {
+ "code_upload_access": {
+ "permission": "Everybody",
+ "addresses": []
+ },
+ "instantiate_default_permission": "Everybody"
+ },
+ "codes": [],
+ "contracts": [],
+ "sequences": []
+ }
+ },
+ "consensus": {
+ "params": {
+ "block": {
+ "max_bytes": "22020096",
+ "max_gas": "-1"
+ },
+ "evidence": {
+ "max_age_num_blocks": "100000",
+ "max_age_duration": "172800000000000",
+ "max_bytes": "1048576"
+ },
+ "validator": {
+ "pub_key_types": [
+ "ed25519"
+ ]
+ },
+ "version": {
+ "app": "0"
+ },
+ "abci": {
+ "vote_extensions_enable_height": "0"
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/genesis/init-docker-genesis.sh b/genesis/init-docker-genesis.sh
new file mode 100755
index 000000000..24a076f00
--- /dev/null
+++ b/genesis/init-docker-genesis.sh
@@ -0,0 +1,106 @@
+#!/bin/sh
+set -e
+set -x
+
+filter_cw20_code() {
+ input=$(cat)
+ # Remove cw20_code field and its value using sed
+ echo "$input" | sed -n -E '
+ # If we find cw20_code, skip until the next closing brace
+ /[[:space:]]*"cw20_code":[[:space:]]*"/ {
+ :skip
+ n
+ /^[[:space:]]*}[,}]?$/! b skip
+ n
+ }
+ # Print all other lines
+ p
+ '
+}
+
+if [ -z "$KEYRING_BACKEND" ]; then
+ echo "KEYRING_BACKEND is not specified defaulting to test"
+ KEYRING_BACKEND="test"
+fi
+
+# Display the parsed values (for debugging)
+echo "Using the following arguments"
+echo "KEYRING_BACKEND: $KEYRING_BACKEND"
+
+KEY_NAME="genesis"
+APP_NAME="inferenced"
+CHAIN_ID="gonka-mainnet"
+COIN_DENOM="ngonka"
+STATE_DIR="$HOME/.inference"
+
+
+output=$($APP_NAME init \
+ --chain-id "$CHAIN_ID" \
+ --default-denom $COIN_DENOM \
+ my-node 2>&1)
+exit_code=$?
+if [ $exit_code -ne 0 ]; then
+ echo "Error: '$APP_NAME init' failed with exit code $exit_code"
+ echo "Output:"
+ echo "$output"
+ exit $exit_code
+fi
+echo "$output" | filter_cw20_code
+
+echo "Setting the chain configuration"
+
+SNAPSHOT_INTERVAL=${SNAPSHOT_INTERVAL:-10}
+SNAPSHOT_KEEP_RECENT=${SNAPSHOT_KEEP_RECENT:-5}
+
+$APP_NAME config set client chain-id $CHAIN_ID
+$APP_NAME config set client keyring-backend $KEYRING_BACKEND
+$APP_NAME config set app minimum-gas-prices "0$COIN_DENOM"
+$APP_NAME config set app state-sync.snapshot-interval $SNAPSHOT_INTERVAL
+$APP_NAME config set app state-sync.snapshot-keep-recent $SNAPSHOT_KEEP_RECENT
+
+echo "Setting the node configuration (config.toml)"
+if [ -n "$P2P_EXTERNAL_ADDRESS" ]; then
+ echo "Setting the external address for P2P to $P2P_EXTERNAL_ADDRESS"
+ $APP_NAME config set config p2p.external_address "$P2P_EXTERNAL_ADDRESS" --skip-validate
+else
+ echo "P2P_EXTERNAL_ADDRESS is not set, skipping"
+fi
+
+sed -Ei 's/^laddr = ".*:26657"$/laddr = "tcp:\/\/0\.0\.0\.0:26657"/g' \
+ $STATE_DIR/config/config.toml
+# no seeds for genesis node
+sed -Ei "s/^seeds = .*$/seeds = \"\"/g" \
+ $STATE_DIR/config/config.toml
+#sed -Ei 's/^log_level = "info"$/log_level = "debug"/g' $STATE_DIR/config/config.toml
+#if [ -n "${DEBUG-}" ]; then
+# sed -i 's/^log_level = "info"/log_level = "debug"/' "$STATE_DIR/config/config.toml"
+#fi
+
+
+modify_genesis_file() {
+ local json_file="$STATE_DIR/config/genesis.json"
+ local override_file="$1"
+
+
+ if [ ! -f "$override_file" ]; then
+ echo "Override file $override_file does not exist. Exiting..."
+ return
+ fi
+ echo "Checking if jq is installed"
+ which jq
+ jq ". * input" "$json_file" "$override_file" > "${json_file}.tmp"
+ mv "${json_file}.tmp" "$json_file"
+ echo "Modified $json_file with file: $override_file"
+ cat "$json_file" | filter_cw20_code
+}
+
+# Usage
+modify_genesis_file 'denom.json'
+MILLION_BASE="000000$COIN_DENOM"
+NATIVE="000000000$COIN_DENOM"
+MILLION_NATIVE="000000$NATIVE"
+
+
+modify_genesis_file 'genesis-overrides.json'
+modify_genesis_file "$HOME/.inference/genesis_overrides.json"
+echo "Genesis file created"
\ No newline at end of file
diff --git a/genesis/validators/gcore/README.md b/genesis/validators/gcore/README.md
new file mode 100644
index 000000000..e72c23467
--- /dev/null
+++ b/genesis/validators/gcore/README.md
@@ -0,0 +1,5 @@
+Account Public Key: `A626Hdn4JBkuep77PVki26ndO6Onbqb//LghjauM8+lA`
+Node ID: `b7dd3863523d78cc5a7c56ddb786395fe49c954a`
+ML Operational Address: `gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p`
+Consensus Public Key: `6BfEgtpNGORi05A9+XTF7yquvV7BKqfOOWcwpD3A8oU=`
+P2P_EXTERNAL_ADDRESS: `tcp://93.119.168.58:5000`
diff --git a/genesis/validators/gcore/genparticipant-b7dd3863523d78cc5a7c56ddb786395fe49c954a.json b/genesis/validators/gcore/genparticipant-b7dd3863523d78cc5a7c56ddb786395fe49c954a.json
new file mode 100644
index 000000000..ac228022e
--- /dev/null
+++ b/genesis/validators/gcore/genparticipant-b7dd3863523d78cc5a7c56ddb786395fe49c954a.json
@@ -0,0 +1 @@
+{"body":{"messages":[{"@type":"/inference.inference.MsgSubmitNewParticipant","creator":"gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u","url":"http://93.119.168.58:8000","validator_key":"6BfEgtpNGORi05A9+XTF7yquvV7BKqfOOWcwpD3A8oU=","worker_key":""},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u","grantee":"gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgStartInference"},"expiration":"2026-08-22T07:21:13.140809555Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u","grantee":"gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgFinishInference"},"expiration":"2026-08-22T07:21:13.140809555Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u","grantee":"gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgClaimRewards"},"expiration":"2026-08-22T07:21:13.140809555Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u","grantee":"gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgValidation"},"expiration":"2026-08-22T07:21:13.140809555Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u","grantee":"gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitPocBatch"},"expiration":"2026-08-22T07:21:13.140809555Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u","grantee":"gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitPocValidation"},"expiration":"2026-08-22T07:21:13.140809555Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u","grantee":"gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitSeed"},"expiration":"2026-08-22T07:21:13.140809555Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u","grantee":"gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgBridgeExchange"},"expiration":"2026-08-22T07:21:13.140809555Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u","grantee":"gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitTrainingKvRecord"},"expiration":"2026-08-22T07:21:13.140809555Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u","grantee":"gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgJoinTraining"},"expiration":"2026-08-22T07:21:13.140809555Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u","grantee":"gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgJoinTrainingStatus"},"expiration":"2026-08-22T07:21:13.140809555Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u","grantee":"gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgTrainingHeartbeat"},"expiration":"2026-08-22T07:21:13.140809555Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u","grantee":"gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSetBarrier"},"expiration":"2026-08-22T07:21:13.140809555Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u","grantee":"gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgClaimTrainingTaskForAssignment"},"expiration":"2026-08-22T07:21:13.140809555Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u","grantee":"gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgAssignTrainingTask"},"expiration":"2026-08-22T07:21:13.140809555Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u","grantee":"gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitNewUnfundedParticipant"},"expiration":"2026-08-22T07:21:13.140809555Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u","grantee":"gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitNewParticipant"},"expiration":"2026-08-22T07:21:13.140809555Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u","grantee":"gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitHardwareDiff"},"expiration":"2026-08-22T07:21:13.140809555Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u","grantee":"gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgInvalidateInference"},"expiration":"2026-08-22T07:21:13.140809555Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u","grantee":"gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgRevalidateInference"},"expiration":"2026-08-22T07:21:13.140809555Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u","grantee":"gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitDealerPart"},"expiration":"2026-08-22T07:21:13.140809555Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u","grantee":"gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitVerificationVector"},"expiration":"2026-08-22T07:21:13.140809555Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u","grantee":"gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgRequestThresholdSignature"},"expiration":"2026-08-22T07:21:13.140809555Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u","grantee":"gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitPartialSignature"},"expiration":"2026-08-22T07:21:13.140809555Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1n7njfqnq7z64efe7xma23zu78xex93e04lm52u","grantee":"gonka1p6aqe3cy6ksthvq4n9v7ffjtdqej4pm32djm2p","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitGroupKeyValidationSignature"},"expiration":"2026-08-22T07:21:13.140809555Z"}}],"memo":"","timeout_height":"0","unordered":false,"timeout_timestamp":null,"extension_options":[],"non_critical_extension_options":[]},"auth_info":{"signer_infos":[{"public_key":{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"A626Hdn4JBkuep77PVki26ndO6Onbqb//LghjauM8+lA"},"mode_info":{"single":{"mode":"SIGN_MODE_DIRECT"}},"sequence":"0"}],"fee":{"amount":[],"gas_limit":"200000","payer":"","granter":""},"tip":null},"signatures":["R2mH5m4Ssagb6TtlFPGIIkSDMa6fSTF2CPhptIeo511eOkMrQG5pKQ3KiA3dQOIzojugbuOAUAwiirOf63vF4w=="]}
diff --git a/genesis/validators/gcore/gentx-b7dd3863523d78cc5a7c56ddb786395fe49c954a.json b/genesis/validators/gcore/gentx-b7dd3863523d78cc5a7c56ddb786395fe49c954a.json
new file mode 100644
index 000000000..2da9ff65f
--- /dev/null
+++ b/genesis/validators/gcore/gentx-b7dd3863523d78cc5a7c56ddb786395fe49c954a.json
@@ -0,0 +1 @@
+{"body":{"messages":[{"@type":"/cosmos.staking.v1beta1.MsgCreateValidator","description":{"moniker":"gcore","identity":"","website":"","security_contact":"","details":""},"commission":{"rate":"0.100000000000000000","max_rate":"0.200000000000000000","max_change_rate":"0.010000000000000000"},"min_self_delegation":"1","delegator_address":"","validator_address":"gonkavaloper1n7njfqnq7z64efe7xma23zu78xex93e0fl2na3","pubkey":{"@type":"/cosmos.crypto.ed25519.PubKey","key":"6BfEgtpNGORi05A9+XTF7yquvV7BKqfOOWcwpD3A8oU="},"value":{"denom":"ngonka","amount":"1"}}],"memo":"","timeout_height":"0","unordered":false,"timeout_timestamp":null,"extension_options":[],"non_critical_extension_options":[]},"auth_info":{"signer_infos":[{"public_key":{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"A626Hdn4JBkuep77PVki26ndO6Onbqb//LghjauM8+lA"},"mode_info":{"single":{"mode":"SIGN_MODE_DIRECT"}},"sequence":"0"}],"fee":{"amount":[],"gas_limit":"200000","payer":"","granter":""},"tip":null},"signatures":["VfDeU1UkaYOhen5YKHlW7pFcBWK4GvLp1pxbXIkrZjk6qyJHTbKsLv49eootB2Pb9k4EkTsIGe//HQZ6ig5kvg=="]}
diff --git a/genesis/validators/gonka-1/README.md b/genesis/validators/gonka-1/README.md
new file mode 100644
index 000000000..7f25be532
--- /dev/null
+++ b/genesis/validators/gonka-1/README.md
@@ -0,0 +1,5 @@
+Account Public Key: `A/EHY6CWbAH8evT5gRDSJdsTMmtQQLQspeRT32La8cX8`
+Node ID: `0772f16cc65cb4d19341b192bd7eba964f11d124`
+ML Operational Address: `gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz`
+Consensus Public Key: `OPwcpfQYOoWDuHKYivRVq5jxrELH0moP5qdznvj3Dps=`
+P2P_EXTERNAL_ADDRESS: `tcp://node1.gonka.ai:5000`
\ No newline at end of file
diff --git a/genesis/validators/gonka-1/genparticipant-0772f16cc65cb4d19341b192bd7eba964f11d124.json b/genesis/validators/gonka-1/genparticipant-0772f16cc65cb4d19341b192bd7eba964f11d124.json
new file mode 100644
index 000000000..eb98e39cf
--- /dev/null
+++ b/genesis/validators/gonka-1/genparticipant-0772f16cc65cb4d19341b192bd7eba964f11d124.json
@@ -0,0 +1 @@
+{"body":{"messages":[{"@type":"/inference.inference.MsgSubmitNewParticipant","creator":"gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le","url":"http://node1.gonka.ai:8000","validator_key":"OPwcpfQYOoWDuHKYivRVq5jxrELH0moP5qdznvj3Dps=","worker_key":""},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le","grantee":"gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgStartInference"},"expiration":"2026-08-22T06:31:44.143457Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le","grantee":"gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgFinishInference"},"expiration":"2026-08-22T06:31:44.143457Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le","grantee":"gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgClaimRewards"},"expiration":"2026-08-22T06:31:44.143457Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le","grantee":"gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgValidation"},"expiration":"2026-08-22T06:31:44.143457Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le","grantee":"gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitPocBatch"},"expiration":"2026-08-22T06:31:44.143457Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le","grantee":"gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitPocValidation"},"expiration":"2026-08-22T06:31:44.143457Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le","grantee":"gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitSeed"},"expiration":"2026-08-22T06:31:44.143457Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le","grantee":"gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgBridgeExchange"},"expiration":"2026-08-22T06:31:44.143457Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le","grantee":"gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitTrainingKvRecord"},"expiration":"2026-08-22T06:31:44.143457Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le","grantee":"gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgJoinTraining"},"expiration":"2026-08-22T06:31:44.143457Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le","grantee":"gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgJoinTrainingStatus"},"expiration":"2026-08-22T06:31:44.143457Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le","grantee":"gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgTrainingHeartbeat"},"expiration":"2026-08-22T06:31:44.143457Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le","grantee":"gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSetBarrier"},"expiration":"2026-08-22T06:31:44.143457Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le","grantee":"gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgClaimTrainingTaskForAssignment"},"expiration":"2026-08-22T06:31:44.143457Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le","grantee":"gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgAssignTrainingTask"},"expiration":"2026-08-22T06:31:44.143457Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le","grantee":"gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitNewUnfundedParticipant"},"expiration":"2026-08-22T06:31:44.143457Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le","grantee":"gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitNewParticipant"},"expiration":"2026-08-22T06:31:44.143457Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le","grantee":"gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitHardwareDiff"},"expiration":"2026-08-22T06:31:44.143457Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le","grantee":"gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgInvalidateInference"},"expiration":"2026-08-22T06:31:44.143457Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le","grantee":"gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgRevalidateInference"},"expiration":"2026-08-22T06:31:44.143457Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le","grantee":"gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitDealerPart"},"expiration":"2026-08-22T06:31:44.143457Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le","grantee":"gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitVerificationVector"},"expiration":"2026-08-22T06:31:44.143457Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le","grantee":"gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgRequestThresholdSignature"},"expiration":"2026-08-22T06:31:44.143457Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le","grantee":"gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitPartialSignature"},"expiration":"2026-08-22T06:31:44.143457Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1y2a9p56kv044327uycmqdexl7zs82fs5ryv5le","grantee":"gonka18hpy9tjeqavj9w66zchdh4w9axaqwdzrd8cedz","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitGroupKeyValidationSignature"},"expiration":"2026-08-22T06:31:44.143457Z"}}],"memo":"","timeout_height":"0","unordered":false,"timeout_timestamp":null,"extension_options":[],"non_critical_extension_options":[]},"auth_info":{"signer_infos":[{"public_key":{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"A/EHY6CWbAH8evT5gRDSJdsTMmtQQLQspeRT32La8cX8"},"mode_info":{"single":{"mode":"SIGN_MODE_DIRECT"}},"sequence":"0"}],"fee":{"amount":[],"gas_limit":"200000","payer":"","granter":""},"tip":null},"signatures":["zUBVvBrL9SMm/XcVKkoqH4dRySjtP0BsxJ3y2YT8I9AMHwDk12xZZhkunID/Di/b+Eu73I7b5gaTXnVDAfgl+Q=="]}
diff --git a/genesis/validators/gonka-1/gentx-0772f16cc65cb4d19341b192bd7eba964f11d124.json b/genesis/validators/gonka-1/gentx-0772f16cc65cb4d19341b192bd7eba964f11d124.json
new file mode 100644
index 000000000..2f42960be
--- /dev/null
+++ b/genesis/validators/gonka-1/gentx-0772f16cc65cb4d19341b192bd7eba964f11d124.json
@@ -0,0 +1 @@
+{"body":{"messages":[{"@type":"/cosmos.staking.v1beta1.MsgCreateValidator","description":{"moniker":"gonka-1","identity":"","website":"","security_contact":"","details":""},"commission":{"rate":"0.100000000000000000","max_rate":"0.200000000000000000","max_change_rate":"0.010000000000000000"},"min_self_delegation":"1","delegator_address":"","validator_address":"gonkavaloper1y2a9p56kv044327uycmqdexl7zs82fs5lyang5","pubkey":{"@type":"/cosmos.crypto.ed25519.PubKey","key":"OPwcpfQYOoWDuHKYivRVq5jxrELH0moP5qdznvj3Dps="},"value":{"denom":"ngonka","amount":"1"}}],"memo":"","timeout_height":"0","unordered":false,"timeout_timestamp":null,"extension_options":[],"non_critical_extension_options":[]},"auth_info":{"signer_infos":[{"public_key":{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"A/EHY6CWbAH8evT5gRDSJdsTMmtQQLQspeRT32La8cX8"},"mode_info":{"single":{"mode":"SIGN_MODE_DIRECT"}},"sequence":"0"}],"fee":{"amount":[],"gas_limit":"200000","payer":"","granter":""},"tip":null},"signatures":["4krCJCFCfs/P16R323TN45+546TYAVdf/Rg2F/f0dA8ItrRi+tj5x/TLPibcWZlAGL2nYT02/AGhbFnWfiUQ9A=="]}
diff --git a/genesis/validators/gonka-2/README.md b/genesis/validators/gonka-2/README.md
new file mode 100644
index 000000000..0430dfd91
--- /dev/null
+++ b/genesis/validators/gonka-2/README.md
@@ -0,0 +1,5 @@
+Account Public Key: `A9CX2rkp0YxVAvKW2bv4nXEU12UEnw/gHjQND1tPWCoY`
+Node ID: `645fbce2dedcc7166f4df7931d2c87ca5188b569`
+ML Operational Address: `gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5`
+Consensus Public Key: `YHtcky8VaH0qQNhYJkN61RPf83oKWsCPXdaewvDEYLo=`
+P2P_EXTERNAL_ADDRESS: `tcp://node2.gonka.ai:5000`
\ No newline at end of file
diff --git a/genesis/validators/gonka-2/genparticipant-645fbce2dedcc7166f4df7931d2c87ca5188b569.json b/genesis/validators/gonka-2/genparticipant-645fbce2dedcc7166f4df7931d2c87ca5188b569.json
new file mode 100644
index 000000000..927a61cd6
--- /dev/null
+++ b/genesis/validators/gonka-2/genparticipant-645fbce2dedcc7166f4df7931d2c87ca5188b569.json
@@ -0,0 +1 @@
+{"body":{"messages":[{"@type":"/inference.inference.MsgSubmitNewParticipant","creator":"gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp","url":"http://node2.gonka.ai:8000","validator_key":"YHtcky8VaH0qQNhYJkN61RPf83oKWsCPXdaewvDEYLo=","worker_key":""},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp","grantee":"gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgStartInference"},"expiration":"2026-08-22T06:32:32.326916Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp","grantee":"gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgFinishInference"},"expiration":"2026-08-22T06:32:32.326916Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp","grantee":"gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgClaimRewards"},"expiration":"2026-08-22T06:32:32.326916Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp","grantee":"gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgValidation"},"expiration":"2026-08-22T06:32:32.326916Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp","grantee":"gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitPocBatch"},"expiration":"2026-08-22T06:32:32.326916Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp","grantee":"gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitPocValidation"},"expiration":"2026-08-22T06:32:32.326916Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp","grantee":"gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitSeed"},"expiration":"2026-08-22T06:32:32.326916Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp","grantee":"gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgBridgeExchange"},"expiration":"2026-08-22T06:32:32.326916Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp","grantee":"gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitTrainingKvRecord"},"expiration":"2026-08-22T06:32:32.326916Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp","grantee":"gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgJoinTraining"},"expiration":"2026-08-22T06:32:32.326916Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp","grantee":"gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgJoinTrainingStatus"},"expiration":"2026-08-22T06:32:32.326916Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp","grantee":"gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgTrainingHeartbeat"},"expiration":"2026-08-22T06:32:32.326916Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp","grantee":"gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSetBarrier"},"expiration":"2026-08-22T06:32:32.326916Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp","grantee":"gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgClaimTrainingTaskForAssignment"},"expiration":"2026-08-22T06:32:32.326916Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp","grantee":"gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgAssignTrainingTask"},"expiration":"2026-08-22T06:32:32.326916Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp","grantee":"gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitNewUnfundedParticipant"},"expiration":"2026-08-22T06:32:32.326916Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp","grantee":"gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitNewParticipant"},"expiration":"2026-08-22T06:32:32.326916Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp","grantee":"gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitHardwareDiff"},"expiration":"2026-08-22T06:32:32.326916Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp","grantee":"gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgInvalidateInference"},"expiration":"2026-08-22T06:32:32.326916Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp","grantee":"gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgRevalidateInference"},"expiration":"2026-08-22T06:32:32.326916Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp","grantee":"gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitDealerPart"},"expiration":"2026-08-22T06:32:32.326916Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp","grantee":"gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitVerificationVector"},"expiration":"2026-08-22T06:32:32.326916Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp","grantee":"gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgRequestThresholdSignature"},"expiration":"2026-08-22T06:32:32.326916Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp","grantee":"gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitPartialSignature"},"expiration":"2026-08-22T06:32:32.326916Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1dkl4mah5erqggvhqkpc8j3qs5tyuetgdy552cp","grantee":"gonka17t3qfgyddzlucyv7jgvp0pezqcxntutw3rtxy5","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitGroupKeyValidationSignature"},"expiration":"2026-08-22T06:32:32.326916Z"}}],"memo":"","timeout_height":"0","unordered":false,"timeout_timestamp":null,"extension_options":[],"non_critical_extension_options":[]},"auth_info":{"signer_infos":[{"public_key":{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"A9CX2rkp0YxVAvKW2bv4nXEU12UEnw/gHjQND1tPWCoY"},"mode_info":{"single":{"mode":"SIGN_MODE_DIRECT"}},"sequence":"0"}],"fee":{"amount":[],"gas_limit":"200000","payer":"","granter":""},"tip":null},"signatures":["L4uv9VZKlZpMHyBIsZgvIoT0SuSDtNZPkqHuNPk8LklOnDDmYO4YgGlN41PYLilOBDsx/sp9F02WWcSIgFniQg=="]}
diff --git a/genesis/validators/gonka-2/gentx-645fbce2dedcc7166f4df7931d2c87ca5188b569.json b/genesis/validators/gonka-2/gentx-645fbce2dedcc7166f4df7931d2c87ca5188b569.json
new file mode 100644
index 000000000..1dc65bba2
--- /dev/null
+++ b/genesis/validators/gonka-2/gentx-645fbce2dedcc7166f4df7931d2c87ca5188b569.json
@@ -0,0 +1 @@
+{"body":{"messages":[{"@type":"/cosmos.staking.v1beta1.MsgCreateValidator","description":{"moniker":"gonka-2","identity":"","website":"","security_contact":"","details":""},"commission":{"rate":"0.100000000000000000","max_rate":"0.200000000000000000","max_change_rate":"0.010000000000000000"},"min_self_delegation":"1","delegator_address":"","validator_address":"gonkavaloper1dkl4mah5erqggvhqkpc8j3qs5tyuetgdc59d0v","pubkey":{"@type":"/cosmos.crypto.ed25519.PubKey","key":"YHtcky8VaH0qQNhYJkN61RPf83oKWsCPXdaewvDEYLo="},"value":{"denom":"ngonka","amount":"1"}}],"memo":"","timeout_height":"0","unordered":false,"timeout_timestamp":null,"extension_options":[],"non_critical_extension_options":[]},"auth_info":{"signer_infos":[{"public_key":{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"A9CX2rkp0YxVAvKW2bv4nXEU12UEnw/gHjQND1tPWCoY"},"mode_info":{"single":{"mode":"SIGN_MODE_DIRECT"}},"sequence":"0"}],"fee":{"amount":[],"gas_limit":"200000","payer":"","granter":""},"tip":null},"signatures":["AuGp4kCjGBpRqv5VOkAIRZcQWcqST9+D/x7z0n5i0tM2TFo/YaWr8G/Y3ZvoqYr8YxcUIKUM6ASKPV8JbxfZdA=="]}
diff --git a/genesis/validators/gonka-3/README.md b/genesis/validators/gonka-3/README.md
new file mode 100644
index 000000000..e6e334e5e
--- /dev/null
+++ b/genesis/validators/gonka-3/README.md
@@ -0,0 +1,5 @@
+Account Public Key: `A+yokzwLbyIn2jzTirjONexkP36AYMv6RxDXMrbCnJzR`
+Node ID: `6140f7090137d93c272ff5ccd863484d1592949d`
+ML Operational Address: `gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej`
+Consensus Public Key: `FODVOcIY8RNoGA7WsiNSL6YQ8N4/A5Ox1IyXgc/FmE0=`
+P2P_EXTERNAL_ADDRESS: `tcp://node3.gonka.ai:5000`
\ No newline at end of file
diff --git a/genesis/validators/gonka-3/genparticipant-6140f7090137d93c272ff5ccd863484d1592949d.json b/genesis/validators/gonka-3/genparticipant-6140f7090137d93c272ff5ccd863484d1592949d.json
new file mode 100644
index 000000000..1b1bd59c1
--- /dev/null
+++ b/genesis/validators/gonka-3/genparticipant-6140f7090137d93c272ff5ccd863484d1592949d.json
@@ -0,0 +1 @@
+{"body":{"messages":[{"@type":"/inference.inference.MsgSubmitNewParticipant","creator":"gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5","url":"http://node3.gonka.ai:8000","validator_key":"FODVOcIY8RNoGA7WsiNSL6YQ8N4/A5Ox1IyXgc/FmE0=","worker_key":""},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5","grantee":"gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgStartInference"},"expiration":"2026-08-22T06:33:56.649748Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5","grantee":"gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgFinishInference"},"expiration":"2026-08-22T06:33:56.649748Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5","grantee":"gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgClaimRewards"},"expiration":"2026-08-22T06:33:56.649748Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5","grantee":"gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgValidation"},"expiration":"2026-08-22T06:33:56.649748Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5","grantee":"gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitPocBatch"},"expiration":"2026-08-22T06:33:56.649748Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5","grantee":"gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitPocValidation"},"expiration":"2026-08-22T06:33:56.649748Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5","grantee":"gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitSeed"},"expiration":"2026-08-22T06:33:56.649748Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5","grantee":"gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgBridgeExchange"},"expiration":"2026-08-22T06:33:56.649748Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5","grantee":"gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitTrainingKvRecord"},"expiration":"2026-08-22T06:33:56.649748Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5","grantee":"gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgJoinTraining"},"expiration":"2026-08-22T06:33:56.649748Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5","grantee":"gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgJoinTrainingStatus"},"expiration":"2026-08-22T06:33:56.649748Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5","grantee":"gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgTrainingHeartbeat"},"expiration":"2026-08-22T06:33:56.649748Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5","grantee":"gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSetBarrier"},"expiration":"2026-08-22T06:33:56.649748Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5","grantee":"gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgClaimTrainingTaskForAssignment"},"expiration":"2026-08-22T06:33:56.649748Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5","grantee":"gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgAssignTrainingTask"},"expiration":"2026-08-22T06:33:56.649748Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5","grantee":"gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitNewUnfundedParticipant"},"expiration":"2026-08-22T06:33:56.649748Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5","grantee":"gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitNewParticipant"},"expiration":"2026-08-22T06:33:56.649748Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5","grantee":"gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitHardwareDiff"},"expiration":"2026-08-22T06:33:56.649748Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5","grantee":"gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgInvalidateInference"},"expiration":"2026-08-22T06:33:56.649748Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5","grantee":"gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgRevalidateInference"},"expiration":"2026-08-22T06:33:56.649748Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5","grantee":"gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitDealerPart"},"expiration":"2026-08-22T06:33:56.649748Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5","grantee":"gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitVerificationVector"},"expiration":"2026-08-22T06:33:56.649748Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5","grantee":"gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgRequestThresholdSignature"},"expiration":"2026-08-22T06:33:56.649748Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5","grantee":"gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitPartialSignature"},"expiration":"2026-08-22T06:33:56.649748Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1kx9mca3xm8u8ypzfuhmxey66u0ufxhs7nm6wc5","grantee":"gonka1dkfx2wl3d5a8qs85yuh8eymf4qz4n0khf7uyej","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitGroupKeyValidationSignature"},"expiration":"2026-08-22T06:33:56.649748Z"}}],"memo":"","timeout_height":"0","unordered":false,"timeout_timestamp":null,"extension_options":[],"non_critical_extension_options":[]},"auth_info":{"signer_infos":[{"public_key":{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"A+yokzwLbyIn2jzTirjONexkP36AYMv6RxDXMrbCnJzR"},"mode_info":{"single":{"mode":"SIGN_MODE_DIRECT"}},"sequence":"0"}],"fee":{"amount":[],"gas_limit":"200000","payer":"","granter":""},"tip":null},"signatures":["e3RmOI3fOc7Hv1eT+GnG57o5/xliVUx2WVqHElXLi2p1qxxye440+6OXfx9EZLitJalNn840z8KpcnTBtBWehQ=="]}
diff --git a/genesis/validators/gonka-3/gentx-6140f7090137d93c272ff5ccd863484d1592949d.json b/genesis/validators/gonka-3/gentx-6140f7090137d93c272ff5ccd863484d1592949d.json
new file mode 100644
index 000000000..6d7163099
--- /dev/null
+++ b/genesis/validators/gonka-3/gentx-6140f7090137d93c272ff5ccd863484d1592949d.json
@@ -0,0 +1 @@
+{"body":{"messages":[{"@type":"/cosmos.staking.v1beta1.MsgCreateValidator","description":{"moniker":"gonka-3","identity":"","website":"","security_contact":"","details":""},"commission":{"rate":"0.100000000000000000","max_rate":"0.200000000000000000","max_change_rate":"0.010000000000000000"},"min_self_delegation":"1","delegator_address":"","validator_address":"gonkavaloper1kx9mca3xm8u8ypzfuhmxey66u0ufxhs70mtf0e","pubkey":{"@type":"/cosmos.crypto.ed25519.PubKey","key":"FODVOcIY8RNoGA7WsiNSL6YQ8N4/A5Ox1IyXgc/FmE0="},"value":{"denom":"ngonka","amount":"1"}}],"memo":"","timeout_height":"0","unordered":false,"timeout_timestamp":null,"extension_options":[],"non_critical_extension_options":[]},"auth_info":{"signer_infos":[{"public_key":{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"A+yokzwLbyIn2jzTirjONexkP36AYMv6RxDXMrbCnJzR"},"mode_info":{"single":{"mode":"SIGN_MODE_DIRECT"}},"sequence":"0"}],"fee":{"amount":[],"gas_limit":"200000","payer":"","granter":""},"tip":null},"signatures":["WBNogY6fLiWm8KNV3NEQC2GFsHHzJypZiEyozQCmmMoV8uYs0oGtM2OpjLXpy6XfZRhaPx49AcZ6zaEsr/OnNQ=="]}
diff --git a/genesis/validators/gonka-gid-001/README.md b/genesis/validators/gonka-gid-001/README.md
new file mode 100644
index 000000000..ec708b825
--- /dev/null
+++ b/genesis/validators/gonka-gid-001/README.md
@@ -0,0 +1,5 @@
+Account Public Key: `Ar8WnJJJs/wRe8YM7+p50eC9akdOPuqeuRsIfos4W4wR`
+Node ID: `4d63a0411a257669e794ff62f801550a8449d239`
+ML Operational Address: `gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd`
+Consensus Public Key: `WDLSFDAjM9OGUER2hmpFivYbaZiXNl8/+2Vq61Z/dDc=`
+P2P_EXTERNAL_ADDRESS: `tcp://69.19.136.233:5000`
\ No newline at end of file
diff --git a/genesis/validators/gonka-gid-001/genparticipant-4d63a0411a257669e794ff62f801550a8449d239.json b/genesis/validators/gonka-gid-001/genparticipant-4d63a0411a257669e794ff62f801550a8449d239.json
new file mode 100644
index 000000000..0e0fc47dd
--- /dev/null
+++ b/genesis/validators/gonka-gid-001/genparticipant-4d63a0411a257669e794ff62f801550a8449d239.json
@@ -0,0 +1 @@
+{"body":{"messages":[{"@type":"/inference.inference.MsgSubmitNewParticipant","creator":"gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5","url":"http://69.19.136.233:8000","validator_key":"WDLSFDAjM9OGUER2hmpFivYbaZiXNl8/+2Vq61Z/dDc=","worker_key":""},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5","grantee":"gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgStartInference"},"expiration":"2026-08-22T06:35:18.689281Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5","grantee":"gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgFinishInference"},"expiration":"2026-08-22T06:35:18.689281Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5","grantee":"gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgClaimRewards"},"expiration":"2026-08-22T06:35:18.689281Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5","grantee":"gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgValidation"},"expiration":"2026-08-22T06:35:18.689281Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5","grantee":"gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitPocBatch"},"expiration":"2026-08-22T06:35:18.689281Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5","grantee":"gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitPocValidation"},"expiration":"2026-08-22T06:35:18.689281Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5","grantee":"gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitSeed"},"expiration":"2026-08-22T06:35:18.689281Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5","grantee":"gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgBridgeExchange"},"expiration":"2026-08-22T06:35:18.689281Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5","grantee":"gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitTrainingKvRecord"},"expiration":"2026-08-22T06:35:18.689281Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5","grantee":"gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgJoinTraining"},"expiration":"2026-08-22T06:35:18.689281Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5","grantee":"gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgJoinTrainingStatus"},"expiration":"2026-08-22T06:35:18.689281Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5","grantee":"gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgTrainingHeartbeat"},"expiration":"2026-08-22T06:35:18.689281Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5","grantee":"gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSetBarrier"},"expiration":"2026-08-22T06:35:18.689281Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5","grantee":"gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgClaimTrainingTaskForAssignment"},"expiration":"2026-08-22T06:35:18.689281Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5","grantee":"gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgAssignTrainingTask"},"expiration":"2026-08-22T06:35:18.689281Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5","grantee":"gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitNewUnfundedParticipant"},"expiration":"2026-08-22T06:35:18.689281Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5","grantee":"gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitNewParticipant"},"expiration":"2026-08-22T06:35:18.689281Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5","grantee":"gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitHardwareDiff"},"expiration":"2026-08-22T06:35:18.689281Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5","grantee":"gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgInvalidateInference"},"expiration":"2026-08-22T06:35:18.689281Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5","grantee":"gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgRevalidateInference"},"expiration":"2026-08-22T06:35:18.689281Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5","grantee":"gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitDealerPart"},"expiration":"2026-08-22T06:35:18.689281Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5","grantee":"gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitVerificationVector"},"expiration":"2026-08-22T06:35:18.689281Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5","grantee":"gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgRequestThresholdSignature"},"expiration":"2026-08-22T06:35:18.689281Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5","grantee":"gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitPartialSignature"},"expiration":"2026-08-22T06:35:18.689281Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1r90m7wlp95zz92eqltys77xyyqkcmz72rc0kv5","grantee":"gonka1zmuc2sd9s4e47szpwhurjf6xmcuzu2uhjlrttd","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitGroupKeyValidationSignature"},"expiration":"2026-08-22T06:35:18.689281Z"}}],"memo":"","timeout_height":"0","unordered":false,"timeout_timestamp":null,"extension_options":[],"non_critical_extension_options":[]},"auth_info":{"signer_infos":[{"public_key":{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"Ar8WnJJJs/wRe8YM7+p50eC9akdOPuqeuRsIfos4W4wR"},"mode_info":{"single":{"mode":"SIGN_MODE_DIRECT"}},"sequence":"0"}],"fee":{"amount":[],"gas_limit":"200000","payer":"","granter":""},"tip":null},"signatures":["qZPxrg/RMVAo1Oi+3M/30lCRs7CiKyvQvT3Itk4kgmsAKS605I9yXlYTPYuK6D0dZM1Q8gJWTIW5aTKVw2xT1Q=="]}
diff --git a/genesis/validators/gonka-gid-001/gentx-4d63a0411a257669e794ff62f801550a8449d239.json b/genesis/validators/gonka-gid-001/gentx-4d63a0411a257669e794ff62f801550a8449d239.json
new file mode 100644
index 000000000..d5d0193de
--- /dev/null
+++ b/genesis/validators/gonka-gid-001/gentx-4d63a0411a257669e794ff62f801550a8449d239.json
@@ -0,0 +1 @@
+{"body":{"messages":[{"@type":"/cosmos.staking.v1beta1.MsgCreateValidator","description":{"moniker":"gonka-gid-001","identity":"","website":"","security_contact":"","details":""},"commission":{"rate":"0.100000000000000000","max_rate":"0.200000000000000000","max_change_rate":"0.010000000000000000"},"min_self_delegation":"1","delegator_address":"","validator_address":"gonkavaloper1r90m7wlp95zz92eqltys77xyyqkcmz72lc73me","pubkey":{"@type":"/cosmos.crypto.ed25519.PubKey","key":"WDLSFDAjM9OGUER2hmpFivYbaZiXNl8/+2Vq61Z/dDc="},"value":{"denom":"ngonka","amount":"1"}}],"memo":"","timeout_height":"0","unordered":false,"timeout_timestamp":null,"extension_options":[],"non_critical_extension_options":[]},"auth_info":{"signer_infos":[{"public_key":{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"Ar8WnJJJs/wRe8YM7+p50eC9akdOPuqeuRsIfos4W4wR"},"mode_info":{"single":{"mode":"SIGN_MODE_DIRECT"}},"sequence":"0"}],"fee":{"amount":[],"gas_limit":"200000","payer":"","granter":""},"tip":null},"signatures":["QfMnGJ5NKPhH7ubZc0ImJjPwA+DamRFw/I3QWivPQwpmh9N19OltzMgZX9OCWOfDLWc1crVqe/aa+xWRo5xUkQ=="]}
diff --git a/genesis/validators/gonka-hy-001/README.md b/genesis/validators/gonka-hy-001/README.md
new file mode 100644
index 000000000..9a72887c5
--- /dev/null
+++ b/genesis/validators/gonka-hy-001/README.md
@@ -0,0 +1,5 @@
+Account Public Key: `AxbqG2vVhIHEJ375h/B+ei4HiQeboZF6EujXGVvBoLYg`
+Node ID: `78f3279bd30fe6f1b84a9c40c3b97bd74e575981`
+ML Operational Address: `gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt`
+Consensus Public Key: `jFC9XywnI7hzIEQ1kmSQf8Q1iuqy861P7vBrqa3LQxs=`
+P2P_EXTERNAL_ADDRESS: `tcp://185.216.21.98:5000`
\ No newline at end of file
diff --git a/genesis/validators/gonka-hy-001/genparticipant-78f3279bd30fe6f1b84a9c40c3b97bd74e575981.json b/genesis/validators/gonka-hy-001/genparticipant-78f3279bd30fe6f1b84a9c40c3b97bd74e575981.json
new file mode 100644
index 000000000..289b0122c
--- /dev/null
+++ b/genesis/validators/gonka-hy-001/genparticipant-78f3279bd30fe6f1b84a9c40c3b97bd74e575981.json
@@ -0,0 +1 @@
+{"body":{"messages":[{"@type":"/inference.inference.MsgSubmitNewParticipant","creator":"gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk","url":"http://185.216.21.98:8000","validator_key":"jFC9XywnI7hzIEQ1kmSQf8Q1iuqy861P7vBrqa3LQxs=","worker_key":""},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk","grantee":"gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgStartInference"},"expiration":"2026-08-22T06:31:51.491091Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk","grantee":"gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgFinishInference"},"expiration":"2026-08-22T06:31:51.491091Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk","grantee":"gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgClaimRewards"},"expiration":"2026-08-22T06:31:51.491091Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk","grantee":"gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgValidation"},"expiration":"2026-08-22T06:31:51.491091Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk","grantee":"gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitPocBatch"},"expiration":"2026-08-22T06:31:51.491091Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk","grantee":"gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitPocValidation"},"expiration":"2026-08-22T06:31:51.491091Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk","grantee":"gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitSeed"},"expiration":"2026-08-22T06:31:51.491091Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk","grantee":"gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgBridgeExchange"},"expiration":"2026-08-22T06:31:51.491091Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk","grantee":"gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitTrainingKvRecord"},"expiration":"2026-08-22T06:31:51.491091Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk","grantee":"gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgJoinTraining"},"expiration":"2026-08-22T06:31:51.491091Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk","grantee":"gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgJoinTrainingStatus"},"expiration":"2026-08-22T06:31:51.491091Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk","grantee":"gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgTrainingHeartbeat"},"expiration":"2026-08-22T06:31:51.491091Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk","grantee":"gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSetBarrier"},"expiration":"2026-08-22T06:31:51.491091Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk","grantee":"gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgClaimTrainingTaskForAssignment"},"expiration":"2026-08-22T06:31:51.491091Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk","grantee":"gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgAssignTrainingTask"},"expiration":"2026-08-22T06:31:51.491091Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk","grantee":"gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitNewUnfundedParticipant"},"expiration":"2026-08-22T06:31:51.491091Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk","grantee":"gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitNewParticipant"},"expiration":"2026-08-22T06:31:51.491091Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk","grantee":"gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitHardwareDiff"},"expiration":"2026-08-22T06:31:51.491091Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk","grantee":"gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgInvalidateInference"},"expiration":"2026-08-22T06:31:51.491091Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk","grantee":"gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgRevalidateInference"},"expiration":"2026-08-22T06:31:51.491091Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk","grantee":"gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitDealerPart"},"expiration":"2026-08-22T06:31:51.491091Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk","grantee":"gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitVerificationVector"},"expiration":"2026-08-22T06:31:51.491091Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk","grantee":"gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgRequestThresholdSignature"},"expiration":"2026-08-22T06:31:51.491091Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk","grantee":"gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitPartialSignature"},"expiration":"2026-08-22T06:31:51.491091Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1ktl3kkn9l68c9amanu8u4868mcjmtsr5tgzmjk","grantee":"gonka1fcfw2mfw7x803dzr8ss2xldfhvkg22wllr0nyt","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitGroupKeyValidationSignature"},"expiration":"2026-08-22T06:31:51.491091Z"}}],"memo":"","timeout_height":"0","unordered":false,"timeout_timestamp":null,"extension_options":[],"non_critical_extension_options":[]},"auth_info":{"signer_infos":[{"public_key":{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"AxbqG2vVhIHEJ375h/B+ei4HiQeboZF6EujXGVvBoLYg"},"mode_info":{"single":{"mode":"SIGN_MODE_DIRECT"}},"sequence":"0"}],"fee":{"amount":[],"gas_limit":"200000","payer":"","granter":""},"tip":null},"signatures":["HBpSw9aK4cm2+yh2JYvNNBFFFuP+aeAEyCcCgAEK4h0bZ5eUBGpLxGd/34ftOt/5+jZAW0OJMyAmYJHUzcxKfg=="]}
diff --git a/genesis/validators/gonka-hy-001/gentx-78f3279bd30fe6f1b84a9c40c3b97bd74e575981.json b/genesis/validators/gonka-hy-001/gentx-78f3279bd30fe6f1b84a9c40c3b97bd74e575981.json
new file mode 100644
index 000000000..1f312e7df
--- /dev/null
+++ b/genesis/validators/gonka-hy-001/gentx-78f3279bd30fe6f1b84a9c40c3b97bd74e575981.json
@@ -0,0 +1 @@
+{"body":{"messages":[{"@type":"/cosmos.staking.v1beta1.MsgCreateValidator","description":{"moniker":"gonka-hy-001","identity":"","website":"","security_contact":"","details":""},"commission":{"rate":"0.100000000000000000","max_rate":"0.200000000000000000","max_change_rate":"0.010000000000000000"},"min_self_delegation":"1","delegator_address":"","validator_address":"gonkavaloper1ktl3kkn9l68c9amanu8u4868mcjmtsr5hgnu9m","pubkey":{"@type":"/cosmos.crypto.ed25519.PubKey","key":"jFC9XywnI7hzIEQ1kmSQf8Q1iuqy861P7vBrqa3LQxs="},"value":{"denom":"ngonka","amount":"1"}}],"memo":"","timeout_height":"0","unordered":false,"timeout_timestamp":null,"extension_options":[],"non_critical_extension_options":[]},"auth_info":{"signer_infos":[{"public_key":{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"AxbqG2vVhIHEJ375h/B+ei4HiQeboZF6EujXGVvBoLYg"},"mode_info":{"single":{"mode":"SIGN_MODE_DIRECT"}},"sequence":"0"}],"fee":{"amount":[],"gas_limit":"200000","payer":"","granter":""},"tip":null},"signatures":["ZrDl/LG3aQwylhd/8Z5MamhDUt5h+3kT+BWLCGXet75iKZeMsmy5IE2TdLPmKLtdK1OFw3t2fN1P6bRIJ4QOVw=="]}
diff --git a/genesis/validators/node-201081/README.md b/genesis/validators/node-201081/README.md
new file mode 100644
index 000000000..1b407f905
--- /dev/null
+++ b/genesis/validators/node-201081/README.md
@@ -0,0 +1,5 @@
+Account Public Key: `AxNmIzNd3iKvSzHcLXVNVsg5+N7sL0Nh0DAgozogvH28`
+Node ID: `947a89a2d5f2af45cb7853f56be0bab8303ffce9`
+ML Operational Address: `gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d`
+Consensus Public Key: `BUWZfCeWI3O+UXcmCbnjacmi0RY0PzX/8aJKdy3rP48=`
+P2P_EXTERNAL_ADDRESS: `tcp://36.189.234.197:18027`
diff --git a/genesis/validators/node-201081/genparticipant-947a89a2d5f2af45cb7853f56be0bab8303ffce9.json b/genesis/validators/node-201081/genparticipant-947a89a2d5f2af45cb7853f56be0bab8303ffce9.json
new file mode 100644
index 000000000..a54307ddd
--- /dev/null
+++ b/genesis/validators/node-201081/genparticipant-947a89a2d5f2af45cb7853f56be0bab8303ffce9.json
@@ -0,0 +1 @@
+{"body":{"messages":[{"@type":"/inference.inference.MsgSubmitNewParticipant","creator":"gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq","url":"http://36.189.234.197:18026","validator_key":"BUWZfCeWI3O+UXcmCbnjacmi0RY0PzX/8aJKdy3rP48=","worker_key":""},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq","grantee":"gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgStartInference"},"expiration":"2026-08-22T06:56:11.338930474Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq","grantee":"gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgFinishInference"},"expiration":"2026-08-22T06:56:11.338930474Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq","grantee":"gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgClaimRewards"},"expiration":"2026-08-22T06:56:11.338930474Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq","grantee":"gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgValidation"},"expiration":"2026-08-22T06:56:11.338930474Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq","grantee":"gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitPocBatch"},"expiration":"2026-08-22T06:56:11.338930474Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq","grantee":"gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitPocValidation"},"expiration":"2026-08-22T06:56:11.338930474Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq","grantee":"gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitSeed"},"expiration":"2026-08-22T06:56:11.338930474Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq","grantee":"gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgBridgeExchange"},"expiration":"2026-08-22T06:56:11.338930474Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq","grantee":"gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitTrainingKvRecord"},"expiration":"2026-08-22T06:56:11.338930474Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq","grantee":"gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgJoinTraining"},"expiration":"2026-08-22T06:56:11.338930474Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq","grantee":"gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgJoinTrainingStatus"},"expiration":"2026-08-22T06:56:11.338930474Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq","grantee":"gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgTrainingHeartbeat"},"expiration":"2026-08-22T06:56:11.338930474Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq","grantee":"gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSetBarrier"},"expiration":"2026-08-22T06:56:11.338930474Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq","grantee":"gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgClaimTrainingTaskForAssignment"},"expiration":"2026-08-22T06:56:11.338930474Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq","grantee":"gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgAssignTrainingTask"},"expiration":"2026-08-22T06:56:11.338930474Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq","grantee":"gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitNewUnfundedParticipant"},"expiration":"2026-08-22T06:56:11.338930474Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq","grantee":"gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitNewParticipant"},"expiration":"2026-08-22T06:56:11.338930474Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq","grantee":"gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitHardwareDiff"},"expiration":"2026-08-22T06:56:11.338930474Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq","grantee":"gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgInvalidateInference"},"expiration":"2026-08-22T06:56:11.338930474Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq","grantee":"gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgRevalidateInference"},"expiration":"2026-08-22T06:56:11.338930474Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq","grantee":"gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitDealerPart"},"expiration":"2026-08-22T06:56:11.338930474Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq","grantee":"gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitVerificationVector"},"expiration":"2026-08-22T06:56:11.338930474Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq","grantee":"gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgRequestThresholdSignature"},"expiration":"2026-08-22T06:56:11.338930474Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq","grantee":"gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitPartialSignature"},"expiration":"2026-08-22T06:56:11.338930474Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka15p7s7w2hx0y8095lddd4ummm2y0kwpwljk00aq","grantee":"gonka1s2xr5m98696099cplagcalpcjt4mkr79n6764d","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitGroupKeyValidationSignature"},"expiration":"2026-08-22T06:56:11.338930474Z"}}],"memo":"","timeout_height":"0","unordered":false,"timeout_timestamp":null,"extension_options":[],"non_critical_extension_options":[]},"auth_info":{"signer_infos":[{"public_key":{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"AxNmIzNd3iKvSzHcLXVNVsg5+N7sL0Nh0DAgozogvH28"},"mode_info":{"single":{"mode":"SIGN_MODE_DIRECT"}},"sequence":"0"}],"fee":{"amount":[],"gas_limit":"200000","payer":"","granter":""},"tip":null},"signatures":["ExfTHuMuvOVpl1LYWAIblhRooZGrOXAupZci31kgSa0aIHsz+oj9vLErpRYX2ZfgjNS/E0NyeVpEHxYsIWzbBA=="]}
diff --git a/genesis/validators/node-201081/gentx-947a89a2d5f2af45cb7853f56be0bab8303ffce9.json b/genesis/validators/node-201081/gentx-947a89a2d5f2af45cb7853f56be0bab8303ffce9.json
new file mode 100644
index 000000000..276426064
--- /dev/null
+++ b/genesis/validators/node-201081/gentx-947a89a2d5f2af45cb7853f56be0bab8303ffce9.json
@@ -0,0 +1 @@
+{"body":{"messages":[{"@type":"/cosmos.staking.v1beta1.MsgCreateValidator","description":{"moniker":"node-201081","identity":"","website":"","security_contact":"","details":""},"commission":{"rate":"0.100000000000000000","max_rate":"0.200000000000000000","max_change_rate":"0.010000000000000000"},"min_self_delegation":"1","delegator_address":"","validator_address":"gonkavaloper15p7s7w2hx0y8095lddd4ummm2y0kwpwlwk7g2d","pubkey":{"@type":"/cosmos.crypto.ed25519.PubKey","key":"BUWZfCeWI3O+UXcmCbnjacmi0RY0PzX/8aJKdy3rP48="},"value":{"denom":"ngonka","amount":"1"}}],"memo":"","timeout_height":"0","unordered":false,"timeout_timestamp":null,"extension_options":[],"non_critical_extension_options":[]},"auth_info":{"signer_infos":[{"public_key":{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"AxNmIzNd3iKvSzHcLXVNVsg5+N7sL0Nh0DAgozogvH28"},"mode_info":{"single":{"mode":"SIGN_MODE_DIRECT"}},"sequence":"0"}],"fee":{"amount":[],"gas_limit":"200000","payer":"","granter":""},"tip":null},"signatures":["HVuMF7qaSsUMKKsAnG7DXpqKNs8t/WSgIO8ebRdZEkxAKvdyn4e1/d7JWIDrkgA1CHsyGoVEd5YPt66Wvvj/fw=="]}
diff --git a/genesis/validators/node-6ali-01/README.md b/genesis/validators/node-6ali-01/README.md
new file mode 100644
index 000000000..b47db2094
--- /dev/null
+++ b/genesis/validators/node-6ali-01/README.md
@@ -0,0 +1,5 @@
+Account Public Key: `A1uX2Pz8eBXxc/m3VXOglAv/UTo/YvkDA1hAqL4rUUyp`
+Node ID: `39ebfea6d2ab91e90c26cb702345cfa2f9bc611b`
+ML Operational Address: `gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs`
+Consensus Public Key: `5QYFI0kdyBPrcld3FfOwoZdynfwN5li0qUbg3zwFK4I=`
+P2P_EXTERNAL_ADDRESS: `tcp://47.236.26.199:5000`
diff --git a/genesis/validators/node-6ali-01/genparticipant-39ebfea6d2ab91e90c26cb702345cfa2f9bc611b.json b/genesis/validators/node-6ali-01/genparticipant-39ebfea6d2ab91e90c26cb702345cfa2f9bc611b.json
new file mode 100644
index 000000000..9c3e704db
--- /dev/null
+++ b/genesis/validators/node-6ali-01/genparticipant-39ebfea6d2ab91e90c26cb702345cfa2f9bc611b.json
@@ -0,0 +1 @@
+{"body":{"messages":[{"@type":"/inference.inference.MsgSubmitNewParticipant","creator":"gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p","url":"http://47.236.26.199:8000","validator_key":"5QYFI0kdyBPrcld3FfOwoZdynfwN5li0qUbg3zwFK4I=","worker_key":""},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p","grantee":"gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgStartInference"},"expiration":"2026-08-22T06:57:49.230081892Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p","grantee":"gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgFinishInference"},"expiration":"2026-08-22T06:57:49.230081892Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p","grantee":"gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgClaimRewards"},"expiration":"2026-08-22T06:57:49.230081892Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p","grantee":"gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgValidation"},"expiration":"2026-08-22T06:57:49.230081892Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p","grantee":"gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitPocBatch"},"expiration":"2026-08-22T06:57:49.230081892Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p","grantee":"gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitPocValidation"},"expiration":"2026-08-22T06:57:49.230081892Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p","grantee":"gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitSeed"},"expiration":"2026-08-22T06:57:49.230081892Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p","grantee":"gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgBridgeExchange"},"expiration":"2026-08-22T06:57:49.230081892Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p","grantee":"gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitTrainingKvRecord"},"expiration":"2026-08-22T06:57:49.230081892Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p","grantee":"gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgJoinTraining"},"expiration":"2026-08-22T06:57:49.230081892Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p","grantee":"gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgJoinTrainingStatus"},"expiration":"2026-08-22T06:57:49.230081892Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p","grantee":"gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgTrainingHeartbeat"},"expiration":"2026-08-22T06:57:49.230081892Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p","grantee":"gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSetBarrier"},"expiration":"2026-08-22T06:57:49.230081892Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p","grantee":"gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgClaimTrainingTaskForAssignment"},"expiration":"2026-08-22T06:57:49.230081892Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p","grantee":"gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgAssignTrainingTask"},"expiration":"2026-08-22T06:57:49.230081892Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p","grantee":"gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitNewUnfundedParticipant"},"expiration":"2026-08-22T06:57:49.230081892Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p","grantee":"gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitNewParticipant"},"expiration":"2026-08-22T06:57:49.230081892Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p","grantee":"gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitHardwareDiff"},"expiration":"2026-08-22T06:57:49.230081892Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p","grantee":"gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgInvalidateInference"},"expiration":"2026-08-22T06:57:49.230081892Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p","grantee":"gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgRevalidateInference"},"expiration":"2026-08-22T06:57:49.230081892Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p","grantee":"gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitDealerPart"},"expiration":"2026-08-22T06:57:49.230081892Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p","grantee":"gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitVerificationVector"},"expiration":"2026-08-22T06:57:49.230081892Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p","grantee":"gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgRequestThresholdSignature"},"expiration":"2026-08-22T06:57:49.230081892Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p","grantee":"gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitPartialSignature"},"expiration":"2026-08-22T06:57:49.230081892Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgv9h82p","grantee":"gonka1rpxwqfv42uysslavpeudh8p855nv80pmnj6sxs","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitGroupKeyValidationSignature"},"expiration":"2026-08-22T06:57:49.230081892Z"}}],"memo":"","timeout_height":"0","unordered":false,"timeout_timestamp":null,"extension_options":[],"non_critical_extension_options":[]},"auth_info":{"signer_infos":[{"public_key":{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"A1uX2Pz8eBXxc/m3VXOglAv/UTo/YvkDA1hAqL4rUUyp"},"mode_info":{"single":{"mode":"SIGN_MODE_DIRECT"}},"sequence":"0"}],"fee":{"amount":[],"gas_limit":"200000","payer":"","granter":""},"tip":null},"signatures":["8DYglTTEx4ZR1riNgb6+tZhGDyGN2cY1yJSrCaianhAFhUr+ruA2qrtmDahFfFSN/3y/lLE71Yvnx4lalZaoSg=="]}
diff --git a/genesis/validators/node-6ali-01/gentx-39ebfea6d2ab91e90c26cb702345cfa2f9bc611b.json b/genesis/validators/node-6ali-01/gentx-39ebfea6d2ab91e90c26cb702345cfa2f9bc611b.json
new file mode 100644
index 000000000..53e04d814
--- /dev/null
+++ b/genesis/validators/node-6ali-01/gentx-39ebfea6d2ab91e90c26cb702345cfa2f9bc611b.json
@@ -0,0 +1 @@
+{"body":{"messages":[{"@type":"/cosmos.staking.v1beta1.MsgCreateValidator","description":{"moniker":"node-6ali-01","identity":"","website":"","security_contact":"","details":""},"commission":{"rate":"0.100000000000000000","max_rate":"0.200000000000000000","max_change_rate":"0.010000000000000000"},"min_self_delegation":"1","delegator_address":"","validator_address":"gonkavaloper1d7p03cu2y2yt3vytq9wlfm6tlz0lfhlgs9xqav","pubkey":{"@type":"/cosmos.crypto.ed25519.PubKey","key":"5QYFI0kdyBPrcld3FfOwoZdynfwN5li0qUbg3zwFK4I="},"value":{"denom":"ngonka","amount":"1"}}],"memo":"","timeout_height":"0","unordered":false,"timeout_timestamp":null,"extension_options":[],"non_critical_extension_options":[]},"auth_info":{"signer_infos":[{"public_key":{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"A1uX2Pz8eBXxc/m3VXOglAv/UTo/YvkDA1hAqL4rUUyp"},"mode_info":{"single":{"mode":"SIGN_MODE_DIRECT"}},"sequence":"0"}],"fee":{"amount":[],"gas_limit":"200000","payer":"","granter":""},"tip":null},"signatures":["4O/GI5Q3lFDGH5Fn5RIlX1gbnQyffl4Rx9RPKOfnq9w2Jt0c/bu90184fsOj5uhllBiMhPX4RJnY94b8SYsSag=="]}
diff --git a/genesis/validators/node-6ali-02/README.md b/genesis/validators/node-6ali-02/README.md
new file mode 100644
index 000000000..8cf45fe0c
--- /dev/null
+++ b/genesis/validators/node-6ali-02/README.md
@@ -0,0 +1,5 @@
+Account Public Key: `ApNB0x1fYdt0m1eUwiMgJjMfsuiUMlu+TqkiSO2S73iC`
+Node ID: `d53a970a40231474fb4092ee64609b975d906085`
+ML Operational Address: `gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z`
+Consensus Public Key: `LLqBxOz+vD3p7sQsdEhBfrFH2QFMjy3fMasB9yBGSqs=`
+P2P_EXTERNAL_ADDRESS: `tcp://47.236.19.22:15000`
diff --git a/genesis/validators/node-6ali-02/genparticipant-d53a970a40231474fb4092ee64609b975d906085.json b/genesis/validators/node-6ali-02/genparticipant-d53a970a40231474fb4092ee64609b975d906085.json
new file mode 100644
index 000000000..fbecba065
--- /dev/null
+++ b/genesis/validators/node-6ali-02/genparticipant-d53a970a40231474fb4092ee64609b975d906085.json
@@ -0,0 +1 @@
+{"body":{"messages":[{"@type":"/inference.inference.MsgSubmitNewParticipant","creator":"gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m","url":"http://47.236.19.22:18000","validator_key":"LLqBxOz+vD3p7sQsdEhBfrFH2QFMjy3fMasB9yBGSqs=","worker_key":""},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m","grantee":"gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgStartInference"},"expiration":"2026-08-22T06:59:50.169638492Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m","grantee":"gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgFinishInference"},"expiration":"2026-08-22T06:59:50.169638492Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m","grantee":"gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgClaimRewards"},"expiration":"2026-08-22T06:59:50.169638492Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m","grantee":"gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgValidation"},"expiration":"2026-08-22T06:59:50.169638492Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m","grantee":"gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitPocBatch"},"expiration":"2026-08-22T06:59:50.169638492Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m","grantee":"gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitPocValidation"},"expiration":"2026-08-22T06:59:50.169638492Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m","grantee":"gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitSeed"},"expiration":"2026-08-22T06:59:50.169638492Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m","grantee":"gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgBridgeExchange"},"expiration":"2026-08-22T06:59:50.169638492Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m","grantee":"gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitTrainingKvRecord"},"expiration":"2026-08-22T06:59:50.169638492Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m","grantee":"gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgJoinTraining"},"expiration":"2026-08-22T06:59:50.169638492Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m","grantee":"gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgJoinTrainingStatus"},"expiration":"2026-08-22T06:59:50.169638492Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m","grantee":"gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgTrainingHeartbeat"},"expiration":"2026-08-22T06:59:50.169638492Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m","grantee":"gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSetBarrier"},"expiration":"2026-08-22T06:59:50.169638492Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m","grantee":"gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgClaimTrainingTaskForAssignment"},"expiration":"2026-08-22T06:59:50.169638492Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m","grantee":"gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgAssignTrainingTask"},"expiration":"2026-08-22T06:59:50.169638492Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m","grantee":"gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitNewUnfundedParticipant"},"expiration":"2026-08-22T06:59:50.169638492Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m","grantee":"gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitNewParticipant"},"expiration":"2026-08-22T06:59:50.169638492Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m","grantee":"gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitHardwareDiff"},"expiration":"2026-08-22T06:59:50.169638492Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m","grantee":"gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgInvalidateInference"},"expiration":"2026-08-22T06:59:50.169638492Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m","grantee":"gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgRevalidateInference"},"expiration":"2026-08-22T06:59:50.169638492Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m","grantee":"gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitDealerPart"},"expiration":"2026-08-22T06:59:50.169638492Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m","grantee":"gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitVerificationVector"},"expiration":"2026-08-22T06:59:50.169638492Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m","grantee":"gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgRequestThresholdSignature"},"expiration":"2026-08-22T06:59:50.169638492Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m","grantee":"gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitPartialSignature"},"expiration":"2026-08-22T06:59:50.169638492Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1p2lhgng7tcqju7emk989s5fpdr7k2c3ek6h26m","grantee":"gonka1f9ky6gznukjd9k29k3wq9d0yc6uv6sfhg9xr4z","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitGroupKeyValidationSignature"},"expiration":"2026-08-22T06:59:50.169638492Z"}}],"memo":"","timeout_height":"0","unordered":false,"timeout_timestamp":null,"extension_options":[],"non_critical_extension_options":[]},"auth_info":{"signer_infos":[{"public_key":{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"ApNB0x1fYdt0m1eUwiMgJjMfsuiUMlu+TqkiSO2S73iC"},"mode_info":{"single":{"mode":"SIGN_MODE_DIRECT"}},"sequence":"0"}],"fee":{"amount":[],"gas_limit":"200000","payer":"","granter":""},"tip":null},"signatures":["F2V/tG5KFRk/BYknljxeU/an2zqk+kpmWHWbV6pUXrFFzULpyP4BXXnE4y85XfVq6iZ37N1iG07HtXUtUtvfXQ=="]}
diff --git a/genesis/validators/node-6ali-02/gentx-d53a970a40231474fb4092ee64609b975d906085.json b/genesis/validators/node-6ali-02/gentx-d53a970a40231474fb4092ee64609b975d906085.json
new file mode 100644
index 000000000..75d5f6620
--- /dev/null
+++ b/genesis/validators/node-6ali-02/gentx-d53a970a40231474fb4092ee64609b975d906085.json
@@ -0,0 +1 @@
+{"body":{"messages":[{"@type":"/cosmos.staking.v1beta1.MsgCreateValidator","description":{"moniker":"node-6ali-02","identity":"","website":"","security_contact":"","details":""},"commission":{"rate":"0.100000000000000000","max_rate":"0.200000000000000000","max_change_rate":"0.010000000000000000"},"min_self_delegation":"1","delegator_address":"","validator_address":"gonkavaloper1p2lhgng7tcqju7emk989s5fpdr7k2c3e26xddk","pubkey":{"@type":"/cosmos.crypto.ed25519.PubKey","key":"LLqBxOz+vD3p7sQsdEhBfrFH2QFMjy3fMasB9yBGSqs="},"value":{"denom":"ngonka","amount":"1"}}],"memo":"","timeout_height":"0","unordered":false,"timeout_timestamp":null,"extension_options":[],"non_critical_extension_options":[]},"auth_info":{"signer_infos":[{"public_key":{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"ApNB0x1fYdt0m1eUwiMgJjMfsuiUMlu+TqkiSO2S73iC"},"mode_info":{"single":{"mode":"SIGN_MODE_DIRECT"}},"sequence":"0"}],"fee":{"amount":[],"gas_limit":"200000","payer":"","granter":""},"tip":null},"signatures":["3x+0Ok78uDwhKtTFWjszcv4sYiJzTvXbPj1grJcQDeU7lv041ocAMuUWOuh1/RZX7AZKXPznpE1xYldDPYVx6w=="]}
diff --git a/genesis/validators/node-710122/README.md b/genesis/validators/node-710122/README.md
new file mode 100644
index 000000000..7773f679b
--- /dev/null
+++ b/genesis/validators/node-710122/README.md
@@ -0,0 +1,5 @@
+Account Public Key: `AuTi5Ju0Qh5ITZFyxLxnvi69jG5j6+/rEtypPo/jilCj`
+Node ID: `b4ad5a33520ce10d0b7ed5193e2de71e2f1f7a51`
+ML Operational Address: `gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc`
+Consensus Public Key: `2ykmApZ4pfSMfoREBUDu/vImEYlOym8ymVWOw2wcMQo=`
+P2P_EXTERNAL_ADDRESS: `tcp://36.189.234.237:17240`
diff --git a/genesis/validators/node-710122/genparticipant-b4ad5a33520ce10d0b7ed5193e2de71e2f1f7a51.json b/genesis/validators/node-710122/genparticipant-b4ad5a33520ce10d0b7ed5193e2de71e2f1f7a51.json
new file mode 100644
index 000000000..a1d3183f2
--- /dev/null
+++ b/genesis/validators/node-710122/genparticipant-b4ad5a33520ce10d0b7ed5193e2de71e2f1f7a51.json
@@ -0,0 +1 @@
+{"body":{"messages":[{"@type":"/inference.inference.MsgSubmitNewParticipant","creator":"gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje","url":"http://36.189.234.237:17241","validator_key":"2ykmApZ4pfSMfoREBUDu/vImEYlOym8ymVWOw2wcMQo=","worker_key":""},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje","grantee":"gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgStartInference"},"expiration":"2026-08-22T06:51:05.361604158Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje","grantee":"gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgFinishInference"},"expiration":"2026-08-22T06:51:05.361604158Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje","grantee":"gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgClaimRewards"},"expiration":"2026-08-22T06:51:05.361604158Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje","grantee":"gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgValidation"},"expiration":"2026-08-22T06:51:05.361604158Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje","grantee":"gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitPocBatch"},"expiration":"2026-08-22T06:51:05.361604158Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje","grantee":"gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitPocValidation"},"expiration":"2026-08-22T06:51:05.361604158Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje","grantee":"gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitSeed"},"expiration":"2026-08-22T06:51:05.361604158Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje","grantee":"gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgBridgeExchange"},"expiration":"2026-08-22T06:51:05.361604158Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje","grantee":"gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitTrainingKvRecord"},"expiration":"2026-08-22T06:51:05.361604158Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje","grantee":"gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgJoinTraining"},"expiration":"2026-08-22T06:51:05.361604158Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje","grantee":"gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgJoinTrainingStatus"},"expiration":"2026-08-22T06:51:05.361604158Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje","grantee":"gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgTrainingHeartbeat"},"expiration":"2026-08-22T06:51:05.361604158Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje","grantee":"gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSetBarrier"},"expiration":"2026-08-22T06:51:05.361604158Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje","grantee":"gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgClaimTrainingTaskForAssignment"},"expiration":"2026-08-22T06:51:05.361604158Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje","grantee":"gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgAssignTrainingTask"},"expiration":"2026-08-22T06:51:05.361604158Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje","grantee":"gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitNewUnfundedParticipant"},"expiration":"2026-08-22T06:51:05.361604158Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje","grantee":"gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitNewParticipant"},"expiration":"2026-08-22T06:51:05.361604158Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje","grantee":"gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitHardwareDiff"},"expiration":"2026-08-22T06:51:05.361604158Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje","grantee":"gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgInvalidateInference"},"expiration":"2026-08-22T06:51:05.361604158Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje","grantee":"gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgRevalidateInference"},"expiration":"2026-08-22T06:51:05.361604158Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje","grantee":"gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitDealerPart"},"expiration":"2026-08-22T06:51:05.361604158Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje","grantee":"gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitVerificationVector"},"expiration":"2026-08-22T06:51:05.361604158Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje","grantee":"gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgRequestThresholdSignature"},"expiration":"2026-08-22T06:51:05.361604158Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje","grantee":"gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitPartialSignature"},"expiration":"2026-08-22T06:51:05.361604158Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka1vhprg9epy683xghp8ddtdlw2y9cycecmm64tje","grantee":"gonka1qpnut0ta7dj4ll3g2x0jxmdh26uc7ws5zqnpzc","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitGroupKeyValidationSignature"},"expiration":"2026-08-22T06:51:05.361604158Z"}}],"memo":"","timeout_height":"0","unordered":false,"timeout_timestamp":null,"extension_options":[],"non_critical_extension_options":[]},"auth_info":{"signer_infos":[{"public_key":{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"AuTi5Ju0Qh5ITZFyxLxnvi69jG5j6+/rEtypPo/jilCj"},"mode_info":{"single":{"mode":"SIGN_MODE_DIRECT"}},"sequence":"0"}],"fee":{"amount":[],"gas_limit":"200000","payer":"","granter":""},"tip":null},"signatures":["7PDoB/DZmDO3NIBkLhg4SatlRQPmC9jfuhAmKEAlLK1yZ8fSEsF7kFZheNCGH7tx4hwe/9Hehim8rt4BLqkrqQ=="]}
diff --git a/genesis/validators/node-710122/gentx-b4ad5a33520ce10d0b7ed5193e2de71e2f1f7a51.json b/genesis/validators/node-710122/gentx-b4ad5a33520ce10d0b7ed5193e2de71e2f1f7a51.json
new file mode 100644
index 000000000..2f157c043
--- /dev/null
+++ b/genesis/validators/node-710122/gentx-b4ad5a33520ce10d0b7ed5193e2de71e2f1f7a51.json
@@ -0,0 +1 @@
+{"body":{"messages":[{"@type":"/cosmos.staking.v1beta1.MsgCreateValidator","description":{"moniker":"node-710122","identity":"","website":"","security_contact":"","details":""},"commission":{"rate":"0.100000000000000000","max_rate":"0.200000000000000000","max_change_rate":"0.010000000000000000"},"min_self_delegation":"1","delegator_address":"","validator_address":"gonkavaloper1vhprg9epy683xghp8ddtdlw2y9cycecm86yv95","pubkey":{"@type":"/cosmos.crypto.ed25519.PubKey","key":"2ykmApZ4pfSMfoREBUDu/vImEYlOym8ymVWOw2wcMQo="},"value":{"denom":"ngonka","amount":"1"}}],"memo":"","timeout_height":"0","unordered":false,"timeout_timestamp":null,"extension_options":[],"non_critical_extension_options":[]},"auth_info":{"signer_infos":[{"public_key":{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"AuTi5Ju0Qh5ITZFyxLxnvi69jG5j6+/rEtypPo/jilCj"},"mode_info":{"single":{"mode":"SIGN_MODE_DIRECT"}},"sequence":"0"}],"fee":{"amount":[],"gas_limit":"200000","payer":"","granter":""},"tip":null},"signatures":["odw4zBxs5YtqjxMvcKJWSMlni9QnaRt3YuDigvC77EwEqZI9S7eX2tvMuE6ztMSFX46gOEsTVEO19GazkJgINg=="]}
diff --git a/genesis/validators/spvre/README.md b/genesis/validators/spvre/README.md
new file mode 100644
index 000000000..dcbabe4bc
--- /dev/null
+++ b/genesis/validators/spvre/README.md
@@ -0,0 +1,5 @@
+Account Public Key: `Auz6M2noPEepwz55meXHhx3hNGpjIglMiBXXXkQ+yOV9`
+Node ID: `780e60b5defca577a160590e0bf51c6bb916d2c6`
+ML Operational Address: `gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t`
+Consensus Public Key: `pM9MGrvN6zoLAuA6SKndq2GT/AY8b9tr8PodsnmV4Bk=`
+P2P_EXTERNAL_ADDRESS: `tcp://gonka.spv.re:5000`
\ No newline at end of file
diff --git a/genesis/validators/spvre/genparticipant-780e60b5defca577a160590e0bf51c6bb916d2c6.json b/genesis/validators/spvre/genparticipant-780e60b5defca577a160590e0bf51c6bb916d2c6.json
new file mode 100644
index 000000000..9cedfd63f
--- /dev/null
+++ b/genesis/validators/spvre/genparticipant-780e60b5defca577a160590e0bf51c6bb916d2c6.json
@@ -0,0 +1 @@
+{"body":{"messages":[{"@type":"/inference.inference.MsgSubmitNewParticipant","creator":"gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6","url":"http://gonka.spv.re:8000","validator_key":"pM9MGrvN6zoLAuA6SKndq2GT/AY8b9tr8PodsnmV4Bk=","worker_key":""},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6","grantee":"gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgStartInference"},"expiration":"2026-08-22T06:28:04.044351Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6","grantee":"gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgFinishInference"},"expiration":"2026-08-22T06:28:04.044351Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6","grantee":"gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgClaimRewards"},"expiration":"2026-08-22T06:28:04.044351Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6","grantee":"gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgValidation"},"expiration":"2026-08-22T06:28:04.044351Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6","grantee":"gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitPocBatch"},"expiration":"2026-08-22T06:28:04.044351Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6","grantee":"gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitPocValidation"},"expiration":"2026-08-22T06:28:04.044351Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6","grantee":"gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitSeed"},"expiration":"2026-08-22T06:28:04.044351Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6","grantee":"gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgBridgeExchange"},"expiration":"2026-08-22T06:28:04.044351Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6","grantee":"gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitTrainingKvRecord"},"expiration":"2026-08-22T06:28:04.044351Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6","grantee":"gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgJoinTraining"},"expiration":"2026-08-22T06:28:04.044351Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6","grantee":"gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgJoinTrainingStatus"},"expiration":"2026-08-22T06:28:04.044351Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6","grantee":"gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgTrainingHeartbeat"},"expiration":"2026-08-22T06:28:04.044351Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6","grantee":"gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSetBarrier"},"expiration":"2026-08-22T06:28:04.044351Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6","grantee":"gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgClaimTrainingTaskForAssignment"},"expiration":"2026-08-22T06:28:04.044351Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6","grantee":"gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgAssignTrainingTask"},"expiration":"2026-08-22T06:28:04.044351Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6","grantee":"gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitNewUnfundedParticipant"},"expiration":"2026-08-22T06:28:04.044351Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6","grantee":"gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitNewParticipant"},"expiration":"2026-08-22T06:28:04.044351Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6","grantee":"gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgSubmitHardwareDiff"},"expiration":"2026-08-22T06:28:04.044351Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6","grantee":"gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgInvalidateInference"},"expiration":"2026-08-22T06:28:04.044351Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6","grantee":"gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.inference.MsgRevalidateInference"},"expiration":"2026-08-22T06:28:04.044351Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6","grantee":"gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitDealerPart"},"expiration":"2026-08-22T06:28:04.044351Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6","grantee":"gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitVerificationVector"},"expiration":"2026-08-22T06:28:04.044351Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6","grantee":"gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgRequestThresholdSignature"},"expiration":"2026-08-22T06:28:04.044351Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6","grantee":"gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitPartialSignature"},"expiration":"2026-08-22T06:28:04.044351Z"}},{"@type":"/cosmos.authz.v1beta1.MsgGrant","granter":"gonka19fpma3577v3fnk8nxjkvg442ss8hvglxwqgzz6","grantee":"gonka1pe7uukfqzgkce8g2hlczzh4zug9wt7mdffhk8t","grant":{"authorization":{"@type":"/cosmos.authz.v1beta1.GenericAuthorization","msg":"/inference.bls.MsgSubmitGroupKeyValidationSignature"},"expiration":"2026-08-22T06:28:04.044351Z"}}],"memo":"","timeout_height":"0","unordered":false,"timeout_timestamp":null,"extension_options":[],"non_critical_extension_options":[]},"auth_info":{"signer_infos":[{"public_key":{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"Auz6M2noPEepwz55meXHhx3hNGpjIglMiBXXXkQ+yOV9"},"mode_info":{"single":{"mode":"SIGN_MODE_DIRECT"}},"sequence":"0"}],"fee":{"amount":[],"gas_limit":"200000","payer":"","granter":""},"tip":null},"signatures":["iKLqlX/gtE4NK4fpgmvpDQbylD0yxPFwWP/6TFugAk9Fn0BI8qjXjt0x0fVX5xH6yVFpvxEV5ttqANWkTIvNMA=="]}
diff --git a/genesis/validators/spvre/gentx-780e60b5defca577a160590e0bf51c6bb916d2c6.json b/genesis/validators/spvre/gentx-780e60b5defca577a160590e0bf51c6bb916d2c6.json
new file mode 100644
index 000000000..f9acaf8ad
--- /dev/null
+++ b/genesis/validators/spvre/gentx-780e60b5defca577a160590e0bf51c6bb916d2c6.json
@@ -0,0 +1 @@
+{"body":{"messages":[{"@type":"/cosmos.staking.v1beta1.MsgCreateValidator","description":{"moniker":"spvre","identity":"","website":"","security_contact":"","details":""},"commission":{"rate":"0.100000000000000000","max_rate":"0.200000000000000000","max_change_rate":"0.010000000000000000"},"min_self_delegation":"1","delegator_address":"","validator_address":"gonkavaloper19fpma3577v3fnk8nxjkvg442ss8hvglxjqe94h","pubkey":{"@type":"/cosmos.crypto.ed25519.PubKey","key":"pM9MGrvN6zoLAuA6SKndq2GT/AY8b9tr8PodsnmV4Bk="},"value":{"denom":"ngonka","amount":"1"}}],"memo":"","timeout_height":"0","unordered":false,"timeout_timestamp":null,"extension_options":[],"non_critical_extension_options":[]},"auth_info":{"signer_infos":[{"public_key":{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"Auz6M2noPEepwz55meXHhx3hNGpjIglMiBXXXkQ+yOV9"},"mode_info":{"single":{"mode":"SIGN_MODE_DIRECT"}},"sequence":"0"}],"fee":{"amount":[],"gas_limit":"200000","payer":"","granter":""},"tip":null},"signatures":["2yGlYQV9TAT31CUHCZ4qBQsTt158Ha9g49rRX/2XnF0H2q27fuV5QLSwXE8tYeN0HThIE+3/BaNTLMPC0zIuHw=="]}
diff --git a/genesis/validators/template/README.md b/genesis/validators/template/README.md
new file mode 100644
index 000000000..3d70c8bd7
--- /dev/null
+++ b/genesis/validators/template/README.md
@@ -0,0 +1,5 @@
+Account Public Key:
+Node ID:
+ML Operational Address:
+Consensus Public Key:
+P2P_EXTERNAL_ADDRESS:
\ No newline at end of file
diff --git a/inference-chain/Dockerfile b/inference-chain/Dockerfile
new file mode 100644
index 000000000..ede2f755d
--- /dev/null
+++ b/inference-chain/Dockerfile
@@ -0,0 +1,113 @@
+# syntax=docker/dockerfile:1.4
+
+################################################################################
+# Build stage
+################################################################################
+FROM golang:1.23.2-alpine3.20 AS builder
+
+ARG GOOS=linux
+ARG GOARCH=amd64
+
+ENV GOOS=${GOOS} \
+ GOARCH=${GOARCH} \
+ CGO_ENABLED=1 \
+ GO111MODULE=on \
+ GOCACHE=/root/.cache/go-build \
+ GOMODCACHE=/go/pkg/mod \
+ CGO_CFLAGS="-I/lib" \
+ CGO_LDFLAGS="-L/lib" \
+ # Override the wasmvm library path to use our musl version
+ LD_LIBRARY_PATH=/lib
+
+RUN apk add --no-cache make gcc musl-dev git patchelf
+
+# Use the musl libc version of wasmvm and create a symlink for the linker
+RUN if [ "$GOARCH" = "arm64" ]; then \
+ wget -O /lib/libwasmvm_muslc.aarch64.a https://github.com/CosmWasm/wasmvm/releases/download/v2.2.4/libwasmvm_muslc.aarch64.a \
+ && echo "27fb13821dbc519119f4f98c30a42cb32429b111b0fdc883686c34a41777488f /lib/libwasmvm_muslc.aarch64.a" | sha256sum -c \
+ && ln -s /lib/libwasmvm_muslc.aarch64.a /lib/libwasmvm_muslc.a \
+ && rm -f /go/pkg/mod/github.com/\!cosm\!wasm/wasmvm@v2.2.4/internal/api/libwasmvm.aarch64.so; \
+ else \
+ wget -O /lib/libwasmvm_muslc.x86_64.a https://github.com/CosmWasm/wasmvm/releases/download/v2.2.4/libwasmvm_muslc.x86_64.a \
+ && echo "70c989684d2b48ca17bbd55bb694bbb136d75c393c067ef3bdbca31d2b23b578 /lib/libwasmvm_muslc.x86_64.a" | sha256sum -c \
+ && ln -s /lib/libwasmvm_muslc.x86_64.a /lib/libwasmvm_muslc.a \
+ && rm -f /go/pkg/mod/github.com/\!cosm\!wasm/wasmvm@v2.2.4/internal/api/libwasmvm.x86_64.so; \
+ fi
+
+COPY inference-chain/contracts/wrapped-token/artifacts/wrapped_token.wasm /root/wrapped_token.wasm
+
+WORKDIR /app/inference-chain
+
+COPY inference-chain/go.mod inference-chain/go.sum ./
+
+RUN --mount=type=cache,id=go-build-cache,target=/root/.cache/go-build \
+ --mount=type=cache,id=go-mod-cache,target=/go/pkg/mod \
+ CGO_ENABLED=1 CC=gcc \
+ go mod download
+
+COPY inference-chain/. .
+
+ARG LDFLAGS
+ARG TAGS=""
+RUN --mount=type=cache,id=go-build-cache,target=/root/.cache/go-build \
+ --mount=type=cache,id=go-mod-cache,target=/go/pkg/mod \
+ CGO_ENABLED=1 CC=gcc \
+ go build -mod=readonly -tags="muslc ${TAGS}" -ldflags "${LDFLAGS}" \
+ -o ./build/inferenced \
+ ./cmd/inferenced/main.go \
+ && patchelf --set-rpath '$ORIGIN:$ORIGIN/current:/root/.inference/cosmovisor/current' ./build/inferenced
+RUN mkdir /build_output
+
+################################################################################
+# Binary Exporter stage (for --output optimization)
+################################################################################
+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 /root/wrapped_token.wasm /build_output/wrapped_token.wasm
+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
+
+ARG GOOS
+ARG GOARCH
+
+RUN apk update && \
+ apk add --no-cache sed ca-certificates gcc musl-dev && \
+ rm -rf /var/cache/apk/*
+RUN apk update && apk add --no-cache jq
+
+ARG GENESIS_OVERRIDES_FILE=inference-chain/prod_genesis_overrides.json
+
+WORKDIR /root
+
+ENV DAEMON_HOME=/root/.inference
+ENV DAEMON_NAME=inferenced
+ENV DAEMON_ALLOW_DOWNLOAD_BINARIES=true
+ENV DAEMON_RESTART_AFTER_UPGRADE=true
+ENV DAEMON_DOWNLOAD_RETRIES=-1
+
+COPY --from=builder /app/inference-chain/build/inferenced /usr/bin/inferenced
+COPY inference-chain/scripts/init-docker-genesis.sh /root/init-docker-genesis.sh
+COPY inference-chain/scripts/init-docker.sh /root/init-docker.sh
+COPY inference-chain/scripts/reset-state.sh /root/reset-state.sh
+COPY inference-chain/contracts /root/contracts
+COPY inference-chain/tgbot_private_key.json /root/tgbot_private_key.json
+COPY inference-chain/app_overrides.toml /root/app_overrides.toml
+COPY ./cosmovisor/v1.7.2/${GOOS}-${GOARCH}/cosmovisor /usr/bin/cosmovisor
+COPY inference-chain/denom.json /root/denom.json
+COPY $GENESIS_OVERRIDES_FILE /root/genesis_overrides.json
+COPY --from=builder /lib/libwasmvm_muslc.*.a /lib/
+COPY --from=builder /root/wrapped_token.wasm /root/wrapped_token.wasm
+
+RUN chmod +x /root/init-docker.sh /root/init-docker-genesis.sh \
+ && find /root/contracts -type f -name "*.sh" -exec chmod +x {} +
+
+EXPOSE 26656 26657 1317 9090
+
+CMD ["sh", "./init-docker.sh"]
\ No newline at end of file
diff --git a/inference-chain/Makefile b/inference-chain/Makefile
new file mode 100644
index 000000000..8e15c505b
--- /dev/null
+++ b/inference-chain/Makefile
@@ -0,0 +1,285 @@
+.PHONY: all install build build-docker init clean-state mock-expected-keepers docker-push release build-all package deploy
+
+BRANCH := $(shell git rev-parse --abbrev-ref HEAD)
+COMMIT := $(shell git log -1 --format='%H')
+
+VERSION ?= $(shell git describe --always)
+SET_LATEST ?= 0
+SET_LATEST := $(shell if [ "$(SET_LATEST)" = "1" ]; then echo 1; else echo 0; fi)
+
+ldflags = \
+ -X github.com/cosmos/cosmos-sdk/version.Name=inference-chain \
+ -X github.com/cosmos/cosmos-sdk/version.AppName=inferenced \
+ -X github.com/cosmos/cosmos-sdk/version.Version=$(VERSION) \
+ -X github.com/cosmos/cosmos-sdk/version.Commit=$(COMMIT)
+
+GENESIS_OVERRIDES_FILE ?= inference-chain/prod_genesis_overrides.json
+TESTS ?= 0
+TESTS := $(shell if [ "$(TESTS)" = "1" ]; then echo 1; else echo 0; fi)
+
+# wasmvm static library URLs
+WASMVM_VERSION := v2.2.4
+WASMVM_STATIC_DARWIN_URL := https://github.com/CosmWasm/wasmvm/releases/download/$(WASMVM_VERSION)/libwasmvmstatic_darwin.a
+WASMVM_STATIC_LINUX_X64_URL := https://github.com/CosmWasm/wasmvm/releases/download/$(WASMVM_VERSION)/libwasmvm_muslc.x86_64.a
+WASMVM_STATIC_LINUX_ARM64_URL := https://github.com/CosmWasm/wasmvm/releases/download/$(WASMVM_VERSION)/libwasmvm_muslc.aarch64.a
+
+install:
+ @echo "Installing locally with ldflags..."
+ @go install -ldflags "$(ldflags)" -mod=readonly ./cmd/inferenced/main.go
+
+_build-macos:
+ @echo "Building macOS binary with static wasmvm library..."
+ @echo "Downloading static wasmvm library for macOS..."
+ @mkdir -p /tmp/wasmvm-static
+ @curl -L -o /tmp/wasmvm-static/libwasmvm.a $(WASMVM_STATIC_DARWIN_URL)
+ @echo "Building with static wasmvm library..."
+ @CGO_ENABLED=1 CC=gcc \
+ CGO_LDFLAGS="-L/tmp/wasmvm-static -lwasmvm" \
+ go build -ldflags "$(ldflags)" -tags "sys_wasmvm" -o ./build/inferenced ./cmd/inferenced/main.go
+ @echo "Running codesign for macOS..."
+ @codesign --remove-signature ./build/inferenced || true
+ @codesign --force --sign - ./build/inferenced || true
+ @echo "Cleaning up..."
+ @rm -rf /tmp/wasmvm-static
+
+_build-linux:
+ @echo "Building with static wasmvm linking for Linux..."
+ @CGO_ENABLED=1 CC=gcc \
+ go build -ldflags "$(ldflags) -extldflags '-static'" -tags "muslc" -o ./build/inferenced ./cmd/inferenced/main.go
+
+build:
+ @if [ "$(shell uname)" = "Darwin" ]; then \
+ $(MAKE) _build-macos; \
+ else \
+ $(MAKE) _build-linux; \
+ fi
+
+define DOCKER_BUILD
+ @echo "--> building inferenced docker image"
+ @echo "platform: $(PLATFORM)"
+ @echo "GOARCH: $(GOARCH)"
+ @echo "LDFLAGS: $(ldflags)"
+ @echo "GOOS: $(GOOS)"
+ @echo "GENESIS_OVERRIDES_FILE: $(GENESIS_OVERRIDES_FILE)"
+
+
+ @echo "Creating minimal build context..."
+ @rm -rf .docker-context && mkdir -p .docker-context/inference-chain
+ @cp -r * .docker-context/inference-chain/ 2>/dev/null || true
+ @cp -r .[^.]* .docker-context/inference-chain/ 2>/dev/null || true
+ @mkdir -p .docker-context/cosmovisor && cp -r ../cosmovisor/* .docker-context/cosmovisor/
+ @DOCKER_BUILDKIT=1 \
+ docker build \
+ --load \
+ --platform $(PLATFORM) \
+ --build-arg LDFLAGS='$(ldflags)' \
+ --build-arg GOOS=$(GOOS) \
+ --build-arg GOARCH=$(GOARCH) \
+ --build-arg GENESIS_OVERRIDES_FILE=$(GENESIS_OVERRIDES_FILE) \
+ -f $(DOCKER_FILE) \
+ .docker-context \
+ -t $(DOCKER_TAG)
+ @rm -rf .docker-context
+endef
+
+define DOCKER_BUILD_UPGRADE
+ @echo "--> building inferenced docker image"
+ @echo "platform: $(PLATFORM)"
+ @echo "GOARCH: $(GOARCH)"
+ @echo "LDFLAGS: $(ldflags)"
+ @echo "GOOS: $(GOOS)"
+ @echo "TAGS: $(if $(filter 1,$(TESTS)),upgraded,not set)"
+
+ @echo "Creating minimal build context for upgrade..."
+ @rm -rf .docker-context && mkdir -p .docker-context/inference-chain
+ @cp -r * .docker-context/inference-chain/ 2>/dev/null || true
+ @cp -r .[^.]* .docker-context/inference-chain/ 2>/dev/null || true
+ @mkdir -p .docker-context/cosmovisor && cp -r ../cosmovisor/* .docker-context/cosmovisor/
+ @DOCKER_BUILDKIT=1 \
+ docker build \
+ --platform $(PLATFORM) \
+ --build-arg LDFLAGS='$(ldflags)' \
+ --build-arg GOOS=$(GOOS) \
+ --build-arg GOARCH=$(GOARCH) \
+ $(if $(filter 1,$(TESTS)),--build-arg TAGS='upgraded',) \
+ --target binary-exporter \
+ -f $(DOCKER_FILE) \
+ --output type=local,dest=./output \
+ .docker-context
+ @rm -rf .docker-context
+endef
+
+build-docker:
+ rm -rf build/
+ $(eval PLATFORM=linux/amd64)
+ $(eval GOOS=linux)
+ $(eval GOARCH=amd64)
+ $(eval DOCKER_FILE=Dockerfile)
+ $(eval DOCKER_TAG=ghcr.io/product-science/inferenced:$(VERSION))
+ $(eval GENESIS_OVERRIDES_FILE=$(GENESIS_OVERRIDES_FILE))
+ $(DOCKER_BUILD)
+ @if [ "$(SET_LATEST)" = "1" ]; then \
+ echo "Setting latest tag..."; \
+ docker tag $(DOCKER_TAG) ghcr.io/product-science/inferenced:latest; \
+ fi
+
+
+clean-state:
+ rm -rf "$(HOME)/.inference"
+
+docker-push:
+ @echo "pushing to GitHub Container Registry"
+ @docker push ghcr.io/product-science/inferenced:$(VERSION)
+
+ @if [ "$(SET_LATEST)" = "1" ]; then \
+ @echo "Setting latest tag..."; \
+ @docker tag ghcr.io/product-science/inferenced:$(VERSION) ghcr.io/product-science/inferenced:latest; \
+ @echo "Pushing latest tag to GitHub Container Registry"; \
+ @docker push ghcr.io/product-science/inferenced:latest; \
+ 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/*
+ @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"
+ # 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
+ @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"
+
+#################################################
+# CROSS-COMPILATION SECTION
+#################################################
+
+PLATFORMS := linux darwin windows
+ARCHS := amd64 arm64
+
+release: build-docker
+
+build-all:
+ @echo "Building all platforms/architectures..."
+ @echo "Building native Darwin binaries..."
+ @$(MAKE) --no-print-directory build-darwin-amd64 build-darwin-arm64
+ @echo "Building Linux binaries via Docker..."
+ @$(MAKE) --no-print-directory build-linux-docker
+ @echo "Note: Windows builds require additional setup. Use build-windows-docker if needed."
+ @echo "All builds complete."
+
+build-windows-docker:
+ @echo "Building Windows binary using Docker (amd64 only)..."
+ @mkdir -p build/windows/amd64
+ @docker run --rm --platform linux/amd64 \
+ -v "$(PWD)":/workspace \
+ -w /workspace \
+ golang:1.23-bullseye \
+ bash -c '\
+ echo "Installing mingw-w64..." && \
+ apt-get update -qq && apt-get install -y -qq gcc-mingw-w64 && \
+ echo "Building windows/amd64..." && \
+ CGO_ENABLED=1 CC=x86_64-w64-mingw32-gcc GOOS=windows GOARCH=amd64 go build -ldflags "$(ldflags)" -o build/windows/amd64/inferenced.exe ./cmd/inferenced/main.go && \
+ echo "Windows build complete!"'
+
+build-linux-docker:
+ @echo "Building Linux binaries using Docker..."
+ @mkdir -p build/linux/amd64 build/linux/arm64
+ @echo "Building linux/amd64..."
+ @docker run --rm --platform linux/amd64 \
+ -v "$(PWD)":/workspace \
+ -w /workspace \
+ golang:1.23-alpine \
+ sh -c '\
+ echo "Installing dependencies..." && \
+ apk add --no-cache gcc musl-dev curl && \
+ echo "Downloading Go modules..." && \
+ go mod download && \
+ echo "Downloading static wasmvm library for amd64..." && \
+ mkdir -p /lib/wasmvm-static && \
+ curl -L -o /lib/wasmvm-static/libwasmvm_muslc.x86_64.a $(WASMVM_STATIC_LINUX_X64_URL) && \
+ ln -sf /lib/wasmvm-static/libwasmvm_muslc.x86_64.a /lib/libwasmvm_muslc.a && \
+ echo "Building static linux/amd64..." && \
+ CGO_ENABLED=1 CC=gcc CGO_LDFLAGS="-L/lib/wasmvm-static" GOOS=linux GOARCH=amd64 \
+ go build -ldflags "$(ldflags) -extldflags '\''-static'\''" -tags "muslc" -o build/linux/amd64/inferenced ./cmd/inferenced/main.go'
+ @echo "Building linux/arm64..."
+ @docker run --rm --platform linux/arm64 \
+ -v "$(PWD)":/workspace \
+ -w /workspace \
+ golang:1.23-alpine \
+ sh -c '\
+ echo "Installing dependencies..." && \
+ apk add --no-cache gcc musl-dev curl && \
+ echo "Downloading Go modules..." && \
+ go mod download && \
+ echo "Downloading static wasmvm library for arm64..." && \
+ mkdir -p /lib/wasmvm-static && \
+ curl -L -o /lib/wasmvm-static/libwasmvm_muslc.aarch64.a $(WASMVM_STATIC_LINUX_ARM64_URL) && \
+ ln -sf /lib/wasmvm-static/libwasmvm_muslc.aarch64.a /lib/libwasmvm_muslc.a && \
+ echo "Building static linux/arm64..." && \
+ CGO_ENABLED=1 CC=gcc CGO_LDFLAGS="-L/lib/wasmvm-static" GOOS=linux GOARCH=arm64 \
+ go build -ldflags "$(ldflags) -extldflags '\''-static'\''" -tags "muslc" -o build/linux/arm64/inferenced ./cmd/inferenced/main.go'
+ @echo "Static Linux builds complete!"
+
+
+build-%:
+ $(eval OS := $(word 1,$(subst -, ,$*)))
+ $(eval ARCH := $(word 2,$(subst -, ,$*)))
+
+ @echo "Building binary for OS: $(OS), ARCH: $(ARCH)"
+ @mkdir -p build/$(OS)/$(ARCH)
+ @if [ "$(OS)" = "$(shell go env GOOS)" ]; then \
+ echo "Building for $(OS)/$(ARCH) with static wasmvm..."; \
+ if [ "$(OS)" = "darwin" ]; then \
+ echo "Setting up static wasmvm for macOS..."; \
+ mkdir -p /tmp/wasmvm-static-$(OS)-$(ARCH); \
+ curl -L -o /tmp/wasmvm-static-$(OS)-$(ARCH)/libwasmvm.a $(WASMVM_STATIC_DARWIN_URL); \
+ CGO_ENABLED=1 CC=gcc GOOS=$(OS) GOARCH=$(ARCH) \
+ CGO_LDFLAGS="-L/tmp/wasmvm-static-$(OS)-$(ARCH) -lwasmvm" \
+ go build -ldflags "$(ldflags)" -tags "sys_wasmvm" -o build/$(OS)/$(ARCH)/inferenced ./cmd/inferenced/main.go; \
+ rm -rf /tmp/wasmvm-static-$(OS)-$(ARCH); \
+ codesign --remove-signature build/$(OS)/$(ARCH)/inferenced || true; \
+ codesign --force --sign - build/$(OS)/$(ARCH)/inferenced || true; \
+ else \
+ echo "Building static for Linux..."; \
+ CGO_ENABLED=1 CC=gcc GOOS=$(OS) GOARCH=$(ARCH) \
+ go build -ldflags "$(ldflags) -extldflags '-static'" -tags "muslc" -o build/$(OS)/$(ARCH)/inferenced ./cmd/inferenced/main.go; \
+ fi; \
+ else \
+ echo "Cross-compilation for $(OS)/$(ARCH) requires Docker build..."; \
+ echo "Use 'make build-all-docker' for cross-compilation"; \
+ mkdir -p build/$(OS)/$(ARCH) && touch build/$(OS)/$(ARCH)/.skipped; \
+ fi
+
+package:
+ @echo "Packaging binaries..."
+ @mkdir -p release
+ @for os in $(PLATFORMS); do \
+ for arch in $(ARCHS); do \
+ if [ -f build/$$os/$$arch/inferenced ] && [ ! -f build/$$os/$$arch/.skipped ]; then \
+ echo "Packaging $$os/$$arch..."; \
+ zip -j release/inferenced-$$os-$$arch.zip build/$$os/$$arch/inferenced; \
+ else \
+ echo "Skipping $$os/$$arch (no binary found)"; \
+ fi; \
+ done; \
+ done
+
+mock-expected-keepers:
+ @mockgen -source=x/inference/types/expected_keepers.go \
+ -package keeper \
+ -destination=testutil/keeper/expected_keepers_mocks.go
diff --git a/inference-chain/api/inference/bls/events.pulsar.go b/inference-chain/api/inference/bls/events.pulsar.go
new file mode 100644
index 000000000..69ddda2a3
--- /dev/null
+++ b/inference-chain/api/inference/bls/events.pulsar.go
@@ -0,0 +1,7066 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package bls
+
+import (
+ _ "cosmossdk.io/api/amino"
+ fmt "fmt"
+ _ "github.com/cosmos/cosmos-proto"
+ runtime "github.com/cosmos/cosmos-proto/runtime"
+ _ "github.com/cosmos/gogoproto/gogoproto"
+ 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 _ protoreflect.List = (*_EventKeyGenerationInitiated_4_list)(nil)
+
+type _EventKeyGenerationInitiated_4_list struct {
+ list *[]*BLSParticipantInfo
+}
+
+func (x *_EventKeyGenerationInitiated_4_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_EventKeyGenerationInitiated_4_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_EventKeyGenerationInitiated_4_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*BLSParticipantInfo)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_EventKeyGenerationInitiated_4_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*BLSParticipantInfo)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_EventKeyGenerationInitiated_4_list) AppendMutable() protoreflect.Value {
+ v := new(BLSParticipantInfo)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_EventKeyGenerationInitiated_4_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_EventKeyGenerationInitiated_4_list) NewElement() protoreflect.Value {
+ v := new(BLSParticipantInfo)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_EventKeyGenerationInitiated_4_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_EventKeyGenerationInitiated protoreflect.MessageDescriptor
+ fd_EventKeyGenerationInitiated_epoch_id protoreflect.FieldDescriptor
+ fd_EventKeyGenerationInitiated_i_total_slots protoreflect.FieldDescriptor
+ fd_EventKeyGenerationInitiated_t_slots_degree protoreflect.FieldDescriptor
+ fd_EventKeyGenerationInitiated_participants protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bls_events_proto_init()
+ md_EventKeyGenerationInitiated = File_inference_bls_events_proto.Messages().ByName("EventKeyGenerationInitiated")
+ fd_EventKeyGenerationInitiated_epoch_id = md_EventKeyGenerationInitiated.Fields().ByName("epoch_id")
+ fd_EventKeyGenerationInitiated_i_total_slots = md_EventKeyGenerationInitiated.Fields().ByName("i_total_slots")
+ fd_EventKeyGenerationInitiated_t_slots_degree = md_EventKeyGenerationInitiated.Fields().ByName("t_slots_degree")
+ fd_EventKeyGenerationInitiated_participants = md_EventKeyGenerationInitiated.Fields().ByName("participants")
+}
+
+var _ protoreflect.Message = (*fastReflection_EventKeyGenerationInitiated)(nil)
+
+type fastReflection_EventKeyGenerationInitiated EventKeyGenerationInitiated
+
+func (x *EventKeyGenerationInitiated) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_EventKeyGenerationInitiated)(x)
+}
+
+func (x *EventKeyGenerationInitiated) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_events_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_EventKeyGenerationInitiated_messageType fastReflection_EventKeyGenerationInitiated_messageType
+var _ protoreflect.MessageType = fastReflection_EventKeyGenerationInitiated_messageType{}
+
+type fastReflection_EventKeyGenerationInitiated_messageType struct{}
+
+func (x fastReflection_EventKeyGenerationInitiated_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_EventKeyGenerationInitiated)(nil)
+}
+func (x fastReflection_EventKeyGenerationInitiated_messageType) New() protoreflect.Message {
+ return new(fastReflection_EventKeyGenerationInitiated)
+}
+func (x fastReflection_EventKeyGenerationInitiated_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_EventKeyGenerationInitiated
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_EventKeyGenerationInitiated) Descriptor() protoreflect.MessageDescriptor {
+ return md_EventKeyGenerationInitiated
+}
+
+// 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_EventKeyGenerationInitiated) Type() protoreflect.MessageType {
+ return _fastReflection_EventKeyGenerationInitiated_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_EventKeyGenerationInitiated) New() protoreflect.Message {
+ return new(fastReflection_EventKeyGenerationInitiated)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_EventKeyGenerationInitiated) Interface() protoreflect.ProtoMessage {
+ return (*EventKeyGenerationInitiated)(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_EventKeyGenerationInitiated) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.EpochId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.EpochId)
+ if !f(fd_EventKeyGenerationInitiated_epoch_id, value) {
+ return
+ }
+ }
+ if x.ITotalSlots != uint32(0) {
+ value := protoreflect.ValueOfUint32(x.ITotalSlots)
+ if !f(fd_EventKeyGenerationInitiated_i_total_slots, value) {
+ return
+ }
+ }
+ if x.TSlotsDegree != uint32(0) {
+ value := protoreflect.ValueOfUint32(x.TSlotsDegree)
+ if !f(fd_EventKeyGenerationInitiated_t_slots_degree, value) {
+ return
+ }
+ }
+ if len(x.Participants) != 0 {
+ value := protoreflect.ValueOfList(&_EventKeyGenerationInitiated_4_list{list: &x.Participants})
+ if !f(fd_EventKeyGenerationInitiated_participants, 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_EventKeyGenerationInitiated) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bls.EventKeyGenerationInitiated.epoch_id":
+ return x.EpochId != uint64(0)
+ case "inference.bls.EventKeyGenerationInitiated.i_total_slots":
+ return x.ITotalSlots != uint32(0)
+ case "inference.bls.EventKeyGenerationInitiated.t_slots_degree":
+ return x.TSlotsDegree != uint32(0)
+ case "inference.bls.EventKeyGenerationInitiated.participants":
+ return len(x.Participants) != 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventKeyGenerationInitiated"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventKeyGenerationInitiated 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_EventKeyGenerationInitiated) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bls.EventKeyGenerationInitiated.epoch_id":
+ x.EpochId = uint64(0)
+ case "inference.bls.EventKeyGenerationInitiated.i_total_slots":
+ x.ITotalSlots = uint32(0)
+ case "inference.bls.EventKeyGenerationInitiated.t_slots_degree":
+ x.TSlotsDegree = uint32(0)
+ case "inference.bls.EventKeyGenerationInitiated.participants":
+ x.Participants = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventKeyGenerationInitiated"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventKeyGenerationInitiated 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_EventKeyGenerationInitiated) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bls.EventKeyGenerationInitiated.epoch_id":
+ value := x.EpochId
+ return protoreflect.ValueOfUint64(value)
+ case "inference.bls.EventKeyGenerationInitiated.i_total_slots":
+ value := x.ITotalSlots
+ return protoreflect.ValueOfUint32(value)
+ case "inference.bls.EventKeyGenerationInitiated.t_slots_degree":
+ value := x.TSlotsDegree
+ return protoreflect.ValueOfUint32(value)
+ case "inference.bls.EventKeyGenerationInitiated.participants":
+ if len(x.Participants) == 0 {
+ return protoreflect.ValueOfList(&_EventKeyGenerationInitiated_4_list{})
+ }
+ listValue := &_EventKeyGenerationInitiated_4_list{list: &x.Participants}
+ return protoreflect.ValueOfList(listValue)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventKeyGenerationInitiated"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventKeyGenerationInitiated 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_EventKeyGenerationInitiated) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bls.EventKeyGenerationInitiated.epoch_id":
+ x.EpochId = value.Uint()
+ case "inference.bls.EventKeyGenerationInitiated.i_total_slots":
+ x.ITotalSlots = uint32(value.Uint())
+ case "inference.bls.EventKeyGenerationInitiated.t_slots_degree":
+ x.TSlotsDegree = uint32(value.Uint())
+ case "inference.bls.EventKeyGenerationInitiated.participants":
+ lv := value.List()
+ clv := lv.(*_EventKeyGenerationInitiated_4_list)
+ x.Participants = *clv.list
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventKeyGenerationInitiated"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventKeyGenerationInitiated 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_EventKeyGenerationInitiated) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.EventKeyGenerationInitiated.participants":
+ if x.Participants == nil {
+ x.Participants = []*BLSParticipantInfo{}
+ }
+ value := &_EventKeyGenerationInitiated_4_list{list: &x.Participants}
+ return protoreflect.ValueOfList(value)
+ case "inference.bls.EventKeyGenerationInitiated.epoch_id":
+ panic(fmt.Errorf("field epoch_id of message inference.bls.EventKeyGenerationInitiated is not mutable"))
+ case "inference.bls.EventKeyGenerationInitiated.i_total_slots":
+ panic(fmt.Errorf("field i_total_slots of message inference.bls.EventKeyGenerationInitiated is not mutable"))
+ case "inference.bls.EventKeyGenerationInitiated.t_slots_degree":
+ panic(fmt.Errorf("field t_slots_degree of message inference.bls.EventKeyGenerationInitiated is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventKeyGenerationInitiated"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventKeyGenerationInitiated 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_EventKeyGenerationInitiated) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.EventKeyGenerationInitiated.epoch_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.bls.EventKeyGenerationInitiated.i_total_slots":
+ return protoreflect.ValueOfUint32(uint32(0))
+ case "inference.bls.EventKeyGenerationInitiated.t_slots_degree":
+ return protoreflect.ValueOfUint32(uint32(0))
+ case "inference.bls.EventKeyGenerationInitiated.participants":
+ list := []*BLSParticipantInfo{}
+ return protoreflect.ValueOfList(&_EventKeyGenerationInitiated_4_list{list: &list})
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventKeyGenerationInitiated"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventKeyGenerationInitiated 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_EventKeyGenerationInitiated) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.EventKeyGenerationInitiated", 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_EventKeyGenerationInitiated) 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_EventKeyGenerationInitiated) 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_EventKeyGenerationInitiated) 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_EventKeyGenerationInitiated) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*EventKeyGenerationInitiated)
+ 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.EpochId != 0 {
+ n += 1 + runtime.Sov(uint64(x.EpochId))
+ }
+ if x.ITotalSlots != 0 {
+ n += 1 + runtime.Sov(uint64(x.ITotalSlots))
+ }
+ if x.TSlotsDegree != 0 {
+ n += 1 + runtime.Sov(uint64(x.TSlotsDegree))
+ }
+ if len(x.Participants) > 0 {
+ for _, e := range x.Participants {
+ 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().(*EventKeyGenerationInitiated)
+ 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.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] = 0x22
+ }
+ }
+ if x.TSlotsDegree != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.TSlotsDegree))
+ i--
+ dAtA[i] = 0x18
+ }
+ if x.ITotalSlots != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.ITotalSlots))
+ i--
+ dAtA[i] = 0x10
+ }
+ 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...)
+ } 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().(*EventKeyGenerationInitiated)
+ 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: EventKeyGenerationInitiated: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: EventKeyGenerationInitiated: 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 != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ITotalSlots", wireType)
+ }
+ x.ITotalSlots = 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.ITotalSlots |= uint32(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 TSlotsDegree", wireType)
+ }
+ x.TSlotsDegree = 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.TSlotsDegree |= 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 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, &BLSParticipantInfo{})
+ 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
+ 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_EventDealerPartSubmitted protoreflect.MessageDescriptor
+ fd_EventDealerPartSubmitted_epoch_id protoreflect.FieldDescriptor
+ fd_EventDealerPartSubmitted_dealer_address protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bls_events_proto_init()
+ md_EventDealerPartSubmitted = File_inference_bls_events_proto.Messages().ByName("EventDealerPartSubmitted")
+ fd_EventDealerPartSubmitted_epoch_id = md_EventDealerPartSubmitted.Fields().ByName("epoch_id")
+ fd_EventDealerPartSubmitted_dealer_address = md_EventDealerPartSubmitted.Fields().ByName("dealer_address")
+}
+
+var _ protoreflect.Message = (*fastReflection_EventDealerPartSubmitted)(nil)
+
+type fastReflection_EventDealerPartSubmitted EventDealerPartSubmitted
+
+func (x *EventDealerPartSubmitted) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_EventDealerPartSubmitted)(x)
+}
+
+func (x *EventDealerPartSubmitted) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_events_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_EventDealerPartSubmitted_messageType fastReflection_EventDealerPartSubmitted_messageType
+var _ protoreflect.MessageType = fastReflection_EventDealerPartSubmitted_messageType{}
+
+type fastReflection_EventDealerPartSubmitted_messageType struct{}
+
+func (x fastReflection_EventDealerPartSubmitted_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_EventDealerPartSubmitted)(nil)
+}
+func (x fastReflection_EventDealerPartSubmitted_messageType) New() protoreflect.Message {
+ return new(fastReflection_EventDealerPartSubmitted)
+}
+func (x fastReflection_EventDealerPartSubmitted_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_EventDealerPartSubmitted
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_EventDealerPartSubmitted) Descriptor() protoreflect.MessageDescriptor {
+ return md_EventDealerPartSubmitted
+}
+
+// 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_EventDealerPartSubmitted) Type() protoreflect.MessageType {
+ return _fastReflection_EventDealerPartSubmitted_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_EventDealerPartSubmitted) New() protoreflect.Message {
+ return new(fastReflection_EventDealerPartSubmitted)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_EventDealerPartSubmitted) Interface() protoreflect.ProtoMessage {
+ return (*EventDealerPartSubmitted)(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_EventDealerPartSubmitted) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.EpochId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.EpochId)
+ if !f(fd_EventDealerPartSubmitted_epoch_id, value) {
+ return
+ }
+ }
+ if x.DealerAddress != "" {
+ value := protoreflect.ValueOfString(x.DealerAddress)
+ if !f(fd_EventDealerPartSubmitted_dealer_address, 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_EventDealerPartSubmitted) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bls.EventDealerPartSubmitted.epoch_id":
+ return x.EpochId != uint64(0)
+ case "inference.bls.EventDealerPartSubmitted.dealer_address":
+ return x.DealerAddress != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventDealerPartSubmitted"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventDealerPartSubmitted 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_EventDealerPartSubmitted) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bls.EventDealerPartSubmitted.epoch_id":
+ x.EpochId = uint64(0)
+ case "inference.bls.EventDealerPartSubmitted.dealer_address":
+ x.DealerAddress = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventDealerPartSubmitted"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventDealerPartSubmitted 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_EventDealerPartSubmitted) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bls.EventDealerPartSubmitted.epoch_id":
+ value := x.EpochId
+ return protoreflect.ValueOfUint64(value)
+ case "inference.bls.EventDealerPartSubmitted.dealer_address":
+ value := x.DealerAddress
+ return protoreflect.ValueOfString(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventDealerPartSubmitted"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventDealerPartSubmitted 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_EventDealerPartSubmitted) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bls.EventDealerPartSubmitted.epoch_id":
+ x.EpochId = value.Uint()
+ case "inference.bls.EventDealerPartSubmitted.dealer_address":
+ x.DealerAddress = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventDealerPartSubmitted"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventDealerPartSubmitted 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_EventDealerPartSubmitted) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.EventDealerPartSubmitted.epoch_id":
+ panic(fmt.Errorf("field epoch_id of message inference.bls.EventDealerPartSubmitted is not mutable"))
+ case "inference.bls.EventDealerPartSubmitted.dealer_address":
+ panic(fmt.Errorf("field dealer_address of message inference.bls.EventDealerPartSubmitted is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventDealerPartSubmitted"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventDealerPartSubmitted 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_EventDealerPartSubmitted) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.EventDealerPartSubmitted.epoch_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.bls.EventDealerPartSubmitted.dealer_address":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventDealerPartSubmitted"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventDealerPartSubmitted 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_EventDealerPartSubmitted) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.EventDealerPartSubmitted", 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_EventDealerPartSubmitted) 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_EventDealerPartSubmitted) 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_EventDealerPartSubmitted) 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_EventDealerPartSubmitted) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*EventDealerPartSubmitted)
+ 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.EpochId != 0 {
+ n += 1 + runtime.Sov(uint64(x.EpochId))
+ }
+ l = len(x.DealerAddress)
+ 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().(*EventDealerPartSubmitted)
+ 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.DealerAddress) > 0 {
+ i -= len(x.DealerAddress)
+ copy(dAtA[i:], x.DealerAddress)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DealerAddress)))
+ i--
+ 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...)
+ } 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().(*EventDealerPartSubmitted)
+ 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: EventDealerPartSubmitted: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: EventDealerPartSubmitted: 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 DealerAddress", 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.DealerAddress = 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_EventVerifyingPhaseStarted protoreflect.MessageDescriptor
+ fd_EventVerifyingPhaseStarted_epoch_id protoreflect.FieldDescriptor
+ fd_EventVerifyingPhaseStarted_verifying_phase_deadline_block protoreflect.FieldDescriptor
+ fd_EventVerifyingPhaseStarted_epoch_data protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bls_events_proto_init()
+ md_EventVerifyingPhaseStarted = File_inference_bls_events_proto.Messages().ByName("EventVerifyingPhaseStarted")
+ fd_EventVerifyingPhaseStarted_epoch_id = md_EventVerifyingPhaseStarted.Fields().ByName("epoch_id")
+ fd_EventVerifyingPhaseStarted_verifying_phase_deadline_block = md_EventVerifyingPhaseStarted.Fields().ByName("verifying_phase_deadline_block")
+ fd_EventVerifyingPhaseStarted_epoch_data = md_EventVerifyingPhaseStarted.Fields().ByName("epoch_data")
+}
+
+var _ protoreflect.Message = (*fastReflection_EventVerifyingPhaseStarted)(nil)
+
+type fastReflection_EventVerifyingPhaseStarted EventVerifyingPhaseStarted
+
+func (x *EventVerifyingPhaseStarted) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_EventVerifyingPhaseStarted)(x)
+}
+
+func (x *EventVerifyingPhaseStarted) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_events_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_EventVerifyingPhaseStarted_messageType fastReflection_EventVerifyingPhaseStarted_messageType
+var _ protoreflect.MessageType = fastReflection_EventVerifyingPhaseStarted_messageType{}
+
+type fastReflection_EventVerifyingPhaseStarted_messageType struct{}
+
+func (x fastReflection_EventVerifyingPhaseStarted_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_EventVerifyingPhaseStarted)(nil)
+}
+func (x fastReflection_EventVerifyingPhaseStarted_messageType) New() protoreflect.Message {
+ return new(fastReflection_EventVerifyingPhaseStarted)
+}
+func (x fastReflection_EventVerifyingPhaseStarted_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_EventVerifyingPhaseStarted
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_EventVerifyingPhaseStarted) Descriptor() protoreflect.MessageDescriptor {
+ return md_EventVerifyingPhaseStarted
+}
+
+// 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_EventVerifyingPhaseStarted) Type() protoreflect.MessageType {
+ return _fastReflection_EventVerifyingPhaseStarted_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_EventVerifyingPhaseStarted) New() protoreflect.Message {
+ return new(fastReflection_EventVerifyingPhaseStarted)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_EventVerifyingPhaseStarted) Interface() protoreflect.ProtoMessage {
+ return (*EventVerifyingPhaseStarted)(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_EventVerifyingPhaseStarted) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.EpochId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.EpochId)
+ if !f(fd_EventVerifyingPhaseStarted_epoch_id, value) {
+ return
+ }
+ }
+ if x.VerifyingPhaseDeadlineBlock != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.VerifyingPhaseDeadlineBlock)
+ if !f(fd_EventVerifyingPhaseStarted_verifying_phase_deadline_block, value) {
+ return
+ }
+ }
+ if x.EpochData != nil {
+ value := protoreflect.ValueOfMessage(x.EpochData.ProtoReflect())
+ if !f(fd_EventVerifyingPhaseStarted_epoch_data, 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_EventVerifyingPhaseStarted) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bls.EventVerifyingPhaseStarted.epoch_id":
+ return x.EpochId != uint64(0)
+ case "inference.bls.EventVerifyingPhaseStarted.verifying_phase_deadline_block":
+ return x.VerifyingPhaseDeadlineBlock != uint64(0)
+ case "inference.bls.EventVerifyingPhaseStarted.epoch_data":
+ return x.EpochData != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventVerifyingPhaseStarted"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventVerifyingPhaseStarted 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_EventVerifyingPhaseStarted) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bls.EventVerifyingPhaseStarted.epoch_id":
+ x.EpochId = uint64(0)
+ case "inference.bls.EventVerifyingPhaseStarted.verifying_phase_deadline_block":
+ x.VerifyingPhaseDeadlineBlock = uint64(0)
+ case "inference.bls.EventVerifyingPhaseStarted.epoch_data":
+ x.EpochData = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventVerifyingPhaseStarted"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventVerifyingPhaseStarted 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_EventVerifyingPhaseStarted) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bls.EventVerifyingPhaseStarted.epoch_id":
+ value := x.EpochId
+ return protoreflect.ValueOfUint64(value)
+ case "inference.bls.EventVerifyingPhaseStarted.verifying_phase_deadline_block":
+ value := x.VerifyingPhaseDeadlineBlock
+ return protoreflect.ValueOfUint64(value)
+ case "inference.bls.EventVerifyingPhaseStarted.epoch_data":
+ value := x.EpochData
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventVerifyingPhaseStarted"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventVerifyingPhaseStarted 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_EventVerifyingPhaseStarted) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bls.EventVerifyingPhaseStarted.epoch_id":
+ x.EpochId = value.Uint()
+ case "inference.bls.EventVerifyingPhaseStarted.verifying_phase_deadline_block":
+ x.VerifyingPhaseDeadlineBlock = value.Uint()
+ case "inference.bls.EventVerifyingPhaseStarted.epoch_data":
+ x.EpochData = value.Message().Interface().(*EpochBLSData)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventVerifyingPhaseStarted"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventVerifyingPhaseStarted 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_EventVerifyingPhaseStarted) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.EventVerifyingPhaseStarted.epoch_data":
+ if x.EpochData == nil {
+ x.EpochData = new(EpochBLSData)
+ }
+ return protoreflect.ValueOfMessage(x.EpochData.ProtoReflect())
+ case "inference.bls.EventVerifyingPhaseStarted.epoch_id":
+ panic(fmt.Errorf("field epoch_id of message inference.bls.EventVerifyingPhaseStarted is not mutable"))
+ case "inference.bls.EventVerifyingPhaseStarted.verifying_phase_deadline_block":
+ panic(fmt.Errorf("field verifying_phase_deadline_block of message inference.bls.EventVerifyingPhaseStarted is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventVerifyingPhaseStarted"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventVerifyingPhaseStarted 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_EventVerifyingPhaseStarted) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.EventVerifyingPhaseStarted.epoch_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.bls.EventVerifyingPhaseStarted.verifying_phase_deadline_block":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.bls.EventVerifyingPhaseStarted.epoch_data":
+ m := new(EpochBLSData)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventVerifyingPhaseStarted"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventVerifyingPhaseStarted 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_EventVerifyingPhaseStarted) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.EventVerifyingPhaseStarted", 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_EventVerifyingPhaseStarted) 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_EventVerifyingPhaseStarted) 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_EventVerifyingPhaseStarted) 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_EventVerifyingPhaseStarted) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*EventVerifyingPhaseStarted)
+ 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.EpochId != 0 {
+ n += 1 + runtime.Sov(uint64(x.EpochId))
+ }
+ if x.VerifyingPhaseDeadlineBlock != 0 {
+ n += 1 + runtime.Sov(uint64(x.VerifyingPhaseDeadlineBlock))
+ }
+ if x.EpochData != nil {
+ l = options.Size(x.EpochData)
+ 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().(*EventVerifyingPhaseStarted)
+ 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.EpochData != nil {
+ encoded, err := options.Marshal(x.EpochData)
+ 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.VerifyingPhaseDeadlineBlock != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.VerifyingPhaseDeadlineBlock))
+ i--
+ dAtA[i] = 0x10
+ }
+ 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...)
+ } 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().(*EventVerifyingPhaseStarted)
+ 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: EventVerifyingPhaseStarted: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: EventVerifyingPhaseStarted: 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 != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field VerifyingPhaseDeadlineBlock", wireType)
+ }
+ x.VerifyingPhaseDeadlineBlock = 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.VerifyingPhaseDeadlineBlock |= 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 EpochData", 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.EpochData == nil {
+ x.EpochData = &EpochBLSData{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.EpochData); 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_EventDKGFailed protoreflect.MessageDescriptor
+ fd_EventDKGFailed_epoch_id protoreflect.FieldDescriptor
+ fd_EventDKGFailed_reason protoreflect.FieldDescriptor
+ fd_EventDKGFailed_epoch_data protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bls_events_proto_init()
+ md_EventDKGFailed = File_inference_bls_events_proto.Messages().ByName("EventDKGFailed")
+ fd_EventDKGFailed_epoch_id = md_EventDKGFailed.Fields().ByName("epoch_id")
+ fd_EventDKGFailed_reason = md_EventDKGFailed.Fields().ByName("reason")
+ fd_EventDKGFailed_epoch_data = md_EventDKGFailed.Fields().ByName("epoch_data")
+}
+
+var _ protoreflect.Message = (*fastReflection_EventDKGFailed)(nil)
+
+type fastReflection_EventDKGFailed EventDKGFailed
+
+func (x *EventDKGFailed) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_EventDKGFailed)(x)
+}
+
+func (x *EventDKGFailed) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_events_proto_msgTypes[3]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_EventDKGFailed_messageType fastReflection_EventDKGFailed_messageType
+var _ protoreflect.MessageType = fastReflection_EventDKGFailed_messageType{}
+
+type fastReflection_EventDKGFailed_messageType struct{}
+
+func (x fastReflection_EventDKGFailed_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_EventDKGFailed)(nil)
+}
+func (x fastReflection_EventDKGFailed_messageType) New() protoreflect.Message {
+ return new(fastReflection_EventDKGFailed)
+}
+func (x fastReflection_EventDKGFailed_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_EventDKGFailed
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_EventDKGFailed) Descriptor() protoreflect.MessageDescriptor {
+ return md_EventDKGFailed
+}
+
+// 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_EventDKGFailed) Type() protoreflect.MessageType {
+ return _fastReflection_EventDKGFailed_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_EventDKGFailed) New() protoreflect.Message {
+ return new(fastReflection_EventDKGFailed)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_EventDKGFailed) Interface() protoreflect.ProtoMessage {
+ return (*EventDKGFailed)(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_EventDKGFailed) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.EpochId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.EpochId)
+ if !f(fd_EventDKGFailed_epoch_id, value) {
+ return
+ }
+ }
+ if x.Reason != "" {
+ value := protoreflect.ValueOfString(x.Reason)
+ if !f(fd_EventDKGFailed_reason, value) {
+ return
+ }
+ }
+ if x.EpochData != nil {
+ value := protoreflect.ValueOfMessage(x.EpochData.ProtoReflect())
+ if !f(fd_EventDKGFailed_epoch_data, 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_EventDKGFailed) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bls.EventDKGFailed.epoch_id":
+ return x.EpochId != uint64(0)
+ case "inference.bls.EventDKGFailed.reason":
+ return x.Reason != ""
+ case "inference.bls.EventDKGFailed.epoch_data":
+ return x.EpochData != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventDKGFailed"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventDKGFailed 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_EventDKGFailed) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bls.EventDKGFailed.epoch_id":
+ x.EpochId = uint64(0)
+ case "inference.bls.EventDKGFailed.reason":
+ x.Reason = ""
+ case "inference.bls.EventDKGFailed.epoch_data":
+ x.EpochData = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventDKGFailed"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventDKGFailed 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_EventDKGFailed) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bls.EventDKGFailed.epoch_id":
+ value := x.EpochId
+ return protoreflect.ValueOfUint64(value)
+ case "inference.bls.EventDKGFailed.reason":
+ value := x.Reason
+ return protoreflect.ValueOfString(value)
+ case "inference.bls.EventDKGFailed.epoch_data":
+ value := x.EpochData
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventDKGFailed"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventDKGFailed 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_EventDKGFailed) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bls.EventDKGFailed.epoch_id":
+ x.EpochId = value.Uint()
+ case "inference.bls.EventDKGFailed.reason":
+ x.Reason = value.Interface().(string)
+ case "inference.bls.EventDKGFailed.epoch_data":
+ x.EpochData = value.Message().Interface().(*EpochBLSData)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventDKGFailed"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventDKGFailed 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_EventDKGFailed) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.EventDKGFailed.epoch_data":
+ if x.EpochData == nil {
+ x.EpochData = new(EpochBLSData)
+ }
+ return protoreflect.ValueOfMessage(x.EpochData.ProtoReflect())
+ case "inference.bls.EventDKGFailed.epoch_id":
+ panic(fmt.Errorf("field epoch_id of message inference.bls.EventDKGFailed is not mutable"))
+ case "inference.bls.EventDKGFailed.reason":
+ panic(fmt.Errorf("field reason of message inference.bls.EventDKGFailed is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventDKGFailed"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventDKGFailed 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_EventDKGFailed) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.EventDKGFailed.epoch_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.bls.EventDKGFailed.reason":
+ return protoreflect.ValueOfString("")
+ case "inference.bls.EventDKGFailed.epoch_data":
+ m := new(EpochBLSData)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventDKGFailed"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventDKGFailed 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_EventDKGFailed) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.EventDKGFailed", 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_EventDKGFailed) 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_EventDKGFailed) 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_EventDKGFailed) 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_EventDKGFailed) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*EventDKGFailed)
+ 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.EpochId != 0 {
+ n += 1 + runtime.Sov(uint64(x.EpochId))
+ }
+ l = len(x.Reason)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.EpochData != nil {
+ l = options.Size(x.EpochData)
+ 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().(*EventDKGFailed)
+ 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.EpochData != nil {
+ encoded, err := options.Marshal(x.EpochData)
+ 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.Reason) > 0 {
+ i -= len(x.Reason)
+ copy(dAtA[i:], x.Reason)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Reason)))
+ i--
+ 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...)
+ } 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().(*EventDKGFailed)
+ 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: EventDKGFailed: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: EventDKGFailed: 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 Reason", 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.Reason = 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 EpochData", 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.EpochData == nil {
+ x.EpochData = &EpochBLSData{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.EpochData); 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_EventVerificationVectorSubmitted protoreflect.MessageDescriptor
+ fd_EventVerificationVectorSubmitted_epoch_id protoreflect.FieldDescriptor
+ fd_EventVerificationVectorSubmitted_participant_address protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bls_events_proto_init()
+ md_EventVerificationVectorSubmitted = File_inference_bls_events_proto.Messages().ByName("EventVerificationVectorSubmitted")
+ fd_EventVerificationVectorSubmitted_epoch_id = md_EventVerificationVectorSubmitted.Fields().ByName("epoch_id")
+ fd_EventVerificationVectorSubmitted_participant_address = md_EventVerificationVectorSubmitted.Fields().ByName("participant_address")
+}
+
+var _ protoreflect.Message = (*fastReflection_EventVerificationVectorSubmitted)(nil)
+
+type fastReflection_EventVerificationVectorSubmitted EventVerificationVectorSubmitted
+
+func (x *EventVerificationVectorSubmitted) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_EventVerificationVectorSubmitted)(x)
+}
+
+func (x *EventVerificationVectorSubmitted) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_events_proto_msgTypes[4]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_EventVerificationVectorSubmitted_messageType fastReflection_EventVerificationVectorSubmitted_messageType
+var _ protoreflect.MessageType = fastReflection_EventVerificationVectorSubmitted_messageType{}
+
+type fastReflection_EventVerificationVectorSubmitted_messageType struct{}
+
+func (x fastReflection_EventVerificationVectorSubmitted_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_EventVerificationVectorSubmitted)(nil)
+}
+func (x fastReflection_EventVerificationVectorSubmitted_messageType) New() protoreflect.Message {
+ return new(fastReflection_EventVerificationVectorSubmitted)
+}
+func (x fastReflection_EventVerificationVectorSubmitted_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_EventVerificationVectorSubmitted
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_EventVerificationVectorSubmitted) Descriptor() protoreflect.MessageDescriptor {
+ return md_EventVerificationVectorSubmitted
+}
+
+// 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_EventVerificationVectorSubmitted) Type() protoreflect.MessageType {
+ return _fastReflection_EventVerificationVectorSubmitted_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_EventVerificationVectorSubmitted) New() protoreflect.Message {
+ return new(fastReflection_EventVerificationVectorSubmitted)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_EventVerificationVectorSubmitted) Interface() protoreflect.ProtoMessage {
+ return (*EventVerificationVectorSubmitted)(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_EventVerificationVectorSubmitted) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.EpochId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.EpochId)
+ if !f(fd_EventVerificationVectorSubmitted_epoch_id, value) {
+ return
+ }
+ }
+ if x.ParticipantAddress != "" {
+ value := protoreflect.ValueOfString(x.ParticipantAddress)
+ if !f(fd_EventVerificationVectorSubmitted_participant_address, 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_EventVerificationVectorSubmitted) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bls.EventVerificationVectorSubmitted.epoch_id":
+ return x.EpochId != uint64(0)
+ case "inference.bls.EventVerificationVectorSubmitted.participant_address":
+ return x.ParticipantAddress != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventVerificationVectorSubmitted"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventVerificationVectorSubmitted 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_EventVerificationVectorSubmitted) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bls.EventVerificationVectorSubmitted.epoch_id":
+ x.EpochId = uint64(0)
+ case "inference.bls.EventVerificationVectorSubmitted.participant_address":
+ x.ParticipantAddress = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventVerificationVectorSubmitted"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventVerificationVectorSubmitted 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_EventVerificationVectorSubmitted) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bls.EventVerificationVectorSubmitted.epoch_id":
+ value := x.EpochId
+ return protoreflect.ValueOfUint64(value)
+ case "inference.bls.EventVerificationVectorSubmitted.participant_address":
+ value := x.ParticipantAddress
+ return protoreflect.ValueOfString(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventVerificationVectorSubmitted"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventVerificationVectorSubmitted 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_EventVerificationVectorSubmitted) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bls.EventVerificationVectorSubmitted.epoch_id":
+ x.EpochId = value.Uint()
+ case "inference.bls.EventVerificationVectorSubmitted.participant_address":
+ x.ParticipantAddress = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventVerificationVectorSubmitted"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventVerificationVectorSubmitted 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_EventVerificationVectorSubmitted) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.EventVerificationVectorSubmitted.epoch_id":
+ panic(fmt.Errorf("field epoch_id of message inference.bls.EventVerificationVectorSubmitted is not mutable"))
+ case "inference.bls.EventVerificationVectorSubmitted.participant_address":
+ panic(fmt.Errorf("field participant_address of message inference.bls.EventVerificationVectorSubmitted is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventVerificationVectorSubmitted"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventVerificationVectorSubmitted 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_EventVerificationVectorSubmitted) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.EventVerificationVectorSubmitted.epoch_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.bls.EventVerificationVectorSubmitted.participant_address":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventVerificationVectorSubmitted"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventVerificationVectorSubmitted 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_EventVerificationVectorSubmitted) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.EventVerificationVectorSubmitted", 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_EventVerificationVectorSubmitted) 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_EventVerificationVectorSubmitted) 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_EventVerificationVectorSubmitted) 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_EventVerificationVectorSubmitted) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*EventVerificationVectorSubmitted)
+ 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.EpochId != 0 {
+ n += 1 + runtime.Sov(uint64(x.EpochId))
+ }
+ l = len(x.ParticipantAddress)
+ 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().(*EventVerificationVectorSubmitted)
+ 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.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.EpochId != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochId))
+ 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().(*EventVerificationVectorSubmitted)
+ 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: EventVerificationVectorSubmitted: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: EventVerificationVectorSubmitted: 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 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
+ 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_EventGroupPublicKeyGenerated protoreflect.MessageDescriptor
+ fd_EventGroupPublicKeyGenerated_epoch_id protoreflect.FieldDescriptor
+ fd_EventGroupPublicKeyGenerated_group_public_key protoreflect.FieldDescriptor
+ fd_EventGroupPublicKeyGenerated_i_total_slots protoreflect.FieldDescriptor
+ fd_EventGroupPublicKeyGenerated_t_slots_degree protoreflect.FieldDescriptor
+ fd_EventGroupPublicKeyGenerated_epoch_data protoreflect.FieldDescriptor
+ fd_EventGroupPublicKeyGenerated_chain_id protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bls_events_proto_init()
+ md_EventGroupPublicKeyGenerated = File_inference_bls_events_proto.Messages().ByName("EventGroupPublicKeyGenerated")
+ fd_EventGroupPublicKeyGenerated_epoch_id = md_EventGroupPublicKeyGenerated.Fields().ByName("epoch_id")
+ fd_EventGroupPublicKeyGenerated_group_public_key = md_EventGroupPublicKeyGenerated.Fields().ByName("group_public_key")
+ fd_EventGroupPublicKeyGenerated_i_total_slots = md_EventGroupPublicKeyGenerated.Fields().ByName("i_total_slots")
+ fd_EventGroupPublicKeyGenerated_t_slots_degree = md_EventGroupPublicKeyGenerated.Fields().ByName("t_slots_degree")
+ fd_EventGroupPublicKeyGenerated_epoch_data = md_EventGroupPublicKeyGenerated.Fields().ByName("epoch_data")
+ fd_EventGroupPublicKeyGenerated_chain_id = md_EventGroupPublicKeyGenerated.Fields().ByName("chain_id")
+}
+
+var _ protoreflect.Message = (*fastReflection_EventGroupPublicKeyGenerated)(nil)
+
+type fastReflection_EventGroupPublicKeyGenerated EventGroupPublicKeyGenerated
+
+func (x *EventGroupPublicKeyGenerated) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_EventGroupPublicKeyGenerated)(x)
+}
+
+func (x *EventGroupPublicKeyGenerated) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_events_proto_msgTypes[5]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_EventGroupPublicKeyGenerated_messageType fastReflection_EventGroupPublicKeyGenerated_messageType
+var _ protoreflect.MessageType = fastReflection_EventGroupPublicKeyGenerated_messageType{}
+
+type fastReflection_EventGroupPublicKeyGenerated_messageType struct{}
+
+func (x fastReflection_EventGroupPublicKeyGenerated_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_EventGroupPublicKeyGenerated)(nil)
+}
+func (x fastReflection_EventGroupPublicKeyGenerated_messageType) New() protoreflect.Message {
+ return new(fastReflection_EventGroupPublicKeyGenerated)
+}
+func (x fastReflection_EventGroupPublicKeyGenerated_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_EventGroupPublicKeyGenerated
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_EventGroupPublicKeyGenerated) Descriptor() protoreflect.MessageDescriptor {
+ return md_EventGroupPublicKeyGenerated
+}
+
+// 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_EventGroupPublicKeyGenerated) Type() protoreflect.MessageType {
+ return _fastReflection_EventGroupPublicKeyGenerated_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_EventGroupPublicKeyGenerated) New() protoreflect.Message {
+ return new(fastReflection_EventGroupPublicKeyGenerated)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_EventGroupPublicKeyGenerated) Interface() protoreflect.ProtoMessage {
+ return (*EventGroupPublicKeyGenerated)(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_EventGroupPublicKeyGenerated) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.EpochId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.EpochId)
+ if !f(fd_EventGroupPublicKeyGenerated_epoch_id, value) {
+ return
+ }
+ }
+ if len(x.GroupPublicKey) != 0 {
+ value := protoreflect.ValueOfBytes(x.GroupPublicKey)
+ if !f(fd_EventGroupPublicKeyGenerated_group_public_key, value) {
+ return
+ }
+ }
+ if x.ITotalSlots != uint32(0) {
+ value := protoreflect.ValueOfUint32(x.ITotalSlots)
+ if !f(fd_EventGroupPublicKeyGenerated_i_total_slots, value) {
+ return
+ }
+ }
+ if x.TSlotsDegree != uint32(0) {
+ value := protoreflect.ValueOfUint32(x.TSlotsDegree)
+ if !f(fd_EventGroupPublicKeyGenerated_t_slots_degree, value) {
+ return
+ }
+ }
+ if x.EpochData != nil {
+ value := protoreflect.ValueOfMessage(x.EpochData.ProtoReflect())
+ if !f(fd_EventGroupPublicKeyGenerated_epoch_data, value) {
+ return
+ }
+ }
+ if x.ChainId != "" {
+ value := protoreflect.ValueOfString(x.ChainId)
+ if !f(fd_EventGroupPublicKeyGenerated_chain_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_EventGroupPublicKeyGenerated) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bls.EventGroupPublicKeyGenerated.epoch_id":
+ return x.EpochId != uint64(0)
+ case "inference.bls.EventGroupPublicKeyGenerated.group_public_key":
+ return len(x.GroupPublicKey) != 0
+ case "inference.bls.EventGroupPublicKeyGenerated.i_total_slots":
+ return x.ITotalSlots != uint32(0)
+ case "inference.bls.EventGroupPublicKeyGenerated.t_slots_degree":
+ return x.TSlotsDegree != uint32(0)
+ case "inference.bls.EventGroupPublicKeyGenerated.epoch_data":
+ return x.EpochData != nil
+ case "inference.bls.EventGroupPublicKeyGenerated.chain_id":
+ return x.ChainId != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventGroupPublicKeyGenerated"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventGroupPublicKeyGenerated 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_EventGroupPublicKeyGenerated) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bls.EventGroupPublicKeyGenerated.epoch_id":
+ x.EpochId = uint64(0)
+ case "inference.bls.EventGroupPublicKeyGenerated.group_public_key":
+ x.GroupPublicKey = nil
+ case "inference.bls.EventGroupPublicKeyGenerated.i_total_slots":
+ x.ITotalSlots = uint32(0)
+ case "inference.bls.EventGroupPublicKeyGenerated.t_slots_degree":
+ x.TSlotsDegree = uint32(0)
+ case "inference.bls.EventGroupPublicKeyGenerated.epoch_data":
+ x.EpochData = nil
+ case "inference.bls.EventGroupPublicKeyGenerated.chain_id":
+ x.ChainId = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventGroupPublicKeyGenerated"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventGroupPublicKeyGenerated 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_EventGroupPublicKeyGenerated) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bls.EventGroupPublicKeyGenerated.epoch_id":
+ value := x.EpochId
+ return protoreflect.ValueOfUint64(value)
+ case "inference.bls.EventGroupPublicKeyGenerated.group_public_key":
+ value := x.GroupPublicKey
+ return protoreflect.ValueOfBytes(value)
+ case "inference.bls.EventGroupPublicKeyGenerated.i_total_slots":
+ value := x.ITotalSlots
+ return protoreflect.ValueOfUint32(value)
+ case "inference.bls.EventGroupPublicKeyGenerated.t_slots_degree":
+ value := x.TSlotsDegree
+ return protoreflect.ValueOfUint32(value)
+ case "inference.bls.EventGroupPublicKeyGenerated.epoch_data":
+ value := x.EpochData
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.bls.EventGroupPublicKeyGenerated.chain_id":
+ value := x.ChainId
+ return protoreflect.ValueOfString(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventGroupPublicKeyGenerated"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventGroupPublicKeyGenerated 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_EventGroupPublicKeyGenerated) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bls.EventGroupPublicKeyGenerated.epoch_id":
+ x.EpochId = value.Uint()
+ case "inference.bls.EventGroupPublicKeyGenerated.group_public_key":
+ x.GroupPublicKey = value.Bytes()
+ case "inference.bls.EventGroupPublicKeyGenerated.i_total_slots":
+ x.ITotalSlots = uint32(value.Uint())
+ case "inference.bls.EventGroupPublicKeyGenerated.t_slots_degree":
+ x.TSlotsDegree = uint32(value.Uint())
+ case "inference.bls.EventGroupPublicKeyGenerated.epoch_data":
+ x.EpochData = value.Message().Interface().(*EpochBLSData)
+ case "inference.bls.EventGroupPublicKeyGenerated.chain_id":
+ x.ChainId = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventGroupPublicKeyGenerated"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventGroupPublicKeyGenerated 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_EventGroupPublicKeyGenerated) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.EventGroupPublicKeyGenerated.epoch_data":
+ if x.EpochData == nil {
+ x.EpochData = new(EpochBLSData)
+ }
+ return protoreflect.ValueOfMessage(x.EpochData.ProtoReflect())
+ case "inference.bls.EventGroupPublicKeyGenerated.epoch_id":
+ panic(fmt.Errorf("field epoch_id of message inference.bls.EventGroupPublicKeyGenerated is not mutable"))
+ case "inference.bls.EventGroupPublicKeyGenerated.group_public_key":
+ panic(fmt.Errorf("field group_public_key of message inference.bls.EventGroupPublicKeyGenerated is not mutable"))
+ case "inference.bls.EventGroupPublicKeyGenerated.i_total_slots":
+ panic(fmt.Errorf("field i_total_slots of message inference.bls.EventGroupPublicKeyGenerated is not mutable"))
+ case "inference.bls.EventGroupPublicKeyGenerated.t_slots_degree":
+ panic(fmt.Errorf("field t_slots_degree of message inference.bls.EventGroupPublicKeyGenerated is not mutable"))
+ case "inference.bls.EventGroupPublicKeyGenerated.chain_id":
+ panic(fmt.Errorf("field chain_id of message inference.bls.EventGroupPublicKeyGenerated is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventGroupPublicKeyGenerated"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventGroupPublicKeyGenerated 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_EventGroupPublicKeyGenerated) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.EventGroupPublicKeyGenerated.epoch_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.bls.EventGroupPublicKeyGenerated.group_public_key":
+ return protoreflect.ValueOfBytes(nil)
+ case "inference.bls.EventGroupPublicKeyGenerated.i_total_slots":
+ return protoreflect.ValueOfUint32(uint32(0))
+ case "inference.bls.EventGroupPublicKeyGenerated.t_slots_degree":
+ return protoreflect.ValueOfUint32(uint32(0))
+ case "inference.bls.EventGroupPublicKeyGenerated.epoch_data":
+ m := new(EpochBLSData)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.bls.EventGroupPublicKeyGenerated.chain_id":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventGroupPublicKeyGenerated"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventGroupPublicKeyGenerated 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_EventGroupPublicKeyGenerated) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.EventGroupPublicKeyGenerated", 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_EventGroupPublicKeyGenerated) 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_EventGroupPublicKeyGenerated) 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_EventGroupPublicKeyGenerated) 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_EventGroupPublicKeyGenerated) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*EventGroupPublicKeyGenerated)
+ 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.EpochId != 0 {
+ n += 1 + runtime.Sov(uint64(x.EpochId))
+ }
+ l = len(x.GroupPublicKey)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.ITotalSlots != 0 {
+ n += 1 + runtime.Sov(uint64(x.ITotalSlots))
+ }
+ if x.TSlotsDegree != 0 {
+ n += 1 + runtime.Sov(uint64(x.TSlotsDegree))
+ }
+ if x.EpochData != nil {
+ l = options.Size(x.EpochData)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ l = len(x.ChainId)
+ 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().(*EventGroupPublicKeyGenerated)
+ 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.ChainId) > 0 {
+ i -= len(x.ChainId)
+ copy(dAtA[i:], x.ChainId)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ChainId)))
+ i--
+ dAtA[i] = 0x32
+ }
+ if x.EpochData != nil {
+ encoded, err := options.Marshal(x.EpochData)
+ 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.TSlotsDegree != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.TSlotsDegree))
+ i--
+ dAtA[i] = 0x20
+ }
+ if x.ITotalSlots != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.ITotalSlots))
+ i--
+ dAtA[i] = 0x18
+ }
+ if len(x.GroupPublicKey) > 0 {
+ i -= len(x.GroupPublicKey)
+ copy(dAtA[i:], x.GroupPublicKey)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.GroupPublicKey)))
+ i--
+ 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...)
+ } 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().(*EventGroupPublicKeyGenerated)
+ 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: EventGroupPublicKeyGenerated: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: EventGroupPublicKeyGenerated: 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 GroupPublicKey", 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.GroupPublicKey = append(x.GroupPublicKey[:0], dAtA[iNdEx:postIndex]...)
+ if x.GroupPublicKey == nil {
+ x.GroupPublicKey = []byte{}
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ITotalSlots", wireType)
+ }
+ x.ITotalSlots = 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.ITotalSlots |= uint32(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 TSlotsDegree", wireType)
+ }
+ x.TSlotsDegree = 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.TSlotsDegree |= uint32(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 EpochData", 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.EpochData == nil {
+ x.EpochData = &EpochBLSData{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.EpochData); err != nil {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+ }
+ iNdEx = postIndex
+ case 6:
+ 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
+ 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_EventGroupKeyValidated protoreflect.MessageDescriptor
+ fd_EventGroupKeyValidated_new_epoch_id protoreflect.FieldDescriptor
+ fd_EventGroupKeyValidated_final_signature protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bls_events_proto_init()
+ md_EventGroupKeyValidated = File_inference_bls_events_proto.Messages().ByName("EventGroupKeyValidated")
+ fd_EventGroupKeyValidated_new_epoch_id = md_EventGroupKeyValidated.Fields().ByName("new_epoch_id")
+ fd_EventGroupKeyValidated_final_signature = md_EventGroupKeyValidated.Fields().ByName("final_signature")
+}
+
+var _ protoreflect.Message = (*fastReflection_EventGroupKeyValidated)(nil)
+
+type fastReflection_EventGroupKeyValidated EventGroupKeyValidated
+
+func (x *EventGroupKeyValidated) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_EventGroupKeyValidated)(x)
+}
+
+func (x *EventGroupKeyValidated) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_events_proto_msgTypes[6]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_EventGroupKeyValidated_messageType fastReflection_EventGroupKeyValidated_messageType
+var _ protoreflect.MessageType = fastReflection_EventGroupKeyValidated_messageType{}
+
+type fastReflection_EventGroupKeyValidated_messageType struct{}
+
+func (x fastReflection_EventGroupKeyValidated_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_EventGroupKeyValidated)(nil)
+}
+func (x fastReflection_EventGroupKeyValidated_messageType) New() protoreflect.Message {
+ return new(fastReflection_EventGroupKeyValidated)
+}
+func (x fastReflection_EventGroupKeyValidated_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_EventGroupKeyValidated
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_EventGroupKeyValidated) Descriptor() protoreflect.MessageDescriptor {
+ return md_EventGroupKeyValidated
+}
+
+// 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_EventGroupKeyValidated) Type() protoreflect.MessageType {
+ return _fastReflection_EventGroupKeyValidated_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_EventGroupKeyValidated) New() protoreflect.Message {
+ return new(fastReflection_EventGroupKeyValidated)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_EventGroupKeyValidated) Interface() protoreflect.ProtoMessage {
+ return (*EventGroupKeyValidated)(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_EventGroupKeyValidated) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.NewEpochId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.NewEpochId)
+ if !f(fd_EventGroupKeyValidated_new_epoch_id, value) {
+ return
+ }
+ }
+ if len(x.FinalSignature) != 0 {
+ value := protoreflect.ValueOfBytes(x.FinalSignature)
+ if !f(fd_EventGroupKeyValidated_final_signature, 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_EventGroupKeyValidated) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bls.EventGroupKeyValidated.new_epoch_id":
+ return x.NewEpochId != uint64(0)
+ case "inference.bls.EventGroupKeyValidated.final_signature":
+ return len(x.FinalSignature) != 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventGroupKeyValidated"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventGroupKeyValidated 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_EventGroupKeyValidated) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bls.EventGroupKeyValidated.new_epoch_id":
+ x.NewEpochId = uint64(0)
+ case "inference.bls.EventGroupKeyValidated.final_signature":
+ x.FinalSignature = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventGroupKeyValidated"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventGroupKeyValidated 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_EventGroupKeyValidated) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bls.EventGroupKeyValidated.new_epoch_id":
+ value := x.NewEpochId
+ return protoreflect.ValueOfUint64(value)
+ case "inference.bls.EventGroupKeyValidated.final_signature":
+ value := x.FinalSignature
+ return protoreflect.ValueOfBytes(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventGroupKeyValidated"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventGroupKeyValidated 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_EventGroupKeyValidated) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bls.EventGroupKeyValidated.new_epoch_id":
+ x.NewEpochId = value.Uint()
+ case "inference.bls.EventGroupKeyValidated.final_signature":
+ x.FinalSignature = value.Bytes()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventGroupKeyValidated"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventGroupKeyValidated 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_EventGroupKeyValidated) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.EventGroupKeyValidated.new_epoch_id":
+ panic(fmt.Errorf("field new_epoch_id of message inference.bls.EventGroupKeyValidated is not mutable"))
+ case "inference.bls.EventGroupKeyValidated.final_signature":
+ panic(fmt.Errorf("field final_signature of message inference.bls.EventGroupKeyValidated is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventGroupKeyValidated"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventGroupKeyValidated 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_EventGroupKeyValidated) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.EventGroupKeyValidated.new_epoch_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.bls.EventGroupKeyValidated.final_signature":
+ return protoreflect.ValueOfBytes(nil)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventGroupKeyValidated"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventGroupKeyValidated 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_EventGroupKeyValidated) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.EventGroupKeyValidated", 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_EventGroupKeyValidated) 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_EventGroupKeyValidated) 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_EventGroupKeyValidated) 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_EventGroupKeyValidated) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*EventGroupKeyValidated)
+ 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.NewEpochId != 0 {
+ n += 1 + runtime.Sov(uint64(x.NewEpochId))
+ }
+ l = len(x.FinalSignature)
+ 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().(*EventGroupKeyValidated)
+ 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.FinalSignature) > 0 {
+ i -= len(x.FinalSignature)
+ copy(dAtA[i:], x.FinalSignature)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.FinalSignature)))
+ i--
+ dAtA[i] = 0x12
+ }
+ if x.NewEpochId != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.NewEpochId))
+ 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().(*EventGroupKeyValidated)
+ 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: EventGroupKeyValidated: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: EventGroupKeyValidated: 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 NewEpochId", wireType)
+ }
+ x.NewEpochId = 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.NewEpochId |= 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 FinalSignature", 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.FinalSignature = append(x.FinalSignature[:0], dAtA[iNdEx:postIndex]...)
+ if x.FinalSignature == nil {
+ x.FinalSignature = []byte{}
+ }
+ 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_EventGroupKeyValidationFailed protoreflect.MessageDescriptor
+ fd_EventGroupKeyValidationFailed_new_epoch_id protoreflect.FieldDescriptor
+ fd_EventGroupKeyValidationFailed_reason protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bls_events_proto_init()
+ md_EventGroupKeyValidationFailed = File_inference_bls_events_proto.Messages().ByName("EventGroupKeyValidationFailed")
+ fd_EventGroupKeyValidationFailed_new_epoch_id = md_EventGroupKeyValidationFailed.Fields().ByName("new_epoch_id")
+ fd_EventGroupKeyValidationFailed_reason = md_EventGroupKeyValidationFailed.Fields().ByName("reason")
+}
+
+var _ protoreflect.Message = (*fastReflection_EventGroupKeyValidationFailed)(nil)
+
+type fastReflection_EventGroupKeyValidationFailed EventGroupKeyValidationFailed
+
+func (x *EventGroupKeyValidationFailed) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_EventGroupKeyValidationFailed)(x)
+}
+
+func (x *EventGroupKeyValidationFailed) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_events_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_EventGroupKeyValidationFailed_messageType fastReflection_EventGroupKeyValidationFailed_messageType
+var _ protoreflect.MessageType = fastReflection_EventGroupKeyValidationFailed_messageType{}
+
+type fastReflection_EventGroupKeyValidationFailed_messageType struct{}
+
+func (x fastReflection_EventGroupKeyValidationFailed_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_EventGroupKeyValidationFailed)(nil)
+}
+func (x fastReflection_EventGroupKeyValidationFailed_messageType) New() protoreflect.Message {
+ return new(fastReflection_EventGroupKeyValidationFailed)
+}
+func (x fastReflection_EventGroupKeyValidationFailed_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_EventGroupKeyValidationFailed
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_EventGroupKeyValidationFailed) Descriptor() protoreflect.MessageDescriptor {
+ return md_EventGroupKeyValidationFailed
+}
+
+// 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_EventGroupKeyValidationFailed) Type() protoreflect.MessageType {
+ return _fastReflection_EventGroupKeyValidationFailed_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_EventGroupKeyValidationFailed) New() protoreflect.Message {
+ return new(fastReflection_EventGroupKeyValidationFailed)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_EventGroupKeyValidationFailed) Interface() protoreflect.ProtoMessage {
+ return (*EventGroupKeyValidationFailed)(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_EventGroupKeyValidationFailed) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.NewEpochId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.NewEpochId)
+ if !f(fd_EventGroupKeyValidationFailed_new_epoch_id, value) {
+ return
+ }
+ }
+ if x.Reason != "" {
+ value := protoreflect.ValueOfString(x.Reason)
+ if !f(fd_EventGroupKeyValidationFailed_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_EventGroupKeyValidationFailed) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bls.EventGroupKeyValidationFailed.new_epoch_id":
+ return x.NewEpochId != uint64(0)
+ case "inference.bls.EventGroupKeyValidationFailed.reason":
+ return x.Reason != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventGroupKeyValidationFailed"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventGroupKeyValidationFailed 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_EventGroupKeyValidationFailed) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bls.EventGroupKeyValidationFailed.new_epoch_id":
+ x.NewEpochId = uint64(0)
+ case "inference.bls.EventGroupKeyValidationFailed.reason":
+ x.Reason = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventGroupKeyValidationFailed"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventGroupKeyValidationFailed 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_EventGroupKeyValidationFailed) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bls.EventGroupKeyValidationFailed.new_epoch_id":
+ value := x.NewEpochId
+ return protoreflect.ValueOfUint64(value)
+ case "inference.bls.EventGroupKeyValidationFailed.reason":
+ value := x.Reason
+ return protoreflect.ValueOfString(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventGroupKeyValidationFailed"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventGroupKeyValidationFailed 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_EventGroupKeyValidationFailed) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bls.EventGroupKeyValidationFailed.new_epoch_id":
+ x.NewEpochId = value.Uint()
+ case "inference.bls.EventGroupKeyValidationFailed.reason":
+ x.Reason = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventGroupKeyValidationFailed"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventGroupKeyValidationFailed 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_EventGroupKeyValidationFailed) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.EventGroupKeyValidationFailed.new_epoch_id":
+ panic(fmt.Errorf("field new_epoch_id of message inference.bls.EventGroupKeyValidationFailed is not mutable"))
+ case "inference.bls.EventGroupKeyValidationFailed.reason":
+ panic(fmt.Errorf("field reason of message inference.bls.EventGroupKeyValidationFailed is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventGroupKeyValidationFailed"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventGroupKeyValidationFailed 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_EventGroupKeyValidationFailed) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.EventGroupKeyValidationFailed.new_epoch_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.bls.EventGroupKeyValidationFailed.reason":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventGroupKeyValidationFailed"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventGroupKeyValidationFailed 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_EventGroupKeyValidationFailed) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.EventGroupKeyValidationFailed", 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_EventGroupKeyValidationFailed) 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_EventGroupKeyValidationFailed) 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_EventGroupKeyValidationFailed) 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_EventGroupKeyValidationFailed) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*EventGroupKeyValidationFailed)
+ 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.NewEpochId != 0 {
+ n += 1 + runtime.Sov(uint64(x.NewEpochId))
+ }
+ l = len(x.Reason)
+ 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().(*EventGroupKeyValidationFailed)
+ 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.Reason) > 0 {
+ i -= len(x.Reason)
+ copy(dAtA[i:], x.Reason)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Reason)))
+ i--
+ dAtA[i] = 0x12
+ }
+ if x.NewEpochId != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.NewEpochId))
+ 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().(*EventGroupKeyValidationFailed)
+ 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: EventGroupKeyValidationFailed: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: EventGroupKeyValidationFailed: 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 NewEpochId", wireType)
+ }
+ x.NewEpochId = 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.NewEpochId |= 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 Reason", 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.Reason = 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_EventThresholdSigningRequested protoreflect.MessageDescriptor
+ fd_EventThresholdSigningRequested_request_id protoreflect.FieldDescriptor
+ fd_EventThresholdSigningRequested_current_epoch_id protoreflect.FieldDescriptor
+ fd_EventThresholdSigningRequested_encoded_data protoreflect.FieldDescriptor
+ fd_EventThresholdSigningRequested_message_hash protoreflect.FieldDescriptor
+ fd_EventThresholdSigningRequested_deadline_block_height protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bls_events_proto_init()
+ md_EventThresholdSigningRequested = File_inference_bls_events_proto.Messages().ByName("EventThresholdSigningRequested")
+ fd_EventThresholdSigningRequested_request_id = md_EventThresholdSigningRequested.Fields().ByName("request_id")
+ fd_EventThresholdSigningRequested_current_epoch_id = md_EventThresholdSigningRequested.Fields().ByName("current_epoch_id")
+ fd_EventThresholdSigningRequested_encoded_data = md_EventThresholdSigningRequested.Fields().ByName("encoded_data")
+ fd_EventThresholdSigningRequested_message_hash = md_EventThresholdSigningRequested.Fields().ByName("message_hash")
+ fd_EventThresholdSigningRequested_deadline_block_height = md_EventThresholdSigningRequested.Fields().ByName("deadline_block_height")
+}
+
+var _ protoreflect.Message = (*fastReflection_EventThresholdSigningRequested)(nil)
+
+type fastReflection_EventThresholdSigningRequested EventThresholdSigningRequested
+
+func (x *EventThresholdSigningRequested) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_EventThresholdSigningRequested)(x)
+}
+
+func (x *EventThresholdSigningRequested) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_events_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_EventThresholdSigningRequested_messageType fastReflection_EventThresholdSigningRequested_messageType
+var _ protoreflect.MessageType = fastReflection_EventThresholdSigningRequested_messageType{}
+
+type fastReflection_EventThresholdSigningRequested_messageType struct{}
+
+func (x fastReflection_EventThresholdSigningRequested_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_EventThresholdSigningRequested)(nil)
+}
+func (x fastReflection_EventThresholdSigningRequested_messageType) New() protoreflect.Message {
+ return new(fastReflection_EventThresholdSigningRequested)
+}
+func (x fastReflection_EventThresholdSigningRequested_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_EventThresholdSigningRequested
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_EventThresholdSigningRequested) Descriptor() protoreflect.MessageDescriptor {
+ return md_EventThresholdSigningRequested
+}
+
+// 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_EventThresholdSigningRequested) Type() protoreflect.MessageType {
+ return _fastReflection_EventThresholdSigningRequested_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_EventThresholdSigningRequested) New() protoreflect.Message {
+ return new(fastReflection_EventThresholdSigningRequested)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_EventThresholdSigningRequested) Interface() protoreflect.ProtoMessage {
+ return (*EventThresholdSigningRequested)(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_EventThresholdSigningRequested) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if len(x.RequestId) != 0 {
+ value := protoreflect.ValueOfBytes(x.RequestId)
+ if !f(fd_EventThresholdSigningRequested_request_id, value) {
+ return
+ }
+ }
+ if x.CurrentEpochId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.CurrentEpochId)
+ if !f(fd_EventThresholdSigningRequested_current_epoch_id, value) {
+ return
+ }
+ }
+ if len(x.EncodedData) != 0 {
+ value := protoreflect.ValueOfBytes(x.EncodedData)
+ if !f(fd_EventThresholdSigningRequested_encoded_data, value) {
+ return
+ }
+ }
+ if len(x.MessageHash) != 0 {
+ value := protoreflect.ValueOfBytes(x.MessageHash)
+ if !f(fd_EventThresholdSigningRequested_message_hash, value) {
+ return
+ }
+ }
+ if x.DeadlineBlockHeight != int64(0) {
+ value := protoreflect.ValueOfInt64(x.DeadlineBlockHeight)
+ if !f(fd_EventThresholdSigningRequested_deadline_block_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_EventThresholdSigningRequested) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bls.EventThresholdSigningRequested.request_id":
+ return len(x.RequestId) != 0
+ case "inference.bls.EventThresholdSigningRequested.current_epoch_id":
+ return x.CurrentEpochId != uint64(0)
+ case "inference.bls.EventThresholdSigningRequested.encoded_data":
+ return len(x.EncodedData) != 0
+ case "inference.bls.EventThresholdSigningRequested.message_hash":
+ return len(x.MessageHash) != 0
+ case "inference.bls.EventThresholdSigningRequested.deadline_block_height":
+ return x.DeadlineBlockHeight != int64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventThresholdSigningRequested"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventThresholdSigningRequested 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_EventThresholdSigningRequested) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bls.EventThresholdSigningRequested.request_id":
+ x.RequestId = nil
+ case "inference.bls.EventThresholdSigningRequested.current_epoch_id":
+ x.CurrentEpochId = uint64(0)
+ case "inference.bls.EventThresholdSigningRequested.encoded_data":
+ x.EncodedData = nil
+ case "inference.bls.EventThresholdSigningRequested.message_hash":
+ x.MessageHash = nil
+ case "inference.bls.EventThresholdSigningRequested.deadline_block_height":
+ x.DeadlineBlockHeight = int64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventThresholdSigningRequested"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventThresholdSigningRequested 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_EventThresholdSigningRequested) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bls.EventThresholdSigningRequested.request_id":
+ value := x.RequestId
+ return protoreflect.ValueOfBytes(value)
+ case "inference.bls.EventThresholdSigningRequested.current_epoch_id":
+ value := x.CurrentEpochId
+ return protoreflect.ValueOfUint64(value)
+ case "inference.bls.EventThresholdSigningRequested.encoded_data":
+ value := x.EncodedData
+ return protoreflect.ValueOfBytes(value)
+ case "inference.bls.EventThresholdSigningRequested.message_hash":
+ value := x.MessageHash
+ return protoreflect.ValueOfBytes(value)
+ case "inference.bls.EventThresholdSigningRequested.deadline_block_height":
+ value := x.DeadlineBlockHeight
+ return protoreflect.ValueOfInt64(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventThresholdSigningRequested"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventThresholdSigningRequested 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_EventThresholdSigningRequested) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bls.EventThresholdSigningRequested.request_id":
+ x.RequestId = value.Bytes()
+ case "inference.bls.EventThresholdSigningRequested.current_epoch_id":
+ x.CurrentEpochId = value.Uint()
+ case "inference.bls.EventThresholdSigningRequested.encoded_data":
+ x.EncodedData = value.Bytes()
+ case "inference.bls.EventThresholdSigningRequested.message_hash":
+ x.MessageHash = value.Bytes()
+ case "inference.bls.EventThresholdSigningRequested.deadline_block_height":
+ x.DeadlineBlockHeight = value.Int()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventThresholdSigningRequested"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventThresholdSigningRequested 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_EventThresholdSigningRequested) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.EventThresholdSigningRequested.request_id":
+ panic(fmt.Errorf("field request_id of message inference.bls.EventThresholdSigningRequested is not mutable"))
+ case "inference.bls.EventThresholdSigningRequested.current_epoch_id":
+ panic(fmt.Errorf("field current_epoch_id of message inference.bls.EventThresholdSigningRequested is not mutable"))
+ case "inference.bls.EventThresholdSigningRequested.encoded_data":
+ panic(fmt.Errorf("field encoded_data of message inference.bls.EventThresholdSigningRequested is not mutable"))
+ case "inference.bls.EventThresholdSigningRequested.message_hash":
+ panic(fmt.Errorf("field message_hash of message inference.bls.EventThresholdSigningRequested is not mutable"))
+ case "inference.bls.EventThresholdSigningRequested.deadline_block_height":
+ panic(fmt.Errorf("field deadline_block_height of message inference.bls.EventThresholdSigningRequested is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventThresholdSigningRequested"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventThresholdSigningRequested 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_EventThresholdSigningRequested) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.EventThresholdSigningRequested.request_id":
+ return protoreflect.ValueOfBytes(nil)
+ case "inference.bls.EventThresholdSigningRequested.current_epoch_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.bls.EventThresholdSigningRequested.encoded_data":
+ return protoreflect.ValueOfBytes(nil)
+ case "inference.bls.EventThresholdSigningRequested.message_hash":
+ return protoreflect.ValueOfBytes(nil)
+ case "inference.bls.EventThresholdSigningRequested.deadline_block_height":
+ return protoreflect.ValueOfInt64(int64(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventThresholdSigningRequested"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventThresholdSigningRequested 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_EventThresholdSigningRequested) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.EventThresholdSigningRequested", 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_EventThresholdSigningRequested) 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_EventThresholdSigningRequested) 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_EventThresholdSigningRequested) 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_EventThresholdSigningRequested) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*EventThresholdSigningRequested)
+ 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.RequestId)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.CurrentEpochId != 0 {
+ n += 1 + runtime.Sov(uint64(x.CurrentEpochId))
+ }
+ l = len(x.EncodedData)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ l = len(x.MessageHash)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.DeadlineBlockHeight != 0 {
+ n += 1 + runtime.Sov(uint64(x.DeadlineBlockHeight))
+ }
+ 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().(*EventThresholdSigningRequested)
+ 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.DeadlineBlockHeight != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.DeadlineBlockHeight))
+ i--
+ dAtA[i] = 0x28
+ }
+ if len(x.MessageHash) > 0 {
+ i -= len(x.MessageHash)
+ copy(dAtA[i:], x.MessageHash)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.MessageHash)))
+ i--
+ dAtA[i] = 0x22
+ }
+ if len(x.EncodedData) > 0 {
+ i -= len(x.EncodedData)
+ copy(dAtA[i:], x.EncodedData)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.EncodedData)))
+ i--
+ dAtA[i] = 0x1a
+ }
+ if x.CurrentEpochId != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.CurrentEpochId))
+ 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 {
+ 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().(*EventThresholdSigningRequested)
+ 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: EventThresholdSigningRequested: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: EventThresholdSigningRequested: 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 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.RequestId = append(x.RequestId[:0], dAtA[iNdEx:postIndex]...)
+ if x.RequestId == nil {
+ x.RequestId = []byte{}
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field CurrentEpochId", wireType)
+ }
+ x.CurrentEpochId = 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.CurrentEpochId |= 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 EncodedData", 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.EncodedData = append(x.EncodedData[:0], dAtA[iNdEx:postIndex]...)
+ if x.EncodedData == nil {
+ x.EncodedData = []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 MessageHash", 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.MessageHash = append(x.MessageHash[:0], dAtA[iNdEx:postIndex]...)
+ if x.MessageHash == nil {
+ x.MessageHash = []byte{}
+ }
+ iNdEx = postIndex
+ case 5:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DeadlineBlockHeight", wireType)
+ }
+ x.DeadlineBlockHeight = 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.DeadlineBlockHeight |= 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_EventThresholdSigningCompleted protoreflect.MessageDescriptor
+ fd_EventThresholdSigningCompleted_request_id protoreflect.FieldDescriptor
+ fd_EventThresholdSigningCompleted_current_epoch_id protoreflect.FieldDescriptor
+ fd_EventThresholdSigningCompleted_final_signature protoreflect.FieldDescriptor
+ fd_EventThresholdSigningCompleted_participating_slots protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bls_events_proto_init()
+ md_EventThresholdSigningCompleted = File_inference_bls_events_proto.Messages().ByName("EventThresholdSigningCompleted")
+ fd_EventThresholdSigningCompleted_request_id = md_EventThresholdSigningCompleted.Fields().ByName("request_id")
+ fd_EventThresholdSigningCompleted_current_epoch_id = md_EventThresholdSigningCompleted.Fields().ByName("current_epoch_id")
+ fd_EventThresholdSigningCompleted_final_signature = md_EventThresholdSigningCompleted.Fields().ByName("final_signature")
+ fd_EventThresholdSigningCompleted_participating_slots = md_EventThresholdSigningCompleted.Fields().ByName("participating_slots")
+}
+
+var _ protoreflect.Message = (*fastReflection_EventThresholdSigningCompleted)(nil)
+
+type fastReflection_EventThresholdSigningCompleted EventThresholdSigningCompleted
+
+func (x *EventThresholdSigningCompleted) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_EventThresholdSigningCompleted)(x)
+}
+
+func (x *EventThresholdSigningCompleted) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_events_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_EventThresholdSigningCompleted_messageType fastReflection_EventThresholdSigningCompleted_messageType
+var _ protoreflect.MessageType = fastReflection_EventThresholdSigningCompleted_messageType{}
+
+type fastReflection_EventThresholdSigningCompleted_messageType struct{}
+
+func (x fastReflection_EventThresholdSigningCompleted_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_EventThresholdSigningCompleted)(nil)
+}
+func (x fastReflection_EventThresholdSigningCompleted_messageType) New() protoreflect.Message {
+ return new(fastReflection_EventThresholdSigningCompleted)
+}
+func (x fastReflection_EventThresholdSigningCompleted_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_EventThresholdSigningCompleted
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_EventThresholdSigningCompleted) Descriptor() protoreflect.MessageDescriptor {
+ return md_EventThresholdSigningCompleted
+}
+
+// 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_EventThresholdSigningCompleted) Type() protoreflect.MessageType {
+ return _fastReflection_EventThresholdSigningCompleted_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_EventThresholdSigningCompleted) New() protoreflect.Message {
+ return new(fastReflection_EventThresholdSigningCompleted)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_EventThresholdSigningCompleted) Interface() protoreflect.ProtoMessage {
+ return (*EventThresholdSigningCompleted)(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_EventThresholdSigningCompleted) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if len(x.RequestId) != 0 {
+ value := protoreflect.ValueOfBytes(x.RequestId)
+ if !f(fd_EventThresholdSigningCompleted_request_id, value) {
+ return
+ }
+ }
+ if x.CurrentEpochId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.CurrentEpochId)
+ if !f(fd_EventThresholdSigningCompleted_current_epoch_id, value) {
+ return
+ }
+ }
+ if len(x.FinalSignature) != 0 {
+ value := protoreflect.ValueOfBytes(x.FinalSignature)
+ if !f(fd_EventThresholdSigningCompleted_final_signature, value) {
+ return
+ }
+ }
+ if x.ParticipatingSlots != uint32(0) {
+ value := protoreflect.ValueOfUint32(x.ParticipatingSlots)
+ if !f(fd_EventThresholdSigningCompleted_participating_slots, 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_EventThresholdSigningCompleted) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bls.EventThresholdSigningCompleted.request_id":
+ return len(x.RequestId) != 0
+ case "inference.bls.EventThresholdSigningCompleted.current_epoch_id":
+ return x.CurrentEpochId != uint64(0)
+ case "inference.bls.EventThresholdSigningCompleted.final_signature":
+ return len(x.FinalSignature) != 0
+ case "inference.bls.EventThresholdSigningCompleted.participating_slots":
+ return x.ParticipatingSlots != uint32(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventThresholdSigningCompleted"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventThresholdSigningCompleted 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_EventThresholdSigningCompleted) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bls.EventThresholdSigningCompleted.request_id":
+ x.RequestId = nil
+ case "inference.bls.EventThresholdSigningCompleted.current_epoch_id":
+ x.CurrentEpochId = uint64(0)
+ case "inference.bls.EventThresholdSigningCompleted.final_signature":
+ x.FinalSignature = nil
+ case "inference.bls.EventThresholdSigningCompleted.participating_slots":
+ x.ParticipatingSlots = uint32(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventThresholdSigningCompleted"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventThresholdSigningCompleted 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_EventThresholdSigningCompleted) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bls.EventThresholdSigningCompleted.request_id":
+ value := x.RequestId
+ return protoreflect.ValueOfBytes(value)
+ case "inference.bls.EventThresholdSigningCompleted.current_epoch_id":
+ value := x.CurrentEpochId
+ return protoreflect.ValueOfUint64(value)
+ case "inference.bls.EventThresholdSigningCompleted.final_signature":
+ value := x.FinalSignature
+ return protoreflect.ValueOfBytes(value)
+ case "inference.bls.EventThresholdSigningCompleted.participating_slots":
+ value := x.ParticipatingSlots
+ return protoreflect.ValueOfUint32(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventThresholdSigningCompleted"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventThresholdSigningCompleted 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_EventThresholdSigningCompleted) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bls.EventThresholdSigningCompleted.request_id":
+ x.RequestId = value.Bytes()
+ case "inference.bls.EventThresholdSigningCompleted.current_epoch_id":
+ x.CurrentEpochId = value.Uint()
+ case "inference.bls.EventThresholdSigningCompleted.final_signature":
+ x.FinalSignature = value.Bytes()
+ case "inference.bls.EventThresholdSigningCompleted.participating_slots":
+ x.ParticipatingSlots = uint32(value.Uint())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventThresholdSigningCompleted"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventThresholdSigningCompleted 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_EventThresholdSigningCompleted) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.EventThresholdSigningCompleted.request_id":
+ panic(fmt.Errorf("field request_id of message inference.bls.EventThresholdSigningCompleted is not mutable"))
+ case "inference.bls.EventThresholdSigningCompleted.current_epoch_id":
+ panic(fmt.Errorf("field current_epoch_id of message inference.bls.EventThresholdSigningCompleted is not mutable"))
+ case "inference.bls.EventThresholdSigningCompleted.final_signature":
+ panic(fmt.Errorf("field final_signature of message inference.bls.EventThresholdSigningCompleted is not mutable"))
+ case "inference.bls.EventThresholdSigningCompleted.participating_slots":
+ panic(fmt.Errorf("field participating_slots of message inference.bls.EventThresholdSigningCompleted is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventThresholdSigningCompleted"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventThresholdSigningCompleted 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_EventThresholdSigningCompleted) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.EventThresholdSigningCompleted.request_id":
+ return protoreflect.ValueOfBytes(nil)
+ case "inference.bls.EventThresholdSigningCompleted.current_epoch_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.bls.EventThresholdSigningCompleted.final_signature":
+ return protoreflect.ValueOfBytes(nil)
+ case "inference.bls.EventThresholdSigningCompleted.participating_slots":
+ return protoreflect.ValueOfUint32(uint32(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventThresholdSigningCompleted"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventThresholdSigningCompleted 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_EventThresholdSigningCompleted) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.EventThresholdSigningCompleted", 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_EventThresholdSigningCompleted) 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_EventThresholdSigningCompleted) 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_EventThresholdSigningCompleted) 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_EventThresholdSigningCompleted) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*EventThresholdSigningCompleted)
+ 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.RequestId)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.CurrentEpochId != 0 {
+ n += 1 + runtime.Sov(uint64(x.CurrentEpochId))
+ }
+ l = len(x.FinalSignature)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.ParticipatingSlots != 0 {
+ n += 1 + runtime.Sov(uint64(x.ParticipatingSlots))
+ }
+ 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().(*EventThresholdSigningCompleted)
+ 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.ParticipatingSlots != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.ParticipatingSlots))
+ i--
+ dAtA[i] = 0x20
+ }
+ if len(x.FinalSignature) > 0 {
+ i -= len(x.FinalSignature)
+ copy(dAtA[i:], x.FinalSignature)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.FinalSignature)))
+ i--
+ dAtA[i] = 0x1a
+ }
+ if x.CurrentEpochId != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.CurrentEpochId))
+ 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 {
+ 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().(*EventThresholdSigningCompleted)
+ 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: EventThresholdSigningCompleted: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: EventThresholdSigningCompleted: 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 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.RequestId = append(x.RequestId[:0], dAtA[iNdEx:postIndex]...)
+ if x.RequestId == nil {
+ x.RequestId = []byte{}
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field CurrentEpochId", wireType)
+ }
+ x.CurrentEpochId = 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.CurrentEpochId |= 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 FinalSignature", 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.FinalSignature = append(x.FinalSignature[:0], dAtA[iNdEx:postIndex]...)
+ if x.FinalSignature == nil {
+ x.FinalSignature = []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 ParticipatingSlots", wireType)
+ }
+ x.ParticipatingSlots = 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.ParticipatingSlots |= 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
+ }
+ }
+
+ 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_EventThresholdSigningFailed protoreflect.MessageDescriptor
+ fd_EventThresholdSigningFailed_request_id protoreflect.FieldDescriptor
+ fd_EventThresholdSigningFailed_current_epoch_id protoreflect.FieldDescriptor
+ fd_EventThresholdSigningFailed_reason protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bls_events_proto_init()
+ md_EventThresholdSigningFailed = File_inference_bls_events_proto.Messages().ByName("EventThresholdSigningFailed")
+ fd_EventThresholdSigningFailed_request_id = md_EventThresholdSigningFailed.Fields().ByName("request_id")
+ fd_EventThresholdSigningFailed_current_epoch_id = md_EventThresholdSigningFailed.Fields().ByName("current_epoch_id")
+ fd_EventThresholdSigningFailed_reason = md_EventThresholdSigningFailed.Fields().ByName("reason")
+}
+
+var _ protoreflect.Message = (*fastReflection_EventThresholdSigningFailed)(nil)
+
+type fastReflection_EventThresholdSigningFailed EventThresholdSigningFailed
+
+func (x *EventThresholdSigningFailed) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_EventThresholdSigningFailed)(x)
+}
+
+func (x *EventThresholdSigningFailed) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_events_proto_msgTypes[10]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_EventThresholdSigningFailed_messageType fastReflection_EventThresholdSigningFailed_messageType
+var _ protoreflect.MessageType = fastReflection_EventThresholdSigningFailed_messageType{}
+
+type fastReflection_EventThresholdSigningFailed_messageType struct{}
+
+func (x fastReflection_EventThresholdSigningFailed_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_EventThresholdSigningFailed)(nil)
+}
+func (x fastReflection_EventThresholdSigningFailed_messageType) New() protoreflect.Message {
+ return new(fastReflection_EventThresholdSigningFailed)
+}
+func (x fastReflection_EventThresholdSigningFailed_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_EventThresholdSigningFailed
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_EventThresholdSigningFailed) Descriptor() protoreflect.MessageDescriptor {
+ return md_EventThresholdSigningFailed
+}
+
+// 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_EventThresholdSigningFailed) Type() protoreflect.MessageType {
+ return _fastReflection_EventThresholdSigningFailed_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_EventThresholdSigningFailed) New() protoreflect.Message {
+ return new(fastReflection_EventThresholdSigningFailed)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_EventThresholdSigningFailed) Interface() protoreflect.ProtoMessage {
+ return (*EventThresholdSigningFailed)(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_EventThresholdSigningFailed) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if len(x.RequestId) != 0 {
+ value := protoreflect.ValueOfBytes(x.RequestId)
+ if !f(fd_EventThresholdSigningFailed_request_id, value) {
+ return
+ }
+ }
+ if x.CurrentEpochId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.CurrentEpochId)
+ if !f(fd_EventThresholdSigningFailed_current_epoch_id, value) {
+ return
+ }
+ }
+ if x.Reason != "" {
+ value := protoreflect.ValueOfString(x.Reason)
+ if !f(fd_EventThresholdSigningFailed_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_EventThresholdSigningFailed) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bls.EventThresholdSigningFailed.request_id":
+ return len(x.RequestId) != 0
+ case "inference.bls.EventThresholdSigningFailed.current_epoch_id":
+ return x.CurrentEpochId != uint64(0)
+ case "inference.bls.EventThresholdSigningFailed.reason":
+ return x.Reason != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventThresholdSigningFailed"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventThresholdSigningFailed 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_EventThresholdSigningFailed) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bls.EventThresholdSigningFailed.request_id":
+ x.RequestId = nil
+ case "inference.bls.EventThresholdSigningFailed.current_epoch_id":
+ x.CurrentEpochId = uint64(0)
+ case "inference.bls.EventThresholdSigningFailed.reason":
+ x.Reason = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventThresholdSigningFailed"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventThresholdSigningFailed 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_EventThresholdSigningFailed) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bls.EventThresholdSigningFailed.request_id":
+ value := x.RequestId
+ return protoreflect.ValueOfBytes(value)
+ case "inference.bls.EventThresholdSigningFailed.current_epoch_id":
+ value := x.CurrentEpochId
+ return protoreflect.ValueOfUint64(value)
+ case "inference.bls.EventThresholdSigningFailed.reason":
+ value := x.Reason
+ return protoreflect.ValueOfString(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventThresholdSigningFailed"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventThresholdSigningFailed 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_EventThresholdSigningFailed) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bls.EventThresholdSigningFailed.request_id":
+ x.RequestId = value.Bytes()
+ case "inference.bls.EventThresholdSigningFailed.current_epoch_id":
+ x.CurrentEpochId = value.Uint()
+ case "inference.bls.EventThresholdSigningFailed.reason":
+ x.Reason = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventThresholdSigningFailed"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventThresholdSigningFailed 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_EventThresholdSigningFailed) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.EventThresholdSigningFailed.request_id":
+ panic(fmt.Errorf("field request_id of message inference.bls.EventThresholdSigningFailed is not mutable"))
+ case "inference.bls.EventThresholdSigningFailed.current_epoch_id":
+ panic(fmt.Errorf("field current_epoch_id of message inference.bls.EventThresholdSigningFailed is not mutable"))
+ case "inference.bls.EventThresholdSigningFailed.reason":
+ panic(fmt.Errorf("field reason of message inference.bls.EventThresholdSigningFailed is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventThresholdSigningFailed"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventThresholdSigningFailed 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_EventThresholdSigningFailed) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.EventThresholdSigningFailed.request_id":
+ return protoreflect.ValueOfBytes(nil)
+ case "inference.bls.EventThresholdSigningFailed.current_epoch_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.bls.EventThresholdSigningFailed.reason":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EventThresholdSigningFailed"))
+ }
+ panic(fmt.Errorf("message inference.bls.EventThresholdSigningFailed 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_EventThresholdSigningFailed) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.EventThresholdSigningFailed", 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_EventThresholdSigningFailed) 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_EventThresholdSigningFailed) 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_EventThresholdSigningFailed) 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_EventThresholdSigningFailed) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*EventThresholdSigningFailed)
+ 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.RequestId)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.CurrentEpochId != 0 {
+ n += 1 + runtime.Sov(uint64(x.CurrentEpochId))
+ }
+ l = len(x.Reason)
+ 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().(*EventThresholdSigningFailed)
+ 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.Reason) > 0 {
+ i -= len(x.Reason)
+ copy(dAtA[i:], x.Reason)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Reason)))
+ i--
+ dAtA[i] = 0x1a
+ }
+ if x.CurrentEpochId != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.CurrentEpochId))
+ 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 {
+ 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().(*EventThresholdSigningFailed)
+ 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: EventThresholdSigningFailed: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: EventThresholdSigningFailed: 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 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.RequestId = append(x.RequestId[:0], dAtA[iNdEx:postIndex]...)
+ if x.RequestId == nil {
+ x.RequestId = []byte{}
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field CurrentEpochId", wireType)
+ }
+ x.CurrentEpochId = 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.CurrentEpochId |= 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 Reason", 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.Reason = 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/bls/events.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)
+)
+
+// EventKeyGenerationInitiated is emitted when DKG is initiated for an epoch
+type EventKeyGenerationInitiated struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // epoch_id uniquely identifies this DKG round
+ EpochId uint64 `protobuf:"varint,1,opt,name=epoch_id,json=epochId,proto3" json:"epoch_id,omitempty"`
+ // i_total_slots is the total number of slots in the DKG
+ ITotalSlots uint32 `protobuf:"varint,2,opt,name=i_total_slots,json=iTotalSlots,proto3" json:"i_total_slots,omitempty"`
+ // t_slots_degree is the polynomial degree t for the threshold scheme
+ TSlotsDegree uint32 `protobuf:"varint,3,opt,name=t_slots_degree,json=tSlotsDegree,proto3" json:"t_slots_degree,omitempty"`
+ // participants contains information about all participants in this DKG round
+ Participants []*BLSParticipantInfo `protobuf:"bytes,4,rep,name=participants,proto3" json:"participants,omitempty"`
+}
+
+func (x *EventKeyGenerationInitiated) Reset() {
+ *x = EventKeyGenerationInitiated{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_events_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *EventKeyGenerationInitiated) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*EventKeyGenerationInitiated) ProtoMessage() {}
+
+// Deprecated: Use EventKeyGenerationInitiated.ProtoReflect.Descriptor instead.
+func (*EventKeyGenerationInitiated) Descriptor() ([]byte, []int) {
+ return file_inference_bls_events_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *EventKeyGenerationInitiated) GetEpochId() uint64 {
+ if x != nil {
+ return x.EpochId
+ }
+ return 0
+}
+
+func (x *EventKeyGenerationInitiated) GetITotalSlots() uint32 {
+ if x != nil {
+ return x.ITotalSlots
+ }
+ return 0
+}
+
+func (x *EventKeyGenerationInitiated) GetTSlotsDegree() uint32 {
+ if x != nil {
+ return x.TSlotsDegree
+ }
+ return 0
+}
+
+func (x *EventKeyGenerationInitiated) GetParticipants() []*BLSParticipantInfo {
+ if x != nil {
+ return x.Participants
+ }
+ return nil
+}
+
+// EventDealerPartSubmitted is emitted when a participant submits their dealer part
+type EventDealerPartSubmitted struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // epoch_id identifies the DKG round this dealer part belongs to
+ EpochId uint64 `protobuf:"varint,1,opt,name=epoch_id,json=epochId,proto3" json:"epoch_id,omitempty"`
+ // dealer_address is the address of the dealer who submitted their part
+ DealerAddress string `protobuf:"bytes,2,opt,name=dealer_address,json=dealerAddress,proto3" json:"dealer_address,omitempty"`
+}
+
+func (x *EventDealerPartSubmitted) Reset() {
+ *x = EventDealerPartSubmitted{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_events_proto_msgTypes[1]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *EventDealerPartSubmitted) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*EventDealerPartSubmitted) ProtoMessage() {}
+
+// Deprecated: Use EventDealerPartSubmitted.ProtoReflect.Descriptor instead.
+func (*EventDealerPartSubmitted) Descriptor() ([]byte, []int) {
+ return file_inference_bls_events_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *EventDealerPartSubmitted) GetEpochId() uint64 {
+ if x != nil {
+ return x.EpochId
+ }
+ return 0
+}
+
+func (x *EventDealerPartSubmitted) GetDealerAddress() string {
+ if x != nil {
+ return x.DealerAddress
+ }
+ return ""
+}
+
+// EventVerifyingPhaseStarted is emitted when the DKG transitions to the verification phase
+type EventVerifyingPhaseStarted struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // epoch_id identifies the DKG round entering verification phase
+ EpochId uint64 `protobuf:"varint,1,opt,name=epoch_id,json=epochId,proto3" json:"epoch_id,omitempty"`
+ // verifying_phase_deadline_block is the block height deadline for the verification phase
+ VerifyingPhaseDeadlineBlock uint64 `protobuf:"varint,2,opt,name=verifying_phase_deadline_block,json=verifyingPhaseDeadlineBlock,proto3" json:"verifying_phase_deadline_block,omitempty"`
+ // epoch_data contains the complete epoch BLS data at the time of transition
+ EpochData *EpochBLSData `protobuf:"bytes,3,opt,name=epoch_data,json=epochData,proto3" json:"epoch_data,omitempty"`
+}
+
+func (x *EventVerifyingPhaseStarted) Reset() {
+ *x = EventVerifyingPhaseStarted{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_events_proto_msgTypes[2]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *EventVerifyingPhaseStarted) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*EventVerifyingPhaseStarted) ProtoMessage() {}
+
+// Deprecated: Use EventVerifyingPhaseStarted.ProtoReflect.Descriptor instead.
+func (*EventVerifyingPhaseStarted) Descriptor() ([]byte, []int) {
+ return file_inference_bls_events_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *EventVerifyingPhaseStarted) GetEpochId() uint64 {
+ if x != nil {
+ return x.EpochId
+ }
+ return 0
+}
+
+func (x *EventVerifyingPhaseStarted) GetVerifyingPhaseDeadlineBlock() uint64 {
+ if x != nil {
+ return x.VerifyingPhaseDeadlineBlock
+ }
+ return 0
+}
+
+func (x *EventVerifyingPhaseStarted) GetEpochData() *EpochBLSData {
+ if x != nil {
+ return x.EpochData
+ }
+ return nil
+}
+
+// EventDKGFailed is emitted when a DKG round fails
+type EventDKGFailed struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // epoch_id identifies the DKG round that failed
+ EpochId uint64 `protobuf:"varint,1,opt,name=epoch_id,json=epochId,proto3" json:"epoch_id,omitempty"`
+ // reason describes why the DKG failed
+ Reason string `protobuf:"bytes,2,opt,name=reason,proto3" json:"reason,omitempty"`
+ // epoch_data contains the complete epoch BLS data at the time of failure
+ EpochData *EpochBLSData `protobuf:"bytes,3,opt,name=epoch_data,json=epochData,proto3" json:"epoch_data,omitempty"`
+}
+
+func (x *EventDKGFailed) Reset() {
+ *x = EventDKGFailed{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_events_proto_msgTypes[3]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *EventDKGFailed) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*EventDKGFailed) ProtoMessage() {}
+
+// Deprecated: Use EventDKGFailed.ProtoReflect.Descriptor instead.
+func (*EventDKGFailed) Descriptor() ([]byte, []int) {
+ return file_inference_bls_events_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *EventDKGFailed) GetEpochId() uint64 {
+ if x != nil {
+ return x.EpochId
+ }
+ return 0
+}
+
+func (x *EventDKGFailed) GetReason() string {
+ if x != nil {
+ return x.Reason
+ }
+ return ""
+}
+
+func (x *EventDKGFailed) GetEpochData() *EpochBLSData {
+ if x != nil {
+ return x.EpochData
+ }
+ return nil
+}
+
+// EventVerificationVectorSubmitted is emitted when a participant submits their verification vector
+type EventVerificationVectorSubmitted struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // epoch_id identifies the DKG round this verification submission belongs to
+ EpochId uint64 `protobuf:"varint,1,opt,name=epoch_id,json=epochId,proto3" json:"epoch_id,omitempty"`
+ // participant_address is the address of the participant who submitted verification
+ ParticipantAddress string `protobuf:"bytes,2,opt,name=participant_address,json=participantAddress,proto3" json:"participant_address,omitempty"`
+}
+
+func (x *EventVerificationVectorSubmitted) Reset() {
+ *x = EventVerificationVectorSubmitted{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_events_proto_msgTypes[4]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *EventVerificationVectorSubmitted) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*EventVerificationVectorSubmitted) ProtoMessage() {}
+
+// Deprecated: Use EventVerificationVectorSubmitted.ProtoReflect.Descriptor instead.
+func (*EventVerificationVectorSubmitted) Descriptor() ([]byte, []int) {
+ return file_inference_bls_events_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *EventVerificationVectorSubmitted) GetEpochId() uint64 {
+ if x != nil {
+ return x.EpochId
+ }
+ return 0
+}
+
+func (x *EventVerificationVectorSubmitted) GetParticipantAddress() string {
+ if x != nil {
+ return x.ParticipantAddress
+ }
+ return ""
+}
+
+// EventGroupPublicKeyGenerated is emitted when the DKG completes successfully and group public key is computed
+type EventGroupPublicKeyGenerated struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // epoch_id uniquely identifies this DKG round
+ EpochId uint64 `protobuf:"varint,1,opt,name=epoch_id,json=epochId,proto3" json:"epoch_id,omitempty"`
+ // group_public_key is the final aggregated group public key (compressed G2 format, 96 bytes)
+ GroupPublicKey []byte `protobuf:"bytes,2,opt,name=group_public_key,json=groupPublicKey,proto3" json:"group_public_key,omitempty"`
+ // i_total_slots is the total number of slots in the DKG
+ ITotalSlots uint32 `protobuf:"varint,3,opt,name=i_total_slots,json=iTotalSlots,proto3" json:"i_total_slots,omitempty"`
+ // t_slots_degree is the polynomial degree t for the threshold scheme
+ TSlotsDegree uint32 `protobuf:"varint,4,opt,name=t_slots_degree,json=tSlotsDegree,proto3" json:"t_slots_degree,omitempty"`
+ // epoch_data contains the complete epoch BLS data at the time of completion
+ EpochData *EpochBLSData `protobuf:"bytes,5,opt,name=epoch_data,json=epochData,proto3" json:"epoch_data,omitempty"`
+ // chain_id is the chain ID for EIP-155 compatibility
+ ChainId string `protobuf:"bytes,6,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
+}
+
+func (x *EventGroupPublicKeyGenerated) Reset() {
+ *x = EventGroupPublicKeyGenerated{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_events_proto_msgTypes[5]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *EventGroupPublicKeyGenerated) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*EventGroupPublicKeyGenerated) ProtoMessage() {}
+
+// Deprecated: Use EventGroupPublicKeyGenerated.ProtoReflect.Descriptor instead.
+func (*EventGroupPublicKeyGenerated) Descriptor() ([]byte, []int) {
+ return file_inference_bls_events_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *EventGroupPublicKeyGenerated) GetEpochId() uint64 {
+ if x != nil {
+ return x.EpochId
+ }
+ return 0
+}
+
+func (x *EventGroupPublicKeyGenerated) GetGroupPublicKey() []byte {
+ if x != nil {
+ return x.GroupPublicKey
+ }
+ return nil
+}
+
+func (x *EventGroupPublicKeyGenerated) GetITotalSlots() uint32 {
+ if x != nil {
+ return x.ITotalSlots
+ }
+ return 0
+}
+
+func (x *EventGroupPublicKeyGenerated) GetTSlotsDegree() uint32 {
+ if x != nil {
+ return x.TSlotsDegree
+ }
+ return 0
+}
+
+func (x *EventGroupPublicKeyGenerated) GetEpochData() *EpochBLSData {
+ if x != nil {
+ return x.EpochData
+ }
+ return nil
+}
+
+func (x *EventGroupPublicKeyGenerated) GetChainId() string {
+ if x != nil {
+ return x.ChainId
+ }
+ return ""
+}
+
+// EventGroupKeyValidated is emitted when group key validation completes successfully
+type EventGroupKeyValidated struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // new_epoch_id identifies the epoch whose group public key was successfully validated
+ NewEpochId uint64 `protobuf:"varint,1,opt,name=new_epoch_id,json=newEpochId,proto3" json:"new_epoch_id,omitempty"`
+ // final_signature is the aggregated signature validating the new group public key (G1 point, 48-byte compressed)
+ FinalSignature []byte `protobuf:"bytes,2,opt,name=final_signature,json=finalSignature,proto3" json:"final_signature,omitempty"`
+}
+
+func (x *EventGroupKeyValidated) Reset() {
+ *x = EventGroupKeyValidated{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_events_proto_msgTypes[6]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *EventGroupKeyValidated) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*EventGroupKeyValidated) ProtoMessage() {}
+
+// Deprecated: Use EventGroupKeyValidated.ProtoReflect.Descriptor instead.
+func (*EventGroupKeyValidated) Descriptor() ([]byte, []int) {
+ return file_inference_bls_events_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *EventGroupKeyValidated) GetNewEpochId() uint64 {
+ if x != nil {
+ return x.NewEpochId
+ }
+ return 0
+}
+
+func (x *EventGroupKeyValidated) GetFinalSignature() []byte {
+ if x != nil {
+ return x.FinalSignature
+ }
+ return nil
+}
+
+// EventGroupKeyValidationFailed is emitted when group key validation fails
+type EventGroupKeyValidationFailed struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // new_epoch_id identifies the epoch whose group public key validation failed
+ NewEpochId uint64 `protobuf:"varint,1,opt,name=new_epoch_id,json=newEpochId,proto3" json:"new_epoch_id,omitempty"`
+ // reason describes why the validation failed
+ Reason string `protobuf:"bytes,2,opt,name=reason,proto3" json:"reason,omitempty"`
+}
+
+func (x *EventGroupKeyValidationFailed) Reset() {
+ *x = EventGroupKeyValidationFailed{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_events_proto_msgTypes[7]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *EventGroupKeyValidationFailed) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*EventGroupKeyValidationFailed) ProtoMessage() {}
+
+// Deprecated: Use EventGroupKeyValidationFailed.ProtoReflect.Descriptor instead.
+func (*EventGroupKeyValidationFailed) Descriptor() ([]byte, []int) {
+ return file_inference_bls_events_proto_rawDescGZIP(), []int{7}
+}
+
+func (x *EventGroupKeyValidationFailed) GetNewEpochId() uint64 {
+ if x != nil {
+ return x.NewEpochId
+ }
+ return 0
+}
+
+func (x *EventGroupKeyValidationFailed) GetReason() string {
+ if x != nil {
+ return x.Reason
+ }
+ return ""
+}
+
+// EventThresholdSigningRequested is emitted when a new threshold signing request is created
+type EventThresholdSigningRequested struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // request_id uniquely identifies this threshold signing request
+ RequestId []byte `protobuf:"bytes,1,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`
+ // current_epoch_id identifies the epoch being used for signing
+ CurrentEpochId uint64 `protobuf:"varint,2,opt,name=current_epoch_id,json=currentEpochId,proto3" json:"current_epoch_id,omitempty"`
+ // encoded_data is the Ethereum-compatible abi.encodePacked result that participants will sign
+ EncodedData []byte `protobuf:"bytes,3,opt,name=encoded_data,json=encodedData,proto3" json:"encoded_data,omitempty"`
+ // message_hash is the keccak256 hash of the encoded_data (pre-computed for participants)
+ MessageHash []byte `protobuf:"bytes,4,opt,name=message_hash,json=messageHash,proto3" json:"message_hash,omitempty"`
+ // deadline_block_height is the block height after which this request expires
+ DeadlineBlockHeight int64 `protobuf:"varint,5,opt,name=deadline_block_height,json=deadlineBlockHeight,proto3" json:"deadline_block_height,omitempty"`
+}
+
+func (x *EventThresholdSigningRequested) Reset() {
+ *x = EventThresholdSigningRequested{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_events_proto_msgTypes[8]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *EventThresholdSigningRequested) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*EventThresholdSigningRequested) ProtoMessage() {}
+
+// Deprecated: Use EventThresholdSigningRequested.ProtoReflect.Descriptor instead.
+func (*EventThresholdSigningRequested) Descriptor() ([]byte, []int) {
+ return file_inference_bls_events_proto_rawDescGZIP(), []int{8}
+}
+
+func (x *EventThresholdSigningRequested) GetRequestId() []byte {
+ if x != nil {
+ return x.RequestId
+ }
+ return nil
+}
+
+func (x *EventThresholdSigningRequested) GetCurrentEpochId() uint64 {
+ if x != nil {
+ return x.CurrentEpochId
+ }
+ return 0
+}
+
+func (x *EventThresholdSigningRequested) GetEncodedData() []byte {
+ if x != nil {
+ return x.EncodedData
+ }
+ return nil
+}
+
+func (x *EventThresholdSigningRequested) GetMessageHash() []byte {
+ if x != nil {
+ return x.MessageHash
+ }
+ return nil
+}
+
+func (x *EventThresholdSigningRequested) GetDeadlineBlockHeight() int64 {
+ if x != nil {
+ return x.DeadlineBlockHeight
+ }
+ return 0
+}
+
+// EventThresholdSigningCompleted is emitted when threshold signing completes successfully
+type EventThresholdSigningCompleted struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // request_id identifies the threshold signing request that completed
+ RequestId []byte `protobuf:"bytes,1,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`
+ // current_epoch_id identifies the epoch used for signing
+ CurrentEpochId uint64 `protobuf:"varint,2,opt,name=current_epoch_id,json=currentEpochId,proto3" json:"current_epoch_id,omitempty"`
+ // final_signature is the aggregated BLS threshold signature (G1 point, 48-byte compressed)
+ FinalSignature []byte `protobuf:"bytes,3,opt,name=final_signature,json=finalSignature,proto3" json:"final_signature,omitempty"`
+ // participating_slots is the total number of slots that participated in the signing
+ ParticipatingSlots uint32 `protobuf:"varint,4,opt,name=participating_slots,json=participatingSlots,proto3" json:"participating_slots,omitempty"`
+}
+
+func (x *EventThresholdSigningCompleted) Reset() {
+ *x = EventThresholdSigningCompleted{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_events_proto_msgTypes[9]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *EventThresholdSigningCompleted) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*EventThresholdSigningCompleted) ProtoMessage() {}
+
+// Deprecated: Use EventThresholdSigningCompleted.ProtoReflect.Descriptor instead.
+func (*EventThresholdSigningCompleted) Descriptor() ([]byte, []int) {
+ return file_inference_bls_events_proto_rawDescGZIP(), []int{9}
+}
+
+func (x *EventThresholdSigningCompleted) GetRequestId() []byte {
+ if x != nil {
+ return x.RequestId
+ }
+ return nil
+}
+
+func (x *EventThresholdSigningCompleted) GetCurrentEpochId() uint64 {
+ if x != nil {
+ return x.CurrentEpochId
+ }
+ return 0
+}
+
+func (x *EventThresholdSigningCompleted) GetFinalSignature() []byte {
+ if x != nil {
+ return x.FinalSignature
+ }
+ return nil
+}
+
+func (x *EventThresholdSigningCompleted) GetParticipatingSlots() uint32 {
+ if x != nil {
+ return x.ParticipatingSlots
+ }
+ return 0
+}
+
+// EventThresholdSigningFailed is emitted when threshold signing fails or expires
+type EventThresholdSigningFailed struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // request_id identifies the threshold signing request that failed
+ RequestId []byte `protobuf:"bytes,1,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`
+ // current_epoch_id identifies the epoch used for signing
+ CurrentEpochId uint64 `protobuf:"varint,2,opt,name=current_epoch_id,json=currentEpochId,proto3" json:"current_epoch_id,omitempty"`
+ // reason describes why the signing failed (e.g., "Deadline exceeded", "Insufficient participation")
+ Reason string `protobuf:"bytes,3,opt,name=reason,proto3" json:"reason,omitempty"`
+}
+
+func (x *EventThresholdSigningFailed) Reset() {
+ *x = EventThresholdSigningFailed{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_events_proto_msgTypes[10]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *EventThresholdSigningFailed) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*EventThresholdSigningFailed) ProtoMessage() {}
+
+// Deprecated: Use EventThresholdSigningFailed.ProtoReflect.Descriptor instead.
+func (*EventThresholdSigningFailed) Descriptor() ([]byte, []int) {
+ return file_inference_bls_events_proto_rawDescGZIP(), []int{10}
+}
+
+func (x *EventThresholdSigningFailed) GetRequestId() []byte {
+ if x != nil {
+ return x.RequestId
+ }
+ return nil
+}
+
+func (x *EventThresholdSigningFailed) GetCurrentEpochId() uint64 {
+ if x != nil {
+ return x.CurrentEpochId
+ }
+ return 0
+}
+
+func (x *EventThresholdSigningFailed) GetReason() string {
+ if x != nil {
+ return x.Reason
+ }
+ return ""
+}
+
+var File_inference_bls_events_proto protoreflect.FileDescriptor
+
+var file_inference_bls_events_proto_rawDesc = []byte{
+ 0x0a, 0x1a, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x62, 0x6c, 0x73, 0x2f,
+ 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0d, 0x69, 0x6e,
+ 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x1a, 0x11, 0x61, 0x6d, 0x69,
+ 0x6e, 0x6f, 0x2f, 0x61, 0x6d, 0x69, 0x6e, 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, 0x1a, 0x14, 0x67, 0x6f, 0x67, 0x6f, 0x70,
+ 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a,
+ 0x19, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x62, 0x6c, 0x73, 0x2f, 0x74,
+ 0x79, 0x70, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xcf, 0x01, 0x0a, 0x1b, 0x45,
+ 0x76, 0x65, 0x6e, 0x74, 0x4b, 0x65, 0x79, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f,
+ 0x6e, 0x49, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x65, 0x64, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x70,
+ 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x65, 0x70,
+ 0x6f, 0x63, 0x68, 0x49, 0x64, 0x12, 0x22, 0x0a, 0x0d, 0x69, 0x5f, 0x74, 0x6f, 0x74, 0x61, 0x6c,
+ 0x5f, 0x73, 0x6c, 0x6f, 0x74, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0b, 0x69, 0x54,
+ 0x6f, 0x74, 0x61, 0x6c, 0x53, 0x6c, 0x6f, 0x74, 0x73, 0x12, 0x24, 0x0a, 0x0e, 0x74, 0x5f, 0x73,
+ 0x6c, 0x6f, 0x74, 0x73, 0x5f, 0x64, 0x65, 0x67, 0x72, 0x65, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28,
+ 0x0d, 0x52, 0x0c, 0x74, 0x53, 0x6c, 0x6f, 0x74, 0x73, 0x44, 0x65, 0x67, 0x72, 0x65, 0x65, 0x12,
+ 0x4b, 0x0a, 0x0c, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x18,
+ 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+ 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x2e, 0x42, 0x4c, 0x53, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69,
+ 0x70, 0x61, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0c,
+ 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x22, 0x76, 0x0a, 0x18,
+ 0x45, 0x76, 0x65, 0x6e, 0x74, 0x44, 0x65, 0x61, 0x6c, 0x65, 0x72, 0x50, 0x61, 0x72, 0x74, 0x53,
+ 0x75, 0x62, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x64, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x70, 0x6f, 0x63,
+ 0x68, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x65, 0x70, 0x6f, 0x63,
+ 0x68, 0x49, 0x64, 0x12, 0x3f, 0x0a, 0x0e, 0x64, 0x65, 0x61, 0x6c, 0x65, 0x72, 0x5f, 0x61, 0x64,
+ 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 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, 0x0d, 0x64, 0x65, 0x61, 0x6c, 0x65, 0x72, 0x41, 0x64, 0x64,
+ 0x72, 0x65, 0x73, 0x73, 0x22, 0xbe, 0x01, 0x0a, 0x1a, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x56, 0x65,
+ 0x72, 0x69, 0x66, 0x79, 0x69, 0x6e, 0x67, 0x50, 0x68, 0x61, 0x73, 0x65, 0x53, 0x74, 0x61, 0x72,
+ 0x74, 0x65, 0x64, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x64, 0x18,
+ 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x64, 0x12, 0x43,
+ 0x0a, 0x1e, 0x76, 0x65, 0x72, 0x69, 0x66, 0x79, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x68, 0x61, 0x73,
+ 0x65, 0x5f, 0x64, 0x65, 0x61, 0x64, 0x6c, 0x69, 0x6e, 0x65, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b,
+ 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x1b, 0x76, 0x65, 0x72, 0x69, 0x66, 0x79, 0x69, 0x6e,
+ 0x67, 0x50, 0x68, 0x61, 0x73, 0x65, 0x44, 0x65, 0x61, 0x64, 0x6c, 0x69, 0x6e, 0x65, 0x42, 0x6c,
+ 0x6f, 0x63, 0x6b, 0x12, 0x40, 0x0a, 0x0a, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x64, 0x61, 0x74,
+ 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+ 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x2e, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x42, 0x4c, 0x53,
+ 0x44, 0x61, 0x74, 0x61, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x09, 0x65, 0x70, 0x6f, 0x63,
+ 0x68, 0x44, 0x61, 0x74, 0x61, 0x22, 0x85, 0x01, 0x0a, 0x0e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x44,
+ 0x4b, 0x47, 0x46, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x70, 0x6f, 0x63,
+ 0x68, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x65, 0x70, 0x6f, 0x63,
+ 0x68, 0x49, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x02, 0x20,
+ 0x01, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x12, 0x40, 0x0a, 0x0a, 0x65,
+ 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32,
+ 0x1b, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x2e,
+ 0x45, 0x70, 0x6f, 0x63, 0x68, 0x42, 0x4c, 0x53, 0x44, 0x61, 0x74, 0x61, 0x42, 0x04, 0xc8, 0xde,
+ 0x1f, 0x00, 0x52, 0x09, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x44, 0x61, 0x74, 0x61, 0x22, 0x88, 0x01,
+ 0x0a, 0x20, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x56, 0x65, 0x72, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74,
+ 0x69, 0x6f, 0x6e, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x74,
+ 0x65, 0x64, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x64, 0x18, 0x01,
+ 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x64, 0x12, 0x49, 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, 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, 0x12, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e,
+ 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x8a, 0x02, 0x0a, 0x1c, 0x45, 0x76, 0x65,
+ 0x6e, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79,
+ 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x70, 0x6f,
+ 0x63, 0x68, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x65, 0x70, 0x6f,
+ 0x63, 0x68, 0x49, 0x64, 0x12, 0x28, 0x0a, 0x10, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x70, 0x75,
+ 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0e,
+ 0x67, 0x72, 0x6f, 0x75, 0x70, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x12, 0x22,
+ 0x0a, 0x0d, 0x69, 0x5f, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x73, 0x6c, 0x6f, 0x74, 0x73, 0x18,
+ 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0b, 0x69, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x53, 0x6c, 0x6f,
+ 0x74, 0x73, 0x12, 0x24, 0x0a, 0x0e, 0x74, 0x5f, 0x73, 0x6c, 0x6f, 0x74, 0x73, 0x5f, 0x64, 0x65,
+ 0x67, 0x72, 0x65, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0c, 0x74, 0x53, 0x6c, 0x6f,
+ 0x74, 0x73, 0x44, 0x65, 0x67, 0x72, 0x65, 0x65, 0x12, 0x40, 0x0a, 0x0a, 0x65, 0x70, 0x6f, 0x63,
+ 0x68, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x69,
+ 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x2e, 0x45, 0x70, 0x6f,
+ 0x63, 0x68, 0x42, 0x4c, 0x53, 0x44, 0x61, 0x74, 0x61, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52,
+ 0x09, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x44, 0x61, 0x74, 0x61, 0x12, 0x19, 0x0a, 0x08, 0x63, 0x68,
+ 0x61, 0x69, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x68,
+ 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x63, 0x0a, 0x16, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x47, 0x72,
+ 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x64, 0x12,
+ 0x20, 0x0a, 0x0c, 0x6e, 0x65, 0x77, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x64, 0x18,
+ 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x6e, 0x65, 0x77, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x49,
+ 0x64, 0x12, 0x27, 0x0a, 0x0f, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x69, 0x67, 0x6e, 0x61,
+ 0x74, 0x75, 0x72, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0e, 0x66, 0x69, 0x6e, 0x61,
+ 0x6c, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x22, 0x59, 0x0a, 0x1d, 0x45, 0x76,
+ 0x65, 0x6e, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x56, 0x61, 0x6c, 0x69, 0x64,
+ 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x12, 0x20, 0x0a, 0x0c, 0x6e,
+ 0x65, 0x77, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28,
+ 0x04, 0x52, 0x0a, 0x6e, 0x65, 0x77, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x64, 0x12, 0x16, 0x0a,
+ 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x72,
+ 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x22, 0xe3, 0x01, 0x0a, 0x1e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x54,
+ 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x53, 0x69, 0x67, 0x6e, 0x69, 0x6e, 0x67, 0x52,
+ 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x65, 0x71, 0x75,
+ 0x65, 0x73, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x72, 0x65,
+ 0x71, 0x75, 0x65, 0x73, 0x74, 0x49, 0x64, 0x12, 0x28, 0x0a, 0x10, 0x63, 0x75, 0x72, 0x72, 0x65,
+ 0x6e, 0x74, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28,
+ 0x04, 0x52, 0x0e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x49,
+ 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x5f, 0x64, 0x61, 0x74,
+ 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64,
+ 0x44, 0x61, 0x74, 0x61, 0x12, 0x21, 0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f,
+ 0x68, 0x61, 0x73, 0x68, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x6d, 0x65, 0x73, 0x73,
+ 0x61, 0x67, 0x65, 0x48, 0x61, 0x73, 0x68, 0x12, 0x32, 0x0a, 0x15, 0x64, 0x65, 0x61, 0x64, 0x6c,
+ 0x69, 0x6e, 0x65, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74,
+ 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x13, 0x64, 0x65, 0x61, 0x64, 0x6c, 0x69, 0x6e, 0x65,
+ 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x22, 0xc3, 0x01, 0x0a, 0x1e,
+ 0x45, 0x76, 0x65, 0x6e, 0x74, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x53, 0x69,
+ 0x67, 0x6e, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x12, 0x1d,
+ 0x0a, 0x0a, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01,
+ 0x28, 0x0c, 0x52, 0x09, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x49, 0x64, 0x12, 0x28, 0x0a,
+ 0x10, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69,
+ 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74,
+ 0x45, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x64, 0x12, 0x27, 0x0a, 0x0f, 0x66, 0x69, 0x6e, 0x61, 0x6c,
+ 0x5f, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c,
+ 0x52, 0x0e, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65,
+ 0x12, 0x2f, 0x0a, 0x13, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x74, 0x69, 0x6e,
+ 0x67, 0x5f, 0x73, 0x6c, 0x6f, 0x74, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x12, 0x70,
+ 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x53, 0x6c, 0x6f, 0x74,
+ 0x73, 0x22, 0x7e, 0x0a, 0x1b, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68,
+ 0x6f, 0x6c, 0x64, 0x53, 0x69, 0x67, 0x6e, 0x69, 0x6e, 0x67, 0x46, 0x61, 0x69, 0x6c, 0x65, 0x64,
+ 0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01,
+ 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x49, 0x64, 0x12,
+ 0x28, 0x0a, 0x10, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68,
+ 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0e, 0x63, 0x75, 0x72, 0x72, 0x65,
+ 0x6e, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x61,
+ 0x73, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f,
+ 0x6e, 0x42, 0x95, 0x01, 0x0a, 0x11, 0x63, 0x6f, 0x6d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+ 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x42, 0x0b, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 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 (
+ file_inference_bls_events_proto_rawDescOnce sync.Once
+ file_inference_bls_events_proto_rawDescData = file_inference_bls_events_proto_rawDesc
+)
+
+func file_inference_bls_events_proto_rawDescGZIP() []byte {
+ file_inference_bls_events_proto_rawDescOnce.Do(func() {
+ file_inference_bls_events_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_bls_events_proto_rawDescData)
+ })
+ return file_inference_bls_events_proto_rawDescData
+}
+
+var file_inference_bls_events_proto_msgTypes = make([]protoimpl.MessageInfo, 11)
+var file_inference_bls_events_proto_goTypes = []interface{}{
+ (*EventKeyGenerationInitiated)(nil), // 0: inference.bls.EventKeyGenerationInitiated
+ (*EventDealerPartSubmitted)(nil), // 1: inference.bls.EventDealerPartSubmitted
+ (*EventVerifyingPhaseStarted)(nil), // 2: inference.bls.EventVerifyingPhaseStarted
+ (*EventDKGFailed)(nil), // 3: inference.bls.EventDKGFailed
+ (*EventVerificationVectorSubmitted)(nil), // 4: inference.bls.EventVerificationVectorSubmitted
+ (*EventGroupPublicKeyGenerated)(nil), // 5: inference.bls.EventGroupPublicKeyGenerated
+ (*EventGroupKeyValidated)(nil), // 6: inference.bls.EventGroupKeyValidated
+ (*EventGroupKeyValidationFailed)(nil), // 7: inference.bls.EventGroupKeyValidationFailed
+ (*EventThresholdSigningRequested)(nil), // 8: inference.bls.EventThresholdSigningRequested
+ (*EventThresholdSigningCompleted)(nil), // 9: inference.bls.EventThresholdSigningCompleted
+ (*EventThresholdSigningFailed)(nil), // 10: inference.bls.EventThresholdSigningFailed
+ (*BLSParticipantInfo)(nil), // 11: inference.bls.BLSParticipantInfo
+ (*EpochBLSData)(nil), // 12: inference.bls.EpochBLSData
+}
+var file_inference_bls_events_proto_depIdxs = []int32{
+ 11, // 0: inference.bls.EventKeyGenerationInitiated.participants:type_name -> inference.bls.BLSParticipantInfo
+ 12, // 1: inference.bls.EventVerifyingPhaseStarted.epoch_data:type_name -> inference.bls.EpochBLSData
+ 12, // 2: inference.bls.EventDKGFailed.epoch_data:type_name -> inference.bls.EpochBLSData
+ 12, // 3: inference.bls.EventGroupPublicKeyGenerated.epoch_data:type_name -> inference.bls.EpochBLSData
+ 4, // [4:4] is the sub-list for method output_type
+ 4, // [4:4] is the sub-list for method input_type
+ 4, // [4:4] is the sub-list for extension type_name
+ 4, // [4:4] is the sub-list for extension extendee
+ 0, // [0:4] is the sub-list for field type_name
+}
+
+func init() { file_inference_bls_events_proto_init() }
+func file_inference_bls_events_proto_init() {
+ if File_inference_bls_events_proto != nil {
+ return
+ }
+ file_inference_bls_types_proto_init()
+ if !protoimpl.UnsafeEnabled {
+ file_inference_bls_events_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*EventKeyGenerationInitiated); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_bls_events_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*EventDealerPartSubmitted); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_bls_events_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*EventVerifyingPhaseStarted); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_bls_events_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*EventDKGFailed); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_bls_events_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*EventVerificationVectorSubmitted); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_bls_events_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*EventGroupPublicKeyGenerated); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_bls_events_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*EventGroupKeyValidated); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_bls_events_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*EventGroupKeyValidationFailed); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_bls_events_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*EventThresholdSigningRequested); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_bls_events_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*EventThresholdSigningCompleted); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_bls_events_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*EventThresholdSigningFailed); 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_bls_events_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 11,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_bls_events_proto_goTypes,
+ DependencyIndexes: file_inference_bls_events_proto_depIdxs,
+ MessageInfos: file_inference_bls_events_proto_msgTypes,
+ }.Build()
+ File_inference_bls_events_proto = out.File
+ file_inference_bls_events_proto_rawDesc = nil
+ file_inference_bls_events_proto_goTypes = nil
+ file_inference_bls_events_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/bls/genesis.pulsar.go b/inference-chain/api/inference/bls/genesis.pulsar.go
new file mode 100644
index 000000000..6ccf5d8f2
--- /dev/null
+++ b/inference-chain/api/inference/bls/genesis.pulsar.go
@@ -0,0 +1,655 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package bls
+
+import (
+ _ "cosmossdk.io/api/amino"
+ fmt "fmt"
+ runtime "github.com/cosmos/cosmos-proto/runtime"
+ _ "github.com/cosmos/gogoproto/gogoproto"
+ 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_GenesisState protoreflect.MessageDescriptor
+ fd_GenesisState_params protoreflect.FieldDescriptor
+ fd_GenesisState_active_epoch_id protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bls_genesis_proto_init()
+ md_GenesisState = File_inference_bls_genesis_proto.Messages().ByName("GenesisState")
+ fd_GenesisState_params = md_GenesisState.Fields().ByName("params")
+ fd_GenesisState_active_epoch_id = md_GenesisState.Fields().ByName("active_epoch_id")
+}
+
+var _ protoreflect.Message = (*fastReflection_GenesisState)(nil)
+
+type fastReflection_GenesisState GenesisState
+
+func (x *GenesisState) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_GenesisState)(x)
+}
+
+func (x *GenesisState) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_genesis_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_GenesisState_messageType fastReflection_GenesisState_messageType
+var _ protoreflect.MessageType = fastReflection_GenesisState_messageType{}
+
+type fastReflection_GenesisState_messageType struct{}
+
+func (x fastReflection_GenesisState_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_GenesisState)(nil)
+}
+func (x fastReflection_GenesisState_messageType) New() protoreflect.Message {
+ return new(fastReflection_GenesisState)
+}
+func (x fastReflection_GenesisState_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_GenesisState
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_GenesisState) Descriptor() protoreflect.MessageDescriptor {
+ return md_GenesisState
+}
+
+// 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_GenesisState) Type() protoreflect.MessageType {
+ return _fastReflection_GenesisState_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_GenesisState) New() protoreflect.Message {
+ return new(fastReflection_GenesisState)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_GenesisState) Interface() protoreflect.ProtoMessage {
+ return (*GenesisState)(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_GenesisState) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Params != nil {
+ value := protoreflect.ValueOfMessage(x.Params.ProtoReflect())
+ if !f(fd_GenesisState_params, value) {
+ return
+ }
+ }
+ if x.ActiveEpochId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.ActiveEpochId)
+ if !f(fd_GenesisState_active_epoch_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_GenesisState) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bls.GenesisState.params":
+ return x.Params != nil
+ case "inference.bls.GenesisState.active_epoch_id":
+ return x.ActiveEpochId != uint64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.GenesisState"))
+ }
+ panic(fmt.Errorf("message inference.bls.GenesisState 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_GenesisState) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bls.GenesisState.params":
+ x.Params = nil
+ case "inference.bls.GenesisState.active_epoch_id":
+ x.ActiveEpochId = uint64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.GenesisState"))
+ }
+ panic(fmt.Errorf("message inference.bls.GenesisState 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_GenesisState) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bls.GenesisState.params":
+ value := x.Params
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.bls.GenesisState.active_epoch_id":
+ value := x.ActiveEpochId
+ return protoreflect.ValueOfUint64(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.GenesisState"))
+ }
+ panic(fmt.Errorf("message inference.bls.GenesisState 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_GenesisState) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bls.GenesisState.params":
+ x.Params = value.Message().Interface().(*Params)
+ case "inference.bls.GenesisState.active_epoch_id":
+ x.ActiveEpochId = value.Uint()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.GenesisState"))
+ }
+ panic(fmt.Errorf("message inference.bls.GenesisState 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_GenesisState) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.GenesisState.params":
+ if x.Params == nil {
+ x.Params = new(Params)
+ }
+ return protoreflect.ValueOfMessage(x.Params.ProtoReflect())
+ case "inference.bls.GenesisState.active_epoch_id":
+ panic(fmt.Errorf("field active_epoch_id of message inference.bls.GenesisState is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.GenesisState"))
+ }
+ panic(fmt.Errorf("message inference.bls.GenesisState 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_GenesisState) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.GenesisState.params":
+ m := new(Params)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.bls.GenesisState.active_epoch_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.GenesisState"))
+ }
+ panic(fmt.Errorf("message inference.bls.GenesisState 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_GenesisState) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.GenesisState", 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_GenesisState) 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_GenesisState) 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_GenesisState) 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_GenesisState) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*GenesisState)
+ 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.Params != nil {
+ l = options.Size(x.Params)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.ActiveEpochId != 0 {
+ n += 1 + runtime.Sov(uint64(x.ActiveEpochId))
+ }
+ 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().(*GenesisState)
+ 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.ActiveEpochId != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.ActiveEpochId))
+ i--
+ dAtA[i] = 0x10
+ }
+ 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] = 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().(*GenesisState)
+ 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: GenesisState: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: GenesisState: 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 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 2:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ActiveEpochId", wireType)
+ }
+ x.ActiveEpochId = 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.ActiveEpochId |= 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,
+ }
+}
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// protoc-gen-go v1.27.0
+// protoc (unknown)
+// source: inference/bls/genesis.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)
+)
+
+// GenesisState defines the bls module's genesis state.
+type GenesisState struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // params defines all the parameters of the module.
+ Params *Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params,omitempty"`
+ // active_epoch_id is the current epoch undergoing DKG process
+ // Only one epoch can have active DKG at a time
+ // 0 means no active DKG
+ ActiveEpochId uint64 `protobuf:"varint,2,opt,name=active_epoch_id,json=activeEpochId,proto3" json:"active_epoch_id,omitempty"`
+}
+
+func (x *GenesisState) Reset() {
+ *x = GenesisState{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_genesis_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *GenesisState) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GenesisState) ProtoMessage() {}
+
+// Deprecated: Use GenesisState.ProtoReflect.Descriptor instead.
+func (*GenesisState) Descriptor() ([]byte, []int) {
+ return file_inference_bls_genesis_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *GenesisState) GetParams() *Params {
+ if x != nil {
+ return x.Params
+ }
+ return nil
+}
+
+func (x *GenesisState) GetActiveEpochId() uint64 {
+ if x != nil {
+ return x.ActiveEpochId
+ }
+ return 0
+}
+
+var File_inference_bls_genesis_proto protoreflect.FileDescriptor
+
+var file_inference_bls_genesis_proto_rawDesc = []byte{
+ 0x0a, 0x1b, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x62, 0x6c, 0x73, 0x2f,
+ 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0d, 0x69,
+ 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x1a, 0x11, 0x61, 0x6d,
+ 0x69, 0x6e, 0x6f, 0x2f, 0x61, 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, 0x1a, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+ 0x2f, 0x62, 0x6c, 0x73, 0x2f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+ 0x6f, 0x22, 0x70, 0x0a, 0x0c, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x53, 0x74, 0x61, 0x74,
+ 0x65, 0x12, 0x38, 0x0a, 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28,
+ 0x0b, 0x32, 0x15, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c,
+ 0x73, 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, 0x12, 0x26, 0x0a, 0x0f, 0x61,
+ 0x63, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x64, 0x18, 0x02,
+ 0x20, 0x01, 0x28, 0x04, 0x52, 0x0d, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x45, 0x70, 0x6f, 0x63,
+ 0x68, 0x49, 0x64, 0x42, 0x96, 0x01, 0x0a, 0x11, 0x63, 0x6f, 0x6d, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+ 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x42, 0x0c, 0x47, 0x65, 0x6e, 0x65, 0x73,
+ 0x69, 0x73, 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 (
+ file_inference_bls_genesis_proto_rawDescOnce sync.Once
+ file_inference_bls_genesis_proto_rawDescData = file_inference_bls_genesis_proto_rawDesc
+)
+
+func file_inference_bls_genesis_proto_rawDescGZIP() []byte {
+ file_inference_bls_genesis_proto_rawDescOnce.Do(func() {
+ file_inference_bls_genesis_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_bls_genesis_proto_rawDescData)
+ })
+ return file_inference_bls_genesis_proto_rawDescData
+}
+
+var file_inference_bls_genesis_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_inference_bls_genesis_proto_goTypes = []interface{}{
+ (*GenesisState)(nil), // 0: inference.bls.GenesisState
+ (*Params)(nil), // 1: inference.bls.Params
+}
+var file_inference_bls_genesis_proto_depIdxs = []int32{
+ 1, // 0: inference.bls.GenesisState.params:type_name -> inference.bls.Params
+ 1, // [1:1] is the sub-list for method output_type
+ 1, // [1:1] is the sub-list for method input_type
+ 1, // [1:1] is the sub-list for extension type_name
+ 1, // [1:1] is the sub-list for extension extendee
+ 0, // [0:1] is the sub-list for field type_name
+}
+
+func init() { file_inference_bls_genesis_proto_init() }
+func file_inference_bls_genesis_proto_init() {
+ if File_inference_bls_genesis_proto != nil {
+ return
+ }
+ file_inference_bls_params_proto_init()
+ if !protoimpl.UnsafeEnabled {
+ file_inference_bls_genesis_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*GenesisState); 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_bls_genesis_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 1,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_bls_genesis_proto_goTypes,
+ DependencyIndexes: file_inference_bls_genesis_proto_depIdxs,
+ MessageInfos: file_inference_bls_genesis_proto_msgTypes,
+ }.Build()
+ File_inference_bls_genesis_proto = out.File
+ file_inference_bls_genesis_proto_rawDesc = nil
+ file_inference_bls_genesis_proto_goTypes = nil
+ file_inference_bls_genesis_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/bls/group_validation.pulsar.go b/inference-chain/api/inference/bls/group_validation.pulsar.go
new file mode 100644
index 000000000..0cff88844
--- /dev/null
+++ b/inference-chain/api/inference/bls/group_validation.pulsar.go
@@ -0,0 +1,1118 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package bls
+
+import (
+ _ "cosmossdk.io/api/amino"
+ fmt "fmt"
+ runtime "github.com/cosmos/cosmos-proto/runtime"
+ _ "github.com/cosmos/gogoproto/gogoproto"
+ 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 _ protoreflect.List = (*_GroupKeyValidationState_4_list)(nil)
+
+type _GroupKeyValidationState_4_list struct {
+ list *[]*PartialSignature
+}
+
+func (x *_GroupKeyValidationState_4_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_GroupKeyValidationState_4_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_GroupKeyValidationState_4_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*PartialSignature)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_GroupKeyValidationState_4_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*PartialSignature)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_GroupKeyValidationState_4_list) AppendMutable() protoreflect.Value {
+ v := new(PartialSignature)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_GroupKeyValidationState_4_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_GroupKeyValidationState_4_list) NewElement() protoreflect.Value {
+ v := new(PartialSignature)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_GroupKeyValidationState_4_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_GroupKeyValidationState protoreflect.MessageDescriptor
+ fd_GroupKeyValidationState_new_epoch_id protoreflect.FieldDescriptor
+ fd_GroupKeyValidationState_previous_epoch_id protoreflect.FieldDescriptor
+ fd_GroupKeyValidationState_status protoreflect.FieldDescriptor
+ fd_GroupKeyValidationState_partial_signatures protoreflect.FieldDescriptor
+ fd_GroupKeyValidationState_final_signature protoreflect.FieldDescriptor
+ fd_GroupKeyValidationState_message_hash protoreflect.FieldDescriptor
+ fd_GroupKeyValidationState_slots_covered protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bls_group_validation_proto_init()
+ md_GroupKeyValidationState = File_inference_bls_group_validation_proto.Messages().ByName("GroupKeyValidationState")
+ fd_GroupKeyValidationState_new_epoch_id = md_GroupKeyValidationState.Fields().ByName("new_epoch_id")
+ fd_GroupKeyValidationState_previous_epoch_id = md_GroupKeyValidationState.Fields().ByName("previous_epoch_id")
+ fd_GroupKeyValidationState_status = md_GroupKeyValidationState.Fields().ByName("status")
+ fd_GroupKeyValidationState_partial_signatures = md_GroupKeyValidationState.Fields().ByName("partial_signatures")
+ fd_GroupKeyValidationState_final_signature = md_GroupKeyValidationState.Fields().ByName("final_signature")
+ fd_GroupKeyValidationState_message_hash = md_GroupKeyValidationState.Fields().ByName("message_hash")
+ fd_GroupKeyValidationState_slots_covered = md_GroupKeyValidationState.Fields().ByName("slots_covered")
+}
+
+var _ protoreflect.Message = (*fastReflection_GroupKeyValidationState)(nil)
+
+type fastReflection_GroupKeyValidationState GroupKeyValidationState
+
+func (x *GroupKeyValidationState) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_GroupKeyValidationState)(x)
+}
+
+func (x *GroupKeyValidationState) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_group_validation_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_GroupKeyValidationState_messageType fastReflection_GroupKeyValidationState_messageType
+var _ protoreflect.MessageType = fastReflection_GroupKeyValidationState_messageType{}
+
+type fastReflection_GroupKeyValidationState_messageType struct{}
+
+func (x fastReflection_GroupKeyValidationState_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_GroupKeyValidationState)(nil)
+}
+func (x fastReflection_GroupKeyValidationState_messageType) New() protoreflect.Message {
+ return new(fastReflection_GroupKeyValidationState)
+}
+func (x fastReflection_GroupKeyValidationState_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_GroupKeyValidationState
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_GroupKeyValidationState) Descriptor() protoreflect.MessageDescriptor {
+ return md_GroupKeyValidationState
+}
+
+// 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_GroupKeyValidationState) Type() protoreflect.MessageType {
+ return _fastReflection_GroupKeyValidationState_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_GroupKeyValidationState) New() protoreflect.Message {
+ return new(fastReflection_GroupKeyValidationState)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_GroupKeyValidationState) Interface() protoreflect.ProtoMessage {
+ return (*GroupKeyValidationState)(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_GroupKeyValidationState) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.NewEpochId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.NewEpochId)
+ if !f(fd_GroupKeyValidationState_new_epoch_id, value) {
+ return
+ }
+ }
+ if x.PreviousEpochId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.PreviousEpochId)
+ if !f(fd_GroupKeyValidationState_previous_epoch_id, value) {
+ return
+ }
+ }
+ if x.Status != 0 {
+ value := protoreflect.ValueOfEnum((protoreflect.EnumNumber)(x.Status))
+ if !f(fd_GroupKeyValidationState_status, value) {
+ return
+ }
+ }
+ if len(x.PartialSignatures) != 0 {
+ value := protoreflect.ValueOfList(&_GroupKeyValidationState_4_list{list: &x.PartialSignatures})
+ if !f(fd_GroupKeyValidationState_partial_signatures, value) {
+ return
+ }
+ }
+ if len(x.FinalSignature) != 0 {
+ value := protoreflect.ValueOfBytes(x.FinalSignature)
+ if !f(fd_GroupKeyValidationState_final_signature, value) {
+ return
+ }
+ }
+ if len(x.MessageHash) != 0 {
+ value := protoreflect.ValueOfBytes(x.MessageHash)
+ if !f(fd_GroupKeyValidationState_message_hash, value) {
+ return
+ }
+ }
+ if x.SlotsCovered != uint32(0) {
+ value := protoreflect.ValueOfUint32(x.SlotsCovered)
+ if !f(fd_GroupKeyValidationState_slots_covered, 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_GroupKeyValidationState) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bls.GroupKeyValidationState.new_epoch_id":
+ return x.NewEpochId != uint64(0)
+ case "inference.bls.GroupKeyValidationState.previous_epoch_id":
+ return x.PreviousEpochId != uint64(0)
+ case "inference.bls.GroupKeyValidationState.status":
+ return x.Status != 0
+ case "inference.bls.GroupKeyValidationState.partial_signatures":
+ return len(x.PartialSignatures) != 0
+ case "inference.bls.GroupKeyValidationState.final_signature":
+ return len(x.FinalSignature) != 0
+ case "inference.bls.GroupKeyValidationState.message_hash":
+ return len(x.MessageHash) != 0
+ case "inference.bls.GroupKeyValidationState.slots_covered":
+ return x.SlotsCovered != uint32(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.GroupKeyValidationState"))
+ }
+ panic(fmt.Errorf("message inference.bls.GroupKeyValidationState 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_GroupKeyValidationState) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bls.GroupKeyValidationState.new_epoch_id":
+ x.NewEpochId = uint64(0)
+ case "inference.bls.GroupKeyValidationState.previous_epoch_id":
+ x.PreviousEpochId = uint64(0)
+ case "inference.bls.GroupKeyValidationState.status":
+ x.Status = 0
+ case "inference.bls.GroupKeyValidationState.partial_signatures":
+ x.PartialSignatures = nil
+ case "inference.bls.GroupKeyValidationState.final_signature":
+ x.FinalSignature = nil
+ case "inference.bls.GroupKeyValidationState.message_hash":
+ x.MessageHash = nil
+ case "inference.bls.GroupKeyValidationState.slots_covered":
+ x.SlotsCovered = uint32(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.GroupKeyValidationState"))
+ }
+ panic(fmt.Errorf("message inference.bls.GroupKeyValidationState 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_GroupKeyValidationState) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bls.GroupKeyValidationState.new_epoch_id":
+ value := x.NewEpochId
+ return protoreflect.ValueOfUint64(value)
+ case "inference.bls.GroupKeyValidationState.previous_epoch_id":
+ value := x.PreviousEpochId
+ return protoreflect.ValueOfUint64(value)
+ case "inference.bls.GroupKeyValidationState.status":
+ value := x.Status
+ return protoreflect.ValueOfEnum((protoreflect.EnumNumber)(value))
+ case "inference.bls.GroupKeyValidationState.partial_signatures":
+ if len(x.PartialSignatures) == 0 {
+ return protoreflect.ValueOfList(&_GroupKeyValidationState_4_list{})
+ }
+ listValue := &_GroupKeyValidationState_4_list{list: &x.PartialSignatures}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.bls.GroupKeyValidationState.final_signature":
+ value := x.FinalSignature
+ return protoreflect.ValueOfBytes(value)
+ case "inference.bls.GroupKeyValidationState.message_hash":
+ value := x.MessageHash
+ return protoreflect.ValueOfBytes(value)
+ case "inference.bls.GroupKeyValidationState.slots_covered":
+ value := x.SlotsCovered
+ return protoreflect.ValueOfUint32(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.GroupKeyValidationState"))
+ }
+ panic(fmt.Errorf("message inference.bls.GroupKeyValidationState 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_GroupKeyValidationState) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bls.GroupKeyValidationState.new_epoch_id":
+ x.NewEpochId = value.Uint()
+ case "inference.bls.GroupKeyValidationState.previous_epoch_id":
+ x.PreviousEpochId = value.Uint()
+ case "inference.bls.GroupKeyValidationState.status":
+ x.Status = (GroupKeyValidationStatus)(value.Enum())
+ case "inference.bls.GroupKeyValidationState.partial_signatures":
+ lv := value.List()
+ clv := lv.(*_GroupKeyValidationState_4_list)
+ x.PartialSignatures = *clv.list
+ case "inference.bls.GroupKeyValidationState.final_signature":
+ x.FinalSignature = value.Bytes()
+ case "inference.bls.GroupKeyValidationState.message_hash":
+ x.MessageHash = value.Bytes()
+ case "inference.bls.GroupKeyValidationState.slots_covered":
+ x.SlotsCovered = uint32(value.Uint())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.GroupKeyValidationState"))
+ }
+ panic(fmt.Errorf("message inference.bls.GroupKeyValidationState 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_GroupKeyValidationState) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.GroupKeyValidationState.partial_signatures":
+ if x.PartialSignatures == nil {
+ x.PartialSignatures = []*PartialSignature{}
+ }
+ value := &_GroupKeyValidationState_4_list{list: &x.PartialSignatures}
+ return protoreflect.ValueOfList(value)
+ case "inference.bls.GroupKeyValidationState.new_epoch_id":
+ panic(fmt.Errorf("field new_epoch_id of message inference.bls.GroupKeyValidationState is not mutable"))
+ case "inference.bls.GroupKeyValidationState.previous_epoch_id":
+ panic(fmt.Errorf("field previous_epoch_id of message inference.bls.GroupKeyValidationState is not mutable"))
+ case "inference.bls.GroupKeyValidationState.status":
+ panic(fmt.Errorf("field status of message inference.bls.GroupKeyValidationState is not mutable"))
+ case "inference.bls.GroupKeyValidationState.final_signature":
+ panic(fmt.Errorf("field final_signature of message inference.bls.GroupKeyValidationState is not mutable"))
+ case "inference.bls.GroupKeyValidationState.message_hash":
+ panic(fmt.Errorf("field message_hash of message inference.bls.GroupKeyValidationState is not mutable"))
+ case "inference.bls.GroupKeyValidationState.slots_covered":
+ panic(fmt.Errorf("field slots_covered of message inference.bls.GroupKeyValidationState is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.GroupKeyValidationState"))
+ }
+ panic(fmt.Errorf("message inference.bls.GroupKeyValidationState 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_GroupKeyValidationState) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.GroupKeyValidationState.new_epoch_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.bls.GroupKeyValidationState.previous_epoch_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.bls.GroupKeyValidationState.status":
+ return protoreflect.ValueOfEnum(0)
+ case "inference.bls.GroupKeyValidationState.partial_signatures":
+ list := []*PartialSignature{}
+ return protoreflect.ValueOfList(&_GroupKeyValidationState_4_list{list: &list})
+ case "inference.bls.GroupKeyValidationState.final_signature":
+ return protoreflect.ValueOfBytes(nil)
+ case "inference.bls.GroupKeyValidationState.message_hash":
+ return protoreflect.ValueOfBytes(nil)
+ case "inference.bls.GroupKeyValidationState.slots_covered":
+ return protoreflect.ValueOfUint32(uint32(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.GroupKeyValidationState"))
+ }
+ panic(fmt.Errorf("message inference.bls.GroupKeyValidationState 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_GroupKeyValidationState) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.GroupKeyValidationState", 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_GroupKeyValidationState) 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_GroupKeyValidationState) 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_GroupKeyValidationState) 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_GroupKeyValidationState) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*GroupKeyValidationState)
+ 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.NewEpochId != 0 {
+ n += 1 + runtime.Sov(uint64(x.NewEpochId))
+ }
+ if x.PreviousEpochId != 0 {
+ n += 1 + runtime.Sov(uint64(x.PreviousEpochId))
+ }
+ if x.Status != 0 {
+ n += 1 + runtime.Sov(uint64(x.Status))
+ }
+ if len(x.PartialSignatures) > 0 {
+ for _, e := range x.PartialSignatures {
+ l = options.Size(e)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ }
+ l = len(x.FinalSignature)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ l = len(x.MessageHash)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.SlotsCovered != 0 {
+ n += 1 + runtime.Sov(uint64(x.SlotsCovered))
+ }
+ 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().(*GroupKeyValidationState)
+ 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.SlotsCovered != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.SlotsCovered))
+ i--
+ dAtA[i] = 0x38
+ }
+ if len(x.MessageHash) > 0 {
+ i -= len(x.MessageHash)
+ copy(dAtA[i:], x.MessageHash)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.MessageHash)))
+ i--
+ dAtA[i] = 0x32
+ }
+ if len(x.FinalSignature) > 0 {
+ i -= len(x.FinalSignature)
+ copy(dAtA[i:], x.FinalSignature)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.FinalSignature)))
+ i--
+ dAtA[i] = 0x2a
+ }
+ if len(x.PartialSignatures) > 0 {
+ for iNdEx := len(x.PartialSignatures) - 1; iNdEx >= 0; iNdEx-- {
+ encoded, err := options.Marshal(x.PartialSignatures[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.Status != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.Status))
+ i--
+ dAtA[i] = 0x18
+ }
+ if x.PreviousEpochId != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.PreviousEpochId))
+ i--
+ dAtA[i] = 0x10
+ }
+ if x.NewEpochId != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.NewEpochId))
+ 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().(*GroupKeyValidationState)
+ 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: GroupKeyValidationState: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: GroupKeyValidationState: 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 NewEpochId", wireType)
+ }
+ x.NewEpochId = 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.NewEpochId |= 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 PreviousEpochId", wireType)
+ }
+ x.PreviousEpochId = 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.PreviousEpochId |= 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 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 |= GroupKeyValidationStatus(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 PartialSignatures", 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.PartialSignatures = append(x.PartialSignatures, &PartialSignature{})
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.PartialSignatures[len(x.PartialSignatures)-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 FinalSignature", 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.FinalSignature = append(x.FinalSignature[:0], dAtA[iNdEx:postIndex]...)
+ if x.FinalSignature == nil {
+ x.FinalSignature = []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 MessageHash", 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.MessageHash = append(x.MessageHash[:0], dAtA[iNdEx:postIndex]...)
+ if x.MessageHash == nil {
+ x.MessageHash = []byte{}
+ }
+ iNdEx = postIndex
+ case 7:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field SlotsCovered", wireType)
+ }
+ x.SlotsCovered = 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.SlotsCovered |= 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
+ }
+ }
+
+ 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/bls/group_validation.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)
+)
+
+// GroupKeyValidationStatus defines the status of a group key validation process
+type GroupKeyValidationStatus int32
+
+const (
+ // COLLECTING_SIGNATURES indicates validation is in progress, collecting partial signatures
+ GroupKeyValidationStatus_GROUP_KEY_VALIDATION_STATUS_COLLECTING_SIGNATURES GroupKeyValidationStatus = 0
+ // VALIDATED indicates validation completed successfully with sufficient signatures
+ GroupKeyValidationStatus_GROUP_KEY_VALIDATION_STATUS_VALIDATED GroupKeyValidationStatus = 1
+ // VALIDATION_FAILED indicates validation failed due to insufficient participation or invalid signatures
+ GroupKeyValidationStatus_GROUP_KEY_VALIDATION_STATUS_VALIDATION_FAILED GroupKeyValidationStatus = 2
+)
+
+// Enum value maps for GroupKeyValidationStatus.
+var (
+ GroupKeyValidationStatus_name = map[int32]string{
+ 0: "GROUP_KEY_VALIDATION_STATUS_COLLECTING_SIGNATURES",
+ 1: "GROUP_KEY_VALIDATION_STATUS_VALIDATED",
+ 2: "GROUP_KEY_VALIDATION_STATUS_VALIDATION_FAILED",
+ }
+ GroupKeyValidationStatus_value = map[string]int32{
+ "GROUP_KEY_VALIDATION_STATUS_COLLECTING_SIGNATURES": 0,
+ "GROUP_KEY_VALIDATION_STATUS_VALIDATED": 1,
+ "GROUP_KEY_VALIDATION_STATUS_VALIDATION_FAILED": 2,
+ }
+)
+
+func (x GroupKeyValidationStatus) Enum() *GroupKeyValidationStatus {
+ p := new(GroupKeyValidationStatus)
+ *p = x
+ return p
+}
+
+func (x GroupKeyValidationStatus) String() string {
+ return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (GroupKeyValidationStatus) Descriptor() protoreflect.EnumDescriptor {
+ return file_inference_bls_group_validation_proto_enumTypes[0].Descriptor()
+}
+
+func (GroupKeyValidationStatus) Type() protoreflect.EnumType {
+ return &file_inference_bls_group_validation_proto_enumTypes[0]
+}
+
+func (x GroupKeyValidationStatus) Number() protoreflect.EnumNumber {
+ return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use GroupKeyValidationStatus.Descriptor instead.
+func (GroupKeyValidationStatus) EnumDescriptor() ([]byte, []int) {
+ return file_inference_bls_group_validation_proto_rawDescGZIP(), []int{0}
+}
+
+// GroupKeyValidationState contains the state of a group key validation process for a specific epoch
+type GroupKeyValidationState struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // new_epoch_id is the epoch ID of the new epoch whose group public key is being validated
+ NewEpochId uint64 `protobuf:"varint,1,opt,name=new_epoch_id,json=newEpochId,proto3" json:"new_epoch_id,omitempty"`
+ // previous_epoch_id is the epoch ID of the previous epoch whose validators are performing the validation
+ PreviousEpochId uint64 `protobuf:"varint,2,opt,name=previous_epoch_id,json=previousEpochId,proto3" json:"previous_epoch_id,omitempty"`
+ // status indicates the current status of the validation process
+ Status GroupKeyValidationStatus `protobuf:"varint,3,opt,name=status,proto3,enum=inference.bls.GroupKeyValidationStatus" json:"status,omitempty"`
+ // partial_signatures contains all partial signatures received from participants
+ PartialSignatures []*PartialSignature `protobuf:"bytes,4,rep,name=partial_signatures,json=partialSignatures,proto3" json:"partial_signatures,omitempty"`
+ // final_signature is the aggregated signature when validation completes successfully (G1 point, 48-byte compressed)
+ FinalSignature []byte `protobuf:"bytes,5,opt,name=final_signature,json=finalSignature,proto3" json:"final_signature,omitempty"`
+ // message_hash is the keccak256 hash of the encoded validation data that participants sign
+ MessageHash []byte `protobuf:"bytes,6,opt,name=message_hash,json=messageHash,proto3" json:"message_hash,omitempty"`
+ // slots_covered tracks the total number of slots covered by valid partial signatures received
+ SlotsCovered uint32 `protobuf:"varint,7,opt,name=slots_covered,json=slotsCovered,proto3" json:"slots_covered,omitempty"`
+}
+
+func (x *GroupKeyValidationState) Reset() {
+ *x = GroupKeyValidationState{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_group_validation_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *GroupKeyValidationState) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GroupKeyValidationState) ProtoMessage() {}
+
+// Deprecated: Use GroupKeyValidationState.ProtoReflect.Descriptor instead.
+func (*GroupKeyValidationState) Descriptor() ([]byte, []int) {
+ return file_inference_bls_group_validation_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *GroupKeyValidationState) GetNewEpochId() uint64 {
+ if x != nil {
+ return x.NewEpochId
+ }
+ return 0
+}
+
+func (x *GroupKeyValidationState) GetPreviousEpochId() uint64 {
+ if x != nil {
+ return x.PreviousEpochId
+ }
+ return 0
+}
+
+func (x *GroupKeyValidationState) GetStatus() GroupKeyValidationStatus {
+ if x != nil {
+ return x.Status
+ }
+ return GroupKeyValidationStatus_GROUP_KEY_VALIDATION_STATUS_COLLECTING_SIGNATURES
+}
+
+func (x *GroupKeyValidationState) GetPartialSignatures() []*PartialSignature {
+ if x != nil {
+ return x.PartialSignatures
+ }
+ return nil
+}
+
+func (x *GroupKeyValidationState) GetFinalSignature() []byte {
+ if x != nil {
+ return x.FinalSignature
+ }
+ return nil
+}
+
+func (x *GroupKeyValidationState) GetMessageHash() []byte {
+ if x != nil {
+ return x.MessageHash
+ }
+ return nil
+}
+
+func (x *GroupKeyValidationState) GetSlotsCovered() uint32 {
+ if x != nil {
+ return x.SlotsCovered
+ }
+ return 0
+}
+
+var File_inference_bls_group_validation_proto protoreflect.FileDescriptor
+
+var file_inference_bls_group_validation_proto_rawDesc = []byte{
+ 0x0a, 0x24, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x62, 0x6c, 0x73, 0x2f,
+ 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+ 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0d, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+ 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x1a, 0x11, 0x61, 0x6d, 0x69, 0x6e, 0x6f, 0x2f, 0x61, 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, 0x1a,
+ 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x62, 0x6c, 0x73, 0x2f, 0x70, 0x61,
+ 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xef, 0x02, 0x0a, 0x17, 0x47,
+ 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f,
+ 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x20, 0x0a, 0x0c, 0x6e, 0x65, 0x77, 0x5f, 0x65, 0x70,
+ 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x6e, 0x65,
+ 0x77, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x64, 0x12, 0x2a, 0x0a, 0x11, 0x70, 0x72, 0x65, 0x76,
+ 0x69, 0x6f, 0x75, 0x73, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20,
+ 0x01, 0x28, 0x04, 0x52, 0x0f, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x45, 0x70, 0x6f,
+ 0x63, 0x68, 0x49, 0x64, 0x12, 0x3f, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x03,
+ 0x20, 0x01, 0x28, 0x0e, 0x32, 0x27, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+ 0x2e, 0x62, 0x6c, 0x73, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x56, 0x61, 0x6c,
+ 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73,
+ 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x54, 0x0a, 0x12, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c,
+ 0x5f, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28,
+ 0x0b, 0x32, 0x1f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c,
+ 0x73, 0x2e, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75,
+ 0x72, 0x65, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x11, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61,
+ 0x6c, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x12, 0x27, 0x0a, 0x0f, 0x66,
+ 0x69, 0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x05,
+ 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0e, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x53, 0x69, 0x67, 0x6e, 0x61,
+ 0x74, 0x75, 0x72, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f,
+ 0x68, 0x61, 0x73, 0x68, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x6d, 0x65, 0x73, 0x73,
+ 0x61, 0x67, 0x65, 0x48, 0x61, 0x73, 0x68, 0x12, 0x23, 0x0a, 0x0d, 0x73, 0x6c, 0x6f, 0x74, 0x73,
+ 0x5f, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x65, 0x64, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0c,
+ 0x73, 0x6c, 0x6f, 0x74, 0x73, 0x43, 0x6f, 0x76, 0x65, 0x72, 0x65, 0x64, 0x2a, 0xaf, 0x01, 0x0a,
+ 0x18, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
+ 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x35, 0x0a, 0x31, 0x47, 0x52, 0x4f,
+ 0x55, 0x50, 0x5f, 0x4b, 0x45, 0x59, 0x5f, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x41, 0x54, 0x49, 0x4f,
+ 0x4e, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x43, 0x4f, 0x4c, 0x4c, 0x45, 0x43, 0x54,
+ 0x49, 0x4e, 0x47, 0x5f, 0x53, 0x49, 0x47, 0x4e, 0x41, 0x54, 0x55, 0x52, 0x45, 0x53, 0x10, 0x00,
+ 0x12, 0x29, 0x0a, 0x25, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x4b, 0x45, 0x59, 0x5f, 0x56, 0x41,
+ 0x4c, 0x49, 0x44, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f,
+ 0x56, 0x41, 0x4c, 0x49, 0x44, 0x41, 0x54, 0x45, 0x44, 0x10, 0x01, 0x12, 0x31, 0x0a, 0x2d, 0x47,
+ 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x4b, 0x45, 0x59, 0x5f, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x41, 0x54,
+ 0x49, 0x4f, 0x4e, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x56, 0x41, 0x4c, 0x49, 0x44,
+ 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x46, 0x41, 0x49, 0x4c, 0x45, 0x44, 0x10, 0x02, 0x42, 0x9e,
+ 0x01, 0x0a, 0x11, 0x63, 0x6f, 0x6d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+ 0x2e, 0x62, 0x6c, 0x73, 0x42, 0x14, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x56, 0x61, 0x6c, 0x69, 0x64,
+ 0x61, 0x74, 0x69, 0x6f, 0x6e, 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 (
+ file_inference_bls_group_validation_proto_rawDescOnce sync.Once
+ file_inference_bls_group_validation_proto_rawDescData = file_inference_bls_group_validation_proto_rawDesc
+)
+
+func file_inference_bls_group_validation_proto_rawDescGZIP() []byte {
+ file_inference_bls_group_validation_proto_rawDescOnce.Do(func() {
+ file_inference_bls_group_validation_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_bls_group_validation_proto_rawDescData)
+ })
+ return file_inference_bls_group_validation_proto_rawDescData
+}
+
+var file_inference_bls_group_validation_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
+var file_inference_bls_group_validation_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_inference_bls_group_validation_proto_goTypes = []interface{}{
+ (GroupKeyValidationStatus)(0), // 0: inference.bls.GroupKeyValidationStatus
+ (*GroupKeyValidationState)(nil), // 1: inference.bls.GroupKeyValidationState
+ (*PartialSignature)(nil), // 2: inference.bls.PartialSignature
+}
+var file_inference_bls_group_validation_proto_depIdxs = []int32{
+ 0, // 0: inference.bls.GroupKeyValidationState.status:type_name -> inference.bls.GroupKeyValidationStatus
+ 2, // 1: inference.bls.GroupKeyValidationState.partial_signatures:type_name -> inference.bls.PartialSignature
+ 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_bls_group_validation_proto_init() }
+func file_inference_bls_group_validation_proto_init() {
+ if File_inference_bls_group_validation_proto != nil {
+ return
+ }
+ file_inference_bls_params_proto_init()
+ if !protoimpl.UnsafeEnabled {
+ file_inference_bls_group_validation_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*GroupKeyValidationState); 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_bls_group_validation_proto_rawDesc,
+ NumEnums: 1,
+ NumMessages: 1,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_bls_group_validation_proto_goTypes,
+ DependencyIndexes: file_inference_bls_group_validation_proto_depIdxs,
+ EnumInfos: file_inference_bls_group_validation_proto_enumTypes,
+ MessageInfos: file_inference_bls_group_validation_proto_msgTypes,
+ }.Build()
+ File_inference_bls_group_validation_proto = out.File
+ file_inference_bls_group_validation_proto_rawDesc = nil
+ file_inference_bls_group_validation_proto_goTypes = nil
+ file_inference_bls_group_validation_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/bls/module/module.pulsar.go b/inference-chain/api/inference/bls/module/module.pulsar.go
new file mode 100644
index 000000000..293d9df52
--- /dev/null
+++ b/inference-chain/api/inference/bls/module/module.pulsar.go
@@ -0,0 +1,577 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package module
+
+import (
+ _ "cosmossdk.io/api/cosmos/app/v1alpha1"
+ 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_Module protoreflect.MessageDescriptor
+ fd_Module_authority protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bls_module_module_proto_init()
+ md_Module = File_inference_bls_module_module_proto.Messages().ByName("Module")
+ fd_Module_authority = md_Module.Fields().ByName("authority")
+}
+
+var _ protoreflect.Message = (*fastReflection_Module)(nil)
+
+type fastReflection_Module Module
+
+func (x *Module) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_Module)(x)
+}
+
+func (x *Module) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_module_module_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_Module_messageType fastReflection_Module_messageType
+var _ protoreflect.MessageType = fastReflection_Module_messageType{}
+
+type fastReflection_Module_messageType struct{}
+
+func (x fastReflection_Module_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_Module)(nil)
+}
+func (x fastReflection_Module_messageType) New() protoreflect.Message {
+ return new(fastReflection_Module)
+}
+func (x fastReflection_Module_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_Module
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_Module) Descriptor() protoreflect.MessageDescriptor {
+ return md_Module
+}
+
+// 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_Module) Type() protoreflect.MessageType {
+ return _fastReflection_Module_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_Module) New() protoreflect.Message {
+ return new(fastReflection_Module)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_Module) Interface() protoreflect.ProtoMessage {
+ return (*Module)(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_Module) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Authority != "" {
+ value := protoreflect.ValueOfString(x.Authority)
+ if !f(fd_Module_authority, 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_Module) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bls.module.Module.authority":
+ return x.Authority != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.module.Module"))
+ }
+ panic(fmt.Errorf("message inference.bls.module.Module 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_Module) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bls.module.Module.authority":
+ x.Authority = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.module.Module"))
+ }
+ panic(fmt.Errorf("message inference.bls.module.Module 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_Module) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bls.module.Module.authority":
+ value := x.Authority
+ return protoreflect.ValueOfString(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.module.Module"))
+ }
+ panic(fmt.Errorf("message inference.bls.module.Module 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_Module) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bls.module.Module.authority":
+ x.Authority = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.module.Module"))
+ }
+ panic(fmt.Errorf("message inference.bls.module.Module 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_Module) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.module.Module.authority":
+ panic(fmt.Errorf("field authority of message inference.bls.module.Module is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.module.Module"))
+ }
+ panic(fmt.Errorf("message inference.bls.module.Module 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_Module) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.module.Module.authority":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.module.Module"))
+ }
+ panic(fmt.Errorf("message inference.bls.module.Module 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_Module) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.module.Module", 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_Module) 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_Module) 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_Module) 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_Module) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*Module)
+ 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 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().(*Module)
+ 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.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().(*Module)
+ 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: Module: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Module: 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
+ 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/bls/module/module.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)
+)
+
+// Module is the config object for the module.
+type Module struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // authority defines the custom module authority. If not set, defaults to the governance module.
+ Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"`
+}
+
+func (x *Module) Reset() {
+ *x = Module{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_module_module_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *Module) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Module) ProtoMessage() {}
+
+// Deprecated: Use Module.ProtoReflect.Descriptor instead.
+func (*Module) Descriptor() ([]byte, []int) {
+ return file_inference_bls_module_module_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Module) GetAuthority() string {
+ if x != nil {
+ return x.Authority
+ }
+ return ""
+}
+
+var File_inference_bls_module_module_proto protoreflect.FileDescriptor
+
+var file_inference_bls_module_module_proto_rawDesc = []byte{
+ 0x0a, 0x21, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x62, 0x6c, 0x73, 0x2f,
+ 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x2f, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x2e, 0x70, 0x72,
+ 0x6f, 0x74, 0x6f, 0x12, 0x14, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62,
+ 0x6c, 0x73, 0x2e, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x1a, 0x20, 0x63, 0x6f, 0x73, 0x6d, 0x6f,
+ 0x73, 0x2f, 0x61, 0x70, 0x70, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x6d,
+ 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x59, 0x0a, 0x06, 0x4d,
+ 0x6f, 0x64, 0x75, 0x6c, 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, 0x3a, 0x31, 0xba, 0xc0, 0x96, 0xda, 0x01, 0x2b, 0x0a, 0x29, 0x67, 0x69, 0x74,
+ 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 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, 0x78, 0x2f, 0x62, 0x6c, 0x73, 0x42, 0xc0, 0x01, 0x0a, 0x18, 0x63, 0x6f, 0x6d, 0x2e, 0x69,
+ 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x2e, 0x6d, 0x6f, 0x64,
+ 0x75, 0x6c, 0x65, 0x42, 0x0b, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f,
+ 0x50, 0x01, 0x5a, 0x25, 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, 0x2f, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0xa2, 0x02, 0x03, 0x49, 0x42, 0x4d, 0xaa,
+ 0x02, 0x14, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x42, 0x6c, 0x73, 0x2e,
+ 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0xca, 0x02, 0x14, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+ 0x63, 0x65, 0x5c, 0x42, 0x6c, 0x73, 0x5c, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0xe2, 0x02, 0x20,
+ 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x42, 0x6c, 0x73, 0x5c, 0x4d, 0x6f,
+ 0x64, 0x75, 0x6c, 0x65, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61,
+ 0xea, 0x02, 0x16, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x3a, 0x3a, 0x42, 0x6c,
+ 0x73, 0x3a, 0x3a, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+ 0x33,
+}
+
+var (
+ file_inference_bls_module_module_proto_rawDescOnce sync.Once
+ file_inference_bls_module_module_proto_rawDescData = file_inference_bls_module_module_proto_rawDesc
+)
+
+func file_inference_bls_module_module_proto_rawDescGZIP() []byte {
+ file_inference_bls_module_module_proto_rawDescOnce.Do(func() {
+ file_inference_bls_module_module_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_bls_module_module_proto_rawDescData)
+ })
+ return file_inference_bls_module_module_proto_rawDescData
+}
+
+var file_inference_bls_module_module_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_inference_bls_module_module_proto_goTypes = []interface{}{
+ (*Module)(nil), // 0: inference.bls.module.Module
+}
+var file_inference_bls_module_module_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_bls_module_module_proto_init() }
+func file_inference_bls_module_module_proto_init() {
+ if File_inference_bls_module_module_proto != nil {
+ return
+ }
+ if !protoimpl.UnsafeEnabled {
+ file_inference_bls_module_module_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*Module); 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_bls_module_module_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 1,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_bls_module_module_proto_goTypes,
+ DependencyIndexes: file_inference_bls_module_module_proto_depIdxs,
+ MessageInfos: file_inference_bls_module_module_proto_msgTypes,
+ }.Build()
+ File_inference_bls_module_module_proto = out.File
+ file_inference_bls_module_module_proto_rawDesc = nil
+ file_inference_bls_module_module_proto_goTypes = nil
+ file_inference_bls_module_module_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/bls/params.pulsar.go b/inference-chain/api/inference/bls/params.pulsar.go
new file mode 100644
index 000000000..19ff41b0e
--- /dev/null
+++ b/inference-chain/api/inference/bls/params.pulsar.go
@@ -0,0 +1,1548 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package bls
+
+import (
+ _ "cosmossdk.io/api/amino"
+ fmt "fmt"
+ _ "github.com/cosmos/cosmos-proto"
+ runtime "github.com/cosmos/cosmos-proto/runtime"
+ _ "github.com/cosmos/gogoproto/gogoproto"
+ 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_Params protoreflect.MessageDescriptor
+ fd_Params_i_total_slots protoreflect.FieldDescriptor
+ fd_Params_t_slots_degree_offset protoreflect.FieldDescriptor
+ fd_Params_dealing_phase_duration_blocks protoreflect.FieldDescriptor
+ fd_Params_verification_phase_duration_blocks protoreflect.FieldDescriptor
+ fd_Params_signing_deadline_blocks protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bls_params_proto_init()
+ md_Params = File_inference_bls_params_proto.Messages().ByName("Params")
+ fd_Params_i_total_slots = md_Params.Fields().ByName("i_total_slots")
+ fd_Params_t_slots_degree_offset = md_Params.Fields().ByName("t_slots_degree_offset")
+ fd_Params_dealing_phase_duration_blocks = md_Params.Fields().ByName("dealing_phase_duration_blocks")
+ fd_Params_verification_phase_duration_blocks = md_Params.Fields().ByName("verification_phase_duration_blocks")
+ fd_Params_signing_deadline_blocks = md_Params.Fields().ByName("signing_deadline_blocks")
+}
+
+var _ protoreflect.Message = (*fastReflection_Params)(nil)
+
+type fastReflection_Params Params
+
+func (x *Params) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_Params)(x)
+}
+
+func (x *Params) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_params_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_Params_messageType fastReflection_Params_messageType
+var _ protoreflect.MessageType = fastReflection_Params_messageType{}
+
+type fastReflection_Params_messageType struct{}
+
+func (x fastReflection_Params_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_Params)(nil)
+}
+func (x fastReflection_Params_messageType) New() protoreflect.Message {
+ return new(fastReflection_Params)
+}
+func (x fastReflection_Params_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_Params
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_Params) Descriptor() protoreflect.MessageDescriptor {
+ return md_Params
+}
+
+// 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_Params) Type() protoreflect.MessageType {
+ return _fastReflection_Params_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_Params) New() protoreflect.Message {
+ return new(fastReflection_Params)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_Params) Interface() protoreflect.ProtoMessage {
+ return (*Params)(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_Params) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.ITotalSlots != uint32(0) {
+ value := protoreflect.ValueOfUint32(x.ITotalSlots)
+ if !f(fd_Params_i_total_slots, value) {
+ return
+ }
+ }
+ if x.TSlotsDegreeOffset != uint32(0) {
+ value := protoreflect.ValueOfUint32(x.TSlotsDegreeOffset)
+ if !f(fd_Params_t_slots_degree_offset, value) {
+ return
+ }
+ }
+ if x.DealingPhaseDurationBlocks != int64(0) {
+ value := protoreflect.ValueOfInt64(x.DealingPhaseDurationBlocks)
+ if !f(fd_Params_dealing_phase_duration_blocks, value) {
+ return
+ }
+ }
+ if x.VerificationPhaseDurationBlocks != int64(0) {
+ value := protoreflect.ValueOfInt64(x.VerificationPhaseDurationBlocks)
+ if !f(fd_Params_verification_phase_duration_blocks, value) {
+ return
+ }
+ }
+ if x.SigningDeadlineBlocks != int64(0) {
+ value := protoreflect.ValueOfInt64(x.SigningDeadlineBlocks)
+ if !f(fd_Params_signing_deadline_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_Params) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bls.Params.i_total_slots":
+ return x.ITotalSlots != uint32(0)
+ case "inference.bls.Params.t_slots_degree_offset":
+ return x.TSlotsDegreeOffset != uint32(0)
+ case "inference.bls.Params.dealing_phase_duration_blocks":
+ return x.DealingPhaseDurationBlocks != int64(0)
+ case "inference.bls.Params.verification_phase_duration_blocks":
+ return x.VerificationPhaseDurationBlocks != int64(0)
+ case "inference.bls.Params.signing_deadline_blocks":
+ return x.SigningDeadlineBlocks != int64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.Params"))
+ }
+ panic(fmt.Errorf("message inference.bls.Params 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_Params) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bls.Params.i_total_slots":
+ x.ITotalSlots = uint32(0)
+ case "inference.bls.Params.t_slots_degree_offset":
+ x.TSlotsDegreeOffset = uint32(0)
+ case "inference.bls.Params.dealing_phase_duration_blocks":
+ x.DealingPhaseDurationBlocks = int64(0)
+ case "inference.bls.Params.verification_phase_duration_blocks":
+ x.VerificationPhaseDurationBlocks = int64(0)
+ case "inference.bls.Params.signing_deadline_blocks":
+ x.SigningDeadlineBlocks = int64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.Params"))
+ }
+ panic(fmt.Errorf("message inference.bls.Params 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_Params) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bls.Params.i_total_slots":
+ value := x.ITotalSlots
+ return protoreflect.ValueOfUint32(value)
+ case "inference.bls.Params.t_slots_degree_offset":
+ value := x.TSlotsDegreeOffset
+ return protoreflect.ValueOfUint32(value)
+ case "inference.bls.Params.dealing_phase_duration_blocks":
+ value := x.DealingPhaseDurationBlocks
+ return protoreflect.ValueOfInt64(value)
+ case "inference.bls.Params.verification_phase_duration_blocks":
+ value := x.VerificationPhaseDurationBlocks
+ return protoreflect.ValueOfInt64(value)
+ case "inference.bls.Params.signing_deadline_blocks":
+ value := x.SigningDeadlineBlocks
+ return protoreflect.ValueOfInt64(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.Params"))
+ }
+ panic(fmt.Errorf("message inference.bls.Params 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_Params) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bls.Params.i_total_slots":
+ x.ITotalSlots = uint32(value.Uint())
+ case "inference.bls.Params.t_slots_degree_offset":
+ x.TSlotsDegreeOffset = uint32(value.Uint())
+ case "inference.bls.Params.dealing_phase_duration_blocks":
+ x.DealingPhaseDurationBlocks = value.Int()
+ case "inference.bls.Params.verification_phase_duration_blocks":
+ x.VerificationPhaseDurationBlocks = value.Int()
+ case "inference.bls.Params.signing_deadline_blocks":
+ x.SigningDeadlineBlocks = value.Int()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.Params"))
+ }
+ panic(fmt.Errorf("message inference.bls.Params 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_Params) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.Params.i_total_slots":
+ panic(fmt.Errorf("field i_total_slots of message inference.bls.Params is not mutable"))
+ case "inference.bls.Params.t_slots_degree_offset":
+ panic(fmt.Errorf("field t_slots_degree_offset of message inference.bls.Params is not mutable"))
+ case "inference.bls.Params.dealing_phase_duration_blocks":
+ panic(fmt.Errorf("field dealing_phase_duration_blocks of message inference.bls.Params is not mutable"))
+ case "inference.bls.Params.verification_phase_duration_blocks":
+ panic(fmt.Errorf("field verification_phase_duration_blocks of message inference.bls.Params is not mutable"))
+ case "inference.bls.Params.signing_deadline_blocks":
+ panic(fmt.Errorf("field signing_deadline_blocks of message inference.bls.Params is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.Params"))
+ }
+ panic(fmt.Errorf("message inference.bls.Params 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_Params) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.Params.i_total_slots":
+ return protoreflect.ValueOfUint32(uint32(0))
+ case "inference.bls.Params.t_slots_degree_offset":
+ return protoreflect.ValueOfUint32(uint32(0))
+ case "inference.bls.Params.dealing_phase_duration_blocks":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.bls.Params.verification_phase_duration_blocks":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.bls.Params.signing_deadline_blocks":
+ return protoreflect.ValueOfInt64(int64(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.Params"))
+ }
+ panic(fmt.Errorf("message inference.bls.Params 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_Params) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.Params", 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_Params) 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_Params) 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_Params) 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_Params) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*Params)
+ 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.ITotalSlots != 0 {
+ n += 1 + runtime.Sov(uint64(x.ITotalSlots))
+ }
+ if x.TSlotsDegreeOffset != 0 {
+ n += 1 + runtime.Sov(uint64(x.TSlotsDegreeOffset))
+ }
+ if x.DealingPhaseDurationBlocks != 0 {
+ n += 1 + runtime.Sov(uint64(x.DealingPhaseDurationBlocks))
+ }
+ if x.VerificationPhaseDurationBlocks != 0 {
+ n += 1 + runtime.Sov(uint64(x.VerificationPhaseDurationBlocks))
+ }
+ if x.SigningDeadlineBlocks != 0 {
+ n += 1 + runtime.Sov(uint64(x.SigningDeadlineBlocks))
+ }
+ 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().(*Params)
+ 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.SigningDeadlineBlocks != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.SigningDeadlineBlocks))
+ i--
+ dAtA[i] = 0x28
+ }
+ if x.VerificationPhaseDurationBlocks != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.VerificationPhaseDurationBlocks))
+ i--
+ dAtA[i] = 0x20
+ }
+ if x.DealingPhaseDurationBlocks != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.DealingPhaseDurationBlocks))
+ i--
+ dAtA[i] = 0x18
+ }
+ if x.TSlotsDegreeOffset != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.TSlotsDegreeOffset))
+ i--
+ dAtA[i] = 0x10
+ }
+ if x.ITotalSlots != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.ITotalSlots))
+ 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().(*Params)
+ 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: Params: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Params: 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 ITotalSlots", wireType)
+ }
+ x.ITotalSlots = 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.ITotalSlots |= 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 TSlotsDegreeOffset", wireType)
+ }
+ x.TSlotsDegreeOffset = 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.TSlotsDegreeOffset |= uint32(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 DealingPhaseDurationBlocks", wireType)
+ }
+ x.DealingPhaseDurationBlocks = 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.DealingPhaseDurationBlocks |= 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 VerificationPhaseDurationBlocks", wireType)
+ }
+ x.VerificationPhaseDurationBlocks = 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.VerificationPhaseDurationBlocks |= int64(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 SigningDeadlineBlocks", wireType)
+ }
+ x.SigningDeadlineBlocks = 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.SigningDeadlineBlocks |= 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 _ protoreflect.List = (*_PartialSignature_2_list)(nil)
+
+type _PartialSignature_2_list struct {
+ list *[]uint32
+}
+
+func (x *_PartialSignature_2_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_PartialSignature_2_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfUint32((*x.list)[i])
+}
+
+func (x *_PartialSignature_2_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Uint()
+ concreteValue := (uint32)(valueUnwrapped)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_PartialSignature_2_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Uint()
+ concreteValue := (uint32)(valueUnwrapped)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_PartialSignature_2_list) AppendMutable() protoreflect.Value {
+ panic(fmt.Errorf("AppendMutable can not be called on message PartialSignature at list field SlotIndices as it is not of Message kind"))
+}
+
+func (x *_PartialSignature_2_list) Truncate(n int) {
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_PartialSignature_2_list) NewElement() protoreflect.Value {
+ v := uint32(0)
+ return protoreflect.ValueOfUint32(v)
+}
+
+func (x *_PartialSignature_2_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_PartialSignature protoreflect.MessageDescriptor
+ fd_PartialSignature_participant_address protoreflect.FieldDescriptor
+ fd_PartialSignature_slot_indices protoreflect.FieldDescriptor
+ fd_PartialSignature_signature protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bls_params_proto_init()
+ md_PartialSignature = File_inference_bls_params_proto.Messages().ByName("PartialSignature")
+ fd_PartialSignature_participant_address = md_PartialSignature.Fields().ByName("participant_address")
+ fd_PartialSignature_slot_indices = md_PartialSignature.Fields().ByName("slot_indices")
+ fd_PartialSignature_signature = md_PartialSignature.Fields().ByName("signature")
+}
+
+var _ protoreflect.Message = (*fastReflection_PartialSignature)(nil)
+
+type fastReflection_PartialSignature PartialSignature
+
+func (x *PartialSignature) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_PartialSignature)(x)
+}
+
+func (x *PartialSignature) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_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_PartialSignature_messageType fastReflection_PartialSignature_messageType
+var _ protoreflect.MessageType = fastReflection_PartialSignature_messageType{}
+
+type fastReflection_PartialSignature_messageType struct{}
+
+func (x fastReflection_PartialSignature_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_PartialSignature)(nil)
+}
+func (x fastReflection_PartialSignature_messageType) New() protoreflect.Message {
+ return new(fastReflection_PartialSignature)
+}
+func (x fastReflection_PartialSignature_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_PartialSignature
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_PartialSignature) Descriptor() protoreflect.MessageDescriptor {
+ return md_PartialSignature
+}
+
+// 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_PartialSignature) Type() protoreflect.MessageType {
+ return _fastReflection_PartialSignature_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_PartialSignature) New() protoreflect.Message {
+ return new(fastReflection_PartialSignature)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_PartialSignature) Interface() protoreflect.ProtoMessage {
+ return (*PartialSignature)(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_PartialSignature) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.ParticipantAddress != "" {
+ value := protoreflect.ValueOfString(x.ParticipantAddress)
+ if !f(fd_PartialSignature_participant_address, value) {
+ return
+ }
+ }
+ if len(x.SlotIndices) != 0 {
+ value := protoreflect.ValueOfList(&_PartialSignature_2_list{list: &x.SlotIndices})
+ if !f(fd_PartialSignature_slot_indices, value) {
+ return
+ }
+ }
+ if len(x.Signature) != 0 {
+ value := protoreflect.ValueOfBytes(x.Signature)
+ if !f(fd_PartialSignature_signature, 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_PartialSignature) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bls.PartialSignature.participant_address":
+ return x.ParticipantAddress != ""
+ case "inference.bls.PartialSignature.slot_indices":
+ return len(x.SlotIndices) != 0
+ case "inference.bls.PartialSignature.signature":
+ return len(x.Signature) != 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.PartialSignature"))
+ }
+ panic(fmt.Errorf("message inference.bls.PartialSignature 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_PartialSignature) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bls.PartialSignature.participant_address":
+ x.ParticipantAddress = ""
+ case "inference.bls.PartialSignature.slot_indices":
+ x.SlotIndices = nil
+ case "inference.bls.PartialSignature.signature":
+ x.Signature = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.PartialSignature"))
+ }
+ panic(fmt.Errorf("message inference.bls.PartialSignature 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_PartialSignature) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bls.PartialSignature.participant_address":
+ value := x.ParticipantAddress
+ return protoreflect.ValueOfString(value)
+ case "inference.bls.PartialSignature.slot_indices":
+ if len(x.SlotIndices) == 0 {
+ return protoreflect.ValueOfList(&_PartialSignature_2_list{})
+ }
+ listValue := &_PartialSignature_2_list{list: &x.SlotIndices}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.bls.PartialSignature.signature":
+ value := x.Signature
+ return protoreflect.ValueOfBytes(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.PartialSignature"))
+ }
+ panic(fmt.Errorf("message inference.bls.PartialSignature 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_PartialSignature) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bls.PartialSignature.participant_address":
+ x.ParticipantAddress = value.Interface().(string)
+ case "inference.bls.PartialSignature.slot_indices":
+ lv := value.List()
+ clv := lv.(*_PartialSignature_2_list)
+ x.SlotIndices = *clv.list
+ case "inference.bls.PartialSignature.signature":
+ x.Signature = value.Bytes()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.PartialSignature"))
+ }
+ panic(fmt.Errorf("message inference.bls.PartialSignature 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_PartialSignature) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.PartialSignature.slot_indices":
+ if x.SlotIndices == nil {
+ x.SlotIndices = []uint32{}
+ }
+ value := &_PartialSignature_2_list{list: &x.SlotIndices}
+ return protoreflect.ValueOfList(value)
+ case "inference.bls.PartialSignature.participant_address":
+ panic(fmt.Errorf("field participant_address of message inference.bls.PartialSignature is not mutable"))
+ case "inference.bls.PartialSignature.signature":
+ panic(fmt.Errorf("field signature of message inference.bls.PartialSignature is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.PartialSignature"))
+ }
+ panic(fmt.Errorf("message inference.bls.PartialSignature 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_PartialSignature) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.PartialSignature.participant_address":
+ return protoreflect.ValueOfString("")
+ case "inference.bls.PartialSignature.slot_indices":
+ list := []uint32{}
+ return protoreflect.ValueOfList(&_PartialSignature_2_list{list: &list})
+ case "inference.bls.PartialSignature.signature":
+ return protoreflect.ValueOfBytes(nil)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.PartialSignature"))
+ }
+ panic(fmt.Errorf("message inference.bls.PartialSignature 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_PartialSignature) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.PartialSignature", 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_PartialSignature) 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_PartialSignature) 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_PartialSignature) 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_PartialSignature) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*PartialSignature)
+ 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.ParticipantAddress)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if len(x.SlotIndices) > 0 {
+ l = 0
+ for _, e := range x.SlotIndices {
+ l += runtime.Sov(uint64(e))
+ }
+ n += 1 + runtime.Sov(uint64(l)) + l
+ }
+ l = len(x.Signature)
+ 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().(*PartialSignature)
+ 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.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.SlotIndices) > 0 {
+ var pksize2 int
+ for _, num := range x.SlotIndices {
+ pksize2 += runtime.Sov(uint64(num))
+ }
+ i -= pksize2
+ j1 := i
+ for _, num := range x.SlotIndices {
+ for num >= 1<<7 {
+ dAtA[j1] = uint8(uint64(num)&0x7f | 0x80)
+ num >>= 7
+ j1++
+ }
+ dAtA[j1] = uint8(num)
+ j1++
+ }
+ i = runtime.EncodeVarint(dAtA, i, uint64(pksize2))
+ 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...)
+ } 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().(*PartialSignature)
+ 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: PartialSignature: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: PartialSignature: 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 {
+ var v uint32
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.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 |= uint32(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ x.SlotIndices = append(x.SlotIndices, 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.SlotIndices) == 0 {
+ x.SlotIndices = make([]uint32, 0, elementCount)
+ }
+ for iNdEx < postIndex {
+ var v uint32
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.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 |= uint32(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ x.SlotIndices = append(x.SlotIndices, v)
+ }
+ } else {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field SlotIndices", wireType)
+ }
+ 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 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.Signature = append(x.Signature[:0], dAtA[iNdEx:postIndex]...)
+ if x.Signature == nil {
+ x.Signature = []byte{}
+ }
+ 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/bls/params.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)
+)
+
+// Params defines the parameters for the module.
+type Params struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // Total number of slots for DKG (e.g., 100 for PoC)
+ ITotalSlots uint32 `protobuf:"varint,1,opt,name=i_total_slots,json=iTotalSlots,proto3" json:"i_total_slots,omitempty"`
+ // Polynomial degree offset (e.g., floor(i_total_slots / 2))
+ TSlotsDegreeOffset uint32 `protobuf:"varint,2,opt,name=t_slots_degree_offset,json=tSlotsDegreeOffset,proto3" json:"t_slots_degree_offset,omitempty"`
+ // Duration in blocks for the dealing phase (e.g., 5 blocks for PoC)
+ DealingPhaseDurationBlocks int64 `protobuf:"varint,3,opt,name=dealing_phase_duration_blocks,json=dealingPhaseDurationBlocks,proto3" json:"dealing_phase_duration_blocks,omitempty"`
+ // Duration in blocks for the verification phase (e.g., 3 blocks for PoC)
+ VerificationPhaseDurationBlocks int64 `protobuf:"varint,4,opt,name=verification_phase_duration_blocks,json=verificationPhaseDurationBlocks,proto3" json:"verification_phase_duration_blocks,omitempty"`
+ // Duration in blocks for threshold signing deadline (e.g., 10 blocks for PoC)
+ SigningDeadlineBlocks int64 `protobuf:"varint,5,opt,name=signing_deadline_blocks,json=signingDeadlineBlocks,proto3" json:"signing_deadline_blocks,omitempty"`
+}
+
+func (x *Params) Reset() {
+ *x = Params{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_params_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *Params) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Params) ProtoMessage() {}
+
+// Deprecated: Use Params.ProtoReflect.Descriptor instead.
+func (*Params) Descriptor() ([]byte, []int) {
+ return file_inference_bls_params_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Params) GetITotalSlots() uint32 {
+ if x != nil {
+ return x.ITotalSlots
+ }
+ return 0
+}
+
+func (x *Params) GetTSlotsDegreeOffset() uint32 {
+ if x != nil {
+ return x.TSlotsDegreeOffset
+ }
+ return 0
+}
+
+func (x *Params) GetDealingPhaseDurationBlocks() int64 {
+ if x != nil {
+ return x.DealingPhaseDurationBlocks
+ }
+ return 0
+}
+
+func (x *Params) GetVerificationPhaseDurationBlocks() int64 {
+ if x != nil {
+ return x.VerificationPhaseDurationBlocks
+ }
+ return 0
+}
+
+func (x *Params) GetSigningDeadlineBlocks() int64 {
+ if x != nil {
+ return x.SigningDeadlineBlocks
+ }
+ return 0
+}
+
+// PartialSignature represents a partial signature from a single participant in threshold signing
+type PartialSignature struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // participant_address is the address of the participant who submitted this partial signature
+ ParticipantAddress string `protobuf:"bytes,1,opt,name=participant_address,json=participantAddress,proto3" json:"participant_address,omitempty"`
+ // slot_indices are the slot indices this participant is signing for (from their current epoch assignment)
+ SlotIndices []uint32 `protobuf:"varint,2,rep,packed,name=slot_indices,json=slotIndices,proto3" json:"slot_indices,omitempty"`
+ // signature is the BLS partial signature (G1 point, 48-byte compressed format)
+ Signature []byte `protobuf:"bytes,3,opt,name=signature,proto3" json:"signature,omitempty"`
+}
+
+func (x *PartialSignature) Reset() {
+ *x = PartialSignature{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_params_proto_msgTypes[1]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *PartialSignature) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*PartialSignature) ProtoMessage() {}
+
+// Deprecated: Use PartialSignature.ProtoReflect.Descriptor instead.
+func (*PartialSignature) Descriptor() ([]byte, []int) {
+ return file_inference_bls_params_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *PartialSignature) GetParticipantAddress() string {
+ if x != nil {
+ return x.ParticipantAddress
+ }
+ return ""
+}
+
+func (x *PartialSignature) GetSlotIndices() []uint32 {
+ if x != nil {
+ return x.SlotIndices
+ }
+ return nil
+}
+
+func (x *PartialSignature) GetSignature() []byte {
+ if x != nil {
+ return x.Signature
+ }
+ return nil
+}
+
+var File_inference_bls_params_proto protoreflect.FileDescriptor
+
+var file_inference_bls_params_proto_rawDesc = []byte{
+ 0x0a, 0x1a, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x62, 0x6c, 0x73, 0x2f,
+ 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0d, 0x69, 0x6e,
+ 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x1a, 0x11, 0x61, 0x6d, 0x69,
+ 0x6e, 0x6f, 0x2f, 0x61, 0x6d, 0x69, 0x6e, 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, 0x1a, 0x14, 0x67, 0x6f, 0x67, 0x6f, 0x70,
+ 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22,
+ 0xc8, 0x02, 0x0a, 0x06, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x22, 0x0a, 0x0d, 0x69, 0x5f,
+ 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x73, 0x6c, 0x6f, 0x74, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28,
+ 0x0d, 0x52, 0x0b, 0x69, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x53, 0x6c, 0x6f, 0x74, 0x73, 0x12, 0x31,
+ 0x0a, 0x15, 0x74, 0x5f, 0x73, 0x6c, 0x6f, 0x74, 0x73, 0x5f, 0x64, 0x65, 0x67, 0x72, 0x65, 0x65,
+ 0x5f, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x12, 0x74,
+ 0x53, 0x6c, 0x6f, 0x74, 0x73, 0x44, 0x65, 0x67, 0x72, 0x65, 0x65, 0x4f, 0x66, 0x66, 0x73, 0x65,
+ 0x74, 0x12, 0x41, 0x0a, 0x1d, 0x64, 0x65, 0x61, 0x6c, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x68, 0x61,
+ 0x73, 0x65, 0x5f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x62, 0x6c, 0x6f, 0x63,
+ 0x6b, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x1a, 0x64, 0x65, 0x61, 0x6c, 0x69, 0x6e,
+ 0x67, 0x50, 0x68, 0x61, 0x73, 0x65, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x6c,
+ 0x6f, 0x63, 0x6b, 0x73, 0x12, 0x4b, 0x0a, 0x22, 0x76, 0x65, 0x72, 0x69, 0x66, 0x69, 0x63, 0x61,
+ 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x68, 0x61, 0x73, 0x65, 0x5f, 0x64, 0x75, 0x72, 0x61, 0x74,
+ 0x69, 0x6f, 0x6e, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03,
+ 0x52, 0x1f, 0x76, 0x65, 0x72, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x68,
+ 0x61, 0x73, 0x65, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b,
+ 0x73, 0x12, 0x36, 0x0a, 0x17, 0x73, 0x69, 0x67, 0x6e, 0x69, 0x6e, 0x67, 0x5f, 0x64, 0x65, 0x61,
+ 0x64, 0x6c, 0x69, 0x6e, 0x65, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x18, 0x05, 0x20, 0x01,
+ 0x28, 0x03, 0x52, 0x15, 0x73, 0x69, 0x67, 0x6e, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x61, 0x64, 0x6c,
+ 0x69, 0x6e, 0x65, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x3a, 0x1f, 0xe8, 0xa0, 0x1f, 0x01, 0x8a,
+ 0xe7, 0xb0, 0x2a, 0x16, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x78, 0x2f,
+ 0x62, 0x6c, 0x73, 0x2f, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x9e, 0x01, 0x0a, 0x10, 0x50,
+ 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x12,
+ 0x49, 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, 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, 0x12, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70,
+ 0x61, 0x6e, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x6c,
+ 0x6f, 0x74, 0x5f, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0d,
+ 0x52, 0x0b, 0x73, 0x6c, 0x6f, 0x74, 0x49, 0x6e, 0x64, 0x69, 0x63, 0x65, 0x73, 0x12, 0x1c, 0x0a,
+ 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c,
+ 0x52, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x42, 0x95, 0x01, 0x0a, 0x11,
+ 0x63, 0x6f, 0x6d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c,
+ 0x73, 0x42, 0x0b, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 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 (
+ file_inference_bls_params_proto_rawDescOnce sync.Once
+ file_inference_bls_params_proto_rawDescData = file_inference_bls_params_proto_rawDesc
+)
+
+func file_inference_bls_params_proto_rawDescGZIP() []byte {
+ file_inference_bls_params_proto_rawDescOnce.Do(func() {
+ file_inference_bls_params_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_bls_params_proto_rawDescData)
+ })
+ return file_inference_bls_params_proto_rawDescData
+}
+
+var file_inference_bls_params_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
+var file_inference_bls_params_proto_goTypes = []interface{}{
+ (*Params)(nil), // 0: inference.bls.Params
+ (*PartialSignature)(nil), // 1: inference.bls.PartialSignature
+}
+var file_inference_bls_params_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_bls_params_proto_init() }
+func file_inference_bls_params_proto_init() {
+ if File_inference_bls_params_proto != nil {
+ return
+ }
+ if !protoimpl.UnsafeEnabled {
+ file_inference_bls_params_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*Params); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_bls_params_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*PartialSignature); 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_bls_params_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 2,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_bls_params_proto_goTypes,
+ DependencyIndexes: file_inference_bls_params_proto_depIdxs,
+ MessageInfos: file_inference_bls_params_proto_msgTypes,
+ }.Build()
+ File_inference_bls_params_proto = out.File
+ file_inference_bls_params_proto_rawDesc = nil
+ file_inference_bls_params_proto_goTypes = nil
+ file_inference_bls_params_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/bls/query.pulsar.go b/inference-chain/api/inference/bls/query.pulsar.go
new file mode 100644
index 000000000..dbbe2b2a4
--- /dev/null
+++ b/inference-chain/api/inference/bls/query.pulsar.go
@@ -0,0 +1,4235 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package bls
+
+import (
+ _ "cosmossdk.io/api/amino"
+ v1beta1 "cosmossdk.io/api/cosmos/base/query/v1beta1"
+ fmt "fmt"
+ runtime "github.com/cosmos/cosmos-proto/runtime"
+ _ "github.com/cosmos/gogoproto/gogoproto"
+ _ "google.golang.org/genproto/googleapis/api/annotations"
+ 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_QueryParamsRequest protoreflect.MessageDescriptor
+)
+
+func init() {
+ file_inference_bls_query_proto_init()
+ md_QueryParamsRequest = File_inference_bls_query_proto.Messages().ByName("QueryParamsRequest")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryParamsRequest)(nil)
+
+type fastReflection_QueryParamsRequest QueryParamsRequest
+
+func (x *QueryParamsRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryParamsRequest)(x)
+}
+
+func (x *QueryParamsRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_query_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_QueryParamsRequest_messageType fastReflection_QueryParamsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryParamsRequest_messageType{}
+
+type fastReflection_QueryParamsRequest_messageType struct{}
+
+func (x fastReflection_QueryParamsRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryParamsRequest)(nil)
+}
+func (x fastReflection_QueryParamsRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryParamsRequest)
+}
+func (x fastReflection_QueryParamsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryParamsRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryParamsRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryParamsRequest
+}
+
+// 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_QueryParamsRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryParamsRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryParamsRequest) New() protoreflect.Message {
+ return new(fastReflection_QueryParamsRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryParamsRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryParamsRequest)(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_QueryParamsRequest) 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_QueryParamsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QueryParamsRequest"))
+ }
+ panic(fmt.Errorf("message inference.bls.QueryParamsRequest 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_QueryParamsRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QueryParamsRequest"))
+ }
+ panic(fmt.Errorf("message inference.bls.QueryParamsRequest 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_QueryParamsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QueryParamsRequest"))
+ }
+ panic(fmt.Errorf("message inference.bls.QueryParamsRequest 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_QueryParamsRequest) 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.bls.QueryParamsRequest"))
+ }
+ panic(fmt.Errorf("message inference.bls.QueryParamsRequest 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_QueryParamsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QueryParamsRequest"))
+ }
+ panic(fmt.Errorf("message inference.bls.QueryParamsRequest 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_QueryParamsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QueryParamsRequest"))
+ }
+ panic(fmt.Errorf("message inference.bls.QueryParamsRequest 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_QueryParamsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.QueryParamsRequest", 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_QueryParamsRequest) 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_QueryParamsRequest) 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_QueryParamsRequest) 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_QueryParamsRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryParamsRequest)
+ 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().(*QueryParamsRequest)
+ 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().(*QueryParamsRequest)
+ 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: QueryParamsRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryParamsRequest: 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 (
+ md_QueryParamsResponse protoreflect.MessageDescriptor
+ fd_QueryParamsResponse_params protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bls_query_proto_init()
+ md_QueryParamsResponse = File_inference_bls_query_proto.Messages().ByName("QueryParamsResponse")
+ fd_QueryParamsResponse_params = md_QueryParamsResponse.Fields().ByName("params")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryParamsResponse)(nil)
+
+type fastReflection_QueryParamsResponse QueryParamsResponse
+
+func (x *QueryParamsResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryParamsResponse)(x)
+}
+
+func (x *QueryParamsResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_query_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_QueryParamsResponse_messageType fastReflection_QueryParamsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryParamsResponse_messageType{}
+
+type fastReflection_QueryParamsResponse_messageType struct{}
+
+func (x fastReflection_QueryParamsResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryParamsResponse)(nil)
+}
+func (x fastReflection_QueryParamsResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryParamsResponse)
+}
+func (x fastReflection_QueryParamsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryParamsResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryParamsResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryParamsResponse
+}
+
+// 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_QueryParamsResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryParamsResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryParamsResponse) New() protoreflect.Message {
+ return new(fastReflection_QueryParamsResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryParamsResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryParamsResponse)(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_QueryParamsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Params != nil {
+ value := protoreflect.ValueOfMessage(x.Params.ProtoReflect())
+ if !f(fd_QueryParamsResponse_params, 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_QueryParamsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bls.QueryParamsResponse.params":
+ return x.Params != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QueryParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.QueryParamsResponse 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_QueryParamsResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bls.QueryParamsResponse.params":
+ x.Params = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QueryParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.QueryParamsResponse 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_QueryParamsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bls.QueryParamsResponse.params":
+ value := x.Params
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QueryParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.QueryParamsResponse 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_QueryParamsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bls.QueryParamsResponse.params":
+ x.Params = value.Message().Interface().(*Params)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QueryParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.QueryParamsResponse 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_QueryParamsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.QueryParamsResponse.params":
+ if x.Params == nil {
+ x.Params = new(Params)
+ }
+ return protoreflect.ValueOfMessage(x.Params.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QueryParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.QueryParamsResponse 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_QueryParamsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.QueryParamsResponse.params":
+ m := new(Params)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QueryParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.QueryParamsResponse 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_QueryParamsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.QueryParamsResponse", 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_QueryParamsResponse) 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_QueryParamsResponse) 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_QueryParamsResponse) 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_QueryParamsResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryParamsResponse)
+ 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.Params != nil {
+ l = options.Size(x.Params)
+ 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().(*QueryParamsResponse)
+ 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.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] = 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().(*QueryParamsResponse)
+ 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: QueryParamsResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryParamsResponse: 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 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
+ 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_QueryEpochBLSDataRequest protoreflect.MessageDescriptor
+ fd_QueryEpochBLSDataRequest_epoch_id protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bls_query_proto_init()
+ md_QueryEpochBLSDataRequest = File_inference_bls_query_proto.Messages().ByName("QueryEpochBLSDataRequest")
+ fd_QueryEpochBLSDataRequest_epoch_id = md_QueryEpochBLSDataRequest.Fields().ByName("epoch_id")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryEpochBLSDataRequest)(nil)
+
+type fastReflection_QueryEpochBLSDataRequest QueryEpochBLSDataRequest
+
+func (x *QueryEpochBLSDataRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryEpochBLSDataRequest)(x)
+}
+
+func (x *QueryEpochBLSDataRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_query_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_QueryEpochBLSDataRequest_messageType fastReflection_QueryEpochBLSDataRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryEpochBLSDataRequest_messageType{}
+
+type fastReflection_QueryEpochBLSDataRequest_messageType struct{}
+
+func (x fastReflection_QueryEpochBLSDataRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryEpochBLSDataRequest)(nil)
+}
+func (x fastReflection_QueryEpochBLSDataRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryEpochBLSDataRequest)
+}
+func (x fastReflection_QueryEpochBLSDataRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryEpochBLSDataRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryEpochBLSDataRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryEpochBLSDataRequest
+}
+
+// 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_QueryEpochBLSDataRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryEpochBLSDataRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryEpochBLSDataRequest) New() protoreflect.Message {
+ return new(fastReflection_QueryEpochBLSDataRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryEpochBLSDataRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryEpochBLSDataRequest)(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_QueryEpochBLSDataRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.EpochId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.EpochId)
+ if !f(fd_QueryEpochBLSDataRequest_epoch_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_QueryEpochBLSDataRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bls.QueryEpochBLSDataRequest.epoch_id":
+ return x.EpochId != uint64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QueryEpochBLSDataRequest"))
+ }
+ panic(fmt.Errorf("message inference.bls.QueryEpochBLSDataRequest 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_QueryEpochBLSDataRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bls.QueryEpochBLSDataRequest.epoch_id":
+ x.EpochId = uint64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QueryEpochBLSDataRequest"))
+ }
+ panic(fmt.Errorf("message inference.bls.QueryEpochBLSDataRequest 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_QueryEpochBLSDataRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bls.QueryEpochBLSDataRequest.epoch_id":
+ value := x.EpochId
+ return protoreflect.ValueOfUint64(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QueryEpochBLSDataRequest"))
+ }
+ panic(fmt.Errorf("message inference.bls.QueryEpochBLSDataRequest 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_QueryEpochBLSDataRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bls.QueryEpochBLSDataRequest.epoch_id":
+ x.EpochId = value.Uint()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QueryEpochBLSDataRequest"))
+ }
+ panic(fmt.Errorf("message inference.bls.QueryEpochBLSDataRequest 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_QueryEpochBLSDataRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.QueryEpochBLSDataRequest.epoch_id":
+ panic(fmt.Errorf("field epoch_id of message inference.bls.QueryEpochBLSDataRequest is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QueryEpochBLSDataRequest"))
+ }
+ panic(fmt.Errorf("message inference.bls.QueryEpochBLSDataRequest 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_QueryEpochBLSDataRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.QueryEpochBLSDataRequest.epoch_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QueryEpochBLSDataRequest"))
+ }
+ panic(fmt.Errorf("message inference.bls.QueryEpochBLSDataRequest 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_QueryEpochBLSDataRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.QueryEpochBLSDataRequest", 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_QueryEpochBLSDataRequest) 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_QueryEpochBLSDataRequest) 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_QueryEpochBLSDataRequest) 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_QueryEpochBLSDataRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryEpochBLSDataRequest)
+ 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.EpochId != 0 {
+ n += 1 + runtime.Sov(uint64(x.EpochId))
+ }
+ 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().(*QueryEpochBLSDataRequest)
+ 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.EpochId != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochId))
+ 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().(*QueryEpochBLSDataRequest)
+ 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: QueryEpochBLSDataRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryEpochBLSDataRequest: 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
+ }
+ }
+ 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_QueryEpochBLSDataResponse protoreflect.MessageDescriptor
+ fd_QueryEpochBLSDataResponse_epoch_data protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bls_query_proto_init()
+ md_QueryEpochBLSDataResponse = File_inference_bls_query_proto.Messages().ByName("QueryEpochBLSDataResponse")
+ fd_QueryEpochBLSDataResponse_epoch_data = md_QueryEpochBLSDataResponse.Fields().ByName("epoch_data")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryEpochBLSDataResponse)(nil)
+
+type fastReflection_QueryEpochBLSDataResponse QueryEpochBLSDataResponse
+
+func (x *QueryEpochBLSDataResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryEpochBLSDataResponse)(x)
+}
+
+func (x *QueryEpochBLSDataResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_query_proto_msgTypes[3]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryEpochBLSDataResponse_messageType fastReflection_QueryEpochBLSDataResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryEpochBLSDataResponse_messageType{}
+
+type fastReflection_QueryEpochBLSDataResponse_messageType struct{}
+
+func (x fastReflection_QueryEpochBLSDataResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryEpochBLSDataResponse)(nil)
+}
+func (x fastReflection_QueryEpochBLSDataResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryEpochBLSDataResponse)
+}
+func (x fastReflection_QueryEpochBLSDataResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryEpochBLSDataResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryEpochBLSDataResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryEpochBLSDataResponse
+}
+
+// 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_QueryEpochBLSDataResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryEpochBLSDataResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryEpochBLSDataResponse) New() protoreflect.Message {
+ return new(fastReflection_QueryEpochBLSDataResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryEpochBLSDataResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryEpochBLSDataResponse)(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_QueryEpochBLSDataResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.EpochData != nil {
+ value := protoreflect.ValueOfMessage(x.EpochData.ProtoReflect())
+ if !f(fd_QueryEpochBLSDataResponse_epoch_data, 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_QueryEpochBLSDataResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bls.QueryEpochBLSDataResponse.epoch_data":
+ return x.EpochData != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QueryEpochBLSDataResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.QueryEpochBLSDataResponse 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_QueryEpochBLSDataResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bls.QueryEpochBLSDataResponse.epoch_data":
+ x.EpochData = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QueryEpochBLSDataResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.QueryEpochBLSDataResponse 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_QueryEpochBLSDataResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bls.QueryEpochBLSDataResponse.epoch_data":
+ value := x.EpochData
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QueryEpochBLSDataResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.QueryEpochBLSDataResponse 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_QueryEpochBLSDataResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bls.QueryEpochBLSDataResponse.epoch_data":
+ x.EpochData = value.Message().Interface().(*EpochBLSData)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QueryEpochBLSDataResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.QueryEpochBLSDataResponse 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_QueryEpochBLSDataResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.QueryEpochBLSDataResponse.epoch_data":
+ if x.EpochData == nil {
+ x.EpochData = new(EpochBLSData)
+ }
+ return protoreflect.ValueOfMessage(x.EpochData.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QueryEpochBLSDataResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.QueryEpochBLSDataResponse 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_QueryEpochBLSDataResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.QueryEpochBLSDataResponse.epoch_data":
+ m := new(EpochBLSData)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QueryEpochBLSDataResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.QueryEpochBLSDataResponse 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_QueryEpochBLSDataResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.QueryEpochBLSDataResponse", 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_QueryEpochBLSDataResponse) 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_QueryEpochBLSDataResponse) 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_QueryEpochBLSDataResponse) 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_QueryEpochBLSDataResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryEpochBLSDataResponse)
+ 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.EpochData != nil {
+ l = options.Size(x.EpochData)
+ 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().(*QueryEpochBLSDataResponse)
+ 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.EpochData != nil {
+ encoded, err := options.Marshal(x.EpochData)
+ 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().(*QueryEpochBLSDataResponse)
+ 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: QueryEpochBLSDataResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryEpochBLSDataResponse: 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 EpochData", 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.EpochData == nil {
+ x.EpochData = &EpochBLSData{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.EpochData); 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_QuerySigningStatusRequest protoreflect.MessageDescriptor
+ fd_QuerySigningStatusRequest_request_id protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bls_query_proto_init()
+ md_QuerySigningStatusRequest = File_inference_bls_query_proto.Messages().ByName("QuerySigningStatusRequest")
+ fd_QuerySigningStatusRequest_request_id = md_QuerySigningStatusRequest.Fields().ByName("request_id")
+}
+
+var _ protoreflect.Message = (*fastReflection_QuerySigningStatusRequest)(nil)
+
+type fastReflection_QuerySigningStatusRequest QuerySigningStatusRequest
+
+func (x *QuerySigningStatusRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QuerySigningStatusRequest)(x)
+}
+
+func (x *QuerySigningStatusRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_query_proto_msgTypes[4]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QuerySigningStatusRequest_messageType fastReflection_QuerySigningStatusRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QuerySigningStatusRequest_messageType{}
+
+type fastReflection_QuerySigningStatusRequest_messageType struct{}
+
+func (x fastReflection_QuerySigningStatusRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QuerySigningStatusRequest)(nil)
+}
+func (x fastReflection_QuerySigningStatusRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QuerySigningStatusRequest)
+}
+func (x fastReflection_QuerySigningStatusRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QuerySigningStatusRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QuerySigningStatusRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_QuerySigningStatusRequest
+}
+
+// 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_QuerySigningStatusRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QuerySigningStatusRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QuerySigningStatusRequest) New() protoreflect.Message {
+ return new(fastReflection_QuerySigningStatusRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QuerySigningStatusRequest) Interface() protoreflect.ProtoMessage {
+ return (*QuerySigningStatusRequest)(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_QuerySigningStatusRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if len(x.RequestId) != 0 {
+ value := protoreflect.ValueOfBytes(x.RequestId)
+ if !f(fd_QuerySigningStatusRequest_request_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_QuerySigningStatusRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bls.QuerySigningStatusRequest.request_id":
+ return len(x.RequestId) != 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QuerySigningStatusRequest"))
+ }
+ panic(fmt.Errorf("message inference.bls.QuerySigningStatusRequest 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_QuerySigningStatusRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bls.QuerySigningStatusRequest.request_id":
+ x.RequestId = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QuerySigningStatusRequest"))
+ }
+ panic(fmt.Errorf("message inference.bls.QuerySigningStatusRequest 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_QuerySigningStatusRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bls.QuerySigningStatusRequest.request_id":
+ value := x.RequestId
+ return protoreflect.ValueOfBytes(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QuerySigningStatusRequest"))
+ }
+ panic(fmt.Errorf("message inference.bls.QuerySigningStatusRequest 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_QuerySigningStatusRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bls.QuerySigningStatusRequest.request_id":
+ x.RequestId = value.Bytes()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QuerySigningStatusRequest"))
+ }
+ panic(fmt.Errorf("message inference.bls.QuerySigningStatusRequest 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_QuerySigningStatusRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.QuerySigningStatusRequest.request_id":
+ panic(fmt.Errorf("field request_id of message inference.bls.QuerySigningStatusRequest is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QuerySigningStatusRequest"))
+ }
+ panic(fmt.Errorf("message inference.bls.QuerySigningStatusRequest 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_QuerySigningStatusRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.QuerySigningStatusRequest.request_id":
+ return protoreflect.ValueOfBytes(nil)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QuerySigningStatusRequest"))
+ }
+ panic(fmt.Errorf("message inference.bls.QuerySigningStatusRequest 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_QuerySigningStatusRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.QuerySigningStatusRequest", 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_QuerySigningStatusRequest) 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_QuerySigningStatusRequest) 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_QuerySigningStatusRequest) 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_QuerySigningStatusRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QuerySigningStatusRequest)
+ 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.RequestId)
+ 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().(*QuerySigningStatusRequest)
+ 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.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 {
+ 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().(*QuerySigningStatusRequest)
+ 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: QuerySigningStatusRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QuerySigningStatusRequest: 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 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.RequestId = append(x.RequestId[:0], dAtA[iNdEx:postIndex]...)
+ if x.RequestId == nil {
+ x.RequestId = []byte{}
+ }
+ 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_QuerySigningStatusResponse protoreflect.MessageDescriptor
+ fd_QuerySigningStatusResponse_signing_request protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bls_query_proto_init()
+ md_QuerySigningStatusResponse = File_inference_bls_query_proto.Messages().ByName("QuerySigningStatusResponse")
+ fd_QuerySigningStatusResponse_signing_request = md_QuerySigningStatusResponse.Fields().ByName("signing_request")
+}
+
+var _ protoreflect.Message = (*fastReflection_QuerySigningStatusResponse)(nil)
+
+type fastReflection_QuerySigningStatusResponse QuerySigningStatusResponse
+
+func (x *QuerySigningStatusResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QuerySigningStatusResponse)(x)
+}
+
+func (x *QuerySigningStatusResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_query_proto_msgTypes[5]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QuerySigningStatusResponse_messageType fastReflection_QuerySigningStatusResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QuerySigningStatusResponse_messageType{}
+
+type fastReflection_QuerySigningStatusResponse_messageType struct{}
+
+func (x fastReflection_QuerySigningStatusResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QuerySigningStatusResponse)(nil)
+}
+func (x fastReflection_QuerySigningStatusResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QuerySigningStatusResponse)
+}
+func (x fastReflection_QuerySigningStatusResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QuerySigningStatusResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QuerySigningStatusResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_QuerySigningStatusResponse
+}
+
+// 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_QuerySigningStatusResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QuerySigningStatusResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QuerySigningStatusResponse) New() protoreflect.Message {
+ return new(fastReflection_QuerySigningStatusResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QuerySigningStatusResponse) Interface() protoreflect.ProtoMessage {
+ return (*QuerySigningStatusResponse)(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_QuerySigningStatusResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.SigningRequest != nil {
+ value := protoreflect.ValueOfMessage(x.SigningRequest.ProtoReflect())
+ if !f(fd_QuerySigningStatusResponse_signing_request, 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_QuerySigningStatusResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bls.QuerySigningStatusResponse.signing_request":
+ return x.SigningRequest != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QuerySigningStatusResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.QuerySigningStatusResponse 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_QuerySigningStatusResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bls.QuerySigningStatusResponse.signing_request":
+ x.SigningRequest = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QuerySigningStatusResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.QuerySigningStatusResponse 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_QuerySigningStatusResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bls.QuerySigningStatusResponse.signing_request":
+ value := x.SigningRequest
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QuerySigningStatusResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.QuerySigningStatusResponse 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_QuerySigningStatusResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bls.QuerySigningStatusResponse.signing_request":
+ x.SigningRequest = value.Message().Interface().(*ThresholdSigningRequest)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QuerySigningStatusResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.QuerySigningStatusResponse 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_QuerySigningStatusResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.QuerySigningStatusResponse.signing_request":
+ if x.SigningRequest == nil {
+ x.SigningRequest = new(ThresholdSigningRequest)
+ }
+ return protoreflect.ValueOfMessage(x.SigningRequest.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QuerySigningStatusResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.QuerySigningStatusResponse 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_QuerySigningStatusResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.QuerySigningStatusResponse.signing_request":
+ m := new(ThresholdSigningRequest)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QuerySigningStatusResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.QuerySigningStatusResponse 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_QuerySigningStatusResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.QuerySigningStatusResponse", 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_QuerySigningStatusResponse) 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_QuerySigningStatusResponse) 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_QuerySigningStatusResponse) 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_QuerySigningStatusResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QuerySigningStatusResponse)
+ 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.SigningRequest != nil {
+ l = options.Size(x.SigningRequest)
+ 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().(*QuerySigningStatusResponse)
+ 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.SigningRequest != nil {
+ encoded, err := options.Marshal(x.SigningRequest)
+ 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().(*QuerySigningStatusResponse)
+ 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: QuerySigningStatusResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QuerySigningStatusResponse: 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 SigningRequest", 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.SigningRequest == nil {
+ x.SigningRequest = &ThresholdSigningRequest{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.SigningRequest); 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_QuerySigningHistoryRequest protoreflect.MessageDescriptor
+ fd_QuerySigningHistoryRequest_current_epoch_id protoreflect.FieldDescriptor
+ fd_QuerySigningHistoryRequest_status_filter protoreflect.FieldDescriptor
+ fd_QuerySigningHistoryRequest_pagination protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bls_query_proto_init()
+ md_QuerySigningHistoryRequest = File_inference_bls_query_proto.Messages().ByName("QuerySigningHistoryRequest")
+ fd_QuerySigningHistoryRequest_current_epoch_id = md_QuerySigningHistoryRequest.Fields().ByName("current_epoch_id")
+ fd_QuerySigningHistoryRequest_status_filter = md_QuerySigningHistoryRequest.Fields().ByName("status_filter")
+ fd_QuerySigningHistoryRequest_pagination = md_QuerySigningHistoryRequest.Fields().ByName("pagination")
+}
+
+var _ protoreflect.Message = (*fastReflection_QuerySigningHistoryRequest)(nil)
+
+type fastReflection_QuerySigningHistoryRequest QuerySigningHistoryRequest
+
+func (x *QuerySigningHistoryRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QuerySigningHistoryRequest)(x)
+}
+
+func (x *QuerySigningHistoryRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_query_proto_msgTypes[6]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QuerySigningHistoryRequest_messageType fastReflection_QuerySigningHistoryRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QuerySigningHistoryRequest_messageType{}
+
+type fastReflection_QuerySigningHistoryRequest_messageType struct{}
+
+func (x fastReflection_QuerySigningHistoryRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QuerySigningHistoryRequest)(nil)
+}
+func (x fastReflection_QuerySigningHistoryRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QuerySigningHistoryRequest)
+}
+func (x fastReflection_QuerySigningHistoryRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QuerySigningHistoryRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QuerySigningHistoryRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_QuerySigningHistoryRequest
+}
+
+// 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_QuerySigningHistoryRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QuerySigningHistoryRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QuerySigningHistoryRequest) New() protoreflect.Message {
+ return new(fastReflection_QuerySigningHistoryRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QuerySigningHistoryRequest) Interface() protoreflect.ProtoMessage {
+ return (*QuerySigningHistoryRequest)(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_QuerySigningHistoryRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.CurrentEpochId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.CurrentEpochId)
+ if !f(fd_QuerySigningHistoryRequest_current_epoch_id, value) {
+ return
+ }
+ }
+ if x.StatusFilter != 0 {
+ value := protoreflect.ValueOfEnum((protoreflect.EnumNumber)(x.StatusFilter))
+ if !f(fd_QuerySigningHistoryRequest_status_filter, value) {
+ return
+ }
+ }
+ if x.Pagination != nil {
+ value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+ if !f(fd_QuerySigningHistoryRequest_pagination, 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_QuerySigningHistoryRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bls.QuerySigningHistoryRequest.current_epoch_id":
+ return x.CurrentEpochId != uint64(0)
+ case "inference.bls.QuerySigningHistoryRequest.status_filter":
+ return x.StatusFilter != 0
+ case "inference.bls.QuerySigningHistoryRequest.pagination":
+ return x.Pagination != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QuerySigningHistoryRequest"))
+ }
+ panic(fmt.Errorf("message inference.bls.QuerySigningHistoryRequest 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_QuerySigningHistoryRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bls.QuerySigningHistoryRequest.current_epoch_id":
+ x.CurrentEpochId = uint64(0)
+ case "inference.bls.QuerySigningHistoryRequest.status_filter":
+ x.StatusFilter = 0
+ case "inference.bls.QuerySigningHistoryRequest.pagination":
+ x.Pagination = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QuerySigningHistoryRequest"))
+ }
+ panic(fmt.Errorf("message inference.bls.QuerySigningHistoryRequest 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_QuerySigningHistoryRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bls.QuerySigningHistoryRequest.current_epoch_id":
+ value := x.CurrentEpochId
+ return protoreflect.ValueOfUint64(value)
+ case "inference.bls.QuerySigningHistoryRequest.status_filter":
+ value := x.StatusFilter
+ return protoreflect.ValueOfEnum((protoreflect.EnumNumber)(value))
+ case "inference.bls.QuerySigningHistoryRequest.pagination":
+ value := x.Pagination
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QuerySigningHistoryRequest"))
+ }
+ panic(fmt.Errorf("message inference.bls.QuerySigningHistoryRequest 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_QuerySigningHistoryRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bls.QuerySigningHistoryRequest.current_epoch_id":
+ x.CurrentEpochId = value.Uint()
+ case "inference.bls.QuerySigningHistoryRequest.status_filter":
+ x.StatusFilter = (ThresholdSigningStatus)(value.Enum())
+ case "inference.bls.QuerySigningHistoryRequest.pagination":
+ x.Pagination = value.Message().Interface().(*v1beta1.PageRequest)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QuerySigningHistoryRequest"))
+ }
+ panic(fmt.Errorf("message inference.bls.QuerySigningHistoryRequest 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_QuerySigningHistoryRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.QuerySigningHistoryRequest.pagination":
+ if x.Pagination == nil {
+ x.Pagination = new(v1beta1.PageRequest)
+ }
+ return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+ case "inference.bls.QuerySigningHistoryRequest.current_epoch_id":
+ panic(fmt.Errorf("field current_epoch_id of message inference.bls.QuerySigningHistoryRequest is not mutable"))
+ case "inference.bls.QuerySigningHistoryRequest.status_filter":
+ panic(fmt.Errorf("field status_filter of message inference.bls.QuerySigningHistoryRequest is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QuerySigningHistoryRequest"))
+ }
+ panic(fmt.Errorf("message inference.bls.QuerySigningHistoryRequest 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_QuerySigningHistoryRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.QuerySigningHistoryRequest.current_epoch_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.bls.QuerySigningHistoryRequest.status_filter":
+ return protoreflect.ValueOfEnum(0)
+ case "inference.bls.QuerySigningHistoryRequest.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.bls.QuerySigningHistoryRequest"))
+ }
+ panic(fmt.Errorf("message inference.bls.QuerySigningHistoryRequest 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_QuerySigningHistoryRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.QuerySigningHistoryRequest", 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_QuerySigningHistoryRequest) 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_QuerySigningHistoryRequest) 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_QuerySigningHistoryRequest) 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_QuerySigningHistoryRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QuerySigningHistoryRequest)
+ 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.CurrentEpochId != 0 {
+ n += 1 + runtime.Sov(uint64(x.CurrentEpochId))
+ }
+ if x.StatusFilter != 0 {
+ n += 1 + runtime.Sov(uint64(x.StatusFilter))
+ }
+ if x.Pagination != nil {
+ l = options.Size(x.Pagination)
+ 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().(*QuerySigningHistoryRequest)
+ 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.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] = 0x1a
+ }
+ if x.StatusFilter != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.StatusFilter))
+ i--
+ dAtA[i] = 0x10
+ }
+ if x.CurrentEpochId != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.CurrentEpochId))
+ 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().(*QuerySigningHistoryRequest)
+ 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: QuerySigningHistoryRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QuerySigningHistoryRequest: 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 CurrentEpochId", wireType)
+ }
+ x.CurrentEpochId = 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.CurrentEpochId |= 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 StatusFilter", wireType)
+ }
+ x.StatusFilter = 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.StatusFilter |= ThresholdSigningStatus(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 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:])
+ 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 = (*_QuerySigningHistoryResponse_1_list)(nil)
+
+type _QuerySigningHistoryResponse_1_list struct {
+ list *[]*ThresholdSigningRequest
+}
+
+func (x *_QuerySigningHistoryResponse_1_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_QuerySigningHistoryResponse_1_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QuerySigningHistoryResponse_1_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*ThresholdSigningRequest)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_QuerySigningHistoryResponse_1_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*ThresholdSigningRequest)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QuerySigningHistoryResponse_1_list) AppendMutable() protoreflect.Value {
+ v := new(ThresholdSigningRequest)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QuerySigningHistoryResponse_1_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_QuerySigningHistoryResponse_1_list) NewElement() protoreflect.Value {
+ v := new(ThresholdSigningRequest)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QuerySigningHistoryResponse_1_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_QuerySigningHistoryResponse protoreflect.MessageDescriptor
+ fd_QuerySigningHistoryResponse_signing_requests protoreflect.FieldDescriptor
+ fd_QuerySigningHistoryResponse_pagination protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bls_query_proto_init()
+ md_QuerySigningHistoryResponse = File_inference_bls_query_proto.Messages().ByName("QuerySigningHistoryResponse")
+ fd_QuerySigningHistoryResponse_signing_requests = md_QuerySigningHistoryResponse.Fields().ByName("signing_requests")
+ fd_QuerySigningHistoryResponse_pagination = md_QuerySigningHistoryResponse.Fields().ByName("pagination")
+}
+
+var _ protoreflect.Message = (*fastReflection_QuerySigningHistoryResponse)(nil)
+
+type fastReflection_QuerySigningHistoryResponse QuerySigningHistoryResponse
+
+func (x *QuerySigningHistoryResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QuerySigningHistoryResponse)(x)
+}
+
+func (x *QuerySigningHistoryResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_query_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_QuerySigningHistoryResponse_messageType fastReflection_QuerySigningHistoryResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QuerySigningHistoryResponse_messageType{}
+
+type fastReflection_QuerySigningHistoryResponse_messageType struct{}
+
+func (x fastReflection_QuerySigningHistoryResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QuerySigningHistoryResponse)(nil)
+}
+func (x fastReflection_QuerySigningHistoryResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QuerySigningHistoryResponse)
+}
+func (x fastReflection_QuerySigningHistoryResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QuerySigningHistoryResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QuerySigningHistoryResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_QuerySigningHistoryResponse
+}
+
+// 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_QuerySigningHistoryResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QuerySigningHistoryResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QuerySigningHistoryResponse) New() protoreflect.Message {
+ return new(fastReflection_QuerySigningHistoryResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QuerySigningHistoryResponse) Interface() protoreflect.ProtoMessage {
+ return (*QuerySigningHistoryResponse)(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_QuerySigningHistoryResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if len(x.SigningRequests) != 0 {
+ value := protoreflect.ValueOfList(&_QuerySigningHistoryResponse_1_list{list: &x.SigningRequests})
+ if !f(fd_QuerySigningHistoryResponse_signing_requests, value) {
+ return
+ }
+ }
+ if x.Pagination != nil {
+ value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+ if !f(fd_QuerySigningHistoryResponse_pagination, 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_QuerySigningHistoryResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bls.QuerySigningHistoryResponse.signing_requests":
+ return len(x.SigningRequests) != 0
+ case "inference.bls.QuerySigningHistoryResponse.pagination":
+ return x.Pagination != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QuerySigningHistoryResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.QuerySigningHistoryResponse 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_QuerySigningHistoryResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bls.QuerySigningHistoryResponse.signing_requests":
+ x.SigningRequests = nil
+ case "inference.bls.QuerySigningHistoryResponse.pagination":
+ x.Pagination = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QuerySigningHistoryResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.QuerySigningHistoryResponse 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_QuerySigningHistoryResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bls.QuerySigningHistoryResponse.signing_requests":
+ if len(x.SigningRequests) == 0 {
+ return protoreflect.ValueOfList(&_QuerySigningHistoryResponse_1_list{})
+ }
+ listValue := &_QuerySigningHistoryResponse_1_list{list: &x.SigningRequests}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.bls.QuerySigningHistoryResponse.pagination":
+ value := x.Pagination
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QuerySigningHistoryResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.QuerySigningHistoryResponse 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_QuerySigningHistoryResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bls.QuerySigningHistoryResponse.signing_requests":
+ lv := value.List()
+ clv := lv.(*_QuerySigningHistoryResponse_1_list)
+ x.SigningRequests = *clv.list
+ case "inference.bls.QuerySigningHistoryResponse.pagination":
+ x.Pagination = value.Message().Interface().(*v1beta1.PageResponse)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.QuerySigningHistoryResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.QuerySigningHistoryResponse 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_QuerySigningHistoryResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.QuerySigningHistoryResponse.signing_requests":
+ if x.SigningRequests == nil {
+ x.SigningRequests = []*ThresholdSigningRequest{}
+ }
+ value := &_QuerySigningHistoryResponse_1_list{list: &x.SigningRequests}
+ return protoreflect.ValueOfList(value)
+ case "inference.bls.QuerySigningHistoryResponse.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.bls.QuerySigningHistoryResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.QuerySigningHistoryResponse 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_QuerySigningHistoryResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.QuerySigningHistoryResponse.signing_requests":
+ list := []*ThresholdSigningRequest{}
+ return protoreflect.ValueOfList(&_QuerySigningHistoryResponse_1_list{list: &list})
+ case "inference.bls.QuerySigningHistoryResponse.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.bls.QuerySigningHistoryResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.QuerySigningHistoryResponse 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_QuerySigningHistoryResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.QuerySigningHistoryResponse", 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_QuerySigningHistoryResponse) 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_QuerySigningHistoryResponse) 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_QuerySigningHistoryResponse) 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_QuerySigningHistoryResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QuerySigningHistoryResponse)
+ 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.SigningRequests) > 0 {
+ for _, e := range x.SigningRequests {
+ 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)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*QuerySigningHistoryResponse)
+ 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.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.SigningRequests) > 0 {
+ for iNdEx := len(x.SigningRequests) - 1; iNdEx >= 0; iNdEx-- {
+ encoded, err := options.Marshal(x.SigningRequests[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().(*QuerySigningHistoryResponse)
+ 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: QuerySigningHistoryResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QuerySigningHistoryResponse: 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 SigningRequests", 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.SigningRequests = append(x.SigningRequests, &ThresholdSigningRequest{})
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.SigningRequests[len(x.SigningRequests)-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
+ 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/bls/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_bls_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_bls_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_bls_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_bls_query_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *QueryParamsResponse) GetParams() *Params {
+ if x != nil {
+ return x.Params
+ }
+ return nil
+}
+
+// QueryEpochBLSDataRequest is request type for the Query/EpochBLSData RPC method.
+type QueryEpochBLSDataRequest struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // epoch_id identifies the DKG round to query complete data for
+ EpochId uint64 `protobuf:"varint,1,opt,name=epoch_id,json=epochId,proto3" json:"epoch_id,omitempty"`
+}
+
+func (x *QueryEpochBLSDataRequest) Reset() {
+ *x = QueryEpochBLSDataRequest{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_query_proto_msgTypes[2]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *QueryEpochBLSDataRequest) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryEpochBLSDataRequest) ProtoMessage() {}
+
+// Deprecated: Use QueryEpochBLSDataRequest.ProtoReflect.Descriptor instead.
+func (*QueryEpochBLSDataRequest) Descriptor() ([]byte, []int) {
+ return file_inference_bls_query_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *QueryEpochBLSDataRequest) GetEpochId() uint64 {
+ if x != nil {
+ return x.EpochId
+ }
+ return 0
+}
+
+// QueryEpochBLSDataResponse is response type for the Query/EpochBLSData RPC method.
+type QueryEpochBLSDataResponse struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // epoch_data contains complete BLS data for the specified epoch
+ EpochData *EpochBLSData `protobuf:"bytes,1,opt,name=epoch_data,json=epochData,proto3" json:"epoch_data,omitempty"`
+}
+
+func (x *QueryEpochBLSDataResponse) Reset() {
+ *x = QueryEpochBLSDataResponse{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_query_proto_msgTypes[3]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *QueryEpochBLSDataResponse) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryEpochBLSDataResponse) ProtoMessage() {}
+
+// Deprecated: Use QueryEpochBLSDataResponse.ProtoReflect.Descriptor instead.
+func (*QueryEpochBLSDataResponse) Descriptor() ([]byte, []int) {
+ return file_inference_bls_query_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *QueryEpochBLSDataResponse) GetEpochData() *EpochBLSData {
+ if x != nil {
+ return x.EpochData
+ }
+ return nil
+}
+
+// QuerySigningStatusRequest is request type for the Query/SigningStatus RPC method.
+type QuerySigningStatusRequest struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // request_id uniquely identifies the threshold signing request (32 bytes)
+ RequestId []byte `protobuf:"bytes,1,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`
+}
+
+func (x *QuerySigningStatusRequest) Reset() {
+ *x = QuerySigningStatusRequest{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_query_proto_msgTypes[4]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *QuerySigningStatusRequest) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QuerySigningStatusRequest) ProtoMessage() {}
+
+// Deprecated: Use QuerySigningStatusRequest.ProtoReflect.Descriptor instead.
+func (*QuerySigningStatusRequest) Descriptor() ([]byte, []int) {
+ return file_inference_bls_query_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *QuerySigningStatusRequest) GetRequestId() []byte {
+ if x != nil {
+ return x.RequestId
+ }
+ return nil
+}
+
+// QuerySigningStatusResponse is response type for the Query/SigningStatus RPC method.
+type QuerySigningStatusResponse struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // signing_request contains the complete threshold signing request data
+ SigningRequest *ThresholdSigningRequest `protobuf:"bytes,1,opt,name=signing_request,json=signingRequest,proto3" json:"signing_request,omitempty"`
+}
+
+func (x *QuerySigningStatusResponse) Reset() {
+ *x = QuerySigningStatusResponse{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_query_proto_msgTypes[5]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *QuerySigningStatusResponse) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QuerySigningStatusResponse) ProtoMessage() {}
+
+// Deprecated: Use QuerySigningStatusResponse.ProtoReflect.Descriptor instead.
+func (*QuerySigningStatusResponse) Descriptor() ([]byte, []int) {
+ return file_inference_bls_query_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *QuerySigningStatusResponse) GetSigningRequest() *ThresholdSigningRequest {
+ if x != nil {
+ return x.SigningRequest
+ }
+ return nil
+}
+
+// QuerySigningHistoryRequest is request type for the Query/SigningHistory RPC method.
+type QuerySigningHistoryRequest struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // current_epoch_id filters requests by epoch (optional, 0 means all epochs)
+ CurrentEpochId uint64 `protobuf:"varint,1,opt,name=current_epoch_id,json=currentEpochId,proto3" json:"current_epoch_id,omitempty"`
+ // status_filter filters requests by status (optional, UNDEFINED means all statuses)
+ StatusFilter ThresholdSigningStatus `protobuf:"varint,2,opt,name=status_filter,json=statusFilter,proto3,enum=inference.bls.ThresholdSigningStatus" json:"status_filter,omitempty"`
+ // pagination defines an optional pagination for the request
+ Pagination *v1beta1.PageRequest `protobuf:"bytes,3,opt,name=pagination,proto3" json:"pagination,omitempty"`
+}
+
+func (x *QuerySigningHistoryRequest) Reset() {
+ *x = QuerySigningHistoryRequest{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_query_proto_msgTypes[6]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *QuerySigningHistoryRequest) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QuerySigningHistoryRequest) ProtoMessage() {}
+
+// Deprecated: Use QuerySigningHistoryRequest.ProtoReflect.Descriptor instead.
+func (*QuerySigningHistoryRequest) Descriptor() ([]byte, []int) {
+ return file_inference_bls_query_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *QuerySigningHistoryRequest) GetCurrentEpochId() uint64 {
+ if x != nil {
+ return x.CurrentEpochId
+ }
+ return 0
+}
+
+func (x *QuerySigningHistoryRequest) GetStatusFilter() ThresholdSigningStatus {
+ if x != nil {
+ return x.StatusFilter
+ }
+ return ThresholdSigningStatus_THRESHOLD_SIGNING_STATUS_UNDEFINED
+}
+
+func (x *QuerySigningHistoryRequest) GetPagination() *v1beta1.PageRequest {
+ if x != nil {
+ return x.Pagination
+ }
+ return nil
+}
+
+// QuerySigningHistoryResponse is response type for the Query/SigningHistory RPC method.
+type QuerySigningHistoryResponse struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // signing_requests contains the filtered threshold signing requests
+ SigningRequests []*ThresholdSigningRequest `protobuf:"bytes,1,rep,name=signing_requests,json=signingRequests,proto3" json:"signing_requests,omitempty"`
+ // pagination defines the pagination in the response
+ Pagination *v1beta1.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
+}
+
+func (x *QuerySigningHistoryResponse) Reset() {
+ *x = QuerySigningHistoryResponse{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_query_proto_msgTypes[7]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *QuerySigningHistoryResponse) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QuerySigningHistoryResponse) ProtoMessage() {}
+
+// Deprecated: Use QuerySigningHistoryResponse.ProtoReflect.Descriptor instead.
+func (*QuerySigningHistoryResponse) Descriptor() ([]byte, []int) {
+ return file_inference_bls_query_proto_rawDescGZIP(), []int{7}
+}
+
+func (x *QuerySigningHistoryResponse) GetSigningRequests() []*ThresholdSigningRequest {
+ if x != nil {
+ return x.SigningRequests
+ }
+ return nil
+}
+
+func (x *QuerySigningHistoryResponse) GetPagination() *v1beta1.PageResponse {
+ if x != nil {
+ return x.Pagination
+ }
+ return nil
+}
+
+var File_inference_bls_query_proto protoreflect.FileDescriptor
+
+var file_inference_bls_query_proto_rawDesc = []byte{
+ 0x0a, 0x19, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x62, 0x6c, 0x73, 0x2f,
+ 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0d, 0x69, 0x6e, 0x66,
+ 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x1a, 0x11, 0x61, 0x6d, 0x69, 0x6e,
+ 0x6f, 0x2f, 0x61, 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, 0x1c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x61, 0x70, 0x69, 0x2f,
+ 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+ 0x6f, 0x1a, 0x2a, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x62, 0x61, 0x73, 0x65, 0x2f, 0x71,
+ 0x75, 0x65, 0x72, 0x79, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x70, 0x61, 0x67,
+ 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1a, 0x69,
+ 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x62, 0x6c, 0x73, 0x2f, 0x70, 0x61, 0x72,
+ 0x61, 0x6d, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x19, 0x69, 0x6e, 0x66, 0x65, 0x72,
+ 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x62, 0x6c, 0x73, 0x2f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x70,
+ 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x25, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f,
+ 0x62, 0x6c, 0x73, 0x2f, 0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x5f, 0x73, 0x69,
+ 0x67, 0x6e, 0x69, 0x6e, 0x67, 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, 0x4f, 0x0a, 0x13, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73,
+ 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x38, 0x0a, 0x06, 0x70, 0x61, 0x72, 0x61,
+ 0x6d, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+ 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 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, 0x35, 0x0a, 0x18, 0x51, 0x75, 0x65, 0x72, 0x79, 0x45, 0x70, 0x6f, 0x63, 0x68,
+ 0x42, 0x4c, 0x53, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x19,
+ 0x0a, 0x08, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04,
+ 0x52, 0x07, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x64, 0x22, 0x5d, 0x0a, 0x19, 0x51, 0x75, 0x65,
+ 0x72, 0x79, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x42, 0x4c, 0x53, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65,
+ 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x40, 0x0a, 0x0a, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f,
+ 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x69, 0x6e, 0x66,
+ 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x2e, 0x45, 0x70, 0x6f, 0x63, 0x68,
+ 0x42, 0x4c, 0x53, 0x44, 0x61, 0x74, 0x61, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x09, 0x65,
+ 0x70, 0x6f, 0x63, 0x68, 0x44, 0x61, 0x74, 0x61, 0x22, 0x3a, 0x0a, 0x19, 0x51, 0x75, 0x65, 0x72,
+ 0x79, 0x53, 0x69, 0x67, 0x6e, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65,
+ 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+ 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x72, 0x65, 0x71, 0x75, 0x65,
+ 0x73, 0x74, 0x49, 0x64, 0x22, 0x73, 0x0a, 0x1a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x69, 0x67,
+ 0x6e, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+ 0x73, 0x65, 0x12, 0x55, 0x0a, 0x0f, 0x73, 0x69, 0x67, 0x6e, 0x69, 0x6e, 0x67, 0x5f, 0x72, 0x65,
+ 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x69, 0x6e,
+ 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x2e, 0x54, 0x68, 0x72, 0x65,
+ 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x53, 0x69, 0x67, 0x6e, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x71, 0x75,
+ 0x65, 0x73, 0x74, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0e, 0x73, 0x69, 0x67, 0x6e, 0x69,
+ 0x6e, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0xda, 0x01, 0x0a, 0x1a, 0x51, 0x75,
+ 0x65, 0x72, 0x79, 0x53, 0x69, 0x67, 0x6e, 0x69, 0x6e, 0x67, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72,
+ 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x28, 0x0a, 0x10, 0x63, 0x75, 0x72, 0x72,
+ 0x65, 0x6e, 0x74, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01,
+ 0x28, 0x04, 0x52, 0x0e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68,
+ 0x49, 0x64, 0x12, 0x4a, 0x0a, 0x0d, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x5f, 0x66, 0x69, 0x6c,
+ 0x74, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x25, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+ 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x2e, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68,
+ 0x6f, 0x6c, 0x64, 0x53, 0x69, 0x67, 0x6e, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73,
+ 0x52, 0x0c, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x46,
+ 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 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, 0xbf, 0x01, 0x0a, 0x1b, 0x51, 0x75, 0x65, 0x72, 0x79,
+ 0x53, 0x69, 0x67, 0x6e, 0x69, 0x6e, 0x67, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65,
+ 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x57, 0x0a, 0x10, 0x73, 0x69, 0x67, 0x6e, 0x69, 0x6e,
+ 0x67, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b,
+ 0x32, 0x26, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73,
+ 0x2e, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x53, 0x69, 0x67, 0x6e, 0x69, 0x6e,
+ 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0f,
+ 0x73, 0x69, 0x67, 0x6e, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 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, 0x32, 0xf2, 0x04, 0x0a, 0x05, 0x51, 0x75, 0x65,
+ 0x72, 0x79, 0x12, 0x7d, 0x0a, 0x06, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x21, 0x2e, 0x69,
+ 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x2e, 0x51, 0x75, 0x65,
+ 0x72, 0x79, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
+ 0x22, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x2e,
+ 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f,
+ 0x6e, 0x73, 0x65, 0x22, 0x2c, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x26, 0x12, 0x24, 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, 0x62, 0x6c, 0x73, 0x2f, 0x70, 0x61, 0x72, 0x61, 0x6d,
+ 0x73, 0x12, 0x9e, 0x01, 0x0a, 0x0c, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x42, 0x4c, 0x53, 0x44, 0x61,
+ 0x74, 0x61, 0x12, 0x27, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62,
+ 0x6c, 0x73, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x42, 0x4c, 0x53,
+ 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x69, 0x6e,
+ 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x2e, 0x51, 0x75, 0x65, 0x72,
+ 0x79, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x42, 0x4c, 0x53, 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, 0x62, 0x6c, 0x73, 0x2f, 0x65, 0x70, 0x6f,
+ 0x63, 0x68, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x7b, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69,
+ 0x64, 0x7d, 0x12, 0xa7, 0x01, 0x0a, 0x0d, 0x53, 0x69, 0x67, 0x6e, 0x69, 0x6e, 0x67, 0x53, 0x74,
+ 0x61, 0x74, 0x75, 0x73, 0x12, 0x28, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+ 0x2e, 0x62, 0x6c, 0x73, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x69, 0x67, 0x6e, 0x69, 0x6e,
+ 0x67, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29,
+ 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x2e, 0x51,
+ 0x75, 0x65, 0x72, 0x79, 0x53, 0x69, 0x67, 0x6e, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x61, 0x74, 0x75,
+ 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x41, 0x82, 0xd3, 0xe4, 0x93, 0x02,
+ 0x3b, 0x12, 0x39, 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, 0x62, 0x6c, 0x73,
+ 0x2f, 0x73, 0x69, 0x67, 0x6e, 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2f,
+ 0x7b, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x5f, 0x69, 0x64, 0x7d, 0x12, 0x9e, 0x01, 0x0a,
+ 0x0e, 0x53, 0x69, 0x67, 0x6e, 0x69, 0x6e, 0x67, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x12,
+ 0x29, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x2e,
+ 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x69, 0x67, 0x6e, 0x69, 0x6e, 0x67, 0x48, 0x69, 0x73, 0x74,
+ 0x6f, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x69, 0x6e, 0x66,
+ 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79,
+ 0x53, 0x69, 0x67, 0x6e, 0x69, 0x6e, 0x67, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 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, 0x62, 0x6c, 0x73, 0x2f, 0x73, 0x69,
+ 0x67, 0x6e, 0x69, 0x6e, 0x67, 0x5f, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x94, 0x01,
+ 0x0a, 0x11, 0x63, 0x6f, 0x6d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+ 0x62, 0x6c, 0x73, 0x42, 0x0a, 0x51, 0x75, 0x65, 0x72, 0x79, 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 (
+ file_inference_bls_query_proto_rawDescOnce sync.Once
+ file_inference_bls_query_proto_rawDescData = file_inference_bls_query_proto_rawDesc
+)
+
+func file_inference_bls_query_proto_rawDescGZIP() []byte {
+ file_inference_bls_query_proto_rawDescOnce.Do(func() {
+ file_inference_bls_query_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_bls_query_proto_rawDescData)
+ })
+ return file_inference_bls_query_proto_rawDescData
+}
+
+var file_inference_bls_query_proto_msgTypes = make([]protoimpl.MessageInfo, 8)
+var file_inference_bls_query_proto_goTypes = []interface{}{
+ (*QueryParamsRequest)(nil), // 0: inference.bls.QueryParamsRequest
+ (*QueryParamsResponse)(nil), // 1: inference.bls.QueryParamsResponse
+ (*QueryEpochBLSDataRequest)(nil), // 2: inference.bls.QueryEpochBLSDataRequest
+ (*QueryEpochBLSDataResponse)(nil), // 3: inference.bls.QueryEpochBLSDataResponse
+ (*QuerySigningStatusRequest)(nil), // 4: inference.bls.QuerySigningStatusRequest
+ (*QuerySigningStatusResponse)(nil), // 5: inference.bls.QuerySigningStatusResponse
+ (*QuerySigningHistoryRequest)(nil), // 6: inference.bls.QuerySigningHistoryRequest
+ (*QuerySigningHistoryResponse)(nil), // 7: inference.bls.QuerySigningHistoryResponse
+ (*Params)(nil), // 8: inference.bls.Params
+ (*EpochBLSData)(nil), // 9: inference.bls.EpochBLSData
+ (*ThresholdSigningRequest)(nil), // 10: inference.bls.ThresholdSigningRequest
+ (ThresholdSigningStatus)(0), // 11: inference.bls.ThresholdSigningStatus
+ (*v1beta1.PageRequest)(nil), // 12: cosmos.base.query.v1beta1.PageRequest
+ (*v1beta1.PageResponse)(nil), // 13: cosmos.base.query.v1beta1.PageResponse
+}
+var file_inference_bls_query_proto_depIdxs = []int32{
+ 8, // 0: inference.bls.QueryParamsResponse.params:type_name -> inference.bls.Params
+ 9, // 1: inference.bls.QueryEpochBLSDataResponse.epoch_data:type_name -> inference.bls.EpochBLSData
+ 10, // 2: inference.bls.QuerySigningStatusResponse.signing_request:type_name -> inference.bls.ThresholdSigningRequest
+ 11, // 3: inference.bls.QuerySigningHistoryRequest.status_filter:type_name -> inference.bls.ThresholdSigningStatus
+ 12, // 4: inference.bls.QuerySigningHistoryRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest
+ 10, // 5: inference.bls.QuerySigningHistoryResponse.signing_requests:type_name -> inference.bls.ThresholdSigningRequest
+ 13, // 6: inference.bls.QuerySigningHistoryResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse
+ 0, // 7: inference.bls.Query.Params:input_type -> inference.bls.QueryParamsRequest
+ 2, // 8: inference.bls.Query.EpochBLSData:input_type -> inference.bls.QueryEpochBLSDataRequest
+ 4, // 9: inference.bls.Query.SigningStatus:input_type -> inference.bls.QuerySigningStatusRequest
+ 6, // 10: inference.bls.Query.SigningHistory:input_type -> inference.bls.QuerySigningHistoryRequest
+ 1, // 11: inference.bls.Query.Params:output_type -> inference.bls.QueryParamsResponse
+ 3, // 12: inference.bls.Query.EpochBLSData:output_type -> inference.bls.QueryEpochBLSDataResponse
+ 5, // 13: inference.bls.Query.SigningStatus:output_type -> inference.bls.QuerySigningStatusResponse
+ 7, // 14: inference.bls.Query.SigningHistory:output_type -> inference.bls.QuerySigningHistoryResponse
+ 11, // [11:15] is the sub-list for method output_type
+ 7, // [7:11] is the sub-list for method input_type
+ 7, // [7:7] is the sub-list for extension type_name
+ 7, // [7:7] is the sub-list for extension extendee
+ 0, // [0:7] is the sub-list for field type_name
+}
+
+func init() { file_inference_bls_query_proto_init() }
+func file_inference_bls_query_proto_init() {
+ if File_inference_bls_query_proto != nil {
+ return
+ }
+ file_inference_bls_params_proto_init()
+ file_inference_bls_types_proto_init()
+ file_inference_bls_threshold_signing_proto_init()
+ if !protoimpl.UnsafeEnabled {
+ file_inference_bls_query_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*QueryParamsRequest); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_bls_query_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*QueryParamsResponse); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_bls_query_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*QueryEpochBLSDataRequest); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_bls_query_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*QueryEpochBLSDataResponse); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_bls_query_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*QuerySigningStatusRequest); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_bls_query_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*QuerySigningStatusResponse); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_bls_query_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*QuerySigningHistoryRequest); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_bls_query_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*QuerySigningHistoryResponse); 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_bls_query_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 8,
+ NumExtensions: 0,
+ NumServices: 1,
+ },
+ GoTypes: file_inference_bls_query_proto_goTypes,
+ DependencyIndexes: file_inference_bls_query_proto_depIdxs,
+ MessageInfos: file_inference_bls_query_proto_msgTypes,
+ }.Build()
+ File_inference_bls_query_proto = out.File
+ file_inference_bls_query_proto_rawDesc = nil
+ file_inference_bls_query_proto_goTypes = nil
+ file_inference_bls_query_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/bls/query_grpc.pb.go b/inference-chain/api/inference/bls/query_grpc.pb.go
new file mode 100644
index 000000000..a56d8181b
--- /dev/null
+++ b/inference-chain/api/inference/bls/query_grpc.pb.go
@@ -0,0 +1,228 @@
+// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
+// versions:
+// - protoc-gen-go-grpc v1.3.0
+// - protoc (unknown)
+// source: inference/bls/query.proto
+
+package bls
+
+import (
+ context "context"
+ grpc "google.golang.org/grpc"
+ codes "google.golang.org/grpc/codes"
+ status "google.golang.org/grpc/status"
+)
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+// Requires gRPC-Go v1.32.0 or later.
+const _ = grpc.SupportPackageIsVersion7
+
+const (
+ Query_Params_FullMethodName = "/inference.bls.Query/Params"
+ Query_EpochBLSData_FullMethodName = "/inference.bls.Query/EpochBLSData"
+ Query_SigningStatus_FullMethodName = "/inference.bls.Query/SigningStatus"
+ Query_SigningHistory_FullMethodName = "/inference.bls.Query/SigningHistory"
+)
+
+// QueryClient is the client API for Query service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+type QueryClient interface {
+ // Parameters queries the parameters of the module.
+ Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error)
+ // EpochBLSData queries complete BLS data for a specific epoch
+ EpochBLSData(ctx context.Context, in *QueryEpochBLSDataRequest, opts ...grpc.CallOption) (*QueryEpochBLSDataResponse, error)
+ // SigningStatus queries the status of a specific threshold signing request
+ SigningStatus(ctx context.Context, in *QuerySigningStatusRequest, opts ...grpc.CallOption) (*QuerySigningStatusResponse, error)
+ // SigningHistory queries threshold signing requests with filtering and pagination
+ SigningHistory(ctx context.Context, in *QuerySigningHistoryRequest, opts ...grpc.CallOption) (*QuerySigningHistoryResponse, error)
+}
+
+type queryClient struct {
+ cc grpc.ClientConnInterface
+}
+
+func NewQueryClient(cc grpc.ClientConnInterface) 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, Query_Params_FullMethodName, in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *queryClient) EpochBLSData(ctx context.Context, in *QueryEpochBLSDataRequest, opts ...grpc.CallOption) (*QueryEpochBLSDataResponse, error) {
+ out := new(QueryEpochBLSDataResponse)
+ err := c.cc.Invoke(ctx, Query_EpochBLSData_FullMethodName, in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *queryClient) SigningStatus(ctx context.Context, in *QuerySigningStatusRequest, opts ...grpc.CallOption) (*QuerySigningStatusResponse, error) {
+ out := new(QuerySigningStatusResponse)
+ err := c.cc.Invoke(ctx, Query_SigningStatus_FullMethodName, in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *queryClient) SigningHistory(ctx context.Context, in *QuerySigningHistoryRequest, opts ...grpc.CallOption) (*QuerySigningHistoryResponse, error) {
+ out := new(QuerySigningHistoryResponse)
+ err := c.cc.Invoke(ctx, Query_SigningHistory_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
+type QueryServer interface {
+ // Parameters queries the parameters of the module.
+ Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error)
+ // EpochBLSData queries complete BLS data for a specific epoch
+ EpochBLSData(context.Context, *QueryEpochBLSDataRequest) (*QueryEpochBLSDataResponse, error)
+ // SigningStatus queries the status of a specific threshold signing request
+ SigningStatus(context.Context, *QuerySigningStatusRequest) (*QuerySigningStatusResponse, error)
+ // SigningHistory queries threshold signing requests with filtering and pagination
+ SigningHistory(context.Context, *QuerySigningHistoryRequest) (*QuerySigningHistoryResponse, error)
+ mustEmbedUnimplementedQueryServer()
+}
+
+// UnimplementedQueryServer must be embedded to have forward compatible implementations.
+type UnimplementedQueryServer struct {
+}
+
+func (UnimplementedQueryServer) Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method Params not implemented")
+}
+func (UnimplementedQueryServer) EpochBLSData(context.Context, *QueryEpochBLSDataRequest) (*QueryEpochBLSDataResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method EpochBLSData not implemented")
+}
+func (UnimplementedQueryServer) SigningStatus(context.Context, *QuerySigningStatusRequest) (*QuerySigningStatusResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method SigningStatus not implemented")
+}
+func (UnimplementedQueryServer) SigningHistory(context.Context, *QuerySigningHistoryRequest) (*QuerySigningHistoryResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method SigningHistory not implemented")
+}
+func (UnimplementedQueryServer) mustEmbedUnimplementedQueryServer() {}
+
+// UnsafeQueryServer may be embedded to opt out of forward compatibility for this service.
+// Use of this interface is not recommended, as added methods to QueryServer will
+// result in compilation errors.
+type UnsafeQueryServer interface {
+ mustEmbedUnimplementedQueryServer()
+}
+
+func RegisterQueryServer(s grpc.ServiceRegistrar, srv QueryServer) {
+ s.RegisterService(&Query_ServiceDesc, srv)
+}
+
+func _Query_Params_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(QueryParamsRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(QueryServer).Params(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: Query_Params_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(QueryServer).Params(ctx, req.(*QueryParamsRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _Query_EpochBLSData_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(QueryEpochBLSDataRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(QueryServer).EpochBLSData(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: Query_EpochBLSData_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(QueryServer).EpochBLSData(ctx, req.(*QueryEpochBLSDataRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _Query_SigningStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(QuerySigningStatusRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(QueryServer).SigningStatus(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: Query_SigningStatus_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(QueryServer).SigningStatus(ctx, req.(*QuerySigningStatusRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _Query_SigningHistory_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(QuerySigningHistoryRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(QueryServer).SigningHistory(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: Query_SigningHistory_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(QueryServer).SigningHistory(ctx, req.(*QuerySigningHistoryRequest))
+ }
+ 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)
+var Query_ServiceDesc = grpc.ServiceDesc{
+ ServiceName: "inference.bls.Query",
+ HandlerType: (*QueryServer)(nil),
+ Methods: []grpc.MethodDesc{
+ {
+ MethodName: "Params",
+ Handler: _Query_Params_Handler,
+ },
+ {
+ MethodName: "EpochBLSData",
+ Handler: _Query_EpochBLSData_Handler,
+ },
+ {
+ MethodName: "SigningStatus",
+ Handler: _Query_SigningStatus_Handler,
+ },
+ {
+ MethodName: "SigningHistory",
+ Handler: _Query_SigningHistory_Handler,
+ },
+ },
+ Streams: []grpc.StreamDesc{},
+ Metadata: "inference/bls/query.proto",
+}
diff --git a/inference-chain/api/inference/bls/threshold_signing.pulsar.go b/inference-chain/api/inference/bls/threshold_signing.pulsar.go
new file mode 100644
index 000000000..9a742e06c
--- /dev/null
+++ b/inference-chain/api/inference/bls/threshold_signing.pulsar.go
@@ -0,0 +1,2251 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package bls
+
+import (
+ _ "cosmossdk.io/api/amino"
+ fmt "fmt"
+ runtime "github.com/cosmos/cosmos-proto/runtime"
+ _ "github.com/cosmos/gogoproto/gogoproto"
+ 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 _ protoreflect.List = (*_SigningData_4_list)(nil)
+
+type _SigningData_4_list struct {
+ list *[][]byte
+}
+
+func (x *_SigningData_4_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_SigningData_4_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfBytes((*x.list)[i])
+}
+
+func (x *_SigningData_4_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Bytes()
+ concreteValue := valueUnwrapped
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_SigningData_4_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Bytes()
+ concreteValue := valueUnwrapped
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_SigningData_4_list) AppendMutable() protoreflect.Value {
+ panic(fmt.Errorf("AppendMutable can not be called on message SigningData at list field Data as it is not of Message kind"))
+}
+
+func (x *_SigningData_4_list) Truncate(n int) {
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_SigningData_4_list) NewElement() protoreflect.Value {
+ var v []byte
+ return protoreflect.ValueOfBytes(v)
+}
+
+func (x *_SigningData_4_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_SigningData protoreflect.MessageDescriptor
+ fd_SigningData_current_epoch_id protoreflect.FieldDescriptor
+ fd_SigningData_chain_id protoreflect.FieldDescriptor
+ fd_SigningData_request_id protoreflect.FieldDescriptor
+ fd_SigningData_data protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bls_threshold_signing_proto_init()
+ md_SigningData = File_inference_bls_threshold_signing_proto.Messages().ByName("SigningData")
+ fd_SigningData_current_epoch_id = md_SigningData.Fields().ByName("current_epoch_id")
+ fd_SigningData_chain_id = md_SigningData.Fields().ByName("chain_id")
+ fd_SigningData_request_id = md_SigningData.Fields().ByName("request_id")
+ fd_SigningData_data = md_SigningData.Fields().ByName("data")
+}
+
+var _ protoreflect.Message = (*fastReflection_SigningData)(nil)
+
+type fastReflection_SigningData SigningData
+
+func (x *SigningData) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_SigningData)(x)
+}
+
+func (x *SigningData) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_threshold_signing_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_SigningData_messageType fastReflection_SigningData_messageType
+var _ protoreflect.MessageType = fastReflection_SigningData_messageType{}
+
+type fastReflection_SigningData_messageType struct{}
+
+func (x fastReflection_SigningData_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_SigningData)(nil)
+}
+func (x fastReflection_SigningData_messageType) New() protoreflect.Message {
+ return new(fastReflection_SigningData)
+}
+func (x fastReflection_SigningData_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_SigningData
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_SigningData) Descriptor() protoreflect.MessageDescriptor {
+ return md_SigningData
+}
+
+// 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_SigningData) Type() protoreflect.MessageType {
+ return _fastReflection_SigningData_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_SigningData) New() protoreflect.Message {
+ return new(fastReflection_SigningData)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_SigningData) Interface() protoreflect.ProtoMessage {
+ return (*SigningData)(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_SigningData) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.CurrentEpochId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.CurrentEpochId)
+ if !f(fd_SigningData_current_epoch_id, value) {
+ return
+ }
+ }
+ if len(x.ChainId) != 0 {
+ value := protoreflect.ValueOfBytes(x.ChainId)
+ if !f(fd_SigningData_chain_id, value) {
+ return
+ }
+ }
+ if len(x.RequestId) != 0 {
+ value := protoreflect.ValueOfBytes(x.RequestId)
+ if !f(fd_SigningData_request_id, value) {
+ return
+ }
+ }
+ if len(x.Data) != 0 {
+ value := protoreflect.ValueOfList(&_SigningData_4_list{list: &x.Data})
+ if !f(fd_SigningData_data, 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_SigningData) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bls.SigningData.current_epoch_id":
+ return x.CurrentEpochId != uint64(0)
+ case "inference.bls.SigningData.chain_id":
+ return len(x.ChainId) != 0
+ case "inference.bls.SigningData.request_id":
+ return len(x.RequestId) != 0
+ case "inference.bls.SigningData.data":
+ return len(x.Data) != 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.SigningData"))
+ }
+ panic(fmt.Errorf("message inference.bls.SigningData 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_SigningData) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bls.SigningData.current_epoch_id":
+ x.CurrentEpochId = uint64(0)
+ case "inference.bls.SigningData.chain_id":
+ x.ChainId = nil
+ case "inference.bls.SigningData.request_id":
+ x.RequestId = nil
+ case "inference.bls.SigningData.data":
+ x.Data = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.SigningData"))
+ }
+ panic(fmt.Errorf("message inference.bls.SigningData 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_SigningData) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bls.SigningData.current_epoch_id":
+ value := x.CurrentEpochId
+ return protoreflect.ValueOfUint64(value)
+ case "inference.bls.SigningData.chain_id":
+ value := x.ChainId
+ return protoreflect.ValueOfBytes(value)
+ case "inference.bls.SigningData.request_id":
+ value := x.RequestId
+ return protoreflect.ValueOfBytes(value)
+ case "inference.bls.SigningData.data":
+ if len(x.Data) == 0 {
+ return protoreflect.ValueOfList(&_SigningData_4_list{})
+ }
+ listValue := &_SigningData_4_list{list: &x.Data}
+ return protoreflect.ValueOfList(listValue)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.SigningData"))
+ }
+ panic(fmt.Errorf("message inference.bls.SigningData 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_SigningData) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bls.SigningData.current_epoch_id":
+ x.CurrentEpochId = value.Uint()
+ case "inference.bls.SigningData.chain_id":
+ x.ChainId = value.Bytes()
+ case "inference.bls.SigningData.request_id":
+ x.RequestId = value.Bytes()
+ case "inference.bls.SigningData.data":
+ lv := value.List()
+ clv := lv.(*_SigningData_4_list)
+ x.Data = *clv.list
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.SigningData"))
+ }
+ panic(fmt.Errorf("message inference.bls.SigningData 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_SigningData) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.SigningData.data":
+ if x.Data == nil {
+ x.Data = [][]byte{}
+ }
+ value := &_SigningData_4_list{list: &x.Data}
+ return protoreflect.ValueOfList(value)
+ case "inference.bls.SigningData.current_epoch_id":
+ panic(fmt.Errorf("field current_epoch_id of message inference.bls.SigningData is not mutable"))
+ case "inference.bls.SigningData.chain_id":
+ panic(fmt.Errorf("field chain_id of message inference.bls.SigningData is not mutable"))
+ case "inference.bls.SigningData.request_id":
+ panic(fmt.Errorf("field request_id of message inference.bls.SigningData is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.SigningData"))
+ }
+ panic(fmt.Errorf("message inference.bls.SigningData 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_SigningData) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.SigningData.current_epoch_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.bls.SigningData.chain_id":
+ return protoreflect.ValueOfBytes(nil)
+ case "inference.bls.SigningData.request_id":
+ return protoreflect.ValueOfBytes(nil)
+ case "inference.bls.SigningData.data":
+ list := [][]byte{}
+ return protoreflect.ValueOfList(&_SigningData_4_list{list: &list})
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.SigningData"))
+ }
+ panic(fmt.Errorf("message inference.bls.SigningData 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_SigningData) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.SigningData", 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_SigningData) 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_SigningData) 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_SigningData) 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_SigningData) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*SigningData)
+ 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.CurrentEpochId != 0 {
+ n += 1 + runtime.Sov(uint64(x.CurrentEpochId))
+ }
+ l = len(x.ChainId)
+ 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 len(x.Data) > 0 {
+ for _, b := range x.Data {
+ l = len(b)
+ 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().(*SigningData)
+ 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.Data) > 0 {
+ for iNdEx := len(x.Data) - 1; iNdEx >= 0; iNdEx-- {
+ i -= len(x.Data[iNdEx])
+ copy(dAtA[i:], x.Data[iNdEx])
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Data[iNdEx])))
+ i--
+ dAtA[i] = 0x22
+ }
+ }
+ 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] = 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 x.CurrentEpochId != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.CurrentEpochId))
+ 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().(*SigningData)
+ 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: SigningData: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: SigningData: 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 CurrentEpochId", wireType)
+ }
+ x.CurrentEpochId = 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.CurrentEpochId |= 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 ChainId", 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.ChainId = append(x.ChainId[:0], dAtA[iNdEx:postIndex]...)
+ if x.ChainId == nil {
+ x.ChainId = []byte{}
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RequestId", 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.RequestId = append(x.RequestId[:0], dAtA[iNdEx:postIndex]...)
+ if x.RequestId == nil {
+ x.RequestId = []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 Data", 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.Data = append(x.Data, make([]byte, postIndex-iNdEx))
+ copy(x.Data[len(x.Data)-1], 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 = (*_ThresholdSigningRequest_4_list)(nil)
+
+type _ThresholdSigningRequest_4_list struct {
+ list *[][]byte
+}
+
+func (x *_ThresholdSigningRequest_4_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_ThresholdSigningRequest_4_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfBytes((*x.list)[i])
+}
+
+func (x *_ThresholdSigningRequest_4_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Bytes()
+ concreteValue := valueUnwrapped
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_ThresholdSigningRequest_4_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Bytes()
+ concreteValue := valueUnwrapped
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_ThresholdSigningRequest_4_list) AppendMutable() protoreflect.Value {
+ panic(fmt.Errorf("AppendMutable can not be called on message ThresholdSigningRequest at list field Data as it is not of Message kind"))
+}
+
+func (x *_ThresholdSigningRequest_4_list) Truncate(n int) {
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_ThresholdSigningRequest_4_list) NewElement() protoreflect.Value {
+ var v []byte
+ return protoreflect.ValueOfBytes(v)
+}
+
+func (x *_ThresholdSigningRequest_4_list) IsValid() bool {
+ return x.list != nil
+}
+
+var _ protoreflect.List = (*_ThresholdSigningRequest_8_list)(nil)
+
+type _ThresholdSigningRequest_8_list struct {
+ list *[]*PartialSignature
+}
+
+func (x *_ThresholdSigningRequest_8_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_ThresholdSigningRequest_8_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_ThresholdSigningRequest_8_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*PartialSignature)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_ThresholdSigningRequest_8_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*PartialSignature)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_ThresholdSigningRequest_8_list) AppendMutable() protoreflect.Value {
+ v := new(PartialSignature)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_ThresholdSigningRequest_8_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_ThresholdSigningRequest_8_list) NewElement() protoreflect.Value {
+ v := new(PartialSignature)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_ThresholdSigningRequest_8_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_ThresholdSigningRequest protoreflect.MessageDescriptor
+ fd_ThresholdSigningRequest_request_id protoreflect.FieldDescriptor
+ fd_ThresholdSigningRequest_current_epoch_id protoreflect.FieldDescriptor
+ fd_ThresholdSigningRequest_chain_id protoreflect.FieldDescriptor
+ fd_ThresholdSigningRequest_data protoreflect.FieldDescriptor
+ fd_ThresholdSigningRequest_encoded_data protoreflect.FieldDescriptor
+ fd_ThresholdSigningRequest_message_hash protoreflect.FieldDescriptor
+ fd_ThresholdSigningRequest_status protoreflect.FieldDescriptor
+ fd_ThresholdSigningRequest_partial_signatures protoreflect.FieldDescriptor
+ fd_ThresholdSigningRequest_final_signature protoreflect.FieldDescriptor
+ fd_ThresholdSigningRequest_created_block_height protoreflect.FieldDescriptor
+ fd_ThresholdSigningRequest_deadline_block_height protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bls_threshold_signing_proto_init()
+ md_ThresholdSigningRequest = File_inference_bls_threshold_signing_proto.Messages().ByName("ThresholdSigningRequest")
+ fd_ThresholdSigningRequest_request_id = md_ThresholdSigningRequest.Fields().ByName("request_id")
+ fd_ThresholdSigningRequest_current_epoch_id = md_ThresholdSigningRequest.Fields().ByName("current_epoch_id")
+ fd_ThresholdSigningRequest_chain_id = md_ThresholdSigningRequest.Fields().ByName("chain_id")
+ fd_ThresholdSigningRequest_data = md_ThresholdSigningRequest.Fields().ByName("data")
+ fd_ThresholdSigningRequest_encoded_data = md_ThresholdSigningRequest.Fields().ByName("encoded_data")
+ fd_ThresholdSigningRequest_message_hash = md_ThresholdSigningRequest.Fields().ByName("message_hash")
+ fd_ThresholdSigningRequest_status = md_ThresholdSigningRequest.Fields().ByName("status")
+ fd_ThresholdSigningRequest_partial_signatures = md_ThresholdSigningRequest.Fields().ByName("partial_signatures")
+ fd_ThresholdSigningRequest_final_signature = md_ThresholdSigningRequest.Fields().ByName("final_signature")
+ fd_ThresholdSigningRequest_created_block_height = md_ThresholdSigningRequest.Fields().ByName("created_block_height")
+ fd_ThresholdSigningRequest_deadline_block_height = md_ThresholdSigningRequest.Fields().ByName("deadline_block_height")
+}
+
+var _ protoreflect.Message = (*fastReflection_ThresholdSigningRequest)(nil)
+
+type fastReflection_ThresholdSigningRequest ThresholdSigningRequest
+
+func (x *ThresholdSigningRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_ThresholdSigningRequest)(x)
+}
+
+func (x *ThresholdSigningRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_threshold_signing_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_ThresholdSigningRequest_messageType fastReflection_ThresholdSigningRequest_messageType
+var _ protoreflect.MessageType = fastReflection_ThresholdSigningRequest_messageType{}
+
+type fastReflection_ThresholdSigningRequest_messageType struct{}
+
+func (x fastReflection_ThresholdSigningRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_ThresholdSigningRequest)(nil)
+}
+func (x fastReflection_ThresholdSigningRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_ThresholdSigningRequest)
+}
+func (x fastReflection_ThresholdSigningRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_ThresholdSigningRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_ThresholdSigningRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_ThresholdSigningRequest
+}
+
+// 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_ThresholdSigningRequest) Type() protoreflect.MessageType {
+ return _fastReflection_ThresholdSigningRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_ThresholdSigningRequest) New() protoreflect.Message {
+ return new(fastReflection_ThresholdSigningRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_ThresholdSigningRequest) Interface() protoreflect.ProtoMessage {
+ return (*ThresholdSigningRequest)(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_ThresholdSigningRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if len(x.RequestId) != 0 {
+ value := protoreflect.ValueOfBytes(x.RequestId)
+ if !f(fd_ThresholdSigningRequest_request_id, value) {
+ return
+ }
+ }
+ if x.CurrentEpochId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.CurrentEpochId)
+ if !f(fd_ThresholdSigningRequest_current_epoch_id, value) {
+ return
+ }
+ }
+ if len(x.ChainId) != 0 {
+ value := protoreflect.ValueOfBytes(x.ChainId)
+ if !f(fd_ThresholdSigningRequest_chain_id, value) {
+ return
+ }
+ }
+ if len(x.Data) != 0 {
+ value := protoreflect.ValueOfList(&_ThresholdSigningRequest_4_list{list: &x.Data})
+ if !f(fd_ThresholdSigningRequest_data, value) {
+ return
+ }
+ }
+ if len(x.EncodedData) != 0 {
+ value := protoreflect.ValueOfBytes(x.EncodedData)
+ if !f(fd_ThresholdSigningRequest_encoded_data, value) {
+ return
+ }
+ }
+ if len(x.MessageHash) != 0 {
+ value := protoreflect.ValueOfBytes(x.MessageHash)
+ if !f(fd_ThresholdSigningRequest_message_hash, value) {
+ return
+ }
+ }
+ if x.Status != 0 {
+ value := protoreflect.ValueOfEnum((protoreflect.EnumNumber)(x.Status))
+ if !f(fd_ThresholdSigningRequest_status, value) {
+ return
+ }
+ }
+ if len(x.PartialSignatures) != 0 {
+ value := protoreflect.ValueOfList(&_ThresholdSigningRequest_8_list{list: &x.PartialSignatures})
+ if !f(fd_ThresholdSigningRequest_partial_signatures, value) {
+ return
+ }
+ }
+ if len(x.FinalSignature) != 0 {
+ value := protoreflect.ValueOfBytes(x.FinalSignature)
+ if !f(fd_ThresholdSigningRequest_final_signature, value) {
+ return
+ }
+ }
+ if x.CreatedBlockHeight != int64(0) {
+ value := protoreflect.ValueOfInt64(x.CreatedBlockHeight)
+ if !f(fd_ThresholdSigningRequest_created_block_height, value) {
+ return
+ }
+ }
+ if x.DeadlineBlockHeight != int64(0) {
+ value := protoreflect.ValueOfInt64(x.DeadlineBlockHeight)
+ if !f(fd_ThresholdSigningRequest_deadline_block_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_ThresholdSigningRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bls.ThresholdSigningRequest.request_id":
+ return len(x.RequestId) != 0
+ case "inference.bls.ThresholdSigningRequest.current_epoch_id":
+ return x.CurrentEpochId != uint64(0)
+ case "inference.bls.ThresholdSigningRequest.chain_id":
+ return len(x.ChainId) != 0
+ case "inference.bls.ThresholdSigningRequest.data":
+ return len(x.Data) != 0
+ case "inference.bls.ThresholdSigningRequest.encoded_data":
+ return len(x.EncodedData) != 0
+ case "inference.bls.ThresholdSigningRequest.message_hash":
+ return len(x.MessageHash) != 0
+ case "inference.bls.ThresholdSigningRequest.status":
+ return x.Status != 0
+ case "inference.bls.ThresholdSigningRequest.partial_signatures":
+ return len(x.PartialSignatures) != 0
+ case "inference.bls.ThresholdSigningRequest.final_signature":
+ return len(x.FinalSignature) != 0
+ case "inference.bls.ThresholdSigningRequest.created_block_height":
+ return x.CreatedBlockHeight != int64(0)
+ case "inference.bls.ThresholdSigningRequest.deadline_block_height":
+ return x.DeadlineBlockHeight != int64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.ThresholdSigningRequest"))
+ }
+ panic(fmt.Errorf("message inference.bls.ThresholdSigningRequest 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_ThresholdSigningRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bls.ThresholdSigningRequest.request_id":
+ x.RequestId = nil
+ case "inference.bls.ThresholdSigningRequest.current_epoch_id":
+ x.CurrentEpochId = uint64(0)
+ case "inference.bls.ThresholdSigningRequest.chain_id":
+ x.ChainId = nil
+ case "inference.bls.ThresholdSigningRequest.data":
+ x.Data = nil
+ case "inference.bls.ThresholdSigningRequest.encoded_data":
+ x.EncodedData = nil
+ case "inference.bls.ThresholdSigningRequest.message_hash":
+ x.MessageHash = nil
+ case "inference.bls.ThresholdSigningRequest.status":
+ x.Status = 0
+ case "inference.bls.ThresholdSigningRequest.partial_signatures":
+ x.PartialSignatures = nil
+ case "inference.bls.ThresholdSigningRequest.final_signature":
+ x.FinalSignature = nil
+ case "inference.bls.ThresholdSigningRequest.created_block_height":
+ x.CreatedBlockHeight = int64(0)
+ case "inference.bls.ThresholdSigningRequest.deadline_block_height":
+ x.DeadlineBlockHeight = int64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.ThresholdSigningRequest"))
+ }
+ panic(fmt.Errorf("message inference.bls.ThresholdSigningRequest 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_ThresholdSigningRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bls.ThresholdSigningRequest.request_id":
+ value := x.RequestId
+ return protoreflect.ValueOfBytes(value)
+ case "inference.bls.ThresholdSigningRequest.current_epoch_id":
+ value := x.CurrentEpochId
+ return protoreflect.ValueOfUint64(value)
+ case "inference.bls.ThresholdSigningRequest.chain_id":
+ value := x.ChainId
+ return protoreflect.ValueOfBytes(value)
+ case "inference.bls.ThresholdSigningRequest.data":
+ if len(x.Data) == 0 {
+ return protoreflect.ValueOfList(&_ThresholdSigningRequest_4_list{})
+ }
+ listValue := &_ThresholdSigningRequest_4_list{list: &x.Data}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.bls.ThresholdSigningRequest.encoded_data":
+ value := x.EncodedData
+ return protoreflect.ValueOfBytes(value)
+ case "inference.bls.ThresholdSigningRequest.message_hash":
+ value := x.MessageHash
+ return protoreflect.ValueOfBytes(value)
+ case "inference.bls.ThresholdSigningRequest.status":
+ value := x.Status
+ return protoreflect.ValueOfEnum((protoreflect.EnumNumber)(value))
+ case "inference.bls.ThresholdSigningRequest.partial_signatures":
+ if len(x.PartialSignatures) == 0 {
+ return protoreflect.ValueOfList(&_ThresholdSigningRequest_8_list{})
+ }
+ listValue := &_ThresholdSigningRequest_8_list{list: &x.PartialSignatures}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.bls.ThresholdSigningRequest.final_signature":
+ value := x.FinalSignature
+ return protoreflect.ValueOfBytes(value)
+ case "inference.bls.ThresholdSigningRequest.created_block_height":
+ value := x.CreatedBlockHeight
+ return protoreflect.ValueOfInt64(value)
+ case "inference.bls.ThresholdSigningRequest.deadline_block_height":
+ value := x.DeadlineBlockHeight
+ return protoreflect.ValueOfInt64(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.ThresholdSigningRequest"))
+ }
+ panic(fmt.Errorf("message inference.bls.ThresholdSigningRequest 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_ThresholdSigningRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bls.ThresholdSigningRequest.request_id":
+ x.RequestId = value.Bytes()
+ case "inference.bls.ThresholdSigningRequest.current_epoch_id":
+ x.CurrentEpochId = value.Uint()
+ case "inference.bls.ThresholdSigningRequest.chain_id":
+ x.ChainId = value.Bytes()
+ case "inference.bls.ThresholdSigningRequest.data":
+ lv := value.List()
+ clv := lv.(*_ThresholdSigningRequest_4_list)
+ x.Data = *clv.list
+ case "inference.bls.ThresholdSigningRequest.encoded_data":
+ x.EncodedData = value.Bytes()
+ case "inference.bls.ThresholdSigningRequest.message_hash":
+ x.MessageHash = value.Bytes()
+ case "inference.bls.ThresholdSigningRequest.status":
+ x.Status = (ThresholdSigningStatus)(value.Enum())
+ case "inference.bls.ThresholdSigningRequest.partial_signatures":
+ lv := value.List()
+ clv := lv.(*_ThresholdSigningRequest_8_list)
+ x.PartialSignatures = *clv.list
+ case "inference.bls.ThresholdSigningRequest.final_signature":
+ x.FinalSignature = value.Bytes()
+ case "inference.bls.ThresholdSigningRequest.created_block_height":
+ x.CreatedBlockHeight = value.Int()
+ case "inference.bls.ThresholdSigningRequest.deadline_block_height":
+ x.DeadlineBlockHeight = value.Int()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.ThresholdSigningRequest"))
+ }
+ panic(fmt.Errorf("message inference.bls.ThresholdSigningRequest 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_ThresholdSigningRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.ThresholdSigningRequest.data":
+ if x.Data == nil {
+ x.Data = [][]byte{}
+ }
+ value := &_ThresholdSigningRequest_4_list{list: &x.Data}
+ return protoreflect.ValueOfList(value)
+ case "inference.bls.ThresholdSigningRequest.partial_signatures":
+ if x.PartialSignatures == nil {
+ x.PartialSignatures = []*PartialSignature{}
+ }
+ value := &_ThresholdSigningRequest_8_list{list: &x.PartialSignatures}
+ return protoreflect.ValueOfList(value)
+ case "inference.bls.ThresholdSigningRequest.request_id":
+ panic(fmt.Errorf("field request_id of message inference.bls.ThresholdSigningRequest is not mutable"))
+ case "inference.bls.ThresholdSigningRequest.current_epoch_id":
+ panic(fmt.Errorf("field current_epoch_id of message inference.bls.ThresholdSigningRequest is not mutable"))
+ case "inference.bls.ThresholdSigningRequest.chain_id":
+ panic(fmt.Errorf("field chain_id of message inference.bls.ThresholdSigningRequest is not mutable"))
+ case "inference.bls.ThresholdSigningRequest.encoded_data":
+ panic(fmt.Errorf("field encoded_data of message inference.bls.ThresholdSigningRequest is not mutable"))
+ case "inference.bls.ThresholdSigningRequest.message_hash":
+ panic(fmt.Errorf("field message_hash of message inference.bls.ThresholdSigningRequest is not mutable"))
+ case "inference.bls.ThresholdSigningRequest.status":
+ panic(fmt.Errorf("field status of message inference.bls.ThresholdSigningRequest is not mutable"))
+ case "inference.bls.ThresholdSigningRequest.final_signature":
+ panic(fmt.Errorf("field final_signature of message inference.bls.ThresholdSigningRequest is not mutable"))
+ case "inference.bls.ThresholdSigningRequest.created_block_height":
+ panic(fmt.Errorf("field created_block_height of message inference.bls.ThresholdSigningRequest is not mutable"))
+ case "inference.bls.ThresholdSigningRequest.deadline_block_height":
+ panic(fmt.Errorf("field deadline_block_height of message inference.bls.ThresholdSigningRequest is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.ThresholdSigningRequest"))
+ }
+ panic(fmt.Errorf("message inference.bls.ThresholdSigningRequest 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_ThresholdSigningRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.ThresholdSigningRequest.request_id":
+ return protoreflect.ValueOfBytes(nil)
+ case "inference.bls.ThresholdSigningRequest.current_epoch_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.bls.ThresholdSigningRequest.chain_id":
+ return protoreflect.ValueOfBytes(nil)
+ case "inference.bls.ThresholdSigningRequest.data":
+ list := [][]byte{}
+ return protoreflect.ValueOfList(&_ThresholdSigningRequest_4_list{list: &list})
+ case "inference.bls.ThresholdSigningRequest.encoded_data":
+ return protoreflect.ValueOfBytes(nil)
+ case "inference.bls.ThresholdSigningRequest.message_hash":
+ return protoreflect.ValueOfBytes(nil)
+ case "inference.bls.ThresholdSigningRequest.status":
+ return protoreflect.ValueOfEnum(0)
+ case "inference.bls.ThresholdSigningRequest.partial_signatures":
+ list := []*PartialSignature{}
+ return protoreflect.ValueOfList(&_ThresholdSigningRequest_8_list{list: &list})
+ case "inference.bls.ThresholdSigningRequest.final_signature":
+ return protoreflect.ValueOfBytes(nil)
+ case "inference.bls.ThresholdSigningRequest.created_block_height":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.bls.ThresholdSigningRequest.deadline_block_height":
+ return protoreflect.ValueOfInt64(int64(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.ThresholdSigningRequest"))
+ }
+ panic(fmt.Errorf("message inference.bls.ThresholdSigningRequest 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_ThresholdSigningRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.ThresholdSigningRequest", 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_ThresholdSigningRequest) 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_ThresholdSigningRequest) 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_ThresholdSigningRequest) 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_ThresholdSigningRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*ThresholdSigningRequest)
+ 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.RequestId)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.CurrentEpochId != 0 {
+ n += 1 + runtime.Sov(uint64(x.CurrentEpochId))
+ }
+ l = len(x.ChainId)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if len(x.Data) > 0 {
+ for _, b := range x.Data {
+ l = len(b)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ }
+ l = len(x.EncodedData)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ l = len(x.MessageHash)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.Status != 0 {
+ n += 1 + runtime.Sov(uint64(x.Status))
+ }
+ if len(x.PartialSignatures) > 0 {
+ for _, e := range x.PartialSignatures {
+ l = options.Size(e)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ }
+ l = len(x.FinalSignature)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.CreatedBlockHeight != 0 {
+ n += 1 + runtime.Sov(uint64(x.CreatedBlockHeight))
+ }
+ if x.DeadlineBlockHeight != 0 {
+ n += 1 + runtime.Sov(uint64(x.DeadlineBlockHeight))
+ }
+ 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().(*ThresholdSigningRequest)
+ 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.DeadlineBlockHeight != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.DeadlineBlockHeight))
+ i--
+ dAtA[i] = 0x58
+ }
+ if x.CreatedBlockHeight != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.CreatedBlockHeight))
+ i--
+ dAtA[i] = 0x50
+ }
+ if len(x.FinalSignature) > 0 {
+ i -= len(x.FinalSignature)
+ copy(dAtA[i:], x.FinalSignature)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.FinalSignature)))
+ i--
+ dAtA[i] = 0x4a
+ }
+ if len(x.PartialSignatures) > 0 {
+ for iNdEx := len(x.PartialSignatures) - 1; iNdEx >= 0; iNdEx-- {
+ encoded, err := options.Marshal(x.PartialSignatures[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] = 0x42
+ }
+ }
+ if x.Status != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.Status))
+ i--
+ dAtA[i] = 0x38
+ }
+ if len(x.MessageHash) > 0 {
+ i -= len(x.MessageHash)
+ copy(dAtA[i:], x.MessageHash)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.MessageHash)))
+ i--
+ dAtA[i] = 0x32
+ }
+ if len(x.EncodedData) > 0 {
+ i -= len(x.EncodedData)
+ copy(dAtA[i:], x.EncodedData)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.EncodedData)))
+ i--
+ dAtA[i] = 0x2a
+ }
+ if len(x.Data) > 0 {
+ for iNdEx := len(x.Data) - 1; iNdEx >= 0; iNdEx-- {
+ i -= len(x.Data[iNdEx])
+ copy(dAtA[i:], x.Data[iNdEx])
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Data[iNdEx])))
+ i--
+ dAtA[i] = 0x22
+ }
+ }
+ 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] = 0x1a
+ }
+ if x.CurrentEpochId != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.CurrentEpochId))
+ 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 {
+ 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().(*ThresholdSigningRequest)
+ 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: ThresholdSigningRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ThresholdSigningRequest: 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 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.RequestId = append(x.RequestId[:0], dAtA[iNdEx:postIndex]...)
+ if x.RequestId == nil {
+ x.RequestId = []byte{}
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field CurrentEpochId", wireType)
+ }
+ x.CurrentEpochId = 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.CurrentEpochId |= 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 ChainId", 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.ChainId = append(x.ChainId[:0], dAtA[iNdEx:postIndex]...)
+ if x.ChainId == nil {
+ x.ChainId = []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 Data", 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.Data = append(x.Data, make([]byte, postIndex-iNdEx))
+ copy(x.Data[len(x.Data)-1], 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 EncodedData", 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.EncodedData = append(x.EncodedData[:0], dAtA[iNdEx:postIndex]...)
+ if x.EncodedData == nil {
+ x.EncodedData = []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 MessageHash", 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.MessageHash = append(x.MessageHash[:0], dAtA[iNdEx:postIndex]...)
+ if x.MessageHash == nil {
+ x.MessageHash = []byte{}
+ }
+ iNdEx = postIndex
+ case 7:
+ 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 |= ThresholdSigningStatus(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 8:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PartialSignatures", 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.PartialSignatures = append(x.PartialSignatures, &PartialSignature{})
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.PartialSignatures[len(x.PartialSignatures)-1]); err != nil {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+ }
+ iNdEx = postIndex
+ case 9:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field FinalSignature", 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.FinalSignature = append(x.FinalSignature[:0], dAtA[iNdEx:postIndex]...)
+ if x.FinalSignature == nil {
+ x.FinalSignature = []byte{}
+ }
+ iNdEx = postIndex
+ case 10:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field CreatedBlockHeight", wireType)
+ }
+ x.CreatedBlockHeight = 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.CreatedBlockHeight |= int64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 11:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DeadlineBlockHeight", wireType)
+ }
+ x.DeadlineBlockHeight = 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.DeadlineBlockHeight |= 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,
+ }
+}
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// protoc-gen-go v1.27.0
+// protoc (unknown)
+// source: inference/bls/threshold_signing.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)
+)
+
+// ThresholdSigningStatus defines the different states of a threshold signing request
+type ThresholdSigningStatus int32
+
+const (
+ // UNDEFINED represents an uninitialized or unknown status
+ ThresholdSigningStatus_THRESHOLD_SIGNING_STATUS_UNDEFINED ThresholdSigningStatus = 0
+ // PENDING_SIGNING represents the initial state when a signing request is created
+ ThresholdSigningStatus_THRESHOLD_SIGNING_STATUS_PENDING_SIGNING ThresholdSigningStatus = 1
+ // COLLECTING_SIGNATURES represents the state when collecting partial signatures from participants
+ ThresholdSigningStatus_THRESHOLD_SIGNING_STATUS_COLLECTING_SIGNATURES ThresholdSigningStatus = 2
+ // COMPLETED represents the state when the threshold signature has been successfully created
+ ThresholdSigningStatus_THRESHOLD_SIGNING_STATUS_COMPLETED ThresholdSigningStatus = 3
+ // FAILED represents the state when the threshold signing process has failed
+ ThresholdSigningStatus_THRESHOLD_SIGNING_STATUS_FAILED ThresholdSigningStatus = 4
+ // EXPIRED represents the state when the deadline has passed without sufficient signatures
+ ThresholdSigningStatus_THRESHOLD_SIGNING_STATUS_EXPIRED ThresholdSigningStatus = 5
+)
+
+// Enum value maps for ThresholdSigningStatus.
+var (
+ ThresholdSigningStatus_name = map[int32]string{
+ 0: "THRESHOLD_SIGNING_STATUS_UNDEFINED",
+ 1: "THRESHOLD_SIGNING_STATUS_PENDING_SIGNING",
+ 2: "THRESHOLD_SIGNING_STATUS_COLLECTING_SIGNATURES",
+ 3: "THRESHOLD_SIGNING_STATUS_COMPLETED",
+ 4: "THRESHOLD_SIGNING_STATUS_FAILED",
+ 5: "THRESHOLD_SIGNING_STATUS_EXPIRED",
+ }
+ ThresholdSigningStatus_value = map[string]int32{
+ "THRESHOLD_SIGNING_STATUS_UNDEFINED": 0,
+ "THRESHOLD_SIGNING_STATUS_PENDING_SIGNING": 1,
+ "THRESHOLD_SIGNING_STATUS_COLLECTING_SIGNATURES": 2,
+ "THRESHOLD_SIGNING_STATUS_COMPLETED": 3,
+ "THRESHOLD_SIGNING_STATUS_FAILED": 4,
+ "THRESHOLD_SIGNING_STATUS_EXPIRED": 5,
+ }
+)
+
+func (x ThresholdSigningStatus) Enum() *ThresholdSigningStatus {
+ p := new(ThresholdSigningStatus)
+ *p = x
+ return p
+}
+
+func (x ThresholdSigningStatus) String() string {
+ return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (ThresholdSigningStatus) Descriptor() protoreflect.EnumDescriptor {
+ return file_inference_bls_threshold_signing_proto_enumTypes[0].Descriptor()
+}
+
+func (ThresholdSigningStatus) Type() protoreflect.EnumType {
+ return &file_inference_bls_threshold_signing_proto_enumTypes[0]
+}
+
+func (x ThresholdSigningStatus) Number() protoreflect.EnumNumber {
+ return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use ThresholdSigningStatus.Descriptor instead.
+func (ThresholdSigningStatus) EnumDescriptor() ([]byte, []int) {
+ return file_inference_bls_threshold_signing_proto_rawDescGZIP(), []int{0}
+}
+
+// SigningData represents the data structure for requesting a threshold signature
+// Used as input to the RequestThresholdSignature keeper method
+type SigningData struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // current_epoch_id is the epoch to use for signing (must have completed DKG)
+ CurrentEpochId uint64 `protobuf:"varint,1,opt,name=current_epoch_id,json=currentEpochId,proto3" json:"current_epoch_id,omitempty"`
+ // chain_id is the 32-byte chain identifier for cross-chain security
+ ChainId []byte `protobuf:"bytes,2,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
+ // request_id is the unique 32-byte identifier provided by the calling module (e.g., tx_hash)
+ RequestId []byte `protobuf:"bytes,3,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`
+ // data is the array of 32-byte data chunks to be signed (Ethereum-compatible format)
+ Data [][]byte `protobuf:"bytes,4,rep,name=data,proto3" json:"data,omitempty"`
+}
+
+func (x *SigningData) Reset() {
+ *x = SigningData{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_threshold_signing_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *SigningData) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*SigningData) ProtoMessage() {}
+
+// Deprecated: Use SigningData.ProtoReflect.Descriptor instead.
+func (*SigningData) Descriptor() ([]byte, []int) {
+ return file_inference_bls_threshold_signing_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *SigningData) GetCurrentEpochId() uint64 {
+ if x != nil {
+ return x.CurrentEpochId
+ }
+ return 0
+}
+
+func (x *SigningData) GetChainId() []byte {
+ if x != nil {
+ return x.ChainId
+ }
+ return nil
+}
+
+func (x *SigningData) GetRequestId() []byte {
+ if x != nil {
+ return x.RequestId
+ }
+ return nil
+}
+
+func (x *SigningData) GetData() [][]byte {
+ if x != nil {
+ return x.Data
+ }
+ return nil
+}
+
+// ThresholdSigningRequest represents a complete threshold signing request stored on-chain
+type ThresholdSigningRequest struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // request_id is the unique 32-byte identifier for this signing request
+ RequestId []byte `protobuf:"bytes,1,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`
+ // current_epoch_id is the epoch being used for signing
+ CurrentEpochId uint64 `protobuf:"varint,2,opt,name=current_epoch_id,json=currentEpochId,proto3" json:"current_epoch_id,omitempty"`
+ // chain_id is the 32-byte chain identifier for cross-chain security
+ ChainId []byte `protobuf:"bytes,3,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
+ // data is the original array of 32-byte data chunks to be signed
+ Data [][]byte `protobuf:"bytes,4,rep,name=data,proto3" json:"data,omitempty"`
+ // encoded_data is the Ethereum-compatible abi.encodePacked result
+ EncodedData []byte `protobuf:"bytes,5,opt,name=encoded_data,json=encodedData,proto3" json:"encoded_data,omitempty"`
+ // message_hash is the keccak256 hash of the encoded_data (32 bytes)
+ MessageHash []byte `protobuf:"bytes,6,opt,name=message_hash,json=messageHash,proto3" json:"message_hash,omitempty"`
+ // status is the current state of the signing request
+ Status ThresholdSigningStatus `protobuf:"varint,7,opt,name=status,proto3,enum=inference.bls.ThresholdSigningStatus" json:"status,omitempty"`
+ // partial_signatures contains all partial signatures submitted by participants
+ PartialSignatures []*PartialSignature `protobuf:"bytes,8,rep,name=partial_signatures,json=partialSignatures,proto3" json:"partial_signatures,omitempty"`
+ // final_signature is the aggregated BLS signature (G1 point, 48-byte compressed format)
+ // Only set when status is COMPLETED
+ FinalSignature []byte `protobuf:"bytes,9,opt,name=final_signature,json=finalSignature,proto3" json:"final_signature,omitempty"`
+ // created_block_height is the block height when this request was created
+ CreatedBlockHeight int64 `protobuf:"varint,10,opt,name=created_block_height,json=createdBlockHeight,proto3" json:"created_block_height,omitempty"`
+ // deadline_block_height is the block height after which this request expires
+ DeadlineBlockHeight int64 `protobuf:"varint,11,opt,name=deadline_block_height,json=deadlineBlockHeight,proto3" json:"deadline_block_height,omitempty"`
+}
+
+func (x *ThresholdSigningRequest) Reset() {
+ *x = ThresholdSigningRequest{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_threshold_signing_proto_msgTypes[1]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *ThresholdSigningRequest) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ThresholdSigningRequest) ProtoMessage() {}
+
+// Deprecated: Use ThresholdSigningRequest.ProtoReflect.Descriptor instead.
+func (*ThresholdSigningRequest) Descriptor() ([]byte, []int) {
+ return file_inference_bls_threshold_signing_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *ThresholdSigningRequest) GetRequestId() []byte {
+ if x != nil {
+ return x.RequestId
+ }
+ return nil
+}
+
+func (x *ThresholdSigningRequest) GetCurrentEpochId() uint64 {
+ if x != nil {
+ return x.CurrentEpochId
+ }
+ return 0
+}
+
+func (x *ThresholdSigningRequest) GetChainId() []byte {
+ if x != nil {
+ return x.ChainId
+ }
+ return nil
+}
+
+func (x *ThresholdSigningRequest) GetData() [][]byte {
+ if x != nil {
+ return x.Data
+ }
+ return nil
+}
+
+func (x *ThresholdSigningRequest) GetEncodedData() []byte {
+ if x != nil {
+ return x.EncodedData
+ }
+ return nil
+}
+
+func (x *ThresholdSigningRequest) GetMessageHash() []byte {
+ if x != nil {
+ return x.MessageHash
+ }
+ return nil
+}
+
+func (x *ThresholdSigningRequest) GetStatus() ThresholdSigningStatus {
+ if x != nil {
+ return x.Status
+ }
+ return ThresholdSigningStatus_THRESHOLD_SIGNING_STATUS_UNDEFINED
+}
+
+func (x *ThresholdSigningRequest) GetPartialSignatures() []*PartialSignature {
+ if x != nil {
+ return x.PartialSignatures
+ }
+ return nil
+}
+
+func (x *ThresholdSigningRequest) GetFinalSignature() []byte {
+ if x != nil {
+ return x.FinalSignature
+ }
+ return nil
+}
+
+func (x *ThresholdSigningRequest) GetCreatedBlockHeight() int64 {
+ if x != nil {
+ return x.CreatedBlockHeight
+ }
+ return 0
+}
+
+func (x *ThresholdSigningRequest) GetDeadlineBlockHeight() int64 {
+ if x != nil {
+ return x.DeadlineBlockHeight
+ }
+ return 0
+}
+
+var File_inference_bls_threshold_signing_proto protoreflect.FileDescriptor
+
+var file_inference_bls_threshold_signing_proto_rawDesc = []byte{
+ 0x0a, 0x25, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x62, 0x6c, 0x73, 0x2f,
+ 0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x5f, 0x73, 0x69, 0x67, 0x6e, 0x69, 0x6e,
+ 0x67, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0d, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+ 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x1a, 0x11, 0x61, 0x6d, 0x69, 0x6e, 0x6f, 0x2f, 0x61, 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,
+ 0x1a, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x62, 0x6c, 0x73, 0x2f, 0x70,
+ 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x85, 0x01, 0x0a, 0x0b,
+ 0x53, 0x69, 0x67, 0x6e, 0x69, 0x6e, 0x67, 0x44, 0x61, 0x74, 0x61, 0x12, 0x28, 0x0a, 0x10, 0x63,
+ 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x64, 0x18,
+ 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x45, 0x70,
+ 0x6f, 0x63, 0x68, 0x49, 0x64, 0x12, 0x19, 0x0a, 0x08, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x69,
+ 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64,
+ 0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x03,
+ 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x49, 0x64, 0x12,
+ 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x04, 0x64,
+ 0x61, 0x74, 0x61, 0x22, 0xfb, 0x03, 0x0a, 0x17, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c,
+ 0x64, 0x53, 0x69, 0x67, 0x6e, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12,
+ 0x1d, 0x0a, 0x0a, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20,
+ 0x01, 0x28, 0x0c, 0x52, 0x09, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x49, 0x64, 0x12, 0x28,
+ 0x0a, 0x10, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f,
+ 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e,
+ 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x64, 0x12, 0x19, 0x0a, 0x08, 0x63, 0x68, 0x61, 0x69,
+ 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x63, 0x68, 0x61, 0x69,
+ 0x6e, 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x04, 0x20, 0x03, 0x28,
+ 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x12, 0x21, 0x0a, 0x0c, 0x65, 0x6e, 0x63, 0x6f, 0x64,
+ 0x65, 0x64, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x65,
+ 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x44, 0x61, 0x74, 0x61, 0x12, 0x21, 0x0a, 0x0c, 0x6d, 0x65,
+ 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c,
+ 0x52, 0x0b, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x48, 0x61, 0x73, 0x68, 0x12, 0x3d, 0x0a,
+ 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x25, 0x2e,
+ 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x2e, 0x54, 0x68,
+ 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x53, 0x69, 0x67, 0x6e, 0x69, 0x6e, 0x67, 0x53, 0x74,
+ 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x54, 0x0a, 0x12,
+ 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x5f, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72,
+ 0x65, 0x73, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+ 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x2e, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c,
+ 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52,
+ 0x11, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72,
+ 0x65, 0x73, 0x12, 0x27, 0x0a, 0x0f, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x69, 0x67, 0x6e,
+ 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0e, 0x66, 0x69, 0x6e,
+ 0x61, 0x6c, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x12, 0x30, 0x0a, 0x14, 0x63,
+ 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69,
+ 0x67, 0x68, 0x74, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x03, 0x52, 0x12, 0x63, 0x72, 0x65, 0x61, 0x74,
+ 0x65, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x32, 0x0a,
+ 0x15, 0x64, 0x65, 0x61, 0x64, 0x6c, 0x69, 0x6e, 0x65, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f,
+ 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x03, 0x52, 0x13, 0x64, 0x65,
+ 0x61, 0x64, 0x6c, 0x69, 0x6e, 0x65, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68,
+ 0x74, 0x2a, 0x95, 0x02, 0x0a, 0x16, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x53,
+ 0x69, 0x67, 0x6e, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x26, 0x0a, 0x22,
+ 0x54, 0x48, 0x52, 0x45, 0x53, 0x48, 0x4f, 0x4c, 0x44, 0x5f, 0x53, 0x49, 0x47, 0x4e, 0x49, 0x4e,
+ 0x47, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x55, 0x4e, 0x44, 0x45, 0x46, 0x49, 0x4e,
+ 0x45, 0x44, 0x10, 0x00, 0x12, 0x2c, 0x0a, 0x28, 0x54, 0x48, 0x52, 0x45, 0x53, 0x48, 0x4f, 0x4c,
+ 0x44, 0x5f, 0x53, 0x49, 0x47, 0x4e, 0x49, 0x4e, 0x47, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53,
+ 0x5f, 0x50, 0x45, 0x4e, 0x44, 0x49, 0x4e, 0x47, 0x5f, 0x53, 0x49, 0x47, 0x4e, 0x49, 0x4e, 0x47,
+ 0x10, 0x01, 0x12, 0x32, 0x0a, 0x2e, 0x54, 0x48, 0x52, 0x45, 0x53, 0x48, 0x4f, 0x4c, 0x44, 0x5f,
+ 0x53, 0x49, 0x47, 0x4e, 0x49, 0x4e, 0x47, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x43,
+ 0x4f, 0x4c, 0x4c, 0x45, 0x43, 0x54, 0x49, 0x4e, 0x47, 0x5f, 0x53, 0x49, 0x47, 0x4e, 0x41, 0x54,
+ 0x55, 0x52, 0x45, 0x53, 0x10, 0x02, 0x12, 0x26, 0x0a, 0x22, 0x54, 0x48, 0x52, 0x45, 0x53, 0x48,
+ 0x4f, 0x4c, 0x44, 0x5f, 0x53, 0x49, 0x47, 0x4e, 0x49, 0x4e, 0x47, 0x5f, 0x53, 0x54, 0x41, 0x54,
+ 0x55, 0x53, 0x5f, 0x43, 0x4f, 0x4d, 0x50, 0x4c, 0x45, 0x54, 0x45, 0x44, 0x10, 0x03, 0x12, 0x23,
+ 0x0a, 0x1f, 0x54, 0x48, 0x52, 0x45, 0x53, 0x48, 0x4f, 0x4c, 0x44, 0x5f, 0x53, 0x49, 0x47, 0x4e,
+ 0x49, 0x4e, 0x47, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x46, 0x41, 0x49, 0x4c, 0x45,
+ 0x44, 0x10, 0x04, 0x12, 0x24, 0x0a, 0x20, 0x54, 0x48, 0x52, 0x45, 0x53, 0x48, 0x4f, 0x4c, 0x44,
+ 0x5f, 0x53, 0x49, 0x47, 0x4e, 0x49, 0x4e, 0x47, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f,
+ 0x45, 0x58, 0x50, 0x49, 0x52, 0x45, 0x44, 0x10, 0x05, 0x42, 0x9f, 0x01, 0x0a, 0x11, 0x63, 0x6f,
+ 0x6d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x42,
+ 0x15, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x53, 0x69, 0x67, 0x6e, 0x69, 0x6e,
+ 0x67, 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 (
+ file_inference_bls_threshold_signing_proto_rawDescOnce sync.Once
+ file_inference_bls_threshold_signing_proto_rawDescData = file_inference_bls_threshold_signing_proto_rawDesc
+)
+
+func file_inference_bls_threshold_signing_proto_rawDescGZIP() []byte {
+ file_inference_bls_threshold_signing_proto_rawDescOnce.Do(func() {
+ file_inference_bls_threshold_signing_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_bls_threshold_signing_proto_rawDescData)
+ })
+ return file_inference_bls_threshold_signing_proto_rawDescData
+}
+
+var file_inference_bls_threshold_signing_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
+var file_inference_bls_threshold_signing_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
+var file_inference_bls_threshold_signing_proto_goTypes = []interface{}{
+ (ThresholdSigningStatus)(0), // 0: inference.bls.ThresholdSigningStatus
+ (*SigningData)(nil), // 1: inference.bls.SigningData
+ (*ThresholdSigningRequest)(nil), // 2: inference.bls.ThresholdSigningRequest
+ (*PartialSignature)(nil), // 3: inference.bls.PartialSignature
+}
+var file_inference_bls_threshold_signing_proto_depIdxs = []int32{
+ 0, // 0: inference.bls.ThresholdSigningRequest.status:type_name -> inference.bls.ThresholdSigningStatus
+ 3, // 1: inference.bls.ThresholdSigningRequest.partial_signatures:type_name -> inference.bls.PartialSignature
+ 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_bls_threshold_signing_proto_init() }
+func file_inference_bls_threshold_signing_proto_init() {
+ if File_inference_bls_threshold_signing_proto != nil {
+ return
+ }
+ file_inference_bls_params_proto_init()
+ if !protoimpl.UnsafeEnabled {
+ file_inference_bls_threshold_signing_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*SigningData); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_bls_threshold_signing_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*ThresholdSigningRequest); 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_bls_threshold_signing_proto_rawDesc,
+ NumEnums: 1,
+ NumMessages: 2,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_bls_threshold_signing_proto_goTypes,
+ DependencyIndexes: file_inference_bls_threshold_signing_proto_depIdxs,
+ EnumInfos: file_inference_bls_threshold_signing_proto_enumTypes,
+ MessageInfos: file_inference_bls_threshold_signing_proto_msgTypes,
+ }.Build()
+ File_inference_bls_threshold_signing_proto = out.File
+ file_inference_bls_threshold_signing_proto_rawDesc = nil
+ file_inference_bls_threshold_signing_proto_goTypes = nil
+ file_inference_bls_threshold_signing_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/bls/tx.pulsar.go b/inference-chain/api/inference/bls/tx.pulsar.go
new file mode 100644
index 000000000..d182ec288
--- /dev/null
+++ b/inference-chain/api/inference/bls/tx.pulsar.go
@@ -0,0 +1,7141 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package bls
+
+import (
+ _ "cosmossdk.io/api/amino"
+ _ "cosmossdk.io/api/cosmos/msg/v1"
+ fmt "fmt"
+ _ "github.com/cosmos/cosmos-proto"
+ runtime "github.com/cosmos/cosmos-proto/runtime"
+ _ "github.com/cosmos/gogoproto/gogoproto"
+ 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_MsgUpdateParams protoreflect.MessageDescriptor
+ fd_MsgUpdateParams_authority protoreflect.FieldDescriptor
+ fd_MsgUpdateParams_params protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bls_tx_proto_init()
+ md_MsgUpdateParams = File_inference_bls_tx_proto.Messages().ByName("MsgUpdateParams")
+ fd_MsgUpdateParams_authority = md_MsgUpdateParams.Fields().ByName("authority")
+ fd_MsgUpdateParams_params = md_MsgUpdateParams.Fields().ByName("params")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgUpdateParams)(nil)
+
+type fastReflection_MsgUpdateParams MsgUpdateParams
+
+func (x *MsgUpdateParams) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_MsgUpdateParams)(x)
+}
+
+func (x *MsgUpdateParams) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_tx_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_MsgUpdateParams_messageType fastReflection_MsgUpdateParams_messageType
+var _ protoreflect.MessageType = fastReflection_MsgUpdateParams_messageType{}
+
+type fastReflection_MsgUpdateParams_messageType struct{}
+
+func (x fastReflection_MsgUpdateParams_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_MsgUpdateParams)(nil)
+}
+func (x fastReflection_MsgUpdateParams_messageType) New() protoreflect.Message {
+ return new(fastReflection_MsgUpdateParams)
+}
+func (x fastReflection_MsgUpdateParams_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgUpdateParams
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgUpdateParams) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgUpdateParams
+}
+
+// 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_MsgUpdateParams) Type() protoreflect.MessageType {
+ return _fastReflection_MsgUpdateParams_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgUpdateParams) New() protoreflect.Message {
+ return new(fastReflection_MsgUpdateParams)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgUpdateParams) Interface() protoreflect.ProtoMessage {
+ return (*MsgUpdateParams)(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_MsgUpdateParams) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Authority != "" {
+ value := protoreflect.ValueOfString(x.Authority)
+ if !f(fd_MsgUpdateParams_authority, value) {
+ return
+ }
+ }
+ if x.Params != nil {
+ value := protoreflect.ValueOfMessage(x.Params.ProtoReflect())
+ if !f(fd_MsgUpdateParams_params, 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_MsgUpdateParams) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bls.MsgUpdateParams.authority":
+ return x.Authority != ""
+ case "inference.bls.MsgUpdateParams.params":
+ return x.Params != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgUpdateParams"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgUpdateParams 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_MsgUpdateParams) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bls.MsgUpdateParams.authority":
+ x.Authority = ""
+ case "inference.bls.MsgUpdateParams.params":
+ x.Params = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgUpdateParams"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgUpdateParams 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_MsgUpdateParams) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bls.MsgUpdateParams.authority":
+ value := x.Authority
+ return protoreflect.ValueOfString(value)
+ case "inference.bls.MsgUpdateParams.params":
+ value := x.Params
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgUpdateParams"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgUpdateParams 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_MsgUpdateParams) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bls.MsgUpdateParams.authority":
+ x.Authority = value.Interface().(string)
+ case "inference.bls.MsgUpdateParams.params":
+ x.Params = value.Message().Interface().(*Params)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgUpdateParams"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgUpdateParams 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_MsgUpdateParams) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.MsgUpdateParams.params":
+ if x.Params == nil {
+ x.Params = new(Params)
+ }
+ return protoreflect.ValueOfMessage(x.Params.ProtoReflect())
+ case "inference.bls.MsgUpdateParams.authority":
+ panic(fmt.Errorf("field authority of message inference.bls.MsgUpdateParams is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgUpdateParams"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgUpdateParams 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_MsgUpdateParams) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.MsgUpdateParams.authority":
+ return protoreflect.ValueOfString("")
+ case "inference.bls.MsgUpdateParams.params":
+ m := new(Params)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgUpdateParams"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgUpdateParams 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_MsgUpdateParams) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.MsgUpdateParams", 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_MsgUpdateParams) 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_MsgUpdateParams) 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_MsgUpdateParams) 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_MsgUpdateParams) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*MsgUpdateParams)
+ 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 x.Params != nil {
+ l = options.Size(x.Params)
+ 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().(*MsgUpdateParams)
+ 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.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 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().(*MsgUpdateParams)
+ 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: MsgUpdateParams: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUpdateParams: 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 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
+ 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_MsgUpdateParamsResponse protoreflect.MessageDescriptor
+)
+
+func init() {
+ file_inference_bls_tx_proto_init()
+ md_MsgUpdateParamsResponse = File_inference_bls_tx_proto.Messages().ByName("MsgUpdateParamsResponse")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgUpdateParamsResponse)(nil)
+
+type fastReflection_MsgUpdateParamsResponse MsgUpdateParamsResponse
+
+func (x *MsgUpdateParamsResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_MsgUpdateParamsResponse)(x)
+}
+
+func (x *MsgUpdateParamsResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_tx_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_MsgUpdateParamsResponse_messageType fastReflection_MsgUpdateParamsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgUpdateParamsResponse_messageType{}
+
+type fastReflection_MsgUpdateParamsResponse_messageType struct{}
+
+func (x fastReflection_MsgUpdateParamsResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_MsgUpdateParamsResponse)(nil)
+}
+func (x fastReflection_MsgUpdateParamsResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_MsgUpdateParamsResponse)
+}
+func (x fastReflection_MsgUpdateParamsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgUpdateParamsResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgUpdateParamsResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgUpdateParamsResponse
+}
+
+// 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_MsgUpdateParamsResponse) Type() protoreflect.MessageType {
+ return _fastReflection_MsgUpdateParamsResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgUpdateParamsResponse) New() protoreflect.Message {
+ return new(fastReflection_MsgUpdateParamsResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgUpdateParamsResponse) Interface() protoreflect.ProtoMessage {
+ return (*MsgUpdateParamsResponse)(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_MsgUpdateParamsResponse) 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_MsgUpdateParamsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgUpdateParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgUpdateParamsResponse 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_MsgUpdateParamsResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgUpdateParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgUpdateParamsResponse 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_MsgUpdateParamsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgUpdateParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgUpdateParamsResponse 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_MsgUpdateParamsResponse) 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.bls.MsgUpdateParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgUpdateParamsResponse 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_MsgUpdateParamsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgUpdateParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgUpdateParamsResponse 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_MsgUpdateParamsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgUpdateParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgUpdateParamsResponse 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_MsgUpdateParamsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.MsgUpdateParamsResponse", 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_MsgUpdateParamsResponse) 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_MsgUpdateParamsResponse) 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_MsgUpdateParamsResponse) 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_MsgUpdateParamsResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*MsgUpdateParamsResponse)
+ 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().(*MsgUpdateParamsResponse)
+ 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().(*MsgUpdateParamsResponse)
+ 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: MsgUpdateParamsResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUpdateParamsResponse: 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 = (*_MsgSubmitDealerPart_3_list)(nil)
+
+type _MsgSubmitDealerPart_3_list struct {
+ list *[][]byte
+}
+
+func (x *_MsgSubmitDealerPart_3_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_MsgSubmitDealerPart_3_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfBytes((*x.list)[i])
+}
+
+func (x *_MsgSubmitDealerPart_3_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Bytes()
+ concreteValue := valueUnwrapped
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_MsgSubmitDealerPart_3_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Bytes()
+ concreteValue := valueUnwrapped
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_MsgSubmitDealerPart_3_list) AppendMutable() protoreflect.Value {
+ panic(fmt.Errorf("AppendMutable can not be called on message MsgSubmitDealerPart at list field Commitments as it is not of Message kind"))
+}
+
+func (x *_MsgSubmitDealerPart_3_list) Truncate(n int) {
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_MsgSubmitDealerPart_3_list) NewElement() protoreflect.Value {
+ var v []byte
+ return protoreflect.ValueOfBytes(v)
+}
+
+func (x *_MsgSubmitDealerPart_3_list) IsValid() bool {
+ return x.list != nil
+}
+
+var _ protoreflect.List = (*_MsgSubmitDealerPart_4_list)(nil)
+
+type _MsgSubmitDealerPart_4_list struct {
+ list *[]*EncryptedSharesForParticipant
+}
+
+func (x *_MsgSubmitDealerPart_4_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_MsgSubmitDealerPart_4_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_MsgSubmitDealerPart_4_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*EncryptedSharesForParticipant)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_MsgSubmitDealerPart_4_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*EncryptedSharesForParticipant)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_MsgSubmitDealerPart_4_list) AppendMutable() protoreflect.Value {
+ v := new(EncryptedSharesForParticipant)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_MsgSubmitDealerPart_4_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_MsgSubmitDealerPart_4_list) NewElement() protoreflect.Value {
+ v := new(EncryptedSharesForParticipant)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_MsgSubmitDealerPart_4_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_MsgSubmitDealerPart protoreflect.MessageDescriptor
+ fd_MsgSubmitDealerPart_creator protoreflect.FieldDescriptor
+ fd_MsgSubmitDealerPart_epoch_id protoreflect.FieldDescriptor
+ fd_MsgSubmitDealerPart_commitments protoreflect.FieldDescriptor
+ fd_MsgSubmitDealerPart_encrypted_shares_for_participants protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bls_tx_proto_init()
+ md_MsgSubmitDealerPart = File_inference_bls_tx_proto.Messages().ByName("MsgSubmitDealerPart")
+ fd_MsgSubmitDealerPart_creator = md_MsgSubmitDealerPart.Fields().ByName("creator")
+ fd_MsgSubmitDealerPart_epoch_id = md_MsgSubmitDealerPart.Fields().ByName("epoch_id")
+ fd_MsgSubmitDealerPart_commitments = md_MsgSubmitDealerPart.Fields().ByName("commitments")
+ fd_MsgSubmitDealerPart_encrypted_shares_for_participants = md_MsgSubmitDealerPart.Fields().ByName("encrypted_shares_for_participants")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgSubmitDealerPart)(nil)
+
+type fastReflection_MsgSubmitDealerPart MsgSubmitDealerPart
+
+func (x *MsgSubmitDealerPart) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_MsgSubmitDealerPart)(x)
+}
+
+func (x *MsgSubmitDealerPart) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_tx_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_MsgSubmitDealerPart_messageType fastReflection_MsgSubmitDealerPart_messageType
+var _ protoreflect.MessageType = fastReflection_MsgSubmitDealerPart_messageType{}
+
+type fastReflection_MsgSubmitDealerPart_messageType struct{}
+
+func (x fastReflection_MsgSubmitDealerPart_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_MsgSubmitDealerPart)(nil)
+}
+func (x fastReflection_MsgSubmitDealerPart_messageType) New() protoreflect.Message {
+ return new(fastReflection_MsgSubmitDealerPart)
+}
+func (x fastReflection_MsgSubmitDealerPart_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgSubmitDealerPart
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgSubmitDealerPart) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgSubmitDealerPart
+}
+
+// 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_MsgSubmitDealerPart) Type() protoreflect.MessageType {
+ return _fastReflection_MsgSubmitDealerPart_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgSubmitDealerPart) New() protoreflect.Message {
+ return new(fastReflection_MsgSubmitDealerPart)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgSubmitDealerPart) Interface() protoreflect.ProtoMessage {
+ return (*MsgSubmitDealerPart)(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_MsgSubmitDealerPart) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Creator != "" {
+ value := protoreflect.ValueOfString(x.Creator)
+ if !f(fd_MsgSubmitDealerPart_creator, value) {
+ return
+ }
+ }
+ if x.EpochId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.EpochId)
+ if !f(fd_MsgSubmitDealerPart_epoch_id, value) {
+ return
+ }
+ }
+ if len(x.Commitments) != 0 {
+ value := protoreflect.ValueOfList(&_MsgSubmitDealerPart_3_list{list: &x.Commitments})
+ if !f(fd_MsgSubmitDealerPart_commitments, value) {
+ return
+ }
+ }
+ if len(x.EncryptedSharesForParticipants) != 0 {
+ value := protoreflect.ValueOfList(&_MsgSubmitDealerPart_4_list{list: &x.EncryptedSharesForParticipants})
+ if !f(fd_MsgSubmitDealerPart_encrypted_shares_for_participants, 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_MsgSubmitDealerPart) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bls.MsgSubmitDealerPart.creator":
+ return x.Creator != ""
+ case "inference.bls.MsgSubmitDealerPart.epoch_id":
+ return x.EpochId != uint64(0)
+ case "inference.bls.MsgSubmitDealerPart.commitments":
+ return len(x.Commitments) != 0
+ case "inference.bls.MsgSubmitDealerPart.encrypted_shares_for_participants":
+ return len(x.EncryptedSharesForParticipants) != 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitDealerPart"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitDealerPart 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_MsgSubmitDealerPart) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bls.MsgSubmitDealerPart.creator":
+ x.Creator = ""
+ case "inference.bls.MsgSubmitDealerPart.epoch_id":
+ x.EpochId = uint64(0)
+ case "inference.bls.MsgSubmitDealerPart.commitments":
+ x.Commitments = nil
+ case "inference.bls.MsgSubmitDealerPart.encrypted_shares_for_participants":
+ x.EncryptedSharesForParticipants = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitDealerPart"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitDealerPart 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_MsgSubmitDealerPart) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bls.MsgSubmitDealerPart.creator":
+ value := x.Creator
+ return protoreflect.ValueOfString(value)
+ case "inference.bls.MsgSubmitDealerPart.epoch_id":
+ value := x.EpochId
+ return protoreflect.ValueOfUint64(value)
+ case "inference.bls.MsgSubmitDealerPart.commitments":
+ if len(x.Commitments) == 0 {
+ return protoreflect.ValueOfList(&_MsgSubmitDealerPart_3_list{})
+ }
+ listValue := &_MsgSubmitDealerPart_3_list{list: &x.Commitments}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.bls.MsgSubmitDealerPart.encrypted_shares_for_participants":
+ if len(x.EncryptedSharesForParticipants) == 0 {
+ return protoreflect.ValueOfList(&_MsgSubmitDealerPart_4_list{})
+ }
+ listValue := &_MsgSubmitDealerPart_4_list{list: &x.EncryptedSharesForParticipants}
+ return protoreflect.ValueOfList(listValue)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitDealerPart"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitDealerPart 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_MsgSubmitDealerPart) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bls.MsgSubmitDealerPart.creator":
+ x.Creator = value.Interface().(string)
+ case "inference.bls.MsgSubmitDealerPart.epoch_id":
+ x.EpochId = value.Uint()
+ case "inference.bls.MsgSubmitDealerPart.commitments":
+ lv := value.List()
+ clv := lv.(*_MsgSubmitDealerPart_3_list)
+ x.Commitments = *clv.list
+ case "inference.bls.MsgSubmitDealerPart.encrypted_shares_for_participants":
+ lv := value.List()
+ clv := lv.(*_MsgSubmitDealerPart_4_list)
+ x.EncryptedSharesForParticipants = *clv.list
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitDealerPart"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitDealerPart 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_MsgSubmitDealerPart) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.MsgSubmitDealerPart.commitments":
+ if x.Commitments == nil {
+ x.Commitments = [][]byte{}
+ }
+ value := &_MsgSubmitDealerPart_3_list{list: &x.Commitments}
+ return protoreflect.ValueOfList(value)
+ case "inference.bls.MsgSubmitDealerPart.encrypted_shares_for_participants":
+ if x.EncryptedSharesForParticipants == nil {
+ x.EncryptedSharesForParticipants = []*EncryptedSharesForParticipant{}
+ }
+ value := &_MsgSubmitDealerPart_4_list{list: &x.EncryptedSharesForParticipants}
+ return protoreflect.ValueOfList(value)
+ case "inference.bls.MsgSubmitDealerPart.creator":
+ panic(fmt.Errorf("field creator of message inference.bls.MsgSubmitDealerPart is not mutable"))
+ case "inference.bls.MsgSubmitDealerPart.epoch_id":
+ panic(fmt.Errorf("field epoch_id of message inference.bls.MsgSubmitDealerPart is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitDealerPart"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitDealerPart 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_MsgSubmitDealerPart) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.MsgSubmitDealerPart.creator":
+ return protoreflect.ValueOfString("")
+ case "inference.bls.MsgSubmitDealerPart.epoch_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.bls.MsgSubmitDealerPart.commitments":
+ list := [][]byte{}
+ return protoreflect.ValueOfList(&_MsgSubmitDealerPart_3_list{list: &list})
+ case "inference.bls.MsgSubmitDealerPart.encrypted_shares_for_participants":
+ list := []*EncryptedSharesForParticipant{}
+ return protoreflect.ValueOfList(&_MsgSubmitDealerPart_4_list{list: &list})
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitDealerPart"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitDealerPart 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_MsgSubmitDealerPart) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.MsgSubmitDealerPart", 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_MsgSubmitDealerPart) 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_MsgSubmitDealerPart) 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_MsgSubmitDealerPart) 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_MsgSubmitDealerPart) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*MsgSubmitDealerPart)
+ 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.Creator)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.EpochId != 0 {
+ n += 1 + runtime.Sov(uint64(x.EpochId))
+ }
+ if len(x.Commitments) > 0 {
+ for _, b := range x.Commitments {
+ l = len(b)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ }
+ if len(x.EncryptedSharesForParticipants) > 0 {
+ for _, e := range x.EncryptedSharesForParticipants {
+ 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().(*MsgSubmitDealerPart)
+ 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.EncryptedSharesForParticipants) > 0 {
+ for iNdEx := len(x.EncryptedSharesForParticipants) - 1; iNdEx >= 0; iNdEx-- {
+ encoded, err := options.Marshal(x.EncryptedSharesForParticipants[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.Commitments) > 0 {
+ for iNdEx := len(x.Commitments) - 1; iNdEx >= 0; iNdEx-- {
+ i -= len(x.Commitments[iNdEx])
+ copy(dAtA[i:], x.Commitments[iNdEx])
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Commitments[iNdEx])))
+ i--
+ dAtA[i] = 0x1a
+ }
+ }
+ if x.EpochId != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochId))
+ 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().(*MsgSubmitDealerPart)
+ 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: MsgSubmitDealerPart: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitDealerPart: 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)
+ }
+ 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.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 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 3:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Commitments", 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.Commitments = append(x.Commitments, make([]byte, postIndex-iNdEx))
+ copy(x.Commitments[len(x.Commitments)-1], 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 EncryptedSharesForParticipants", 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.EncryptedSharesForParticipants = append(x.EncryptedSharesForParticipants, &EncryptedSharesForParticipant{})
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.EncryptedSharesForParticipants[len(x.EncryptedSharesForParticipants)-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_MsgSubmitDealerPartResponse protoreflect.MessageDescriptor
+)
+
+func init() {
+ file_inference_bls_tx_proto_init()
+ md_MsgSubmitDealerPartResponse = File_inference_bls_tx_proto.Messages().ByName("MsgSubmitDealerPartResponse")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgSubmitDealerPartResponse)(nil)
+
+type fastReflection_MsgSubmitDealerPartResponse MsgSubmitDealerPartResponse
+
+func (x *MsgSubmitDealerPartResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_MsgSubmitDealerPartResponse)(x)
+}
+
+func (x *MsgSubmitDealerPartResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_tx_proto_msgTypes[3]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_MsgSubmitDealerPartResponse_messageType fastReflection_MsgSubmitDealerPartResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgSubmitDealerPartResponse_messageType{}
+
+type fastReflection_MsgSubmitDealerPartResponse_messageType struct{}
+
+func (x fastReflection_MsgSubmitDealerPartResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_MsgSubmitDealerPartResponse)(nil)
+}
+func (x fastReflection_MsgSubmitDealerPartResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_MsgSubmitDealerPartResponse)
+}
+func (x fastReflection_MsgSubmitDealerPartResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgSubmitDealerPartResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgSubmitDealerPartResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgSubmitDealerPartResponse
+}
+
+// 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_MsgSubmitDealerPartResponse) Type() protoreflect.MessageType {
+ return _fastReflection_MsgSubmitDealerPartResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgSubmitDealerPartResponse) New() protoreflect.Message {
+ return new(fastReflection_MsgSubmitDealerPartResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgSubmitDealerPartResponse) Interface() protoreflect.ProtoMessage {
+ return (*MsgSubmitDealerPartResponse)(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_MsgSubmitDealerPartResponse) 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_MsgSubmitDealerPartResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitDealerPartResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitDealerPartResponse 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_MsgSubmitDealerPartResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitDealerPartResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitDealerPartResponse 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_MsgSubmitDealerPartResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitDealerPartResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitDealerPartResponse 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_MsgSubmitDealerPartResponse) 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.bls.MsgSubmitDealerPartResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitDealerPartResponse 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_MsgSubmitDealerPartResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitDealerPartResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitDealerPartResponse 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_MsgSubmitDealerPartResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitDealerPartResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitDealerPartResponse 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_MsgSubmitDealerPartResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.MsgSubmitDealerPartResponse", 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_MsgSubmitDealerPartResponse) 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_MsgSubmitDealerPartResponse) 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_MsgSubmitDealerPartResponse) 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_MsgSubmitDealerPartResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*MsgSubmitDealerPartResponse)
+ 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().(*MsgSubmitDealerPartResponse)
+ 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().(*MsgSubmitDealerPartResponse)
+ 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: MsgSubmitDealerPartResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitDealerPartResponse: 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 = (*_MsgSubmitVerificationVector_3_list)(nil)
+
+type _MsgSubmitVerificationVector_3_list struct {
+ list *[]bool
+}
+
+func (x *_MsgSubmitVerificationVector_3_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_MsgSubmitVerificationVector_3_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfBool((*x.list)[i])
+}
+
+func (x *_MsgSubmitVerificationVector_3_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Bool()
+ concreteValue := valueUnwrapped
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_MsgSubmitVerificationVector_3_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Bool()
+ concreteValue := valueUnwrapped
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_MsgSubmitVerificationVector_3_list) AppendMutable() protoreflect.Value {
+ panic(fmt.Errorf("AppendMutable can not be called on message MsgSubmitVerificationVector at list field DealerValidity as it is not of Message kind"))
+}
+
+func (x *_MsgSubmitVerificationVector_3_list) Truncate(n int) {
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_MsgSubmitVerificationVector_3_list) NewElement() protoreflect.Value {
+ v := false
+ return protoreflect.ValueOfBool(v)
+}
+
+func (x *_MsgSubmitVerificationVector_3_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_MsgSubmitVerificationVector protoreflect.MessageDescriptor
+ fd_MsgSubmitVerificationVector_creator protoreflect.FieldDescriptor
+ fd_MsgSubmitVerificationVector_epoch_id protoreflect.FieldDescriptor
+ fd_MsgSubmitVerificationVector_dealer_validity protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bls_tx_proto_init()
+ md_MsgSubmitVerificationVector = File_inference_bls_tx_proto.Messages().ByName("MsgSubmitVerificationVector")
+ fd_MsgSubmitVerificationVector_creator = md_MsgSubmitVerificationVector.Fields().ByName("creator")
+ fd_MsgSubmitVerificationVector_epoch_id = md_MsgSubmitVerificationVector.Fields().ByName("epoch_id")
+ fd_MsgSubmitVerificationVector_dealer_validity = md_MsgSubmitVerificationVector.Fields().ByName("dealer_validity")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgSubmitVerificationVector)(nil)
+
+type fastReflection_MsgSubmitVerificationVector MsgSubmitVerificationVector
+
+func (x *MsgSubmitVerificationVector) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_MsgSubmitVerificationVector)(x)
+}
+
+func (x *MsgSubmitVerificationVector) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_tx_proto_msgTypes[4]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_MsgSubmitVerificationVector_messageType fastReflection_MsgSubmitVerificationVector_messageType
+var _ protoreflect.MessageType = fastReflection_MsgSubmitVerificationVector_messageType{}
+
+type fastReflection_MsgSubmitVerificationVector_messageType struct{}
+
+func (x fastReflection_MsgSubmitVerificationVector_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_MsgSubmitVerificationVector)(nil)
+}
+func (x fastReflection_MsgSubmitVerificationVector_messageType) New() protoreflect.Message {
+ return new(fastReflection_MsgSubmitVerificationVector)
+}
+func (x fastReflection_MsgSubmitVerificationVector_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgSubmitVerificationVector
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgSubmitVerificationVector) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgSubmitVerificationVector
+}
+
+// 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_MsgSubmitVerificationVector) Type() protoreflect.MessageType {
+ return _fastReflection_MsgSubmitVerificationVector_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgSubmitVerificationVector) New() protoreflect.Message {
+ return new(fastReflection_MsgSubmitVerificationVector)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgSubmitVerificationVector) Interface() protoreflect.ProtoMessage {
+ return (*MsgSubmitVerificationVector)(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_MsgSubmitVerificationVector) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Creator != "" {
+ value := protoreflect.ValueOfString(x.Creator)
+ if !f(fd_MsgSubmitVerificationVector_creator, value) {
+ return
+ }
+ }
+ if x.EpochId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.EpochId)
+ if !f(fd_MsgSubmitVerificationVector_epoch_id, value) {
+ return
+ }
+ }
+ if len(x.DealerValidity) != 0 {
+ value := protoreflect.ValueOfList(&_MsgSubmitVerificationVector_3_list{list: &x.DealerValidity})
+ if !f(fd_MsgSubmitVerificationVector_dealer_validity, 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_MsgSubmitVerificationVector) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bls.MsgSubmitVerificationVector.creator":
+ return x.Creator != ""
+ case "inference.bls.MsgSubmitVerificationVector.epoch_id":
+ return x.EpochId != uint64(0)
+ case "inference.bls.MsgSubmitVerificationVector.dealer_validity":
+ return len(x.DealerValidity) != 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitVerificationVector"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitVerificationVector 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_MsgSubmitVerificationVector) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bls.MsgSubmitVerificationVector.creator":
+ x.Creator = ""
+ case "inference.bls.MsgSubmitVerificationVector.epoch_id":
+ x.EpochId = uint64(0)
+ case "inference.bls.MsgSubmitVerificationVector.dealer_validity":
+ x.DealerValidity = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitVerificationVector"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitVerificationVector 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_MsgSubmitVerificationVector) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bls.MsgSubmitVerificationVector.creator":
+ value := x.Creator
+ return protoreflect.ValueOfString(value)
+ case "inference.bls.MsgSubmitVerificationVector.epoch_id":
+ value := x.EpochId
+ return protoreflect.ValueOfUint64(value)
+ case "inference.bls.MsgSubmitVerificationVector.dealer_validity":
+ if len(x.DealerValidity) == 0 {
+ return protoreflect.ValueOfList(&_MsgSubmitVerificationVector_3_list{})
+ }
+ listValue := &_MsgSubmitVerificationVector_3_list{list: &x.DealerValidity}
+ return protoreflect.ValueOfList(listValue)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitVerificationVector"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitVerificationVector 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_MsgSubmitVerificationVector) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bls.MsgSubmitVerificationVector.creator":
+ x.Creator = value.Interface().(string)
+ case "inference.bls.MsgSubmitVerificationVector.epoch_id":
+ x.EpochId = value.Uint()
+ case "inference.bls.MsgSubmitVerificationVector.dealer_validity":
+ lv := value.List()
+ clv := lv.(*_MsgSubmitVerificationVector_3_list)
+ x.DealerValidity = *clv.list
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitVerificationVector"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitVerificationVector 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_MsgSubmitVerificationVector) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.MsgSubmitVerificationVector.dealer_validity":
+ if x.DealerValidity == nil {
+ x.DealerValidity = []bool{}
+ }
+ value := &_MsgSubmitVerificationVector_3_list{list: &x.DealerValidity}
+ return protoreflect.ValueOfList(value)
+ case "inference.bls.MsgSubmitVerificationVector.creator":
+ panic(fmt.Errorf("field creator of message inference.bls.MsgSubmitVerificationVector is not mutable"))
+ case "inference.bls.MsgSubmitVerificationVector.epoch_id":
+ panic(fmt.Errorf("field epoch_id of message inference.bls.MsgSubmitVerificationVector is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitVerificationVector"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitVerificationVector 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_MsgSubmitVerificationVector) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.MsgSubmitVerificationVector.creator":
+ return protoreflect.ValueOfString("")
+ case "inference.bls.MsgSubmitVerificationVector.epoch_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.bls.MsgSubmitVerificationVector.dealer_validity":
+ list := []bool{}
+ return protoreflect.ValueOfList(&_MsgSubmitVerificationVector_3_list{list: &list})
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitVerificationVector"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitVerificationVector 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_MsgSubmitVerificationVector) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.MsgSubmitVerificationVector", 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_MsgSubmitVerificationVector) 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_MsgSubmitVerificationVector) 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_MsgSubmitVerificationVector) 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_MsgSubmitVerificationVector) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*MsgSubmitVerificationVector)
+ 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.Creator)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.EpochId != 0 {
+ n += 1 + runtime.Sov(uint64(x.EpochId))
+ }
+ if len(x.DealerValidity) > 0 {
+ n += 1 + runtime.Sov(uint64(len(x.DealerValidity))) + len(x.DealerValidity)*1
+ }
+ 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().(*MsgSubmitVerificationVector)
+ 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.DealerValidity) > 0 {
+ for iNdEx := len(x.DealerValidity) - 1; iNdEx >= 0; iNdEx-- {
+ i--
+ if x.DealerValidity[iNdEx] {
+ dAtA[i] = 1
+ } else {
+ dAtA[i] = 0
+ }
+ }
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DealerValidity)))
+ i--
+ dAtA[i] = 0x1a
+ }
+ if x.EpochId != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochId))
+ 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().(*MsgSubmitVerificationVector)
+ 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: MsgSubmitVerificationVector: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitVerificationVector: 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)
+ }
+ 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.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 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 3:
+ if wireType == 0 {
+ 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.DealerValidity = append(x.DealerValidity, bool(v != 0))
+ } 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
+ if elementCount != 0 && len(x.DealerValidity) == 0 {
+ x.DealerValidity = make([]bool, 0, elementCount)
+ }
+ for iNdEx < postIndex {
+ 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.DealerValidity = append(x.DealerValidity, bool(v != 0))
+ }
+ } else {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DealerValidity", wireType)
+ }
+ 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_MsgSubmitVerificationVectorResponse protoreflect.MessageDescriptor
+)
+
+func init() {
+ file_inference_bls_tx_proto_init()
+ md_MsgSubmitVerificationVectorResponse = File_inference_bls_tx_proto.Messages().ByName("MsgSubmitVerificationVectorResponse")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgSubmitVerificationVectorResponse)(nil)
+
+type fastReflection_MsgSubmitVerificationVectorResponse MsgSubmitVerificationVectorResponse
+
+func (x *MsgSubmitVerificationVectorResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_MsgSubmitVerificationVectorResponse)(x)
+}
+
+func (x *MsgSubmitVerificationVectorResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_tx_proto_msgTypes[5]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_MsgSubmitVerificationVectorResponse_messageType fastReflection_MsgSubmitVerificationVectorResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgSubmitVerificationVectorResponse_messageType{}
+
+type fastReflection_MsgSubmitVerificationVectorResponse_messageType struct{}
+
+func (x fastReflection_MsgSubmitVerificationVectorResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_MsgSubmitVerificationVectorResponse)(nil)
+}
+func (x fastReflection_MsgSubmitVerificationVectorResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_MsgSubmitVerificationVectorResponse)
+}
+func (x fastReflection_MsgSubmitVerificationVectorResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgSubmitVerificationVectorResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgSubmitVerificationVectorResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgSubmitVerificationVectorResponse
+}
+
+// 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_MsgSubmitVerificationVectorResponse) Type() protoreflect.MessageType {
+ return _fastReflection_MsgSubmitVerificationVectorResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgSubmitVerificationVectorResponse) New() protoreflect.Message {
+ return new(fastReflection_MsgSubmitVerificationVectorResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgSubmitVerificationVectorResponse) Interface() protoreflect.ProtoMessage {
+ return (*MsgSubmitVerificationVectorResponse)(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_MsgSubmitVerificationVectorResponse) 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_MsgSubmitVerificationVectorResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitVerificationVectorResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitVerificationVectorResponse 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_MsgSubmitVerificationVectorResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitVerificationVectorResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitVerificationVectorResponse 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_MsgSubmitVerificationVectorResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitVerificationVectorResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitVerificationVectorResponse 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_MsgSubmitVerificationVectorResponse) 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.bls.MsgSubmitVerificationVectorResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitVerificationVectorResponse 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_MsgSubmitVerificationVectorResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitVerificationVectorResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitVerificationVectorResponse 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_MsgSubmitVerificationVectorResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitVerificationVectorResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitVerificationVectorResponse 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_MsgSubmitVerificationVectorResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.MsgSubmitVerificationVectorResponse", 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_MsgSubmitVerificationVectorResponse) 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_MsgSubmitVerificationVectorResponse) 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_MsgSubmitVerificationVectorResponse) 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_MsgSubmitVerificationVectorResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*MsgSubmitVerificationVectorResponse)
+ 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().(*MsgSubmitVerificationVectorResponse)
+ 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().(*MsgSubmitVerificationVectorResponse)
+ 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: MsgSubmitVerificationVectorResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitVerificationVectorResponse: 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 = (*_MsgSubmitGroupKeyValidationSignature_3_list)(nil)
+
+type _MsgSubmitGroupKeyValidationSignature_3_list struct {
+ list *[]uint32
+}
+
+func (x *_MsgSubmitGroupKeyValidationSignature_3_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_MsgSubmitGroupKeyValidationSignature_3_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfUint32((*x.list)[i])
+}
+
+func (x *_MsgSubmitGroupKeyValidationSignature_3_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Uint()
+ concreteValue := (uint32)(valueUnwrapped)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_MsgSubmitGroupKeyValidationSignature_3_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Uint()
+ concreteValue := (uint32)(valueUnwrapped)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_MsgSubmitGroupKeyValidationSignature_3_list) AppendMutable() protoreflect.Value {
+ panic(fmt.Errorf("AppendMutable can not be called on message MsgSubmitGroupKeyValidationSignature at list field SlotIndices as it is not of Message kind"))
+}
+
+func (x *_MsgSubmitGroupKeyValidationSignature_3_list) Truncate(n int) {
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_MsgSubmitGroupKeyValidationSignature_3_list) NewElement() protoreflect.Value {
+ v := uint32(0)
+ return protoreflect.ValueOfUint32(v)
+}
+
+func (x *_MsgSubmitGroupKeyValidationSignature_3_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_MsgSubmitGroupKeyValidationSignature protoreflect.MessageDescriptor
+ fd_MsgSubmitGroupKeyValidationSignature_creator protoreflect.FieldDescriptor
+ fd_MsgSubmitGroupKeyValidationSignature_new_epoch_id protoreflect.FieldDescriptor
+ fd_MsgSubmitGroupKeyValidationSignature_slot_indices protoreflect.FieldDescriptor
+ fd_MsgSubmitGroupKeyValidationSignature_partial_signature protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bls_tx_proto_init()
+ md_MsgSubmitGroupKeyValidationSignature = File_inference_bls_tx_proto.Messages().ByName("MsgSubmitGroupKeyValidationSignature")
+ fd_MsgSubmitGroupKeyValidationSignature_creator = md_MsgSubmitGroupKeyValidationSignature.Fields().ByName("creator")
+ fd_MsgSubmitGroupKeyValidationSignature_new_epoch_id = md_MsgSubmitGroupKeyValidationSignature.Fields().ByName("new_epoch_id")
+ fd_MsgSubmitGroupKeyValidationSignature_slot_indices = md_MsgSubmitGroupKeyValidationSignature.Fields().ByName("slot_indices")
+ fd_MsgSubmitGroupKeyValidationSignature_partial_signature = md_MsgSubmitGroupKeyValidationSignature.Fields().ByName("partial_signature")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgSubmitGroupKeyValidationSignature)(nil)
+
+type fastReflection_MsgSubmitGroupKeyValidationSignature MsgSubmitGroupKeyValidationSignature
+
+func (x *MsgSubmitGroupKeyValidationSignature) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_MsgSubmitGroupKeyValidationSignature)(x)
+}
+
+func (x *MsgSubmitGroupKeyValidationSignature) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_tx_proto_msgTypes[6]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_MsgSubmitGroupKeyValidationSignature_messageType fastReflection_MsgSubmitGroupKeyValidationSignature_messageType
+var _ protoreflect.MessageType = fastReflection_MsgSubmitGroupKeyValidationSignature_messageType{}
+
+type fastReflection_MsgSubmitGroupKeyValidationSignature_messageType struct{}
+
+func (x fastReflection_MsgSubmitGroupKeyValidationSignature_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_MsgSubmitGroupKeyValidationSignature)(nil)
+}
+func (x fastReflection_MsgSubmitGroupKeyValidationSignature_messageType) New() protoreflect.Message {
+ return new(fastReflection_MsgSubmitGroupKeyValidationSignature)
+}
+func (x fastReflection_MsgSubmitGroupKeyValidationSignature_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgSubmitGroupKeyValidationSignature
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgSubmitGroupKeyValidationSignature) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgSubmitGroupKeyValidationSignature
+}
+
+// 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_MsgSubmitGroupKeyValidationSignature) Type() protoreflect.MessageType {
+ return _fastReflection_MsgSubmitGroupKeyValidationSignature_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgSubmitGroupKeyValidationSignature) New() protoreflect.Message {
+ return new(fastReflection_MsgSubmitGroupKeyValidationSignature)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgSubmitGroupKeyValidationSignature) Interface() protoreflect.ProtoMessage {
+ return (*MsgSubmitGroupKeyValidationSignature)(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_MsgSubmitGroupKeyValidationSignature) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Creator != "" {
+ value := protoreflect.ValueOfString(x.Creator)
+ if !f(fd_MsgSubmitGroupKeyValidationSignature_creator, value) {
+ return
+ }
+ }
+ if x.NewEpochId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.NewEpochId)
+ if !f(fd_MsgSubmitGroupKeyValidationSignature_new_epoch_id, value) {
+ return
+ }
+ }
+ if len(x.SlotIndices) != 0 {
+ value := protoreflect.ValueOfList(&_MsgSubmitGroupKeyValidationSignature_3_list{list: &x.SlotIndices})
+ if !f(fd_MsgSubmitGroupKeyValidationSignature_slot_indices, value) {
+ return
+ }
+ }
+ if len(x.PartialSignature) != 0 {
+ value := protoreflect.ValueOfBytes(x.PartialSignature)
+ if !f(fd_MsgSubmitGroupKeyValidationSignature_partial_signature, 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_MsgSubmitGroupKeyValidationSignature) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bls.MsgSubmitGroupKeyValidationSignature.creator":
+ return x.Creator != ""
+ case "inference.bls.MsgSubmitGroupKeyValidationSignature.new_epoch_id":
+ return x.NewEpochId != uint64(0)
+ case "inference.bls.MsgSubmitGroupKeyValidationSignature.slot_indices":
+ return len(x.SlotIndices) != 0
+ case "inference.bls.MsgSubmitGroupKeyValidationSignature.partial_signature":
+ return len(x.PartialSignature) != 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitGroupKeyValidationSignature"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitGroupKeyValidationSignature 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_MsgSubmitGroupKeyValidationSignature) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bls.MsgSubmitGroupKeyValidationSignature.creator":
+ x.Creator = ""
+ case "inference.bls.MsgSubmitGroupKeyValidationSignature.new_epoch_id":
+ x.NewEpochId = uint64(0)
+ case "inference.bls.MsgSubmitGroupKeyValidationSignature.slot_indices":
+ x.SlotIndices = nil
+ case "inference.bls.MsgSubmitGroupKeyValidationSignature.partial_signature":
+ x.PartialSignature = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitGroupKeyValidationSignature"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitGroupKeyValidationSignature 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_MsgSubmitGroupKeyValidationSignature) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bls.MsgSubmitGroupKeyValidationSignature.creator":
+ value := x.Creator
+ return protoreflect.ValueOfString(value)
+ case "inference.bls.MsgSubmitGroupKeyValidationSignature.new_epoch_id":
+ value := x.NewEpochId
+ return protoreflect.ValueOfUint64(value)
+ case "inference.bls.MsgSubmitGroupKeyValidationSignature.slot_indices":
+ if len(x.SlotIndices) == 0 {
+ return protoreflect.ValueOfList(&_MsgSubmitGroupKeyValidationSignature_3_list{})
+ }
+ listValue := &_MsgSubmitGroupKeyValidationSignature_3_list{list: &x.SlotIndices}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.bls.MsgSubmitGroupKeyValidationSignature.partial_signature":
+ value := x.PartialSignature
+ return protoreflect.ValueOfBytes(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitGroupKeyValidationSignature"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitGroupKeyValidationSignature 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_MsgSubmitGroupKeyValidationSignature) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bls.MsgSubmitGroupKeyValidationSignature.creator":
+ x.Creator = value.Interface().(string)
+ case "inference.bls.MsgSubmitGroupKeyValidationSignature.new_epoch_id":
+ x.NewEpochId = value.Uint()
+ case "inference.bls.MsgSubmitGroupKeyValidationSignature.slot_indices":
+ lv := value.List()
+ clv := lv.(*_MsgSubmitGroupKeyValidationSignature_3_list)
+ x.SlotIndices = *clv.list
+ case "inference.bls.MsgSubmitGroupKeyValidationSignature.partial_signature":
+ x.PartialSignature = value.Bytes()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitGroupKeyValidationSignature"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitGroupKeyValidationSignature 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_MsgSubmitGroupKeyValidationSignature) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.MsgSubmitGroupKeyValidationSignature.slot_indices":
+ if x.SlotIndices == nil {
+ x.SlotIndices = []uint32{}
+ }
+ value := &_MsgSubmitGroupKeyValidationSignature_3_list{list: &x.SlotIndices}
+ return protoreflect.ValueOfList(value)
+ case "inference.bls.MsgSubmitGroupKeyValidationSignature.creator":
+ panic(fmt.Errorf("field creator of message inference.bls.MsgSubmitGroupKeyValidationSignature is not mutable"))
+ case "inference.bls.MsgSubmitGroupKeyValidationSignature.new_epoch_id":
+ panic(fmt.Errorf("field new_epoch_id of message inference.bls.MsgSubmitGroupKeyValidationSignature is not mutable"))
+ case "inference.bls.MsgSubmitGroupKeyValidationSignature.partial_signature":
+ panic(fmt.Errorf("field partial_signature of message inference.bls.MsgSubmitGroupKeyValidationSignature is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitGroupKeyValidationSignature"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitGroupKeyValidationSignature 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_MsgSubmitGroupKeyValidationSignature) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.MsgSubmitGroupKeyValidationSignature.creator":
+ return protoreflect.ValueOfString("")
+ case "inference.bls.MsgSubmitGroupKeyValidationSignature.new_epoch_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.bls.MsgSubmitGroupKeyValidationSignature.slot_indices":
+ list := []uint32{}
+ return protoreflect.ValueOfList(&_MsgSubmitGroupKeyValidationSignature_3_list{list: &list})
+ case "inference.bls.MsgSubmitGroupKeyValidationSignature.partial_signature":
+ return protoreflect.ValueOfBytes(nil)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitGroupKeyValidationSignature"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitGroupKeyValidationSignature 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_MsgSubmitGroupKeyValidationSignature) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.MsgSubmitGroupKeyValidationSignature", 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_MsgSubmitGroupKeyValidationSignature) 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_MsgSubmitGroupKeyValidationSignature) 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_MsgSubmitGroupKeyValidationSignature) 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_MsgSubmitGroupKeyValidationSignature) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*MsgSubmitGroupKeyValidationSignature)
+ 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.Creator)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.NewEpochId != 0 {
+ n += 1 + runtime.Sov(uint64(x.NewEpochId))
+ }
+ if len(x.SlotIndices) > 0 {
+ l = 0
+ for _, e := range x.SlotIndices {
+ l += runtime.Sov(uint64(e))
+ }
+ n += 1 + runtime.Sov(uint64(l)) + l
+ }
+ l = len(x.PartialSignature)
+ 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().(*MsgSubmitGroupKeyValidationSignature)
+ 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.PartialSignature) > 0 {
+ i -= len(x.PartialSignature)
+ copy(dAtA[i:], x.PartialSignature)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.PartialSignature)))
+ i--
+ dAtA[i] = 0x22
+ }
+ if len(x.SlotIndices) > 0 {
+ var pksize2 int
+ for _, num := range x.SlotIndices {
+ pksize2 += runtime.Sov(uint64(num))
+ }
+ i -= pksize2
+ j1 := i
+ for _, num := range x.SlotIndices {
+ for num >= 1<<7 {
+ dAtA[j1] = uint8(uint64(num)&0x7f | 0x80)
+ num >>= 7
+ j1++
+ }
+ dAtA[j1] = uint8(num)
+ j1++
+ }
+ i = runtime.EncodeVarint(dAtA, i, uint64(pksize2))
+ i--
+ dAtA[i] = 0x1a
+ }
+ if x.NewEpochId != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.NewEpochId))
+ 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().(*MsgSubmitGroupKeyValidationSignature)
+ 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: MsgSubmitGroupKeyValidationSignature: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitGroupKeyValidationSignature: 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)
+ }
+ 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.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 NewEpochId", wireType)
+ }
+ x.NewEpochId = 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.NewEpochId |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 3:
+ if wireType == 0 {
+ var v uint32
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.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 |= uint32(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ x.SlotIndices = append(x.SlotIndices, 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.SlotIndices) == 0 {
+ x.SlotIndices = make([]uint32, 0, elementCount)
+ }
+ for iNdEx < postIndex {
+ var v uint32
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.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 |= uint32(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ x.SlotIndices = append(x.SlotIndices, v)
+ }
+ } else {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field SlotIndices", wireType)
+ }
+ case 4:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PartialSignature", 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.PartialSignature = append(x.PartialSignature[:0], dAtA[iNdEx:postIndex]...)
+ if x.PartialSignature == nil {
+ x.PartialSignature = []byte{}
+ }
+ 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_MsgSubmitGroupKeyValidationSignatureResponse protoreflect.MessageDescriptor
+)
+
+func init() {
+ file_inference_bls_tx_proto_init()
+ md_MsgSubmitGroupKeyValidationSignatureResponse = File_inference_bls_tx_proto.Messages().ByName("MsgSubmitGroupKeyValidationSignatureResponse")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgSubmitGroupKeyValidationSignatureResponse)(nil)
+
+type fastReflection_MsgSubmitGroupKeyValidationSignatureResponse MsgSubmitGroupKeyValidationSignatureResponse
+
+func (x *MsgSubmitGroupKeyValidationSignatureResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_MsgSubmitGroupKeyValidationSignatureResponse)(x)
+}
+
+func (x *MsgSubmitGroupKeyValidationSignatureResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_tx_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_MsgSubmitGroupKeyValidationSignatureResponse_messageType fastReflection_MsgSubmitGroupKeyValidationSignatureResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgSubmitGroupKeyValidationSignatureResponse_messageType{}
+
+type fastReflection_MsgSubmitGroupKeyValidationSignatureResponse_messageType struct{}
+
+func (x fastReflection_MsgSubmitGroupKeyValidationSignatureResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_MsgSubmitGroupKeyValidationSignatureResponse)(nil)
+}
+func (x fastReflection_MsgSubmitGroupKeyValidationSignatureResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_MsgSubmitGroupKeyValidationSignatureResponse)
+}
+func (x fastReflection_MsgSubmitGroupKeyValidationSignatureResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgSubmitGroupKeyValidationSignatureResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgSubmitGroupKeyValidationSignatureResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgSubmitGroupKeyValidationSignatureResponse
+}
+
+// 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_MsgSubmitGroupKeyValidationSignatureResponse) Type() protoreflect.MessageType {
+ return _fastReflection_MsgSubmitGroupKeyValidationSignatureResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgSubmitGroupKeyValidationSignatureResponse) New() protoreflect.Message {
+ return new(fastReflection_MsgSubmitGroupKeyValidationSignatureResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgSubmitGroupKeyValidationSignatureResponse) Interface() protoreflect.ProtoMessage {
+ return (*MsgSubmitGroupKeyValidationSignatureResponse)(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_MsgSubmitGroupKeyValidationSignatureResponse) 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_MsgSubmitGroupKeyValidationSignatureResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitGroupKeyValidationSignatureResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitGroupKeyValidationSignatureResponse 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_MsgSubmitGroupKeyValidationSignatureResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitGroupKeyValidationSignatureResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitGroupKeyValidationSignatureResponse 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_MsgSubmitGroupKeyValidationSignatureResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitGroupKeyValidationSignatureResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitGroupKeyValidationSignatureResponse 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_MsgSubmitGroupKeyValidationSignatureResponse) 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.bls.MsgSubmitGroupKeyValidationSignatureResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitGroupKeyValidationSignatureResponse 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_MsgSubmitGroupKeyValidationSignatureResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitGroupKeyValidationSignatureResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitGroupKeyValidationSignatureResponse 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_MsgSubmitGroupKeyValidationSignatureResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitGroupKeyValidationSignatureResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitGroupKeyValidationSignatureResponse 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_MsgSubmitGroupKeyValidationSignatureResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.MsgSubmitGroupKeyValidationSignatureResponse", 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_MsgSubmitGroupKeyValidationSignatureResponse) 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_MsgSubmitGroupKeyValidationSignatureResponse) 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_MsgSubmitGroupKeyValidationSignatureResponse) 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_MsgSubmitGroupKeyValidationSignatureResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*MsgSubmitGroupKeyValidationSignatureResponse)
+ 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().(*MsgSubmitGroupKeyValidationSignatureResponse)
+ 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().(*MsgSubmitGroupKeyValidationSignatureResponse)
+ 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: MsgSubmitGroupKeyValidationSignatureResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitGroupKeyValidationSignatureResponse: 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 = (*_MsgSubmitPartialSignature_3_list)(nil)
+
+type _MsgSubmitPartialSignature_3_list struct {
+ list *[]uint32
+}
+
+func (x *_MsgSubmitPartialSignature_3_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_MsgSubmitPartialSignature_3_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfUint32((*x.list)[i])
+}
+
+func (x *_MsgSubmitPartialSignature_3_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Uint()
+ concreteValue := (uint32)(valueUnwrapped)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_MsgSubmitPartialSignature_3_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Uint()
+ concreteValue := (uint32)(valueUnwrapped)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_MsgSubmitPartialSignature_3_list) AppendMutable() protoreflect.Value {
+ panic(fmt.Errorf("AppendMutable can not be called on message MsgSubmitPartialSignature at list field SlotIndices as it is not of Message kind"))
+}
+
+func (x *_MsgSubmitPartialSignature_3_list) Truncate(n int) {
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_MsgSubmitPartialSignature_3_list) NewElement() protoreflect.Value {
+ v := uint32(0)
+ return protoreflect.ValueOfUint32(v)
+}
+
+func (x *_MsgSubmitPartialSignature_3_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_MsgSubmitPartialSignature protoreflect.MessageDescriptor
+ fd_MsgSubmitPartialSignature_creator protoreflect.FieldDescriptor
+ fd_MsgSubmitPartialSignature_request_id protoreflect.FieldDescriptor
+ fd_MsgSubmitPartialSignature_slot_indices protoreflect.FieldDescriptor
+ fd_MsgSubmitPartialSignature_partial_signature protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bls_tx_proto_init()
+ md_MsgSubmitPartialSignature = File_inference_bls_tx_proto.Messages().ByName("MsgSubmitPartialSignature")
+ fd_MsgSubmitPartialSignature_creator = md_MsgSubmitPartialSignature.Fields().ByName("creator")
+ fd_MsgSubmitPartialSignature_request_id = md_MsgSubmitPartialSignature.Fields().ByName("request_id")
+ fd_MsgSubmitPartialSignature_slot_indices = md_MsgSubmitPartialSignature.Fields().ByName("slot_indices")
+ fd_MsgSubmitPartialSignature_partial_signature = md_MsgSubmitPartialSignature.Fields().ByName("partial_signature")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgSubmitPartialSignature)(nil)
+
+type fastReflection_MsgSubmitPartialSignature MsgSubmitPartialSignature
+
+func (x *MsgSubmitPartialSignature) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_MsgSubmitPartialSignature)(x)
+}
+
+func (x *MsgSubmitPartialSignature) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_tx_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_MsgSubmitPartialSignature_messageType fastReflection_MsgSubmitPartialSignature_messageType
+var _ protoreflect.MessageType = fastReflection_MsgSubmitPartialSignature_messageType{}
+
+type fastReflection_MsgSubmitPartialSignature_messageType struct{}
+
+func (x fastReflection_MsgSubmitPartialSignature_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_MsgSubmitPartialSignature)(nil)
+}
+func (x fastReflection_MsgSubmitPartialSignature_messageType) New() protoreflect.Message {
+ return new(fastReflection_MsgSubmitPartialSignature)
+}
+func (x fastReflection_MsgSubmitPartialSignature_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgSubmitPartialSignature
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgSubmitPartialSignature) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgSubmitPartialSignature
+}
+
+// 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_MsgSubmitPartialSignature) Type() protoreflect.MessageType {
+ return _fastReflection_MsgSubmitPartialSignature_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgSubmitPartialSignature) New() protoreflect.Message {
+ return new(fastReflection_MsgSubmitPartialSignature)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgSubmitPartialSignature) Interface() protoreflect.ProtoMessage {
+ return (*MsgSubmitPartialSignature)(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_MsgSubmitPartialSignature) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Creator != "" {
+ value := protoreflect.ValueOfString(x.Creator)
+ if !f(fd_MsgSubmitPartialSignature_creator, value) {
+ return
+ }
+ }
+ if len(x.RequestId) != 0 {
+ value := protoreflect.ValueOfBytes(x.RequestId)
+ if !f(fd_MsgSubmitPartialSignature_request_id, value) {
+ return
+ }
+ }
+ if len(x.SlotIndices) != 0 {
+ value := protoreflect.ValueOfList(&_MsgSubmitPartialSignature_3_list{list: &x.SlotIndices})
+ if !f(fd_MsgSubmitPartialSignature_slot_indices, value) {
+ return
+ }
+ }
+ if len(x.PartialSignature) != 0 {
+ value := protoreflect.ValueOfBytes(x.PartialSignature)
+ if !f(fd_MsgSubmitPartialSignature_partial_signature, 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_MsgSubmitPartialSignature) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bls.MsgSubmitPartialSignature.creator":
+ return x.Creator != ""
+ case "inference.bls.MsgSubmitPartialSignature.request_id":
+ return len(x.RequestId) != 0
+ case "inference.bls.MsgSubmitPartialSignature.slot_indices":
+ return len(x.SlotIndices) != 0
+ case "inference.bls.MsgSubmitPartialSignature.partial_signature":
+ return len(x.PartialSignature) != 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitPartialSignature"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitPartialSignature 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_MsgSubmitPartialSignature) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bls.MsgSubmitPartialSignature.creator":
+ x.Creator = ""
+ case "inference.bls.MsgSubmitPartialSignature.request_id":
+ x.RequestId = nil
+ case "inference.bls.MsgSubmitPartialSignature.slot_indices":
+ x.SlotIndices = nil
+ case "inference.bls.MsgSubmitPartialSignature.partial_signature":
+ x.PartialSignature = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitPartialSignature"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitPartialSignature 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_MsgSubmitPartialSignature) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bls.MsgSubmitPartialSignature.creator":
+ value := x.Creator
+ return protoreflect.ValueOfString(value)
+ case "inference.bls.MsgSubmitPartialSignature.request_id":
+ value := x.RequestId
+ return protoreflect.ValueOfBytes(value)
+ case "inference.bls.MsgSubmitPartialSignature.slot_indices":
+ if len(x.SlotIndices) == 0 {
+ return protoreflect.ValueOfList(&_MsgSubmitPartialSignature_3_list{})
+ }
+ listValue := &_MsgSubmitPartialSignature_3_list{list: &x.SlotIndices}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.bls.MsgSubmitPartialSignature.partial_signature":
+ value := x.PartialSignature
+ return protoreflect.ValueOfBytes(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitPartialSignature"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitPartialSignature 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_MsgSubmitPartialSignature) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bls.MsgSubmitPartialSignature.creator":
+ x.Creator = value.Interface().(string)
+ case "inference.bls.MsgSubmitPartialSignature.request_id":
+ x.RequestId = value.Bytes()
+ case "inference.bls.MsgSubmitPartialSignature.slot_indices":
+ lv := value.List()
+ clv := lv.(*_MsgSubmitPartialSignature_3_list)
+ x.SlotIndices = *clv.list
+ case "inference.bls.MsgSubmitPartialSignature.partial_signature":
+ x.PartialSignature = value.Bytes()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitPartialSignature"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitPartialSignature 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_MsgSubmitPartialSignature) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.MsgSubmitPartialSignature.slot_indices":
+ if x.SlotIndices == nil {
+ x.SlotIndices = []uint32{}
+ }
+ value := &_MsgSubmitPartialSignature_3_list{list: &x.SlotIndices}
+ return protoreflect.ValueOfList(value)
+ case "inference.bls.MsgSubmitPartialSignature.creator":
+ panic(fmt.Errorf("field creator of message inference.bls.MsgSubmitPartialSignature is not mutable"))
+ case "inference.bls.MsgSubmitPartialSignature.request_id":
+ panic(fmt.Errorf("field request_id of message inference.bls.MsgSubmitPartialSignature is not mutable"))
+ case "inference.bls.MsgSubmitPartialSignature.partial_signature":
+ panic(fmt.Errorf("field partial_signature of message inference.bls.MsgSubmitPartialSignature is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitPartialSignature"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitPartialSignature 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_MsgSubmitPartialSignature) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.MsgSubmitPartialSignature.creator":
+ return protoreflect.ValueOfString("")
+ case "inference.bls.MsgSubmitPartialSignature.request_id":
+ return protoreflect.ValueOfBytes(nil)
+ case "inference.bls.MsgSubmitPartialSignature.slot_indices":
+ list := []uint32{}
+ return protoreflect.ValueOfList(&_MsgSubmitPartialSignature_3_list{list: &list})
+ case "inference.bls.MsgSubmitPartialSignature.partial_signature":
+ return protoreflect.ValueOfBytes(nil)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitPartialSignature"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitPartialSignature 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_MsgSubmitPartialSignature) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.MsgSubmitPartialSignature", 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_MsgSubmitPartialSignature) 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_MsgSubmitPartialSignature) 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_MsgSubmitPartialSignature) 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_MsgSubmitPartialSignature) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*MsgSubmitPartialSignature)
+ 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.Creator)
+ 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 len(x.SlotIndices) > 0 {
+ l = 0
+ for _, e := range x.SlotIndices {
+ l += runtime.Sov(uint64(e))
+ }
+ n += 1 + runtime.Sov(uint64(l)) + l
+ }
+ l = len(x.PartialSignature)
+ 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().(*MsgSubmitPartialSignature)
+ 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.PartialSignature) > 0 {
+ i -= len(x.PartialSignature)
+ copy(dAtA[i:], x.PartialSignature)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.PartialSignature)))
+ i--
+ dAtA[i] = 0x22
+ }
+ if len(x.SlotIndices) > 0 {
+ var pksize2 int
+ for _, num := range x.SlotIndices {
+ pksize2 += runtime.Sov(uint64(num))
+ }
+ i -= pksize2
+ j1 := i
+ for _, num := range x.SlotIndices {
+ for num >= 1<<7 {
+ dAtA[j1] = uint8(uint64(num)&0x7f | 0x80)
+ num >>= 7
+ j1++
+ }
+ dAtA[j1] = uint8(num)
+ j1++
+ }
+ i = runtime.EncodeVarint(dAtA, i, uint64(pksize2))
+ 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)))
+ 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)))
+ 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().(*MsgSubmitPartialSignature)
+ 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: MsgSubmitPartialSignature: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitPartialSignature: 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)
+ }
+ 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.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 RequestId", 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.RequestId = append(x.RequestId[:0], dAtA[iNdEx:postIndex]...)
+ if x.RequestId == nil {
+ x.RequestId = []byte{}
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType == 0 {
+ var v uint32
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.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 |= uint32(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ x.SlotIndices = append(x.SlotIndices, 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.SlotIndices) == 0 {
+ x.SlotIndices = make([]uint32, 0, elementCount)
+ }
+ for iNdEx < postIndex {
+ var v uint32
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.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 |= uint32(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ x.SlotIndices = append(x.SlotIndices, v)
+ }
+ } else {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field SlotIndices", wireType)
+ }
+ case 4:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PartialSignature", 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.PartialSignature = append(x.PartialSignature[:0], dAtA[iNdEx:postIndex]...)
+ if x.PartialSignature == nil {
+ x.PartialSignature = []byte{}
+ }
+ 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_MsgSubmitPartialSignatureResponse protoreflect.MessageDescriptor
+)
+
+func init() {
+ file_inference_bls_tx_proto_init()
+ md_MsgSubmitPartialSignatureResponse = File_inference_bls_tx_proto.Messages().ByName("MsgSubmitPartialSignatureResponse")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgSubmitPartialSignatureResponse)(nil)
+
+type fastReflection_MsgSubmitPartialSignatureResponse MsgSubmitPartialSignatureResponse
+
+func (x *MsgSubmitPartialSignatureResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_MsgSubmitPartialSignatureResponse)(x)
+}
+
+func (x *MsgSubmitPartialSignatureResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_tx_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_MsgSubmitPartialSignatureResponse_messageType fastReflection_MsgSubmitPartialSignatureResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgSubmitPartialSignatureResponse_messageType{}
+
+type fastReflection_MsgSubmitPartialSignatureResponse_messageType struct{}
+
+func (x fastReflection_MsgSubmitPartialSignatureResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_MsgSubmitPartialSignatureResponse)(nil)
+}
+func (x fastReflection_MsgSubmitPartialSignatureResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_MsgSubmitPartialSignatureResponse)
+}
+func (x fastReflection_MsgSubmitPartialSignatureResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgSubmitPartialSignatureResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgSubmitPartialSignatureResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgSubmitPartialSignatureResponse
+}
+
+// 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_MsgSubmitPartialSignatureResponse) Type() protoreflect.MessageType {
+ return _fastReflection_MsgSubmitPartialSignatureResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgSubmitPartialSignatureResponse) New() protoreflect.Message {
+ return new(fastReflection_MsgSubmitPartialSignatureResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgSubmitPartialSignatureResponse) Interface() protoreflect.ProtoMessage {
+ return (*MsgSubmitPartialSignatureResponse)(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_MsgSubmitPartialSignatureResponse) 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_MsgSubmitPartialSignatureResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitPartialSignatureResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitPartialSignatureResponse 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_MsgSubmitPartialSignatureResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitPartialSignatureResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitPartialSignatureResponse 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_MsgSubmitPartialSignatureResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitPartialSignatureResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitPartialSignatureResponse 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_MsgSubmitPartialSignatureResponse) 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.bls.MsgSubmitPartialSignatureResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitPartialSignatureResponse 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_MsgSubmitPartialSignatureResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitPartialSignatureResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitPartialSignatureResponse 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_MsgSubmitPartialSignatureResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgSubmitPartialSignatureResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgSubmitPartialSignatureResponse 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_MsgSubmitPartialSignatureResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.MsgSubmitPartialSignatureResponse", 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_MsgSubmitPartialSignatureResponse) 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_MsgSubmitPartialSignatureResponse) 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_MsgSubmitPartialSignatureResponse) 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_MsgSubmitPartialSignatureResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*MsgSubmitPartialSignatureResponse)
+ 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().(*MsgSubmitPartialSignatureResponse)
+ 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().(*MsgSubmitPartialSignatureResponse)
+ 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: MsgSubmitPartialSignatureResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitPartialSignatureResponse: 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 = (*_MsgRequestThresholdSignature_5_list)(nil)
+
+type _MsgRequestThresholdSignature_5_list struct {
+ list *[][]byte
+}
+
+func (x *_MsgRequestThresholdSignature_5_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_MsgRequestThresholdSignature_5_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfBytes((*x.list)[i])
+}
+
+func (x *_MsgRequestThresholdSignature_5_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Bytes()
+ concreteValue := valueUnwrapped
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_MsgRequestThresholdSignature_5_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Bytes()
+ concreteValue := valueUnwrapped
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_MsgRequestThresholdSignature_5_list) AppendMutable() protoreflect.Value {
+ panic(fmt.Errorf("AppendMutable can not be called on message MsgRequestThresholdSignature at list field Data as it is not of Message kind"))
+}
+
+func (x *_MsgRequestThresholdSignature_5_list) Truncate(n int) {
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_MsgRequestThresholdSignature_5_list) NewElement() protoreflect.Value {
+ var v []byte
+ return protoreflect.ValueOfBytes(v)
+}
+
+func (x *_MsgRequestThresholdSignature_5_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_MsgRequestThresholdSignature protoreflect.MessageDescriptor
+ fd_MsgRequestThresholdSignature_creator protoreflect.FieldDescriptor
+ fd_MsgRequestThresholdSignature_current_epoch_id protoreflect.FieldDescriptor
+ fd_MsgRequestThresholdSignature_chain_id protoreflect.FieldDescriptor
+ fd_MsgRequestThresholdSignature_request_id protoreflect.FieldDescriptor
+ fd_MsgRequestThresholdSignature_data protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bls_tx_proto_init()
+ md_MsgRequestThresholdSignature = File_inference_bls_tx_proto.Messages().ByName("MsgRequestThresholdSignature")
+ fd_MsgRequestThresholdSignature_creator = md_MsgRequestThresholdSignature.Fields().ByName("creator")
+ fd_MsgRequestThresholdSignature_current_epoch_id = md_MsgRequestThresholdSignature.Fields().ByName("current_epoch_id")
+ fd_MsgRequestThresholdSignature_chain_id = md_MsgRequestThresholdSignature.Fields().ByName("chain_id")
+ fd_MsgRequestThresholdSignature_request_id = md_MsgRequestThresholdSignature.Fields().ByName("request_id")
+ fd_MsgRequestThresholdSignature_data = md_MsgRequestThresholdSignature.Fields().ByName("data")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgRequestThresholdSignature)(nil)
+
+type fastReflection_MsgRequestThresholdSignature MsgRequestThresholdSignature
+
+func (x *MsgRequestThresholdSignature) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_MsgRequestThresholdSignature)(x)
+}
+
+func (x *MsgRequestThresholdSignature) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_tx_proto_msgTypes[10]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_MsgRequestThresholdSignature_messageType fastReflection_MsgRequestThresholdSignature_messageType
+var _ protoreflect.MessageType = fastReflection_MsgRequestThresholdSignature_messageType{}
+
+type fastReflection_MsgRequestThresholdSignature_messageType struct{}
+
+func (x fastReflection_MsgRequestThresholdSignature_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_MsgRequestThresholdSignature)(nil)
+}
+func (x fastReflection_MsgRequestThresholdSignature_messageType) New() protoreflect.Message {
+ return new(fastReflection_MsgRequestThresholdSignature)
+}
+func (x fastReflection_MsgRequestThresholdSignature_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgRequestThresholdSignature
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgRequestThresholdSignature) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgRequestThresholdSignature
+}
+
+// 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_MsgRequestThresholdSignature) Type() protoreflect.MessageType {
+ return _fastReflection_MsgRequestThresholdSignature_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgRequestThresholdSignature) New() protoreflect.Message {
+ return new(fastReflection_MsgRequestThresholdSignature)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgRequestThresholdSignature) Interface() protoreflect.ProtoMessage {
+ return (*MsgRequestThresholdSignature)(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_MsgRequestThresholdSignature) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Creator != "" {
+ value := protoreflect.ValueOfString(x.Creator)
+ if !f(fd_MsgRequestThresholdSignature_creator, value) {
+ return
+ }
+ }
+ if x.CurrentEpochId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.CurrentEpochId)
+ if !f(fd_MsgRequestThresholdSignature_current_epoch_id, value) {
+ return
+ }
+ }
+ if len(x.ChainId) != 0 {
+ value := protoreflect.ValueOfBytes(x.ChainId)
+ if !f(fd_MsgRequestThresholdSignature_chain_id, value) {
+ return
+ }
+ }
+ if len(x.RequestId) != 0 {
+ value := protoreflect.ValueOfBytes(x.RequestId)
+ if !f(fd_MsgRequestThresholdSignature_request_id, value) {
+ return
+ }
+ }
+ if len(x.Data) != 0 {
+ value := protoreflect.ValueOfList(&_MsgRequestThresholdSignature_5_list{list: &x.Data})
+ if !f(fd_MsgRequestThresholdSignature_data, 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_MsgRequestThresholdSignature) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bls.MsgRequestThresholdSignature.creator":
+ return x.Creator != ""
+ case "inference.bls.MsgRequestThresholdSignature.current_epoch_id":
+ return x.CurrentEpochId != uint64(0)
+ case "inference.bls.MsgRequestThresholdSignature.chain_id":
+ return len(x.ChainId) != 0
+ case "inference.bls.MsgRequestThresholdSignature.request_id":
+ return len(x.RequestId) != 0
+ case "inference.bls.MsgRequestThresholdSignature.data":
+ return len(x.Data) != 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgRequestThresholdSignature"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgRequestThresholdSignature 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_MsgRequestThresholdSignature) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bls.MsgRequestThresholdSignature.creator":
+ x.Creator = ""
+ case "inference.bls.MsgRequestThresholdSignature.current_epoch_id":
+ x.CurrentEpochId = uint64(0)
+ case "inference.bls.MsgRequestThresholdSignature.chain_id":
+ x.ChainId = nil
+ case "inference.bls.MsgRequestThresholdSignature.request_id":
+ x.RequestId = nil
+ case "inference.bls.MsgRequestThresholdSignature.data":
+ x.Data = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgRequestThresholdSignature"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgRequestThresholdSignature 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_MsgRequestThresholdSignature) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bls.MsgRequestThresholdSignature.creator":
+ value := x.Creator
+ return protoreflect.ValueOfString(value)
+ case "inference.bls.MsgRequestThresholdSignature.current_epoch_id":
+ value := x.CurrentEpochId
+ return protoreflect.ValueOfUint64(value)
+ case "inference.bls.MsgRequestThresholdSignature.chain_id":
+ value := x.ChainId
+ return protoreflect.ValueOfBytes(value)
+ case "inference.bls.MsgRequestThresholdSignature.request_id":
+ value := x.RequestId
+ return protoreflect.ValueOfBytes(value)
+ case "inference.bls.MsgRequestThresholdSignature.data":
+ if len(x.Data) == 0 {
+ return protoreflect.ValueOfList(&_MsgRequestThresholdSignature_5_list{})
+ }
+ listValue := &_MsgRequestThresholdSignature_5_list{list: &x.Data}
+ return protoreflect.ValueOfList(listValue)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgRequestThresholdSignature"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgRequestThresholdSignature 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_MsgRequestThresholdSignature) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bls.MsgRequestThresholdSignature.creator":
+ x.Creator = value.Interface().(string)
+ case "inference.bls.MsgRequestThresholdSignature.current_epoch_id":
+ x.CurrentEpochId = value.Uint()
+ case "inference.bls.MsgRequestThresholdSignature.chain_id":
+ x.ChainId = value.Bytes()
+ case "inference.bls.MsgRequestThresholdSignature.request_id":
+ x.RequestId = value.Bytes()
+ case "inference.bls.MsgRequestThresholdSignature.data":
+ lv := value.List()
+ clv := lv.(*_MsgRequestThresholdSignature_5_list)
+ x.Data = *clv.list
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgRequestThresholdSignature"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgRequestThresholdSignature 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_MsgRequestThresholdSignature) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.MsgRequestThresholdSignature.data":
+ if x.Data == nil {
+ x.Data = [][]byte{}
+ }
+ value := &_MsgRequestThresholdSignature_5_list{list: &x.Data}
+ return protoreflect.ValueOfList(value)
+ case "inference.bls.MsgRequestThresholdSignature.creator":
+ panic(fmt.Errorf("field creator of message inference.bls.MsgRequestThresholdSignature is not mutable"))
+ case "inference.bls.MsgRequestThresholdSignature.current_epoch_id":
+ panic(fmt.Errorf("field current_epoch_id of message inference.bls.MsgRequestThresholdSignature is not mutable"))
+ case "inference.bls.MsgRequestThresholdSignature.chain_id":
+ panic(fmt.Errorf("field chain_id of message inference.bls.MsgRequestThresholdSignature is not mutable"))
+ case "inference.bls.MsgRequestThresholdSignature.request_id":
+ panic(fmt.Errorf("field request_id of message inference.bls.MsgRequestThresholdSignature is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgRequestThresholdSignature"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgRequestThresholdSignature 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_MsgRequestThresholdSignature) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.MsgRequestThresholdSignature.creator":
+ return protoreflect.ValueOfString("")
+ case "inference.bls.MsgRequestThresholdSignature.current_epoch_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.bls.MsgRequestThresholdSignature.chain_id":
+ return protoreflect.ValueOfBytes(nil)
+ case "inference.bls.MsgRequestThresholdSignature.request_id":
+ return protoreflect.ValueOfBytes(nil)
+ case "inference.bls.MsgRequestThresholdSignature.data":
+ list := [][]byte{}
+ return protoreflect.ValueOfList(&_MsgRequestThresholdSignature_5_list{list: &list})
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgRequestThresholdSignature"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgRequestThresholdSignature 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_MsgRequestThresholdSignature) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.MsgRequestThresholdSignature", 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_MsgRequestThresholdSignature) 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_MsgRequestThresholdSignature) 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_MsgRequestThresholdSignature) 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_MsgRequestThresholdSignature) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*MsgRequestThresholdSignature)
+ 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.Creator)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.CurrentEpochId != 0 {
+ n += 1 + runtime.Sov(uint64(x.CurrentEpochId))
+ }
+ l = len(x.ChainId)
+ 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 len(x.Data) > 0 {
+ for _, b := range x.Data {
+ l = len(b)
+ 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().(*MsgRequestThresholdSignature)
+ 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.Data) > 0 {
+ for iNdEx := len(x.Data) - 1; iNdEx >= 0; iNdEx-- {
+ i -= len(x.Data[iNdEx])
+ copy(dAtA[i:], x.Data[iNdEx])
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Data[iNdEx])))
+ i--
+ dAtA[i] = 0x2a
+ }
+ }
+ 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] = 0x22
+ }
+ 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] = 0x1a
+ }
+ if x.CurrentEpochId != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.CurrentEpochId))
+ 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().(*MsgRequestThresholdSignature)
+ 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: MsgRequestThresholdSignature: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRequestThresholdSignature: 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)
+ }
+ 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.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 CurrentEpochId", wireType)
+ }
+ x.CurrentEpochId = 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.CurrentEpochId |= 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 ChainId", 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.ChainId = append(x.ChainId[:0], dAtA[iNdEx:postIndex]...)
+ if x.ChainId == nil {
+ x.ChainId = []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 RequestId", 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.RequestId = append(x.RequestId[:0], dAtA[iNdEx:postIndex]...)
+ if x.RequestId == nil {
+ x.RequestId = []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 Data", 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.Data = append(x.Data, make([]byte, postIndex-iNdEx))
+ copy(x.Data[len(x.Data)-1], 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_MsgRequestThresholdSignatureResponse protoreflect.MessageDescriptor
+)
+
+func init() {
+ file_inference_bls_tx_proto_init()
+ md_MsgRequestThresholdSignatureResponse = File_inference_bls_tx_proto.Messages().ByName("MsgRequestThresholdSignatureResponse")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgRequestThresholdSignatureResponse)(nil)
+
+type fastReflection_MsgRequestThresholdSignatureResponse MsgRequestThresholdSignatureResponse
+
+func (x *MsgRequestThresholdSignatureResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_MsgRequestThresholdSignatureResponse)(x)
+}
+
+func (x *MsgRequestThresholdSignatureResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_tx_proto_msgTypes[11]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_MsgRequestThresholdSignatureResponse_messageType fastReflection_MsgRequestThresholdSignatureResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgRequestThresholdSignatureResponse_messageType{}
+
+type fastReflection_MsgRequestThresholdSignatureResponse_messageType struct{}
+
+func (x fastReflection_MsgRequestThresholdSignatureResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_MsgRequestThresholdSignatureResponse)(nil)
+}
+func (x fastReflection_MsgRequestThresholdSignatureResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_MsgRequestThresholdSignatureResponse)
+}
+func (x fastReflection_MsgRequestThresholdSignatureResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgRequestThresholdSignatureResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgRequestThresholdSignatureResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgRequestThresholdSignatureResponse
+}
+
+// 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_MsgRequestThresholdSignatureResponse) Type() protoreflect.MessageType {
+ return _fastReflection_MsgRequestThresholdSignatureResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgRequestThresholdSignatureResponse) New() protoreflect.Message {
+ return new(fastReflection_MsgRequestThresholdSignatureResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgRequestThresholdSignatureResponse) Interface() protoreflect.ProtoMessage {
+ return (*MsgRequestThresholdSignatureResponse)(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_MsgRequestThresholdSignatureResponse) 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_MsgRequestThresholdSignatureResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgRequestThresholdSignatureResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgRequestThresholdSignatureResponse 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_MsgRequestThresholdSignatureResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgRequestThresholdSignatureResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgRequestThresholdSignatureResponse 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_MsgRequestThresholdSignatureResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgRequestThresholdSignatureResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgRequestThresholdSignatureResponse 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_MsgRequestThresholdSignatureResponse) 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.bls.MsgRequestThresholdSignatureResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgRequestThresholdSignatureResponse 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_MsgRequestThresholdSignatureResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgRequestThresholdSignatureResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgRequestThresholdSignatureResponse 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_MsgRequestThresholdSignatureResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.MsgRequestThresholdSignatureResponse"))
+ }
+ panic(fmt.Errorf("message inference.bls.MsgRequestThresholdSignatureResponse 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_MsgRequestThresholdSignatureResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.MsgRequestThresholdSignatureResponse", 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_MsgRequestThresholdSignatureResponse) 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_MsgRequestThresholdSignatureResponse) 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_MsgRequestThresholdSignatureResponse) 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_MsgRequestThresholdSignatureResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*MsgRequestThresholdSignatureResponse)
+ 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().(*MsgRequestThresholdSignatureResponse)
+ 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().(*MsgRequestThresholdSignatureResponse)
+ 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: MsgRequestThresholdSignatureResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRequestThresholdSignatureResponse: 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,
+ }
+}
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// protoc-gen-go v1.27.0
+// protoc (unknown)
+// source: inference/bls/tx.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)
+)
+
+// MsgUpdateParams is the Msg/UpdateParams request type.
+type MsgUpdateParams struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // authority is the address that controls the module (defaults to x/gov unless overwritten).
+ Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"`
+ // params defines the module parameters to update.
+ //
+ // NOTE: All parameters must be supplied.
+ Params *Params `protobuf:"bytes,2,opt,name=params,proto3" json:"params,omitempty"`
+}
+
+func (x *MsgUpdateParams) Reset() {
+ *x = MsgUpdateParams{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_tx_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *MsgUpdateParams) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgUpdateParams) ProtoMessage() {}
+
+// Deprecated: Use MsgUpdateParams.ProtoReflect.Descriptor instead.
+func (*MsgUpdateParams) Descriptor() ([]byte, []int) {
+ return file_inference_bls_tx_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *MsgUpdateParams) GetAuthority() string {
+ if x != nil {
+ return x.Authority
+ }
+ return ""
+}
+
+func (x *MsgUpdateParams) GetParams() *Params {
+ if x != nil {
+ return x.Params
+ }
+ return nil
+}
+
+// MsgUpdateParamsResponse defines the response structure for executing a
+// MsgUpdateParams message.
+type MsgUpdateParamsResponse struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+}
+
+func (x *MsgUpdateParamsResponse) Reset() {
+ *x = MsgUpdateParamsResponse{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_tx_proto_msgTypes[1]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *MsgUpdateParamsResponse) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgUpdateParamsResponse) ProtoMessage() {}
+
+// Deprecated: Use MsgUpdateParamsResponse.ProtoReflect.Descriptor instead.
+func (*MsgUpdateParamsResponse) Descriptor() ([]byte, []int) {
+ return file_inference_bls_tx_proto_rawDescGZIP(), []int{1}
+}
+
+// MsgSubmitDealerPart is the message for submitting dealer parts during the dealing phase
+type MsgSubmitDealerPart struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // creator is the address of the dealer submitting their part
+ Creator string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
+ // epoch_id identifies the DKG round this dealer part belongs to
+ EpochId uint64 `protobuf:"varint,2,opt,name=epoch_id,json=epochId,proto3" json:"epoch_id,omitempty"`
+ // commitments are the G2 points C_kj = g * a_kj representing polynomial commitments
+ Commitments [][]byte `protobuf:"bytes,3,rep,name=commitments,proto3" json:"commitments,omitempty"`
+ // encrypted_shares_for_participants contains encrypted shares for all participants in order
+ // Index i = shares for EpochBLSData.participants[i]
+ EncryptedSharesForParticipants []*EncryptedSharesForParticipant `protobuf:"bytes,4,rep,name=encrypted_shares_for_participants,json=encryptedSharesForParticipants,proto3" json:"encrypted_shares_for_participants,omitempty"`
+}
+
+func (x *MsgSubmitDealerPart) Reset() {
+ *x = MsgSubmitDealerPart{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_tx_proto_msgTypes[2]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *MsgSubmitDealerPart) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgSubmitDealerPart) ProtoMessage() {}
+
+// Deprecated: Use MsgSubmitDealerPart.ProtoReflect.Descriptor instead.
+func (*MsgSubmitDealerPart) Descriptor() ([]byte, []int) {
+ return file_inference_bls_tx_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *MsgSubmitDealerPart) GetCreator() string {
+ if x != nil {
+ return x.Creator
+ }
+ return ""
+}
+
+func (x *MsgSubmitDealerPart) GetEpochId() uint64 {
+ if x != nil {
+ return x.EpochId
+ }
+ return 0
+}
+
+func (x *MsgSubmitDealerPart) GetCommitments() [][]byte {
+ if x != nil {
+ return x.Commitments
+ }
+ return nil
+}
+
+func (x *MsgSubmitDealerPart) GetEncryptedSharesForParticipants() []*EncryptedSharesForParticipant {
+ if x != nil {
+ return x.EncryptedSharesForParticipants
+ }
+ return nil
+}
+
+// MsgSubmitDealerPartResponse defines the response structure for executing a
+// MsgSubmitDealerPart message.
+type MsgSubmitDealerPartResponse struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+}
+
+func (x *MsgSubmitDealerPartResponse) Reset() {
+ *x = MsgSubmitDealerPartResponse{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_tx_proto_msgTypes[3]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *MsgSubmitDealerPartResponse) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgSubmitDealerPartResponse) ProtoMessage() {}
+
+// Deprecated: Use MsgSubmitDealerPartResponse.ProtoReflect.Descriptor instead.
+func (*MsgSubmitDealerPartResponse) Descriptor() ([]byte, []int) {
+ return file_inference_bls_tx_proto_rawDescGZIP(), []int{3}
+}
+
+// MsgSubmitVerificationVector is the message for confirming verification completion during the verifying phase
+type MsgSubmitVerificationVector struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // creator is the address of the participant confirming verification completion
+ Creator string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
+ // epoch_id identifies the DKG round this verification confirmation belongs to
+ EpochId uint64 `protobuf:"varint,2,opt,name=epoch_id,json=epochId,proto3" json:"epoch_id,omitempty"`
+ // dealer_validity is a bitmap indicating which dealers provided valid shares
+ // Index i corresponds to EpochBLSData.participants[i] as dealer
+ // true = dealer's shares verified correctly against their commitments
+ // false = dealer's shares failed verification or dealer didn't submit
+ DealerValidity []bool `protobuf:"varint,3,rep,packed,name=dealer_validity,json=dealerValidity,proto3" json:"dealer_validity,omitempty"`
+}
+
+func (x *MsgSubmitVerificationVector) Reset() {
+ *x = MsgSubmitVerificationVector{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_tx_proto_msgTypes[4]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *MsgSubmitVerificationVector) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgSubmitVerificationVector) ProtoMessage() {}
+
+// Deprecated: Use MsgSubmitVerificationVector.ProtoReflect.Descriptor instead.
+func (*MsgSubmitVerificationVector) Descriptor() ([]byte, []int) {
+ return file_inference_bls_tx_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *MsgSubmitVerificationVector) GetCreator() string {
+ if x != nil {
+ return x.Creator
+ }
+ return ""
+}
+
+func (x *MsgSubmitVerificationVector) GetEpochId() uint64 {
+ if x != nil {
+ return x.EpochId
+ }
+ return 0
+}
+
+func (x *MsgSubmitVerificationVector) GetDealerValidity() []bool {
+ if x != nil {
+ return x.DealerValidity
+ }
+ return nil
+}
+
+// MsgSubmitVerificationVectorResponse defines the response structure for executing a
+// MsgSubmitVerificationVector message.
+type MsgSubmitVerificationVectorResponse struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+}
+
+func (x *MsgSubmitVerificationVectorResponse) Reset() {
+ *x = MsgSubmitVerificationVectorResponse{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_tx_proto_msgTypes[5]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *MsgSubmitVerificationVectorResponse) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgSubmitVerificationVectorResponse) ProtoMessage() {}
+
+// Deprecated: Use MsgSubmitVerificationVectorResponse.ProtoReflect.Descriptor instead.
+func (*MsgSubmitVerificationVectorResponse) Descriptor() ([]byte, []int) {
+ return file_inference_bls_tx_proto_rawDescGZIP(), []int{5}
+}
+
+// MsgSubmitGroupKeyValidationSignature is the message for submitting partial signatures for group key validation
+type MsgSubmitGroupKeyValidationSignature struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // creator is the address of the participant submitting their partial signature
+ Creator string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
+ // new_epoch_id identifies the epoch whose group public key is being validated
+ NewEpochId uint64 `protobuf:"varint,2,opt,name=new_epoch_id,json=newEpochId,proto3" json:"new_epoch_id,omitempty"`
+ // slot_indices are the slot indices this participant is signing for (from their previous epoch assignment)
+ SlotIndices []uint32 `protobuf:"varint,3,rep,packed,name=slot_indices,json=slotIndices,proto3" json:"slot_indices,omitempty"`
+ // partial_signature is the BLS partial signature (G1 point, 48-byte compressed format)
+ PartialSignature []byte `protobuf:"bytes,4,opt,name=partial_signature,json=partialSignature,proto3" json:"partial_signature,omitempty"`
+}
+
+func (x *MsgSubmitGroupKeyValidationSignature) Reset() {
+ *x = MsgSubmitGroupKeyValidationSignature{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_tx_proto_msgTypes[6]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *MsgSubmitGroupKeyValidationSignature) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgSubmitGroupKeyValidationSignature) ProtoMessage() {}
+
+// Deprecated: Use MsgSubmitGroupKeyValidationSignature.ProtoReflect.Descriptor instead.
+func (*MsgSubmitGroupKeyValidationSignature) Descriptor() ([]byte, []int) {
+ return file_inference_bls_tx_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *MsgSubmitGroupKeyValidationSignature) GetCreator() string {
+ if x != nil {
+ return x.Creator
+ }
+ return ""
+}
+
+func (x *MsgSubmitGroupKeyValidationSignature) GetNewEpochId() uint64 {
+ if x != nil {
+ return x.NewEpochId
+ }
+ return 0
+}
+
+func (x *MsgSubmitGroupKeyValidationSignature) GetSlotIndices() []uint32 {
+ if x != nil {
+ return x.SlotIndices
+ }
+ return nil
+}
+
+func (x *MsgSubmitGroupKeyValidationSignature) GetPartialSignature() []byte {
+ if x != nil {
+ return x.PartialSignature
+ }
+ return nil
+}
+
+// MsgSubmitGroupKeyValidationSignatureResponse defines the response structure for executing a
+// MsgSubmitGroupKeyValidationSignature message.
+type MsgSubmitGroupKeyValidationSignatureResponse struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+}
+
+func (x *MsgSubmitGroupKeyValidationSignatureResponse) Reset() {
+ *x = MsgSubmitGroupKeyValidationSignatureResponse{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_tx_proto_msgTypes[7]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *MsgSubmitGroupKeyValidationSignatureResponse) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgSubmitGroupKeyValidationSignatureResponse) ProtoMessage() {}
+
+// Deprecated: Use MsgSubmitGroupKeyValidationSignatureResponse.ProtoReflect.Descriptor instead.
+func (*MsgSubmitGroupKeyValidationSignatureResponse) Descriptor() ([]byte, []int) {
+ return file_inference_bls_tx_proto_rawDescGZIP(), []int{7}
+}
+
+// MsgSubmitPartialSignature is the message for submitting partial signatures for threshold signing
+type MsgSubmitPartialSignature struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // creator is the address of the participant submitting their partial signature
+ Creator string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
+ // request_id identifies the threshold signing request this partial signature is for
+ RequestId []byte `protobuf:"bytes,2,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`
+ // slot_indices are the slot indices this participant is signing for (from their current epoch assignment)
+ SlotIndices []uint32 `protobuf:"varint,3,rep,packed,name=slot_indices,json=slotIndices,proto3" json:"slot_indices,omitempty"`
+ // partial_signature is the aggregated BLS partial signature for all participant's slots (G1 point, 48-byte compressed format)
+ PartialSignature []byte `protobuf:"bytes,4,opt,name=partial_signature,json=partialSignature,proto3" json:"partial_signature,omitempty"`
+}
+
+func (x *MsgSubmitPartialSignature) Reset() {
+ *x = MsgSubmitPartialSignature{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_tx_proto_msgTypes[8]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *MsgSubmitPartialSignature) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgSubmitPartialSignature) ProtoMessage() {}
+
+// Deprecated: Use MsgSubmitPartialSignature.ProtoReflect.Descriptor instead.
+func (*MsgSubmitPartialSignature) Descriptor() ([]byte, []int) {
+ return file_inference_bls_tx_proto_rawDescGZIP(), []int{8}
+}
+
+func (x *MsgSubmitPartialSignature) GetCreator() string {
+ if x != nil {
+ return x.Creator
+ }
+ return ""
+}
+
+func (x *MsgSubmitPartialSignature) GetRequestId() []byte {
+ if x != nil {
+ return x.RequestId
+ }
+ return nil
+}
+
+func (x *MsgSubmitPartialSignature) GetSlotIndices() []uint32 {
+ if x != nil {
+ return x.SlotIndices
+ }
+ return nil
+}
+
+func (x *MsgSubmitPartialSignature) GetPartialSignature() []byte {
+ if x != nil {
+ return x.PartialSignature
+ }
+ return nil
+}
+
+// MsgSubmitPartialSignatureResponse defines the response structure for executing a
+// MsgSubmitPartialSignature message.
+type MsgSubmitPartialSignatureResponse struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+}
+
+func (x *MsgSubmitPartialSignatureResponse) Reset() {
+ *x = MsgSubmitPartialSignatureResponse{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_tx_proto_msgTypes[9]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *MsgSubmitPartialSignatureResponse) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgSubmitPartialSignatureResponse) ProtoMessage() {}
+
+// Deprecated: Use MsgSubmitPartialSignatureResponse.ProtoReflect.Descriptor instead.
+func (*MsgSubmitPartialSignatureResponse) Descriptor() ([]byte, []int) {
+ return file_inference_bls_tx_proto_rawDescGZIP(), []int{9}
+}
+
+// MsgRequestThresholdSignature allows external users to request a threshold signature via transaction
+type MsgRequestThresholdSignature struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // creator is the address of the user requesting the threshold signature
+ Creator string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
+ // current_epoch_id identifies the epoch to use for signing
+ CurrentEpochId uint64 `protobuf:"varint,2,opt,name=current_epoch_id,json=currentEpochId,proto3" json:"current_epoch_id,omitempty"`
+ // chain_id is the chain ID for EIP-155 compatibility (32 bytes)
+ ChainId []byte `protobuf:"bytes,3,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
+ // request_id is the user-provided unique identifier for this request (32 bytes)
+ RequestId []byte `protobuf:"bytes,4,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`
+ // data is the arbitrary data to be signed (array of 32-byte chunks)
+ Data [][]byte `protobuf:"bytes,5,rep,name=data,proto3" json:"data,omitempty"`
+}
+
+func (x *MsgRequestThresholdSignature) Reset() {
+ *x = MsgRequestThresholdSignature{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_tx_proto_msgTypes[10]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *MsgRequestThresholdSignature) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgRequestThresholdSignature) ProtoMessage() {}
+
+// Deprecated: Use MsgRequestThresholdSignature.ProtoReflect.Descriptor instead.
+func (*MsgRequestThresholdSignature) Descriptor() ([]byte, []int) {
+ return file_inference_bls_tx_proto_rawDescGZIP(), []int{10}
+}
+
+func (x *MsgRequestThresholdSignature) GetCreator() string {
+ if x != nil {
+ return x.Creator
+ }
+ return ""
+}
+
+func (x *MsgRequestThresholdSignature) GetCurrentEpochId() uint64 {
+ if x != nil {
+ return x.CurrentEpochId
+ }
+ return 0
+}
+
+func (x *MsgRequestThresholdSignature) GetChainId() []byte {
+ if x != nil {
+ return x.ChainId
+ }
+ return nil
+}
+
+func (x *MsgRequestThresholdSignature) GetRequestId() []byte {
+ if x != nil {
+ return x.RequestId
+ }
+ return nil
+}
+
+func (x *MsgRequestThresholdSignature) GetData() [][]byte {
+ if x != nil {
+ return x.Data
+ }
+ return nil
+}
+
+// MsgRequestThresholdSignatureResponse defines the response structure for executing a
+// MsgRequestThresholdSignature message.
+type MsgRequestThresholdSignatureResponse struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+}
+
+func (x *MsgRequestThresholdSignatureResponse) Reset() {
+ *x = MsgRequestThresholdSignatureResponse{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_tx_proto_msgTypes[11]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *MsgRequestThresholdSignatureResponse) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgRequestThresholdSignatureResponse) ProtoMessage() {}
+
+// Deprecated: Use MsgRequestThresholdSignatureResponse.ProtoReflect.Descriptor instead.
+func (*MsgRequestThresholdSignatureResponse) Descriptor() ([]byte, []int) {
+ return file_inference_bls_tx_proto_rawDescGZIP(), []int{11}
+}
+
+var File_inference_bls_tx_proto protoreflect.FileDescriptor
+
+var file_inference_bls_tx_proto_rawDesc = []byte{
+ 0x0a, 0x16, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x62, 0x6c, 0x73, 0x2f,
+ 0x74, 0x78, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0d, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+ 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x1a, 0x11, 0x61, 0x6d, 0x69, 0x6e, 0x6f, 0x2f, 0x61,
+ 0x6d, 0x69, 0x6e, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 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, 0x1a, 0x14,
+ 0x67, 0x6f, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2e, 0x70,
+ 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1a, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f,
+ 0x62, 0x6c, 0x73, 0x2f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+ 0x1a, 0x19, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x62, 0x6c, 0x73, 0x2f,
+ 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xb7, 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, 0x38, 0x0a, 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d,
+ 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+ 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 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, 0x32, 0x82, 0xe7, 0xb0, 0x2a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74,
+ 0x79, 0x8a, 0xe7, 0xb0, 0x2a, 0x1f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f,
+ 0x78, 0x2f, 0x62, 0x6c, 0x73, 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, 0xbb, 0x02, 0x0a, 0x13, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x44, 0x65,
+ 0x61, 0x6c, 0x65, 0x72, 0x50, 0x61, 0x72, 0x74, 0x12, 0x32, 0x0a, 0x07, 0x63, 0x72, 0x65, 0x61,
+ 0x74, 0x6f, 0x72, 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, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x19, 0x0a, 0x08,
+ 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07,
+ 0x65, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x64, 0x12, 0x20, 0x0a, 0x0b, 0x63, 0x6f, 0x6d, 0x6d, 0x69,
+ 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x0b, 0x63, 0x6f,
+ 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x7d, 0x0a, 0x21, 0x65, 0x6e, 0x63,
+ 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x5f, 0x73, 0x68, 0x61, 0x72, 0x65, 0x73, 0x5f, 0x66, 0x6f,
+ 0x72, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x18, 0x04,
+ 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+ 0x2e, 0x62, 0x6c, 0x73, 0x2e, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x53, 0x68,
+ 0x61, 0x72, 0x65, 0x73, 0x46, 0x6f, 0x72, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61,
+ 0x6e, 0x74, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x1e, 0x65, 0x6e, 0x63, 0x72, 0x79, 0x70,
+ 0x74, 0x65, 0x64, 0x53, 0x68, 0x61, 0x72, 0x65, 0x73, 0x46, 0x6f, 0x72, 0x50, 0x61, 0x72, 0x74,
+ 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x3a, 0x34, 0x82, 0xe7, 0xb0, 0x2a, 0x07, 0x63,
+ 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x8a, 0xe7, 0xb0, 0x2a, 0x23, 0x69, 0x6e, 0x66, 0x65, 0x72,
+ 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x78, 0x2f, 0x62, 0x6c, 0x73, 0x2f, 0x4d, 0x73, 0x67, 0x53, 0x75,
+ 0x62, 0x6d, 0x69, 0x74, 0x44, 0x65, 0x61, 0x6c, 0x65, 0x72, 0x50, 0x61, 0x72, 0x74, 0x22, 0x1d,
+ 0x0a, 0x1b, 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, 0x22, 0xd3, 0x01,
+ 0x0a, 0x1b, 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, 0x12, 0x32, 0x0a,
+ 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 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, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f,
+ 0x72, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20,
+ 0x01, 0x28, 0x04, 0x52, 0x07, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x64, 0x12, 0x27, 0x0a, 0x0f,
+ 0x64, 0x65, 0x61, 0x6c, 0x65, 0x72, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x69, 0x74, 0x79, 0x18,
+ 0x03, 0x20, 0x03, 0x28, 0x08, 0x52, 0x0e, 0x64, 0x65, 0x61, 0x6c, 0x65, 0x72, 0x56, 0x61, 0x6c,
+ 0x69, 0x64, 0x69, 0x74, 0x79, 0x3a, 0x3c, 0x82, 0xe7, 0xb0, 0x2a, 0x07, 0x63, 0x72, 0x65, 0x61,
+ 0x74, 0x6f, 0x72, 0x8a, 0xe7, 0xb0, 0x2a, 0x2b, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+ 0x65, 0x2f, 0x78, 0x2f, 0x62, 0x6c, 0x73, 0x2f, 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, 0x22, 0x25, 0x0a, 0x23, 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, 0x22, 0x93, 0x02, 0x0a, 0x24, 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, 0x32, 0x0a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 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, 0x07,
+ 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x20, 0x0a, 0x0c, 0x6e, 0x65, 0x77, 0x5f, 0x65,
+ 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x6e,
+ 0x65, 0x77, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x6c, 0x6f,
+ 0x74, 0x5f, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0d, 0x52,
+ 0x0b, 0x73, 0x6c, 0x6f, 0x74, 0x49, 0x6e, 0x64, 0x69, 0x63, 0x65, 0x73, 0x12, 0x2b, 0x0a, 0x11,
+ 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x5f, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72,
+ 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x10, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c,
+ 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x3a, 0x45, 0x82, 0xe7, 0xb0, 0x2a, 0x07,
+ 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x8a, 0xe7, 0xb0, 0x2a, 0x34, 0x69, 0x6e, 0x66, 0x65,
+ 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x78, 0x2f, 0x62, 0x6c, 0x73, 0x2f, 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,
+ 0x22, 0x2e, 0x0a, 0x2c, 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,
+ 0x22, 0xfa, 0x01, 0x0a, 0x19, 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, 0x32,
+ 0x0a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 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, 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, 0x0c, 0x52, 0x09, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x49,
+ 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x6c, 0x6f, 0x74, 0x5f, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x65,
+ 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0d, 0x52, 0x0b, 0x73, 0x6c, 0x6f, 0x74, 0x49, 0x6e, 0x64,
+ 0x69, 0x63, 0x65, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x5f,
+ 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52,
+ 0x10, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72,
+ 0x65, 0x3a, 0x3a, 0x82, 0xe7, 0xb0, 0x2a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x8a,
+ 0xe7, 0xb0, 0x2a, 0x29, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x78, 0x2f,
+ 0x62, 0x6c, 0x73, 0x2f, 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, 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, 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, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73,
+ 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x07,
+ 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x28, 0x0a, 0x10, 0x63, 0x75, 0x72, 0x72, 0x65,
+ 0x6e, 0x74, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28,
+ 0x04, 0x52, 0x0e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x49,
+ 0x64, 0x12, 0x19, 0x0a, 0x08, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20,
+ 0x01, 0x28, 0x0c, 0x52, 0x07, 0x63, 0x68, 0x61, 0x69, 0x6e, 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, 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, 0x26,
+ 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, 0x32, 0xd1, 0x05, 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, 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, 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, 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,
+}
+
+var (
+ file_inference_bls_tx_proto_rawDescOnce sync.Once
+ file_inference_bls_tx_proto_rawDescData = file_inference_bls_tx_proto_rawDesc
+)
+
+func file_inference_bls_tx_proto_rawDescGZIP() []byte {
+ file_inference_bls_tx_proto_rawDescOnce.Do(func() {
+ file_inference_bls_tx_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_bls_tx_proto_rawDescData)
+ })
+ return file_inference_bls_tx_proto_rawDescData
+}
+
+var file_inference_bls_tx_proto_msgTypes = make([]protoimpl.MessageInfo, 12)
+var file_inference_bls_tx_proto_goTypes = []interface{}{
+ (*MsgUpdateParams)(nil), // 0: inference.bls.MsgUpdateParams
+ (*MsgUpdateParamsResponse)(nil), // 1: inference.bls.MsgUpdateParamsResponse
+ (*MsgSubmitDealerPart)(nil), // 2: inference.bls.MsgSubmitDealerPart
+ (*MsgSubmitDealerPartResponse)(nil), // 3: inference.bls.MsgSubmitDealerPartResponse
+ (*MsgSubmitVerificationVector)(nil), // 4: inference.bls.MsgSubmitVerificationVector
+ (*MsgSubmitVerificationVectorResponse)(nil), // 5: inference.bls.MsgSubmitVerificationVectorResponse
+ (*MsgSubmitGroupKeyValidationSignature)(nil), // 6: inference.bls.MsgSubmitGroupKeyValidationSignature
+ (*MsgSubmitGroupKeyValidationSignatureResponse)(nil), // 7: inference.bls.MsgSubmitGroupKeyValidationSignatureResponse
+ (*MsgSubmitPartialSignature)(nil), // 8: inference.bls.MsgSubmitPartialSignature
+ (*MsgSubmitPartialSignatureResponse)(nil), // 9: inference.bls.MsgSubmitPartialSignatureResponse
+ (*MsgRequestThresholdSignature)(nil), // 10: inference.bls.MsgRequestThresholdSignature
+ (*MsgRequestThresholdSignatureResponse)(nil), // 11: inference.bls.MsgRequestThresholdSignatureResponse
+ (*Params)(nil), // 12: inference.bls.Params
+ (*EncryptedSharesForParticipant)(nil), // 13: inference.bls.EncryptedSharesForParticipant
+}
+var file_inference_bls_tx_proto_depIdxs = []int32{
+ 12, // 0: inference.bls.MsgUpdateParams.params:type_name -> inference.bls.Params
+ 13, // 1: inference.bls.MsgSubmitDealerPart.encrypted_shares_for_participants:type_name -> inference.bls.EncryptedSharesForParticipant
+ 0, // 2: inference.bls.Msg.UpdateParams:input_type -> inference.bls.MsgUpdateParams
+ 2, // 3: inference.bls.Msg.SubmitDealerPart:input_type -> inference.bls.MsgSubmitDealerPart
+ 4, // 4: inference.bls.Msg.SubmitVerificationVector:input_type -> inference.bls.MsgSubmitVerificationVector
+ 6, // 5: inference.bls.Msg.SubmitGroupKeyValidationSignature:input_type -> inference.bls.MsgSubmitGroupKeyValidationSignature
+ 8, // 6: inference.bls.Msg.SubmitPartialSignature:input_type -> inference.bls.MsgSubmitPartialSignature
+ 10, // 7: inference.bls.Msg.RequestThresholdSignature:input_type -> inference.bls.MsgRequestThresholdSignature
+ 1, // 8: inference.bls.Msg.UpdateParams:output_type -> inference.bls.MsgUpdateParamsResponse
+ 3, // 9: inference.bls.Msg.SubmitDealerPart:output_type -> inference.bls.MsgSubmitDealerPartResponse
+ 5, // 10: inference.bls.Msg.SubmitVerificationVector:output_type -> inference.bls.MsgSubmitVerificationVectorResponse
+ 7, // 11: inference.bls.Msg.SubmitGroupKeyValidationSignature:output_type -> inference.bls.MsgSubmitGroupKeyValidationSignatureResponse
+ 9, // 12: inference.bls.Msg.SubmitPartialSignature:output_type -> inference.bls.MsgSubmitPartialSignatureResponse
+ 11, // 13: inference.bls.Msg.RequestThresholdSignature:output_type -> inference.bls.MsgRequestThresholdSignatureResponse
+ 8, // [8:14] is the sub-list for method output_type
+ 2, // [2:8] 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_bls_tx_proto_init() }
+func file_inference_bls_tx_proto_init() {
+ if File_inference_bls_tx_proto != nil {
+ return
+ }
+ file_inference_bls_params_proto_init()
+ file_inference_bls_types_proto_init()
+ if !protoimpl.UnsafeEnabled {
+ file_inference_bls_tx_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*MsgUpdateParams); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_bls_tx_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*MsgUpdateParamsResponse); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_bls_tx_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*MsgSubmitDealerPart); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_bls_tx_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*MsgSubmitDealerPartResponse); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_bls_tx_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*MsgSubmitVerificationVector); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_bls_tx_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*MsgSubmitVerificationVectorResponse); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_bls_tx_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*MsgSubmitGroupKeyValidationSignature); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_bls_tx_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*MsgSubmitGroupKeyValidationSignatureResponse); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_bls_tx_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*MsgSubmitPartialSignature); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_bls_tx_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*MsgSubmitPartialSignatureResponse); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_bls_tx_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*MsgRequestThresholdSignature); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_bls_tx_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*MsgRequestThresholdSignatureResponse); 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_bls_tx_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 12,
+ NumExtensions: 0,
+ NumServices: 1,
+ },
+ GoTypes: file_inference_bls_tx_proto_goTypes,
+ DependencyIndexes: file_inference_bls_tx_proto_depIdxs,
+ MessageInfos: file_inference_bls_tx_proto_msgTypes,
+ }.Build()
+ File_inference_bls_tx_proto = out.File
+ file_inference_bls_tx_proto_rawDesc = nil
+ file_inference_bls_tx_proto_goTypes = nil
+ file_inference_bls_tx_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/bls/tx_grpc.pb.go b/inference-chain/api/inference/bls/tx_grpc.pb.go
new file mode 100644
index 000000000..b42cb2080
--- /dev/null
+++ b/inference-chain/api/inference/bls/tx_grpc.pb.go
@@ -0,0 +1,308 @@
+// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
+// versions:
+// - protoc-gen-go-grpc v1.3.0
+// - protoc (unknown)
+// source: inference/bls/tx.proto
+
+package bls
+
+import (
+ context "context"
+ grpc "google.golang.org/grpc"
+ codes "google.golang.org/grpc/codes"
+ status "google.golang.org/grpc/status"
+)
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+// Requires gRPC-Go v1.32.0 or later.
+const _ = grpc.SupportPackageIsVersion7
+
+const (
+ Msg_UpdateParams_FullMethodName = "/inference.bls.Msg/UpdateParams"
+ Msg_SubmitDealerPart_FullMethodName = "/inference.bls.Msg/SubmitDealerPart"
+ Msg_SubmitVerificationVector_FullMethodName = "/inference.bls.Msg/SubmitVerificationVector"
+ Msg_SubmitGroupKeyValidationSignature_FullMethodName = "/inference.bls.Msg/SubmitGroupKeyValidationSignature"
+ Msg_SubmitPartialSignature_FullMethodName = "/inference.bls.Msg/SubmitPartialSignature"
+ Msg_RequestThresholdSignature_FullMethodName = "/inference.bls.Msg/RequestThresholdSignature"
+)
+
+// MsgClient is the client API for Msg service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+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)
+ // SubmitDealerPart allows a participant to submit their dealer part during the dealing phase
+ SubmitDealerPart(ctx context.Context, in *MsgSubmitDealerPart, opts ...grpc.CallOption) (*MsgSubmitDealerPartResponse, error)
+ // SubmitVerificationVector allows a participant to confirm they completed verification during the verifying phase
+ SubmitVerificationVector(ctx context.Context, in *MsgSubmitVerificationVector, opts ...grpc.CallOption) (*MsgSubmitVerificationVectorResponse, error)
+ // SubmitGroupKeyValidationSignature allows a participant to submit their partial signature for group key validation
+ 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)
+ // RequestThresholdSignature allows external users to request a threshold signature
+ RequestThresholdSignature(ctx context.Context, in *MsgRequestThresholdSignature, opts ...grpc.CallOption) (*MsgRequestThresholdSignatureResponse, error)
+}
+
+type msgClient struct {
+ cc grpc.ClientConnInterface
+}
+
+func NewMsgClient(cc grpc.ClientConnInterface) MsgClient {
+ return &msgClient{cc}
+}
+
+func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) {
+ out := new(MsgUpdateParamsResponse)
+ err := c.cc.Invoke(ctx, Msg_UpdateParams_FullMethodName, in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *msgClient) SubmitDealerPart(ctx context.Context, in *MsgSubmitDealerPart, opts ...grpc.CallOption) (*MsgSubmitDealerPartResponse, error) {
+ out := new(MsgSubmitDealerPartResponse)
+ err := c.cc.Invoke(ctx, Msg_SubmitDealerPart_FullMethodName, in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *msgClient) SubmitVerificationVector(ctx context.Context, in *MsgSubmitVerificationVector, opts ...grpc.CallOption) (*MsgSubmitVerificationVectorResponse, error) {
+ out := new(MsgSubmitVerificationVectorResponse)
+ err := c.cc.Invoke(ctx, Msg_SubmitVerificationVector_FullMethodName, in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *msgClient) SubmitGroupKeyValidationSignature(ctx context.Context, in *MsgSubmitGroupKeyValidationSignature, opts ...grpc.CallOption) (*MsgSubmitGroupKeyValidationSignatureResponse, error) {
+ out := new(MsgSubmitGroupKeyValidationSignatureResponse)
+ err := c.cc.Invoke(ctx, Msg_SubmitGroupKeyValidationSignature_FullMethodName, in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *msgClient) SubmitPartialSignature(ctx context.Context, in *MsgSubmitPartialSignature, opts ...grpc.CallOption) (*MsgSubmitPartialSignatureResponse, error) {
+ out := new(MsgSubmitPartialSignatureResponse)
+ err := c.cc.Invoke(ctx, Msg_SubmitPartialSignature_FullMethodName, in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+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...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+// MsgServer is the server API for Msg service.
+// All implementations must embed UnimplementedMsgServer
+// for forward compatibility
+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)
+ // SubmitDealerPart allows a participant to submit their dealer part during the dealing phase
+ SubmitDealerPart(context.Context, *MsgSubmitDealerPart) (*MsgSubmitDealerPartResponse, error)
+ // SubmitVerificationVector allows a participant to confirm they completed verification during the verifying phase
+ SubmitVerificationVector(context.Context, *MsgSubmitVerificationVector) (*MsgSubmitVerificationVectorResponse, error)
+ // SubmitGroupKeyValidationSignature allows a participant to submit their partial signature for group key validation
+ SubmitGroupKeyValidationSignature(context.Context, *MsgSubmitGroupKeyValidationSignature) (*MsgSubmitGroupKeyValidationSignatureResponse, error)
+ // SubmitPartialSignature allows a participant to submit their partial signature for threshold signing
+ SubmitPartialSignature(context.Context, *MsgSubmitPartialSignature) (*MsgSubmitPartialSignatureResponse, error)
+ // RequestThresholdSignature allows external users to request a threshold signature
+ RequestThresholdSignature(context.Context, *MsgRequestThresholdSignature) (*MsgRequestThresholdSignatureResponse, error)
+ mustEmbedUnimplementedMsgServer()
+}
+
+// UnimplementedMsgServer must be embedded to have forward compatible implementations.
+type UnimplementedMsgServer struct {
+}
+
+func (UnimplementedMsgServer) UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method UpdateParams not implemented")
+}
+func (UnimplementedMsgServer) SubmitDealerPart(context.Context, *MsgSubmitDealerPart) (*MsgSubmitDealerPartResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method SubmitDealerPart not implemented")
+}
+func (UnimplementedMsgServer) SubmitVerificationVector(context.Context, *MsgSubmitVerificationVector) (*MsgSubmitVerificationVectorResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method SubmitVerificationVector not implemented")
+}
+func (UnimplementedMsgServer) SubmitGroupKeyValidationSignature(context.Context, *MsgSubmitGroupKeyValidationSignature) (*MsgSubmitGroupKeyValidationSignatureResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method SubmitGroupKeyValidationSignature not implemented")
+}
+func (UnimplementedMsgServer) SubmitPartialSignature(context.Context, *MsgSubmitPartialSignature) (*MsgSubmitPartialSignatureResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method SubmitPartialSignature not implemented")
+}
+func (UnimplementedMsgServer) RequestThresholdSignature(context.Context, *MsgRequestThresholdSignature) (*MsgRequestThresholdSignatureResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method RequestThresholdSignature not implemented")
+}
+func (UnimplementedMsgServer) mustEmbedUnimplementedMsgServer() {}
+
+// UnsafeMsgServer may be embedded to opt out of forward compatibility for this service.
+// Use of this interface is not recommended, as added methods to MsgServer will
+// result in compilation errors.
+type UnsafeMsgServer interface {
+ mustEmbedUnimplementedMsgServer()
+}
+
+func RegisterMsgServer(s grpc.ServiceRegistrar, srv MsgServer) {
+ s.RegisterService(&Msg_ServiceDesc, srv)
+}
+
+func _Msg_UpdateParams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(MsgUpdateParams)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(MsgServer).UpdateParams(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: Msg_UpdateParams_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(MsgServer).UpdateParams(ctx, req.(*MsgUpdateParams))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _Msg_SubmitDealerPart_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(MsgSubmitDealerPart)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(MsgServer).SubmitDealerPart(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: Msg_SubmitDealerPart_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(MsgServer).SubmitDealerPart(ctx, req.(*MsgSubmitDealerPart))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _Msg_SubmitVerificationVector_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(MsgSubmitVerificationVector)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(MsgServer).SubmitVerificationVector(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: Msg_SubmitVerificationVector_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(MsgServer).SubmitVerificationVector(ctx, req.(*MsgSubmitVerificationVector))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _Msg_SubmitGroupKeyValidationSignature_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(MsgSubmitGroupKeyValidationSignature)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(MsgServer).SubmitGroupKeyValidationSignature(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: Msg_SubmitGroupKeyValidationSignature_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(MsgServer).SubmitGroupKeyValidationSignature(ctx, req.(*MsgSubmitGroupKeyValidationSignature))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _Msg_SubmitPartialSignature_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(MsgSubmitPartialSignature)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(MsgServer).SubmitPartialSignature(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: Msg_SubmitPartialSignature_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(MsgServer).SubmitPartialSignature(ctx, req.(*MsgSubmitPartialSignature))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _Msg_RequestThresholdSignature_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(MsgRequestThresholdSignature)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(MsgServer).RequestThresholdSignature(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: Msg_RequestThresholdSignature_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(MsgServer).RequestThresholdSignature(ctx, req.(*MsgRequestThresholdSignature))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+// Msg_ServiceDesc is the grpc.ServiceDesc for Msg service.
+// It's only intended for direct use with grpc.RegisterService,
+// and not to be introspected or modified (even as a copy)
+var Msg_ServiceDesc = grpc.ServiceDesc{
+ ServiceName: "inference.bls.Msg",
+ HandlerType: (*MsgServer)(nil),
+ Methods: []grpc.MethodDesc{
+ {
+ MethodName: "UpdateParams",
+ Handler: _Msg_UpdateParams_Handler,
+ },
+ {
+ MethodName: "SubmitDealerPart",
+ Handler: _Msg_SubmitDealerPart_Handler,
+ },
+ {
+ MethodName: "SubmitVerificationVector",
+ Handler: _Msg_SubmitVerificationVector_Handler,
+ },
+ {
+ MethodName: "SubmitGroupKeyValidationSignature",
+ Handler: _Msg_SubmitGroupKeyValidationSignature_Handler,
+ },
+ {
+ MethodName: "SubmitPartialSignature",
+ Handler: _Msg_SubmitPartialSignature_Handler,
+ },
+ {
+ MethodName: "RequestThresholdSignature",
+ Handler: _Msg_RequestThresholdSignature_Handler,
+ },
+ },
+ Streams: []grpc.StreamDesc{},
+ Metadata: "inference/bls/tx.proto",
+}
diff --git a/inference-chain/api/inference/bls/types.pulsar.go b/inference-chain/api/inference/bls/types.pulsar.go
new file mode 100644
index 000000000..d5d596989
--- /dev/null
+++ b/inference-chain/api/inference/bls/types.pulsar.go
@@ -0,0 +1,4362 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package bls
+
+import (
+ _ "cosmossdk.io/api/amino"
+ fmt "fmt"
+ _ "github.com/cosmos/cosmos-proto"
+ runtime "github.com/cosmos/cosmos-proto/runtime"
+ _ "github.com/cosmos/gogoproto/gogoproto"
+ 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_BLSParticipantInfo protoreflect.MessageDescriptor
+ fd_BLSParticipantInfo_address protoreflect.FieldDescriptor
+ fd_BLSParticipantInfo_percentage_weight protoreflect.FieldDescriptor
+ fd_BLSParticipantInfo_secp256k1_public_key protoreflect.FieldDescriptor
+ fd_BLSParticipantInfo_slot_start_index protoreflect.FieldDescriptor
+ fd_BLSParticipantInfo_slot_end_index protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bls_types_proto_init()
+ md_BLSParticipantInfo = File_inference_bls_types_proto.Messages().ByName("BLSParticipantInfo")
+ fd_BLSParticipantInfo_address = md_BLSParticipantInfo.Fields().ByName("address")
+ fd_BLSParticipantInfo_percentage_weight = md_BLSParticipantInfo.Fields().ByName("percentage_weight")
+ fd_BLSParticipantInfo_secp256k1_public_key = md_BLSParticipantInfo.Fields().ByName("secp256k1_public_key")
+ fd_BLSParticipantInfo_slot_start_index = md_BLSParticipantInfo.Fields().ByName("slot_start_index")
+ fd_BLSParticipantInfo_slot_end_index = md_BLSParticipantInfo.Fields().ByName("slot_end_index")
+}
+
+var _ protoreflect.Message = (*fastReflection_BLSParticipantInfo)(nil)
+
+type fastReflection_BLSParticipantInfo BLSParticipantInfo
+
+func (x *BLSParticipantInfo) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_BLSParticipantInfo)(x)
+}
+
+func (x *BLSParticipantInfo) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_types_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_BLSParticipantInfo_messageType fastReflection_BLSParticipantInfo_messageType
+var _ protoreflect.MessageType = fastReflection_BLSParticipantInfo_messageType{}
+
+type fastReflection_BLSParticipantInfo_messageType struct{}
+
+func (x fastReflection_BLSParticipantInfo_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_BLSParticipantInfo)(nil)
+}
+func (x fastReflection_BLSParticipantInfo_messageType) New() protoreflect.Message {
+ return new(fastReflection_BLSParticipantInfo)
+}
+func (x fastReflection_BLSParticipantInfo_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_BLSParticipantInfo
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_BLSParticipantInfo) Descriptor() protoreflect.MessageDescriptor {
+ return md_BLSParticipantInfo
+}
+
+// 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_BLSParticipantInfo) Type() protoreflect.MessageType {
+ return _fastReflection_BLSParticipantInfo_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_BLSParticipantInfo) New() protoreflect.Message {
+ return new(fastReflection_BLSParticipantInfo)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_BLSParticipantInfo) Interface() protoreflect.ProtoMessage {
+ return (*BLSParticipantInfo)(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_BLSParticipantInfo) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Address != "" {
+ value := protoreflect.ValueOfString(x.Address)
+ if !f(fd_BLSParticipantInfo_address, value) {
+ return
+ }
+ }
+ if x.PercentageWeight != "" {
+ value := protoreflect.ValueOfString(x.PercentageWeight)
+ if !f(fd_BLSParticipantInfo_percentage_weight, value) {
+ return
+ }
+ }
+ if len(x.Secp256K1PublicKey) != 0 {
+ value := protoreflect.ValueOfBytes(x.Secp256K1PublicKey)
+ if !f(fd_BLSParticipantInfo_secp256k1_public_key, value) {
+ return
+ }
+ }
+ if x.SlotStartIndex != uint32(0) {
+ value := protoreflect.ValueOfUint32(x.SlotStartIndex)
+ if !f(fd_BLSParticipantInfo_slot_start_index, value) {
+ return
+ }
+ }
+ if x.SlotEndIndex != uint32(0) {
+ value := protoreflect.ValueOfUint32(x.SlotEndIndex)
+ if !f(fd_BLSParticipantInfo_slot_end_index, 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_BLSParticipantInfo) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bls.BLSParticipantInfo.address":
+ return x.Address != ""
+ case "inference.bls.BLSParticipantInfo.percentage_weight":
+ return x.PercentageWeight != ""
+ case "inference.bls.BLSParticipantInfo.secp256k1_public_key":
+ return len(x.Secp256K1PublicKey) != 0
+ case "inference.bls.BLSParticipantInfo.slot_start_index":
+ return x.SlotStartIndex != uint32(0)
+ case "inference.bls.BLSParticipantInfo.slot_end_index":
+ return x.SlotEndIndex != uint32(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.BLSParticipantInfo"))
+ }
+ panic(fmt.Errorf("message inference.bls.BLSParticipantInfo 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_BLSParticipantInfo) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bls.BLSParticipantInfo.address":
+ x.Address = ""
+ case "inference.bls.BLSParticipantInfo.percentage_weight":
+ x.PercentageWeight = ""
+ case "inference.bls.BLSParticipantInfo.secp256k1_public_key":
+ x.Secp256K1PublicKey = nil
+ case "inference.bls.BLSParticipantInfo.slot_start_index":
+ x.SlotStartIndex = uint32(0)
+ case "inference.bls.BLSParticipantInfo.slot_end_index":
+ x.SlotEndIndex = uint32(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.BLSParticipantInfo"))
+ }
+ panic(fmt.Errorf("message inference.bls.BLSParticipantInfo 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_BLSParticipantInfo) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bls.BLSParticipantInfo.address":
+ value := x.Address
+ return protoreflect.ValueOfString(value)
+ case "inference.bls.BLSParticipantInfo.percentage_weight":
+ value := x.PercentageWeight
+ return protoreflect.ValueOfString(value)
+ case "inference.bls.BLSParticipantInfo.secp256k1_public_key":
+ value := x.Secp256K1PublicKey
+ return protoreflect.ValueOfBytes(value)
+ case "inference.bls.BLSParticipantInfo.slot_start_index":
+ value := x.SlotStartIndex
+ return protoreflect.ValueOfUint32(value)
+ case "inference.bls.BLSParticipantInfo.slot_end_index":
+ value := x.SlotEndIndex
+ return protoreflect.ValueOfUint32(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.BLSParticipantInfo"))
+ }
+ panic(fmt.Errorf("message inference.bls.BLSParticipantInfo 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_BLSParticipantInfo) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bls.BLSParticipantInfo.address":
+ x.Address = value.Interface().(string)
+ case "inference.bls.BLSParticipantInfo.percentage_weight":
+ x.PercentageWeight = value.Interface().(string)
+ case "inference.bls.BLSParticipantInfo.secp256k1_public_key":
+ x.Secp256K1PublicKey = value.Bytes()
+ case "inference.bls.BLSParticipantInfo.slot_start_index":
+ x.SlotStartIndex = uint32(value.Uint())
+ case "inference.bls.BLSParticipantInfo.slot_end_index":
+ x.SlotEndIndex = uint32(value.Uint())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.BLSParticipantInfo"))
+ }
+ panic(fmt.Errorf("message inference.bls.BLSParticipantInfo 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_BLSParticipantInfo) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.BLSParticipantInfo.address":
+ panic(fmt.Errorf("field address of message inference.bls.BLSParticipantInfo is not mutable"))
+ case "inference.bls.BLSParticipantInfo.percentage_weight":
+ panic(fmt.Errorf("field percentage_weight of message inference.bls.BLSParticipantInfo is not mutable"))
+ case "inference.bls.BLSParticipantInfo.secp256k1_public_key":
+ panic(fmt.Errorf("field secp256k1_public_key of message inference.bls.BLSParticipantInfo is not mutable"))
+ case "inference.bls.BLSParticipantInfo.slot_start_index":
+ panic(fmt.Errorf("field slot_start_index of message inference.bls.BLSParticipantInfo is not mutable"))
+ case "inference.bls.BLSParticipantInfo.slot_end_index":
+ panic(fmt.Errorf("field slot_end_index of message inference.bls.BLSParticipantInfo is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.BLSParticipantInfo"))
+ }
+ panic(fmt.Errorf("message inference.bls.BLSParticipantInfo 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_BLSParticipantInfo) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.BLSParticipantInfo.address":
+ return protoreflect.ValueOfString("")
+ case "inference.bls.BLSParticipantInfo.percentage_weight":
+ return protoreflect.ValueOfString("")
+ case "inference.bls.BLSParticipantInfo.secp256k1_public_key":
+ return protoreflect.ValueOfBytes(nil)
+ case "inference.bls.BLSParticipantInfo.slot_start_index":
+ return protoreflect.ValueOfUint32(uint32(0))
+ case "inference.bls.BLSParticipantInfo.slot_end_index":
+ return protoreflect.ValueOfUint32(uint32(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.BLSParticipantInfo"))
+ }
+ panic(fmt.Errorf("message inference.bls.BLSParticipantInfo 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_BLSParticipantInfo) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.BLSParticipantInfo", 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_BLSParticipantInfo) 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_BLSParticipantInfo) 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_BLSParticipantInfo) 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_BLSParticipantInfo) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*BLSParticipantInfo)
+ 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.Address)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ l = len(x.PercentageWeight)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ l = len(x.Secp256K1PublicKey)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.SlotStartIndex != 0 {
+ n += 1 + runtime.Sov(uint64(x.SlotStartIndex))
+ }
+ if x.SlotEndIndex != 0 {
+ n += 1 + runtime.Sov(uint64(x.SlotEndIndex))
+ }
+ 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().(*BLSParticipantInfo)
+ 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.SlotEndIndex != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.SlotEndIndex))
+ i--
+ dAtA[i] = 0x28
+ }
+ if x.SlotStartIndex != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.SlotStartIndex))
+ i--
+ dAtA[i] = 0x20
+ }
+ if len(x.Secp256K1PublicKey) > 0 {
+ i -= len(x.Secp256K1PublicKey)
+ copy(dAtA[i:], x.Secp256K1PublicKey)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Secp256K1PublicKey)))
+ i--
+ dAtA[i] = 0x1a
+ }
+ if len(x.PercentageWeight) > 0 {
+ i -= len(x.PercentageWeight)
+ copy(dAtA[i:], x.PercentageWeight)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.PercentageWeight)))
+ 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 {
+ 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().(*BLSParticipantInfo)
+ 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: BLSParticipantInfo: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: BLSParticipantInfo: 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 != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PercentageWeight", 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.PercentageWeight = 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 Secp256K1PublicKey", 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.Secp256K1PublicKey = append(x.Secp256K1PublicKey[:0], dAtA[iNdEx:postIndex]...)
+ if x.Secp256K1PublicKey == nil {
+ x.Secp256K1PublicKey = []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 SlotStartIndex", wireType)
+ }
+ x.SlotStartIndex = 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.SlotStartIndex |= uint32(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 SlotEndIndex", wireType)
+ }
+ x.SlotEndIndex = 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.SlotEndIndex |= 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
+ }
+ }
+
+ 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 = (*_EncryptedSharesForParticipant_1_list)(nil)
+
+type _EncryptedSharesForParticipant_1_list struct {
+ list *[][]byte
+}
+
+func (x *_EncryptedSharesForParticipant_1_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_EncryptedSharesForParticipant_1_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfBytes((*x.list)[i])
+}
+
+func (x *_EncryptedSharesForParticipant_1_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Bytes()
+ concreteValue := valueUnwrapped
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_EncryptedSharesForParticipant_1_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Bytes()
+ concreteValue := valueUnwrapped
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_EncryptedSharesForParticipant_1_list) AppendMutable() protoreflect.Value {
+ panic(fmt.Errorf("AppendMutable can not be called on message EncryptedSharesForParticipant at list field EncryptedShares as it is not of Message kind"))
+}
+
+func (x *_EncryptedSharesForParticipant_1_list) Truncate(n int) {
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_EncryptedSharesForParticipant_1_list) NewElement() protoreflect.Value {
+ var v []byte
+ return protoreflect.ValueOfBytes(v)
+}
+
+func (x *_EncryptedSharesForParticipant_1_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_EncryptedSharesForParticipant protoreflect.MessageDescriptor
+ fd_EncryptedSharesForParticipant_encrypted_shares protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bls_types_proto_init()
+ md_EncryptedSharesForParticipant = File_inference_bls_types_proto.Messages().ByName("EncryptedSharesForParticipant")
+ fd_EncryptedSharesForParticipant_encrypted_shares = md_EncryptedSharesForParticipant.Fields().ByName("encrypted_shares")
+}
+
+var _ protoreflect.Message = (*fastReflection_EncryptedSharesForParticipant)(nil)
+
+type fastReflection_EncryptedSharesForParticipant EncryptedSharesForParticipant
+
+func (x *EncryptedSharesForParticipant) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_EncryptedSharesForParticipant)(x)
+}
+
+func (x *EncryptedSharesForParticipant) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_types_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_EncryptedSharesForParticipant_messageType fastReflection_EncryptedSharesForParticipant_messageType
+var _ protoreflect.MessageType = fastReflection_EncryptedSharesForParticipant_messageType{}
+
+type fastReflection_EncryptedSharesForParticipant_messageType struct{}
+
+func (x fastReflection_EncryptedSharesForParticipant_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_EncryptedSharesForParticipant)(nil)
+}
+func (x fastReflection_EncryptedSharesForParticipant_messageType) New() protoreflect.Message {
+ return new(fastReflection_EncryptedSharesForParticipant)
+}
+func (x fastReflection_EncryptedSharesForParticipant_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_EncryptedSharesForParticipant
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_EncryptedSharesForParticipant) Descriptor() protoreflect.MessageDescriptor {
+ return md_EncryptedSharesForParticipant
+}
+
+// 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_EncryptedSharesForParticipant) Type() protoreflect.MessageType {
+ return _fastReflection_EncryptedSharesForParticipant_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_EncryptedSharesForParticipant) New() protoreflect.Message {
+ return new(fastReflection_EncryptedSharesForParticipant)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_EncryptedSharesForParticipant) Interface() protoreflect.ProtoMessage {
+ return (*EncryptedSharesForParticipant)(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_EncryptedSharesForParticipant) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if len(x.EncryptedShares) != 0 {
+ value := protoreflect.ValueOfList(&_EncryptedSharesForParticipant_1_list{list: &x.EncryptedShares})
+ if !f(fd_EncryptedSharesForParticipant_encrypted_shares, 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_EncryptedSharesForParticipant) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bls.EncryptedSharesForParticipant.encrypted_shares":
+ return len(x.EncryptedShares) != 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EncryptedSharesForParticipant"))
+ }
+ panic(fmt.Errorf("message inference.bls.EncryptedSharesForParticipant 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_EncryptedSharesForParticipant) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bls.EncryptedSharesForParticipant.encrypted_shares":
+ x.EncryptedShares = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EncryptedSharesForParticipant"))
+ }
+ panic(fmt.Errorf("message inference.bls.EncryptedSharesForParticipant 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_EncryptedSharesForParticipant) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bls.EncryptedSharesForParticipant.encrypted_shares":
+ if len(x.EncryptedShares) == 0 {
+ return protoreflect.ValueOfList(&_EncryptedSharesForParticipant_1_list{})
+ }
+ listValue := &_EncryptedSharesForParticipant_1_list{list: &x.EncryptedShares}
+ return protoreflect.ValueOfList(listValue)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EncryptedSharesForParticipant"))
+ }
+ panic(fmt.Errorf("message inference.bls.EncryptedSharesForParticipant 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_EncryptedSharesForParticipant) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bls.EncryptedSharesForParticipant.encrypted_shares":
+ lv := value.List()
+ clv := lv.(*_EncryptedSharesForParticipant_1_list)
+ x.EncryptedShares = *clv.list
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EncryptedSharesForParticipant"))
+ }
+ panic(fmt.Errorf("message inference.bls.EncryptedSharesForParticipant 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_EncryptedSharesForParticipant) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.EncryptedSharesForParticipant.encrypted_shares":
+ if x.EncryptedShares == nil {
+ x.EncryptedShares = [][]byte{}
+ }
+ value := &_EncryptedSharesForParticipant_1_list{list: &x.EncryptedShares}
+ return protoreflect.ValueOfList(value)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EncryptedSharesForParticipant"))
+ }
+ panic(fmt.Errorf("message inference.bls.EncryptedSharesForParticipant 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_EncryptedSharesForParticipant) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.EncryptedSharesForParticipant.encrypted_shares":
+ list := [][]byte{}
+ return protoreflect.ValueOfList(&_EncryptedSharesForParticipant_1_list{list: &list})
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EncryptedSharesForParticipant"))
+ }
+ panic(fmt.Errorf("message inference.bls.EncryptedSharesForParticipant 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_EncryptedSharesForParticipant) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.EncryptedSharesForParticipant", 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_EncryptedSharesForParticipant) 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_EncryptedSharesForParticipant) 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_EncryptedSharesForParticipant) 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_EncryptedSharesForParticipant) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*EncryptedSharesForParticipant)
+ 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.EncryptedShares) > 0 {
+ for _, b := range x.EncryptedShares {
+ l = len(b)
+ 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().(*EncryptedSharesForParticipant)
+ 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.EncryptedShares) > 0 {
+ for iNdEx := len(x.EncryptedShares) - 1; iNdEx >= 0; iNdEx-- {
+ i -= len(x.EncryptedShares[iNdEx])
+ copy(dAtA[i:], x.EncryptedShares[iNdEx])
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.EncryptedShares[iNdEx])))
+ 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().(*EncryptedSharesForParticipant)
+ 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: EncryptedSharesForParticipant: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: EncryptedSharesForParticipant: 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 EncryptedShares", 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.EncryptedShares = append(x.EncryptedShares, make([]byte, postIndex-iNdEx))
+ copy(x.EncryptedShares[len(x.EncryptedShares)-1], 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 = (*_DealerPartStorage_2_list)(nil)
+
+type _DealerPartStorage_2_list struct {
+ list *[][]byte
+}
+
+func (x *_DealerPartStorage_2_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_DealerPartStorage_2_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfBytes((*x.list)[i])
+}
+
+func (x *_DealerPartStorage_2_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Bytes()
+ concreteValue := valueUnwrapped
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_DealerPartStorage_2_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Bytes()
+ concreteValue := valueUnwrapped
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_DealerPartStorage_2_list) AppendMutable() protoreflect.Value {
+ panic(fmt.Errorf("AppendMutable can not be called on message DealerPartStorage at list field Commitments as it is not of Message kind"))
+}
+
+func (x *_DealerPartStorage_2_list) Truncate(n int) {
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_DealerPartStorage_2_list) NewElement() protoreflect.Value {
+ var v []byte
+ return protoreflect.ValueOfBytes(v)
+}
+
+func (x *_DealerPartStorage_2_list) IsValid() bool {
+ return x.list != nil
+}
+
+var _ protoreflect.List = (*_DealerPartStorage_3_list)(nil)
+
+type _DealerPartStorage_3_list struct {
+ list *[]*EncryptedSharesForParticipant
+}
+
+func (x *_DealerPartStorage_3_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_DealerPartStorage_3_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_DealerPartStorage_3_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*EncryptedSharesForParticipant)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_DealerPartStorage_3_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*EncryptedSharesForParticipant)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_DealerPartStorage_3_list) AppendMutable() protoreflect.Value {
+ v := new(EncryptedSharesForParticipant)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_DealerPartStorage_3_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_DealerPartStorage_3_list) NewElement() protoreflect.Value {
+ v := new(EncryptedSharesForParticipant)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_DealerPartStorage_3_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_DealerPartStorage protoreflect.MessageDescriptor
+ fd_DealerPartStorage_dealer_address protoreflect.FieldDescriptor
+ fd_DealerPartStorage_commitments protoreflect.FieldDescriptor
+ fd_DealerPartStorage_participant_shares protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bls_types_proto_init()
+ md_DealerPartStorage = File_inference_bls_types_proto.Messages().ByName("DealerPartStorage")
+ fd_DealerPartStorage_dealer_address = md_DealerPartStorage.Fields().ByName("dealer_address")
+ fd_DealerPartStorage_commitments = md_DealerPartStorage.Fields().ByName("commitments")
+ fd_DealerPartStorage_participant_shares = md_DealerPartStorage.Fields().ByName("participant_shares")
+}
+
+var _ protoreflect.Message = (*fastReflection_DealerPartStorage)(nil)
+
+type fastReflection_DealerPartStorage DealerPartStorage
+
+func (x *DealerPartStorage) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_DealerPartStorage)(x)
+}
+
+func (x *DealerPartStorage) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_types_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_DealerPartStorage_messageType fastReflection_DealerPartStorage_messageType
+var _ protoreflect.MessageType = fastReflection_DealerPartStorage_messageType{}
+
+type fastReflection_DealerPartStorage_messageType struct{}
+
+func (x fastReflection_DealerPartStorage_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_DealerPartStorage)(nil)
+}
+func (x fastReflection_DealerPartStorage_messageType) New() protoreflect.Message {
+ return new(fastReflection_DealerPartStorage)
+}
+func (x fastReflection_DealerPartStorage_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_DealerPartStorage
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_DealerPartStorage) Descriptor() protoreflect.MessageDescriptor {
+ return md_DealerPartStorage
+}
+
+// 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_DealerPartStorage) Type() protoreflect.MessageType {
+ return _fastReflection_DealerPartStorage_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_DealerPartStorage) New() protoreflect.Message {
+ return new(fastReflection_DealerPartStorage)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_DealerPartStorage) Interface() protoreflect.ProtoMessage {
+ return (*DealerPartStorage)(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_DealerPartStorage) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.DealerAddress != "" {
+ value := protoreflect.ValueOfString(x.DealerAddress)
+ if !f(fd_DealerPartStorage_dealer_address, value) {
+ return
+ }
+ }
+ if len(x.Commitments) != 0 {
+ value := protoreflect.ValueOfList(&_DealerPartStorage_2_list{list: &x.Commitments})
+ if !f(fd_DealerPartStorage_commitments, value) {
+ return
+ }
+ }
+ if len(x.ParticipantShares) != 0 {
+ value := protoreflect.ValueOfList(&_DealerPartStorage_3_list{list: &x.ParticipantShares})
+ if !f(fd_DealerPartStorage_participant_shares, 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_DealerPartStorage) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bls.DealerPartStorage.dealer_address":
+ return x.DealerAddress != ""
+ case "inference.bls.DealerPartStorage.commitments":
+ return len(x.Commitments) != 0
+ case "inference.bls.DealerPartStorage.participant_shares":
+ return len(x.ParticipantShares) != 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.DealerPartStorage"))
+ }
+ panic(fmt.Errorf("message inference.bls.DealerPartStorage 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_DealerPartStorage) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bls.DealerPartStorage.dealer_address":
+ x.DealerAddress = ""
+ case "inference.bls.DealerPartStorage.commitments":
+ x.Commitments = nil
+ case "inference.bls.DealerPartStorage.participant_shares":
+ x.ParticipantShares = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.DealerPartStorage"))
+ }
+ panic(fmt.Errorf("message inference.bls.DealerPartStorage 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_DealerPartStorage) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bls.DealerPartStorage.dealer_address":
+ value := x.DealerAddress
+ return protoreflect.ValueOfString(value)
+ case "inference.bls.DealerPartStorage.commitments":
+ if len(x.Commitments) == 0 {
+ return protoreflect.ValueOfList(&_DealerPartStorage_2_list{})
+ }
+ listValue := &_DealerPartStorage_2_list{list: &x.Commitments}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.bls.DealerPartStorage.participant_shares":
+ if len(x.ParticipantShares) == 0 {
+ return protoreflect.ValueOfList(&_DealerPartStorage_3_list{})
+ }
+ listValue := &_DealerPartStorage_3_list{list: &x.ParticipantShares}
+ return protoreflect.ValueOfList(listValue)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.DealerPartStorage"))
+ }
+ panic(fmt.Errorf("message inference.bls.DealerPartStorage 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_DealerPartStorage) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bls.DealerPartStorage.dealer_address":
+ x.DealerAddress = value.Interface().(string)
+ case "inference.bls.DealerPartStorage.commitments":
+ lv := value.List()
+ clv := lv.(*_DealerPartStorage_2_list)
+ x.Commitments = *clv.list
+ case "inference.bls.DealerPartStorage.participant_shares":
+ lv := value.List()
+ clv := lv.(*_DealerPartStorage_3_list)
+ x.ParticipantShares = *clv.list
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.DealerPartStorage"))
+ }
+ panic(fmt.Errorf("message inference.bls.DealerPartStorage 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_DealerPartStorage) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.DealerPartStorage.commitments":
+ if x.Commitments == nil {
+ x.Commitments = [][]byte{}
+ }
+ value := &_DealerPartStorage_2_list{list: &x.Commitments}
+ return protoreflect.ValueOfList(value)
+ case "inference.bls.DealerPartStorage.participant_shares":
+ if x.ParticipantShares == nil {
+ x.ParticipantShares = []*EncryptedSharesForParticipant{}
+ }
+ value := &_DealerPartStorage_3_list{list: &x.ParticipantShares}
+ return protoreflect.ValueOfList(value)
+ case "inference.bls.DealerPartStorage.dealer_address":
+ panic(fmt.Errorf("field dealer_address of message inference.bls.DealerPartStorage is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.DealerPartStorage"))
+ }
+ panic(fmt.Errorf("message inference.bls.DealerPartStorage 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_DealerPartStorage) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.DealerPartStorage.dealer_address":
+ return protoreflect.ValueOfString("")
+ case "inference.bls.DealerPartStorage.commitments":
+ list := [][]byte{}
+ return protoreflect.ValueOfList(&_DealerPartStorage_2_list{list: &list})
+ case "inference.bls.DealerPartStorage.participant_shares":
+ list := []*EncryptedSharesForParticipant{}
+ return protoreflect.ValueOfList(&_DealerPartStorage_3_list{list: &list})
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.DealerPartStorage"))
+ }
+ panic(fmt.Errorf("message inference.bls.DealerPartStorage 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_DealerPartStorage) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.DealerPartStorage", 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_DealerPartStorage) 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_DealerPartStorage) 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_DealerPartStorage) 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_DealerPartStorage) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*DealerPartStorage)
+ 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.DealerAddress)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if len(x.Commitments) > 0 {
+ for _, b := range x.Commitments {
+ l = len(b)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ }
+ if len(x.ParticipantShares) > 0 {
+ for _, e := range x.ParticipantShares {
+ 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().(*DealerPartStorage)
+ 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.ParticipantShares) > 0 {
+ for iNdEx := len(x.ParticipantShares) - 1; iNdEx >= 0; iNdEx-- {
+ encoded, err := options.Marshal(x.ParticipantShares[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.Commitments) > 0 {
+ for iNdEx := len(x.Commitments) - 1; iNdEx >= 0; iNdEx-- {
+ i -= len(x.Commitments[iNdEx])
+ copy(dAtA[i:], x.Commitments[iNdEx])
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Commitments[iNdEx])))
+ i--
+ dAtA[i] = 0x12
+ }
+ }
+ if len(x.DealerAddress) > 0 {
+ i -= len(x.DealerAddress)
+ copy(dAtA[i:], x.DealerAddress)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DealerAddress)))
+ 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().(*DealerPartStorage)
+ 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: DealerPartStorage: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: DealerPartStorage: 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 DealerAddress", 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.DealerAddress = 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 Commitments", 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.Commitments = append(x.Commitments, make([]byte, postIndex-iNdEx))
+ copy(x.Commitments[len(x.Commitments)-1], 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 ParticipantShares", 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.ParticipantShares = append(x.ParticipantShares, &EncryptedSharesForParticipant{})
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ParticipantShares[len(x.ParticipantShares)-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 _ protoreflect.List = (*_VerificationVectorSubmission_1_list)(nil)
+
+type _VerificationVectorSubmission_1_list struct {
+ list *[]bool
+}
+
+func (x *_VerificationVectorSubmission_1_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_VerificationVectorSubmission_1_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfBool((*x.list)[i])
+}
+
+func (x *_VerificationVectorSubmission_1_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Bool()
+ concreteValue := valueUnwrapped
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_VerificationVectorSubmission_1_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Bool()
+ concreteValue := valueUnwrapped
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_VerificationVectorSubmission_1_list) AppendMutable() protoreflect.Value {
+ panic(fmt.Errorf("AppendMutable can not be called on message VerificationVectorSubmission at list field DealerValidity as it is not of Message kind"))
+}
+
+func (x *_VerificationVectorSubmission_1_list) Truncate(n int) {
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_VerificationVectorSubmission_1_list) NewElement() protoreflect.Value {
+ v := false
+ return protoreflect.ValueOfBool(v)
+}
+
+func (x *_VerificationVectorSubmission_1_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_VerificationVectorSubmission protoreflect.MessageDescriptor
+ fd_VerificationVectorSubmission_dealer_validity protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bls_types_proto_init()
+ md_VerificationVectorSubmission = File_inference_bls_types_proto.Messages().ByName("VerificationVectorSubmission")
+ fd_VerificationVectorSubmission_dealer_validity = md_VerificationVectorSubmission.Fields().ByName("dealer_validity")
+}
+
+var _ protoreflect.Message = (*fastReflection_VerificationVectorSubmission)(nil)
+
+type fastReflection_VerificationVectorSubmission VerificationVectorSubmission
+
+func (x *VerificationVectorSubmission) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_VerificationVectorSubmission)(x)
+}
+
+func (x *VerificationVectorSubmission) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_types_proto_msgTypes[3]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_VerificationVectorSubmission_messageType fastReflection_VerificationVectorSubmission_messageType
+var _ protoreflect.MessageType = fastReflection_VerificationVectorSubmission_messageType{}
+
+type fastReflection_VerificationVectorSubmission_messageType struct{}
+
+func (x fastReflection_VerificationVectorSubmission_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_VerificationVectorSubmission)(nil)
+}
+func (x fastReflection_VerificationVectorSubmission_messageType) New() protoreflect.Message {
+ return new(fastReflection_VerificationVectorSubmission)
+}
+func (x fastReflection_VerificationVectorSubmission_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_VerificationVectorSubmission
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_VerificationVectorSubmission) Descriptor() protoreflect.MessageDescriptor {
+ return md_VerificationVectorSubmission
+}
+
+// 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_VerificationVectorSubmission) Type() protoreflect.MessageType {
+ return _fastReflection_VerificationVectorSubmission_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_VerificationVectorSubmission) New() protoreflect.Message {
+ return new(fastReflection_VerificationVectorSubmission)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_VerificationVectorSubmission) Interface() protoreflect.ProtoMessage {
+ return (*VerificationVectorSubmission)(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_VerificationVectorSubmission) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if len(x.DealerValidity) != 0 {
+ value := protoreflect.ValueOfList(&_VerificationVectorSubmission_1_list{list: &x.DealerValidity})
+ if !f(fd_VerificationVectorSubmission_dealer_validity, 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_VerificationVectorSubmission) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bls.VerificationVectorSubmission.dealer_validity":
+ return len(x.DealerValidity) != 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.VerificationVectorSubmission"))
+ }
+ panic(fmt.Errorf("message inference.bls.VerificationVectorSubmission 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_VerificationVectorSubmission) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bls.VerificationVectorSubmission.dealer_validity":
+ x.DealerValidity = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.VerificationVectorSubmission"))
+ }
+ panic(fmt.Errorf("message inference.bls.VerificationVectorSubmission 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_VerificationVectorSubmission) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bls.VerificationVectorSubmission.dealer_validity":
+ if len(x.DealerValidity) == 0 {
+ return protoreflect.ValueOfList(&_VerificationVectorSubmission_1_list{})
+ }
+ listValue := &_VerificationVectorSubmission_1_list{list: &x.DealerValidity}
+ return protoreflect.ValueOfList(listValue)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.VerificationVectorSubmission"))
+ }
+ panic(fmt.Errorf("message inference.bls.VerificationVectorSubmission 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_VerificationVectorSubmission) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bls.VerificationVectorSubmission.dealer_validity":
+ lv := value.List()
+ clv := lv.(*_VerificationVectorSubmission_1_list)
+ x.DealerValidity = *clv.list
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.VerificationVectorSubmission"))
+ }
+ panic(fmt.Errorf("message inference.bls.VerificationVectorSubmission 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_VerificationVectorSubmission) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.VerificationVectorSubmission.dealer_validity":
+ if x.DealerValidity == nil {
+ x.DealerValidity = []bool{}
+ }
+ value := &_VerificationVectorSubmission_1_list{list: &x.DealerValidity}
+ return protoreflect.ValueOfList(value)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.VerificationVectorSubmission"))
+ }
+ panic(fmt.Errorf("message inference.bls.VerificationVectorSubmission 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_VerificationVectorSubmission) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.VerificationVectorSubmission.dealer_validity":
+ list := []bool{}
+ return protoreflect.ValueOfList(&_VerificationVectorSubmission_1_list{list: &list})
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.VerificationVectorSubmission"))
+ }
+ panic(fmt.Errorf("message inference.bls.VerificationVectorSubmission 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_VerificationVectorSubmission) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.VerificationVectorSubmission", 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_VerificationVectorSubmission) 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_VerificationVectorSubmission) 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_VerificationVectorSubmission) 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_VerificationVectorSubmission) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*VerificationVectorSubmission)
+ 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.DealerValidity) > 0 {
+ n += 1 + runtime.Sov(uint64(len(x.DealerValidity))) + len(x.DealerValidity)*1
+ }
+ 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().(*VerificationVectorSubmission)
+ 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.DealerValidity) > 0 {
+ for iNdEx := len(x.DealerValidity) - 1; iNdEx >= 0; iNdEx-- {
+ i--
+ if x.DealerValidity[iNdEx] {
+ dAtA[i] = 1
+ } else {
+ dAtA[i] = 0
+ }
+ }
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DealerValidity)))
+ 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().(*VerificationVectorSubmission)
+ 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: VerificationVectorSubmission: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: VerificationVectorSubmission: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType == 0 {
+ 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.DealerValidity = append(x.DealerValidity, bool(v != 0))
+ } 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
+ if elementCount != 0 && len(x.DealerValidity) == 0 {
+ x.DealerValidity = make([]bool, 0, elementCount)
+ }
+ for iNdEx < postIndex {
+ 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.DealerValidity = append(x.DealerValidity, bool(v != 0))
+ }
+ } else {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DealerValidity", wireType)
+ }
+ 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 = (*_EpochBLSData_4_list)(nil)
+
+type _EpochBLSData_4_list struct {
+ list *[]*BLSParticipantInfo
+}
+
+func (x *_EpochBLSData_4_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_EpochBLSData_4_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_EpochBLSData_4_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*BLSParticipantInfo)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_EpochBLSData_4_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*BLSParticipantInfo)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_EpochBLSData_4_list) AppendMutable() protoreflect.Value {
+ v := new(BLSParticipantInfo)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_EpochBLSData_4_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_EpochBLSData_4_list) NewElement() protoreflect.Value {
+ v := new(BLSParticipantInfo)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_EpochBLSData_4_list) IsValid() bool {
+ return x.list != nil
+}
+
+var _ protoreflect.List = (*_EpochBLSData_9_list)(nil)
+
+type _EpochBLSData_9_list struct {
+ list *[]*DealerPartStorage
+}
+
+func (x *_EpochBLSData_9_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_EpochBLSData_9_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_EpochBLSData_9_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*DealerPartStorage)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_EpochBLSData_9_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*DealerPartStorage)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_EpochBLSData_9_list) AppendMutable() protoreflect.Value {
+ v := new(DealerPartStorage)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_EpochBLSData_9_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_EpochBLSData_9_list) NewElement() protoreflect.Value {
+ v := new(DealerPartStorage)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_EpochBLSData_9_list) IsValid() bool {
+ return x.list != nil
+}
+
+var _ protoreflect.List = (*_EpochBLSData_10_list)(nil)
+
+type _EpochBLSData_10_list struct {
+ list *[]*VerificationVectorSubmission
+}
+
+func (x *_EpochBLSData_10_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_EpochBLSData_10_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_EpochBLSData_10_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*VerificationVectorSubmission)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_EpochBLSData_10_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*VerificationVectorSubmission)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_EpochBLSData_10_list) AppendMutable() protoreflect.Value {
+ v := new(VerificationVectorSubmission)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_EpochBLSData_10_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_EpochBLSData_10_list) NewElement() protoreflect.Value {
+ v := new(VerificationVectorSubmission)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_EpochBLSData_10_list) IsValid() bool {
+ return x.list != nil
+}
+
+var _ protoreflect.List = (*_EpochBLSData_11_list)(nil)
+
+type _EpochBLSData_11_list struct {
+ list *[]bool
+}
+
+func (x *_EpochBLSData_11_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_EpochBLSData_11_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfBool((*x.list)[i])
+}
+
+func (x *_EpochBLSData_11_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Bool()
+ concreteValue := valueUnwrapped
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_EpochBLSData_11_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Bool()
+ concreteValue := valueUnwrapped
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_EpochBLSData_11_list) AppendMutable() protoreflect.Value {
+ panic(fmt.Errorf("AppendMutable can not be called on message EpochBLSData at list field ValidDealers as it is not of Message kind"))
+}
+
+func (x *_EpochBLSData_11_list) Truncate(n int) {
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_EpochBLSData_11_list) NewElement() protoreflect.Value {
+ v := false
+ return protoreflect.ValueOfBool(v)
+}
+
+func (x *_EpochBLSData_11_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_EpochBLSData protoreflect.MessageDescriptor
+ fd_EpochBLSData_epoch_id protoreflect.FieldDescriptor
+ fd_EpochBLSData_i_total_slots protoreflect.FieldDescriptor
+ fd_EpochBLSData_t_slots_degree protoreflect.FieldDescriptor
+ fd_EpochBLSData_participants protoreflect.FieldDescriptor
+ fd_EpochBLSData_dkg_phase protoreflect.FieldDescriptor
+ fd_EpochBLSData_dealing_phase_deadline_block protoreflect.FieldDescriptor
+ fd_EpochBLSData_verifying_phase_deadline_block protoreflect.FieldDescriptor
+ fd_EpochBLSData_group_public_key protoreflect.FieldDescriptor
+ fd_EpochBLSData_dealer_parts protoreflect.FieldDescriptor
+ fd_EpochBLSData_verification_submissions protoreflect.FieldDescriptor
+ fd_EpochBLSData_valid_dealers protoreflect.FieldDescriptor
+ fd_EpochBLSData_validation_signature protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bls_types_proto_init()
+ md_EpochBLSData = File_inference_bls_types_proto.Messages().ByName("EpochBLSData")
+ fd_EpochBLSData_epoch_id = md_EpochBLSData.Fields().ByName("epoch_id")
+ fd_EpochBLSData_i_total_slots = md_EpochBLSData.Fields().ByName("i_total_slots")
+ fd_EpochBLSData_t_slots_degree = md_EpochBLSData.Fields().ByName("t_slots_degree")
+ fd_EpochBLSData_participants = md_EpochBLSData.Fields().ByName("participants")
+ fd_EpochBLSData_dkg_phase = md_EpochBLSData.Fields().ByName("dkg_phase")
+ fd_EpochBLSData_dealing_phase_deadline_block = md_EpochBLSData.Fields().ByName("dealing_phase_deadline_block")
+ fd_EpochBLSData_verifying_phase_deadline_block = md_EpochBLSData.Fields().ByName("verifying_phase_deadline_block")
+ fd_EpochBLSData_group_public_key = md_EpochBLSData.Fields().ByName("group_public_key")
+ fd_EpochBLSData_dealer_parts = md_EpochBLSData.Fields().ByName("dealer_parts")
+ fd_EpochBLSData_verification_submissions = md_EpochBLSData.Fields().ByName("verification_submissions")
+ fd_EpochBLSData_valid_dealers = md_EpochBLSData.Fields().ByName("valid_dealers")
+ fd_EpochBLSData_validation_signature = md_EpochBLSData.Fields().ByName("validation_signature")
+}
+
+var _ protoreflect.Message = (*fastReflection_EpochBLSData)(nil)
+
+type fastReflection_EpochBLSData EpochBLSData
+
+func (x *EpochBLSData) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_EpochBLSData)(x)
+}
+
+func (x *EpochBLSData) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bls_types_proto_msgTypes[4]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_EpochBLSData_messageType fastReflection_EpochBLSData_messageType
+var _ protoreflect.MessageType = fastReflection_EpochBLSData_messageType{}
+
+type fastReflection_EpochBLSData_messageType struct{}
+
+func (x fastReflection_EpochBLSData_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_EpochBLSData)(nil)
+}
+func (x fastReflection_EpochBLSData_messageType) New() protoreflect.Message {
+ return new(fastReflection_EpochBLSData)
+}
+func (x fastReflection_EpochBLSData_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_EpochBLSData
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_EpochBLSData) Descriptor() protoreflect.MessageDescriptor {
+ return md_EpochBLSData
+}
+
+// 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_EpochBLSData) Type() protoreflect.MessageType {
+ return _fastReflection_EpochBLSData_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_EpochBLSData) New() protoreflect.Message {
+ return new(fastReflection_EpochBLSData)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_EpochBLSData) Interface() protoreflect.ProtoMessage {
+ return (*EpochBLSData)(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_EpochBLSData) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.EpochId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.EpochId)
+ if !f(fd_EpochBLSData_epoch_id, value) {
+ return
+ }
+ }
+ if x.ITotalSlots != uint32(0) {
+ value := protoreflect.ValueOfUint32(x.ITotalSlots)
+ if !f(fd_EpochBLSData_i_total_slots, value) {
+ return
+ }
+ }
+ if x.TSlotsDegree != uint32(0) {
+ value := protoreflect.ValueOfUint32(x.TSlotsDegree)
+ if !f(fd_EpochBLSData_t_slots_degree, value) {
+ return
+ }
+ }
+ if len(x.Participants) != 0 {
+ value := protoreflect.ValueOfList(&_EpochBLSData_4_list{list: &x.Participants})
+ if !f(fd_EpochBLSData_participants, value) {
+ return
+ }
+ }
+ if x.DkgPhase != 0 {
+ value := protoreflect.ValueOfEnum((protoreflect.EnumNumber)(x.DkgPhase))
+ if !f(fd_EpochBLSData_dkg_phase, value) {
+ return
+ }
+ }
+ if x.DealingPhaseDeadlineBlock != int64(0) {
+ value := protoreflect.ValueOfInt64(x.DealingPhaseDeadlineBlock)
+ if !f(fd_EpochBLSData_dealing_phase_deadline_block, value) {
+ return
+ }
+ }
+ if x.VerifyingPhaseDeadlineBlock != int64(0) {
+ value := protoreflect.ValueOfInt64(x.VerifyingPhaseDeadlineBlock)
+ if !f(fd_EpochBLSData_verifying_phase_deadline_block, value) {
+ return
+ }
+ }
+ if len(x.GroupPublicKey) != 0 {
+ value := protoreflect.ValueOfBytes(x.GroupPublicKey)
+ if !f(fd_EpochBLSData_group_public_key, value) {
+ return
+ }
+ }
+ if len(x.DealerParts) != 0 {
+ value := protoreflect.ValueOfList(&_EpochBLSData_9_list{list: &x.DealerParts})
+ if !f(fd_EpochBLSData_dealer_parts, value) {
+ return
+ }
+ }
+ if len(x.VerificationSubmissions) != 0 {
+ value := protoreflect.ValueOfList(&_EpochBLSData_10_list{list: &x.VerificationSubmissions})
+ if !f(fd_EpochBLSData_verification_submissions, value) {
+ return
+ }
+ }
+ if len(x.ValidDealers) != 0 {
+ value := protoreflect.ValueOfList(&_EpochBLSData_11_list{list: &x.ValidDealers})
+ if !f(fd_EpochBLSData_valid_dealers, value) {
+ return
+ }
+ }
+ if len(x.ValidationSignature) != 0 {
+ value := protoreflect.ValueOfBytes(x.ValidationSignature)
+ if !f(fd_EpochBLSData_validation_signature, 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_EpochBLSData) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bls.EpochBLSData.epoch_id":
+ return x.EpochId != uint64(0)
+ case "inference.bls.EpochBLSData.i_total_slots":
+ return x.ITotalSlots != uint32(0)
+ case "inference.bls.EpochBLSData.t_slots_degree":
+ return x.TSlotsDegree != uint32(0)
+ case "inference.bls.EpochBLSData.participants":
+ return len(x.Participants) != 0
+ case "inference.bls.EpochBLSData.dkg_phase":
+ return x.DkgPhase != 0
+ case "inference.bls.EpochBLSData.dealing_phase_deadline_block":
+ return x.DealingPhaseDeadlineBlock != int64(0)
+ case "inference.bls.EpochBLSData.verifying_phase_deadline_block":
+ return x.VerifyingPhaseDeadlineBlock != int64(0)
+ case "inference.bls.EpochBLSData.group_public_key":
+ return len(x.GroupPublicKey) != 0
+ case "inference.bls.EpochBLSData.dealer_parts":
+ return len(x.DealerParts) != 0
+ case "inference.bls.EpochBLSData.verification_submissions":
+ return len(x.VerificationSubmissions) != 0
+ case "inference.bls.EpochBLSData.valid_dealers":
+ return len(x.ValidDealers) != 0
+ case "inference.bls.EpochBLSData.validation_signature":
+ return len(x.ValidationSignature) != 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EpochBLSData"))
+ }
+ panic(fmt.Errorf("message inference.bls.EpochBLSData 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_EpochBLSData) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bls.EpochBLSData.epoch_id":
+ x.EpochId = uint64(0)
+ case "inference.bls.EpochBLSData.i_total_slots":
+ x.ITotalSlots = uint32(0)
+ case "inference.bls.EpochBLSData.t_slots_degree":
+ x.TSlotsDegree = uint32(0)
+ case "inference.bls.EpochBLSData.participants":
+ x.Participants = nil
+ case "inference.bls.EpochBLSData.dkg_phase":
+ x.DkgPhase = 0
+ case "inference.bls.EpochBLSData.dealing_phase_deadline_block":
+ x.DealingPhaseDeadlineBlock = int64(0)
+ case "inference.bls.EpochBLSData.verifying_phase_deadline_block":
+ x.VerifyingPhaseDeadlineBlock = int64(0)
+ case "inference.bls.EpochBLSData.group_public_key":
+ x.GroupPublicKey = nil
+ case "inference.bls.EpochBLSData.dealer_parts":
+ x.DealerParts = nil
+ case "inference.bls.EpochBLSData.verification_submissions":
+ x.VerificationSubmissions = nil
+ case "inference.bls.EpochBLSData.valid_dealers":
+ x.ValidDealers = nil
+ case "inference.bls.EpochBLSData.validation_signature":
+ x.ValidationSignature = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EpochBLSData"))
+ }
+ panic(fmt.Errorf("message inference.bls.EpochBLSData 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_EpochBLSData) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bls.EpochBLSData.epoch_id":
+ value := x.EpochId
+ return protoreflect.ValueOfUint64(value)
+ case "inference.bls.EpochBLSData.i_total_slots":
+ value := x.ITotalSlots
+ return protoreflect.ValueOfUint32(value)
+ case "inference.bls.EpochBLSData.t_slots_degree":
+ value := x.TSlotsDegree
+ return protoreflect.ValueOfUint32(value)
+ case "inference.bls.EpochBLSData.participants":
+ if len(x.Participants) == 0 {
+ return protoreflect.ValueOfList(&_EpochBLSData_4_list{})
+ }
+ listValue := &_EpochBLSData_4_list{list: &x.Participants}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.bls.EpochBLSData.dkg_phase":
+ value := x.DkgPhase
+ return protoreflect.ValueOfEnum((protoreflect.EnumNumber)(value))
+ case "inference.bls.EpochBLSData.dealing_phase_deadline_block":
+ value := x.DealingPhaseDeadlineBlock
+ return protoreflect.ValueOfInt64(value)
+ case "inference.bls.EpochBLSData.verifying_phase_deadline_block":
+ value := x.VerifyingPhaseDeadlineBlock
+ return protoreflect.ValueOfInt64(value)
+ case "inference.bls.EpochBLSData.group_public_key":
+ value := x.GroupPublicKey
+ return protoreflect.ValueOfBytes(value)
+ case "inference.bls.EpochBLSData.dealer_parts":
+ if len(x.DealerParts) == 0 {
+ return protoreflect.ValueOfList(&_EpochBLSData_9_list{})
+ }
+ listValue := &_EpochBLSData_9_list{list: &x.DealerParts}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.bls.EpochBLSData.verification_submissions":
+ if len(x.VerificationSubmissions) == 0 {
+ return protoreflect.ValueOfList(&_EpochBLSData_10_list{})
+ }
+ listValue := &_EpochBLSData_10_list{list: &x.VerificationSubmissions}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.bls.EpochBLSData.valid_dealers":
+ if len(x.ValidDealers) == 0 {
+ return protoreflect.ValueOfList(&_EpochBLSData_11_list{})
+ }
+ listValue := &_EpochBLSData_11_list{list: &x.ValidDealers}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.bls.EpochBLSData.validation_signature":
+ value := x.ValidationSignature
+ return protoreflect.ValueOfBytes(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EpochBLSData"))
+ }
+ panic(fmt.Errorf("message inference.bls.EpochBLSData 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_EpochBLSData) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bls.EpochBLSData.epoch_id":
+ x.EpochId = value.Uint()
+ case "inference.bls.EpochBLSData.i_total_slots":
+ x.ITotalSlots = uint32(value.Uint())
+ case "inference.bls.EpochBLSData.t_slots_degree":
+ x.TSlotsDegree = uint32(value.Uint())
+ case "inference.bls.EpochBLSData.participants":
+ lv := value.List()
+ clv := lv.(*_EpochBLSData_4_list)
+ x.Participants = *clv.list
+ case "inference.bls.EpochBLSData.dkg_phase":
+ x.DkgPhase = (DKGPhase)(value.Enum())
+ case "inference.bls.EpochBLSData.dealing_phase_deadline_block":
+ x.DealingPhaseDeadlineBlock = value.Int()
+ case "inference.bls.EpochBLSData.verifying_phase_deadline_block":
+ x.VerifyingPhaseDeadlineBlock = value.Int()
+ case "inference.bls.EpochBLSData.group_public_key":
+ x.GroupPublicKey = value.Bytes()
+ case "inference.bls.EpochBLSData.dealer_parts":
+ lv := value.List()
+ clv := lv.(*_EpochBLSData_9_list)
+ x.DealerParts = *clv.list
+ case "inference.bls.EpochBLSData.verification_submissions":
+ lv := value.List()
+ clv := lv.(*_EpochBLSData_10_list)
+ x.VerificationSubmissions = *clv.list
+ case "inference.bls.EpochBLSData.valid_dealers":
+ lv := value.List()
+ clv := lv.(*_EpochBLSData_11_list)
+ x.ValidDealers = *clv.list
+ case "inference.bls.EpochBLSData.validation_signature":
+ x.ValidationSignature = value.Bytes()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EpochBLSData"))
+ }
+ panic(fmt.Errorf("message inference.bls.EpochBLSData 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_EpochBLSData) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.EpochBLSData.participants":
+ if x.Participants == nil {
+ x.Participants = []*BLSParticipantInfo{}
+ }
+ value := &_EpochBLSData_4_list{list: &x.Participants}
+ return protoreflect.ValueOfList(value)
+ case "inference.bls.EpochBLSData.dealer_parts":
+ if x.DealerParts == nil {
+ x.DealerParts = []*DealerPartStorage{}
+ }
+ value := &_EpochBLSData_9_list{list: &x.DealerParts}
+ return protoreflect.ValueOfList(value)
+ case "inference.bls.EpochBLSData.verification_submissions":
+ if x.VerificationSubmissions == nil {
+ x.VerificationSubmissions = []*VerificationVectorSubmission{}
+ }
+ value := &_EpochBLSData_10_list{list: &x.VerificationSubmissions}
+ return protoreflect.ValueOfList(value)
+ case "inference.bls.EpochBLSData.valid_dealers":
+ if x.ValidDealers == nil {
+ x.ValidDealers = []bool{}
+ }
+ value := &_EpochBLSData_11_list{list: &x.ValidDealers}
+ return protoreflect.ValueOfList(value)
+ case "inference.bls.EpochBLSData.epoch_id":
+ panic(fmt.Errorf("field epoch_id of message inference.bls.EpochBLSData is not mutable"))
+ case "inference.bls.EpochBLSData.i_total_slots":
+ panic(fmt.Errorf("field i_total_slots of message inference.bls.EpochBLSData is not mutable"))
+ case "inference.bls.EpochBLSData.t_slots_degree":
+ panic(fmt.Errorf("field t_slots_degree of message inference.bls.EpochBLSData is not mutable"))
+ case "inference.bls.EpochBLSData.dkg_phase":
+ panic(fmt.Errorf("field dkg_phase of message inference.bls.EpochBLSData is not mutable"))
+ case "inference.bls.EpochBLSData.dealing_phase_deadline_block":
+ panic(fmt.Errorf("field dealing_phase_deadline_block of message inference.bls.EpochBLSData is not mutable"))
+ case "inference.bls.EpochBLSData.verifying_phase_deadline_block":
+ panic(fmt.Errorf("field verifying_phase_deadline_block of message inference.bls.EpochBLSData is not mutable"))
+ case "inference.bls.EpochBLSData.group_public_key":
+ panic(fmt.Errorf("field group_public_key of message inference.bls.EpochBLSData is not mutable"))
+ case "inference.bls.EpochBLSData.validation_signature":
+ panic(fmt.Errorf("field validation_signature of message inference.bls.EpochBLSData is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EpochBLSData"))
+ }
+ panic(fmt.Errorf("message inference.bls.EpochBLSData 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_EpochBLSData) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bls.EpochBLSData.epoch_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.bls.EpochBLSData.i_total_slots":
+ return protoreflect.ValueOfUint32(uint32(0))
+ case "inference.bls.EpochBLSData.t_slots_degree":
+ return protoreflect.ValueOfUint32(uint32(0))
+ case "inference.bls.EpochBLSData.participants":
+ list := []*BLSParticipantInfo{}
+ return protoreflect.ValueOfList(&_EpochBLSData_4_list{list: &list})
+ case "inference.bls.EpochBLSData.dkg_phase":
+ return protoreflect.ValueOfEnum(0)
+ case "inference.bls.EpochBLSData.dealing_phase_deadline_block":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.bls.EpochBLSData.verifying_phase_deadline_block":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.bls.EpochBLSData.group_public_key":
+ return protoreflect.ValueOfBytes(nil)
+ case "inference.bls.EpochBLSData.dealer_parts":
+ list := []*DealerPartStorage{}
+ return protoreflect.ValueOfList(&_EpochBLSData_9_list{list: &list})
+ case "inference.bls.EpochBLSData.verification_submissions":
+ list := []*VerificationVectorSubmission{}
+ return protoreflect.ValueOfList(&_EpochBLSData_10_list{list: &list})
+ case "inference.bls.EpochBLSData.valid_dealers":
+ list := []bool{}
+ return protoreflect.ValueOfList(&_EpochBLSData_11_list{list: &list})
+ case "inference.bls.EpochBLSData.validation_signature":
+ return protoreflect.ValueOfBytes(nil)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bls.EpochBLSData"))
+ }
+ panic(fmt.Errorf("message inference.bls.EpochBLSData 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_EpochBLSData) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bls.EpochBLSData", 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_EpochBLSData) 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_EpochBLSData) 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_EpochBLSData) 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_EpochBLSData) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*EpochBLSData)
+ 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.EpochId != 0 {
+ n += 1 + runtime.Sov(uint64(x.EpochId))
+ }
+ if x.ITotalSlots != 0 {
+ n += 1 + runtime.Sov(uint64(x.ITotalSlots))
+ }
+ if x.TSlotsDegree != 0 {
+ n += 1 + runtime.Sov(uint64(x.TSlotsDegree))
+ }
+ if len(x.Participants) > 0 {
+ for _, e := range x.Participants {
+ l = options.Size(e)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ }
+ if x.DkgPhase != 0 {
+ n += 1 + runtime.Sov(uint64(x.DkgPhase))
+ }
+ if x.DealingPhaseDeadlineBlock != 0 {
+ n += 1 + runtime.Sov(uint64(x.DealingPhaseDeadlineBlock))
+ }
+ if x.VerifyingPhaseDeadlineBlock != 0 {
+ n += 1 + runtime.Sov(uint64(x.VerifyingPhaseDeadlineBlock))
+ }
+ l = len(x.GroupPublicKey)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if len(x.DealerParts) > 0 {
+ for _, e := range x.DealerParts {
+ l = options.Size(e)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ }
+ if len(x.VerificationSubmissions) > 0 {
+ for _, e := range x.VerificationSubmissions {
+ l = options.Size(e)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ }
+ if len(x.ValidDealers) > 0 {
+ n += 1 + runtime.Sov(uint64(len(x.ValidDealers))) + len(x.ValidDealers)*1
+ }
+ l = len(x.ValidationSignature)
+ 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().(*EpochBLSData)
+ 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.ValidationSignature) > 0 {
+ i -= len(x.ValidationSignature)
+ copy(dAtA[i:], x.ValidationSignature)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ValidationSignature)))
+ i--
+ dAtA[i] = 0x62
+ }
+ if len(x.ValidDealers) > 0 {
+ for iNdEx := len(x.ValidDealers) - 1; iNdEx >= 0; iNdEx-- {
+ i--
+ if x.ValidDealers[iNdEx] {
+ dAtA[i] = 1
+ } else {
+ dAtA[i] = 0
+ }
+ }
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ValidDealers)))
+ i--
+ dAtA[i] = 0x5a
+ }
+ if len(x.VerificationSubmissions) > 0 {
+ for iNdEx := len(x.VerificationSubmissions) - 1; iNdEx >= 0; iNdEx-- {
+ encoded, err := options.Marshal(x.VerificationSubmissions[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] = 0x52
+ }
+ }
+ if len(x.DealerParts) > 0 {
+ for iNdEx := len(x.DealerParts) - 1; iNdEx >= 0; iNdEx-- {
+ encoded, err := options.Marshal(x.DealerParts[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] = 0x4a
+ }
+ }
+ if len(x.GroupPublicKey) > 0 {
+ i -= len(x.GroupPublicKey)
+ copy(dAtA[i:], x.GroupPublicKey)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.GroupPublicKey)))
+ i--
+ dAtA[i] = 0x42
+ }
+ if x.VerifyingPhaseDeadlineBlock != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.VerifyingPhaseDeadlineBlock))
+ i--
+ dAtA[i] = 0x38
+ }
+ if x.DealingPhaseDeadlineBlock != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.DealingPhaseDeadlineBlock))
+ i--
+ dAtA[i] = 0x30
+ }
+ if x.DkgPhase != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.DkgPhase))
+ i--
+ dAtA[i] = 0x28
+ }
+ 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] = 0x22
+ }
+ }
+ if x.TSlotsDegree != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.TSlotsDegree))
+ i--
+ dAtA[i] = 0x18
+ }
+ if x.ITotalSlots != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.ITotalSlots))
+ i--
+ dAtA[i] = 0x10
+ }
+ 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...)
+ } 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().(*EpochBLSData)
+ 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: EpochBLSData: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: EpochBLSData: 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 != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ITotalSlots", wireType)
+ }
+ x.ITotalSlots = 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.ITotalSlots |= uint32(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 TSlotsDegree", wireType)
+ }
+ x.TSlotsDegree = 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.TSlotsDegree |= 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 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, &BLSParticipantInfo{})
+ 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 5:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DkgPhase", wireType)
+ }
+ x.DkgPhase = 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.DkgPhase |= DKGPhase(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 DealingPhaseDeadlineBlock", wireType)
+ }
+ x.DealingPhaseDeadlineBlock = 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.DealingPhaseDeadlineBlock |= int64(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 VerifyingPhaseDeadlineBlock", wireType)
+ }
+ x.VerifyingPhaseDeadlineBlock = 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.VerifyingPhaseDeadlineBlock |= int64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 8:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field GroupPublicKey", 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.GroupPublicKey = append(x.GroupPublicKey[:0], dAtA[iNdEx:postIndex]...)
+ if x.GroupPublicKey == nil {
+ x.GroupPublicKey = []byte{}
+ }
+ iNdEx = postIndex
+ case 9:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DealerParts", 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.DealerParts = append(x.DealerParts, &DealerPartStorage{})
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.DealerParts[len(x.DealerParts)-1]); err != nil {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+ }
+ iNdEx = postIndex
+ case 10:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field VerificationSubmissions", 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.VerificationSubmissions = append(x.VerificationSubmissions, &VerificationVectorSubmission{})
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.VerificationSubmissions[len(x.VerificationSubmissions)-1]); err != nil {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+ }
+ iNdEx = postIndex
+ case 11:
+ if wireType == 0 {
+ 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.ValidDealers = append(x.ValidDealers, bool(v != 0))
+ } 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
+ if elementCount != 0 && len(x.ValidDealers) == 0 {
+ x.ValidDealers = make([]bool, 0, elementCount)
+ }
+ for iNdEx < postIndex {
+ 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.ValidDealers = append(x.ValidDealers, bool(v != 0))
+ }
+ } else {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidDealers", wireType)
+ }
+ case 12:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidationSignature", 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.ValidationSignature = append(x.ValidationSignature[:0], dAtA[iNdEx:postIndex]...)
+ if x.ValidationSignature == nil {
+ x.ValidationSignature = []byte{}
+ }
+ 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/bls/types.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)
+)
+
+// DKGPhase defines the different phases of the Distributed Key Generation process
+type DKGPhase int32
+
+const (
+ // UNDEFINED represents an uninitialized or unknown phase
+ DKGPhase_DKG_PHASE_UNDEFINED DKGPhase = 0
+ // DEALING represents the phase where participants submit their dealing parts
+ DKGPhase_DKG_PHASE_DEALING DKGPhase = 1
+ // VERIFYING represents the phase where participants verify dealing parts
+ DKGPhase_DKG_PHASE_VERIFYING DKGPhase = 2
+ // COMPLETED represents the phase where DKG has successfully completed
+ DKGPhase_DKG_PHASE_COMPLETED DKGPhase = 3
+ // FAILED represents the phase where DKG has failed
+ DKGPhase_DKG_PHASE_FAILED DKGPhase = 4
+ // SIGNED represents the phase where DKG has completed and been validated by previous epoch
+ DKGPhase_DKG_PHASE_SIGNED DKGPhase = 5
+)
+
+// Enum value maps for DKGPhase.
+var (
+ DKGPhase_name = map[int32]string{
+ 0: "DKG_PHASE_UNDEFINED",
+ 1: "DKG_PHASE_DEALING",
+ 2: "DKG_PHASE_VERIFYING",
+ 3: "DKG_PHASE_COMPLETED",
+ 4: "DKG_PHASE_FAILED",
+ 5: "DKG_PHASE_SIGNED",
+ }
+ DKGPhase_value = map[string]int32{
+ "DKG_PHASE_UNDEFINED": 0,
+ "DKG_PHASE_DEALING": 1,
+ "DKG_PHASE_VERIFYING": 2,
+ "DKG_PHASE_COMPLETED": 3,
+ "DKG_PHASE_FAILED": 4,
+ "DKG_PHASE_SIGNED": 5,
+ }
+)
+
+func (x DKGPhase) Enum() *DKGPhase {
+ p := new(DKGPhase)
+ *p = x
+ return p
+}
+
+func (x DKGPhase) String() string {
+ return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (DKGPhase) Descriptor() protoreflect.EnumDescriptor {
+ return file_inference_bls_types_proto_enumTypes[0].Descriptor()
+}
+
+func (DKGPhase) Type() protoreflect.EnumType {
+ return &file_inference_bls_types_proto_enumTypes[0]
+}
+
+func (x DKGPhase) Number() protoreflect.EnumNumber {
+ return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use DKGPhase.Descriptor instead.
+func (DKGPhase) EnumDescriptor() ([]byte, []int) {
+ return file_inference_bls_types_proto_rawDescGZIP(), []int{0}
+}
+
+// BLSParticipantInfo contains information about a participant in the DKG process
+type BLSParticipantInfo struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // address is the participant's address
+ Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
+ // percentage_weight is the participant's weight in the validation set (as string for sdk.Dec compatibility)
+ PercentageWeight string `protobuf:"bytes,2,opt,name=percentage_weight,json=percentageWeight,proto3" json:"percentage_weight,omitempty"`
+ // secp256k1_public_key is the participant's secp256k1 public key for encryption
+ Secp256K1PublicKey []byte `protobuf:"bytes,3,opt,name=secp256k1_public_key,json=secp256k1PublicKey,proto3" json:"secp256k1_public_key,omitempty"`
+ // slot_start_index is the first slot index assigned to this participant
+ SlotStartIndex uint32 `protobuf:"varint,4,opt,name=slot_start_index,json=slotStartIndex,proto3" json:"slot_start_index,omitempty"`
+ // slot_end_index is the last slot index assigned to this participant (inclusive)
+ SlotEndIndex uint32 `protobuf:"varint,5,opt,name=slot_end_index,json=slotEndIndex,proto3" json:"slot_end_index,omitempty"`
+}
+
+func (x *BLSParticipantInfo) Reset() {
+ *x = BLSParticipantInfo{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_types_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *BLSParticipantInfo) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BLSParticipantInfo) ProtoMessage() {}
+
+// Deprecated: Use BLSParticipantInfo.ProtoReflect.Descriptor instead.
+func (*BLSParticipantInfo) Descriptor() ([]byte, []int) {
+ return file_inference_bls_types_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *BLSParticipantInfo) GetAddress() string {
+ if x != nil {
+ return x.Address
+ }
+ return ""
+}
+
+func (x *BLSParticipantInfo) GetPercentageWeight() string {
+ if x != nil {
+ return x.PercentageWeight
+ }
+ return ""
+}
+
+func (x *BLSParticipantInfo) GetSecp256K1PublicKey() []byte {
+ if x != nil {
+ return x.Secp256K1PublicKey
+ }
+ return nil
+}
+
+func (x *BLSParticipantInfo) GetSlotStartIndex() uint32 {
+ if x != nil {
+ return x.SlotStartIndex
+ }
+ return 0
+}
+
+func (x *BLSParticipantInfo) GetSlotEndIndex() uint32 {
+ if x != nil {
+ return x.SlotEndIndex
+ }
+ return 0
+}
+
+// EncryptedSharesForParticipant contains encrypted shares for a specific participant
+type EncryptedSharesForParticipant struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // encrypted_shares contains shares for participant's slot range in order
+ // Index i = share for slot (participant.slot_start_index + i)
+ EncryptedShares [][]byte `protobuf:"bytes,1,rep,name=encrypted_shares,json=encryptedShares,proto3" json:"encrypted_shares,omitempty"`
+}
+
+func (x *EncryptedSharesForParticipant) Reset() {
+ *x = EncryptedSharesForParticipant{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_types_proto_msgTypes[1]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *EncryptedSharesForParticipant) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*EncryptedSharesForParticipant) ProtoMessage() {}
+
+// Deprecated: Use EncryptedSharesForParticipant.ProtoReflect.Descriptor instead.
+func (*EncryptedSharesForParticipant) Descriptor() ([]byte, []int) {
+ return file_inference_bls_types_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *EncryptedSharesForParticipant) GetEncryptedShares() [][]byte {
+ if x != nil {
+ return x.EncryptedShares
+ }
+ return nil
+}
+
+// DealerPartStorage contains the storage format for a dealer's contribution to DKG
+type DealerPartStorage struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // dealer_address is the address of the dealer who submitted this part
+ DealerAddress string `protobuf:"bytes,1,opt,name=dealer_address,json=dealerAddress,proto3" json:"dealer_address,omitempty"`
+ // commitments are the G2 points C_kj = g * a_kj representing polynomial commitments
+ Commitments [][]byte `protobuf:"bytes,2,rep,name=commitments,proto3" json:"commitments,omitempty"`
+ // participant_shares contains encrypted shares for all participants in order
+ // Index i = shares for EpochBLSData.participants[i]
+ ParticipantShares []*EncryptedSharesForParticipant `protobuf:"bytes,3,rep,name=participant_shares,json=participantShares,proto3" json:"participant_shares,omitempty"`
+}
+
+func (x *DealerPartStorage) Reset() {
+ *x = DealerPartStorage{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_types_proto_msgTypes[2]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *DealerPartStorage) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DealerPartStorage) ProtoMessage() {}
+
+// Deprecated: Use DealerPartStorage.ProtoReflect.Descriptor instead.
+func (*DealerPartStorage) Descriptor() ([]byte, []int) {
+ return file_inference_bls_types_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *DealerPartStorage) GetDealerAddress() string {
+ if x != nil {
+ return x.DealerAddress
+ }
+ return ""
+}
+
+func (x *DealerPartStorage) GetCommitments() [][]byte {
+ if x != nil {
+ return x.Commitments
+ }
+ return nil
+}
+
+func (x *DealerPartStorage) GetParticipantShares() []*EncryptedSharesForParticipant {
+ if x != nil {
+ return x.ParticipantShares
+ }
+ return nil
+}
+
+// VerificationVectorSubmission contains verification results from a specific participant
+type VerificationVectorSubmission struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // dealer_validity bitmap indicating which dealers this participant verified as valid
+ // Index i corresponds to EpochBLSData.participants[i] as dealer
+ // true = dealer's shares verified correctly; false = failed verification or no submission
+ // Empty array indicates participant has not submitted verification yet
+ DealerValidity []bool `protobuf:"varint,1,rep,packed,name=dealer_validity,json=dealerValidity,proto3" json:"dealer_validity,omitempty"`
+}
+
+func (x *VerificationVectorSubmission) Reset() {
+ *x = VerificationVectorSubmission{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_types_proto_msgTypes[3]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *VerificationVectorSubmission) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*VerificationVectorSubmission) ProtoMessage() {}
+
+// Deprecated: Use VerificationVectorSubmission.ProtoReflect.Descriptor instead.
+func (*VerificationVectorSubmission) Descriptor() ([]byte, []int) {
+ return file_inference_bls_types_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *VerificationVectorSubmission) GetDealerValidity() []bool {
+ if x != nil {
+ return x.DealerValidity
+ }
+ return nil
+}
+
+// EpochBLSData contains all information about a DKG round for a specific epoch
+type EpochBLSData struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // epoch_id uniquely identifies this DKG round
+ EpochId uint64 `protobuf:"varint,1,opt,name=epoch_id,json=epochId,proto3" json:"epoch_id,omitempty"`
+ // i_total_slots is the total number of slots in the DKG
+ ITotalSlots uint32 `protobuf:"varint,2,opt,name=i_total_slots,json=iTotalSlots,proto3" json:"i_total_slots,omitempty"`
+ // t_slots_degree is the polynomial degree t for the threshold scheme
+ TSlotsDegree uint32 `protobuf:"varint,3,opt,name=t_slots_degree,json=tSlotsDegree,proto3" json:"t_slots_degree,omitempty"`
+ // participants contains information about all participants in this DKG round
+ Participants []*BLSParticipantInfo `protobuf:"bytes,4,rep,name=participants,proto3" json:"participants,omitempty"`
+ // dkg_phase indicates the current phase of the DKG process
+ DkgPhase DKGPhase `protobuf:"varint,5,opt,name=dkg_phase,json=dkgPhase,proto3,enum=inference.bls.DKGPhase" json:"dkg_phase,omitempty"`
+ // dealing_phase_deadline_block is the block height deadline for the dealing phase
+ DealingPhaseDeadlineBlock int64 `protobuf:"varint,6,opt,name=dealing_phase_deadline_block,json=dealingPhaseDeadlineBlock,proto3" json:"dealing_phase_deadline_block,omitempty"`
+ // verifying_phase_deadline_block is the block height deadline for the verification phase
+ VerifyingPhaseDeadlineBlock int64 `protobuf:"varint,7,opt,name=verifying_phase_deadline_block,json=verifyingPhaseDeadlineBlock,proto3" json:"verifying_phase_deadline_block,omitempty"`
+ // group_public_key is the final group public key (G2 point) when DKG completes
+ GroupPublicKey []byte `protobuf:"bytes,8,opt,name=group_public_key,json=groupPublicKey,proto3" json:"group_public_key,omitempty"`
+ // dealer_parts contains dealer contributions in the same order as participants array
+ // dealer_parts[i] corresponds to participants[i]'s dealer contribution
+ // nil/empty entries indicate that participant has not submitted their dealer part yet
+ DealerParts []*DealerPartStorage `protobuf:"bytes,9,rep,name=dealer_parts,json=dealerParts,proto3" json:"dealer_parts,omitempty"`
+ // verification_submissions contains verification results from each participant
+ // Each entry tracks which dealers that participant verified as valid
+ VerificationSubmissions []*VerificationVectorSubmission `protobuf:"bytes,10,rep,name=verification_submissions,json=verificationSubmissions,proto3" json:"verification_submissions,omitempty"`
+ // valid_dealers contains the validity of each dealer that was determined during DKG completion
+ // This is populated when the DKG transitions to COMPLETED phase
+ // Index i corresponds to whether dealer i (participants[i]) is valid
+ ValidDealers []bool `protobuf:"varint,11,rep,packed,name=valid_dealers,json=validDealers,proto3" json:"valid_dealers,omitempty"`
+ // validation_signature is the final aggregated signature validating this epoch's group public key
+ // This signature is created by the previous epoch's validators using their BLS slot shares
+ // For Epoch 1 (genesis), this field remains empty (no previous epoch to validate)
+ // For Epoch N+1, stores the signature from Epoch N validators confirming the new group public key
+ // Format: 48-byte G1 compressed signature
+ ValidationSignature []byte `protobuf:"bytes,12,opt,name=validation_signature,json=validationSignature,proto3" json:"validation_signature,omitempty"`
+}
+
+func (x *EpochBLSData) Reset() {
+ *x = EpochBLSData{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bls_types_proto_msgTypes[4]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *EpochBLSData) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*EpochBLSData) ProtoMessage() {}
+
+// Deprecated: Use EpochBLSData.ProtoReflect.Descriptor instead.
+func (*EpochBLSData) Descriptor() ([]byte, []int) {
+ return file_inference_bls_types_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *EpochBLSData) GetEpochId() uint64 {
+ if x != nil {
+ return x.EpochId
+ }
+ return 0
+}
+
+func (x *EpochBLSData) GetITotalSlots() uint32 {
+ if x != nil {
+ return x.ITotalSlots
+ }
+ return 0
+}
+
+func (x *EpochBLSData) GetTSlotsDegree() uint32 {
+ if x != nil {
+ return x.TSlotsDegree
+ }
+ return 0
+}
+
+func (x *EpochBLSData) GetParticipants() []*BLSParticipantInfo {
+ if x != nil {
+ return x.Participants
+ }
+ return nil
+}
+
+func (x *EpochBLSData) GetDkgPhase() DKGPhase {
+ if x != nil {
+ return x.DkgPhase
+ }
+ return DKGPhase_DKG_PHASE_UNDEFINED
+}
+
+func (x *EpochBLSData) GetDealingPhaseDeadlineBlock() int64 {
+ if x != nil {
+ return x.DealingPhaseDeadlineBlock
+ }
+ return 0
+}
+
+func (x *EpochBLSData) GetVerifyingPhaseDeadlineBlock() int64 {
+ if x != nil {
+ return x.VerifyingPhaseDeadlineBlock
+ }
+ return 0
+}
+
+func (x *EpochBLSData) GetGroupPublicKey() []byte {
+ if x != nil {
+ return x.GroupPublicKey
+ }
+ return nil
+}
+
+func (x *EpochBLSData) GetDealerParts() []*DealerPartStorage {
+ if x != nil {
+ return x.DealerParts
+ }
+ return nil
+}
+
+func (x *EpochBLSData) GetVerificationSubmissions() []*VerificationVectorSubmission {
+ if x != nil {
+ return x.VerificationSubmissions
+ }
+ return nil
+}
+
+func (x *EpochBLSData) GetValidDealers() []bool {
+ if x != nil {
+ return x.ValidDealers
+ }
+ return nil
+}
+
+func (x *EpochBLSData) GetValidationSignature() []byte {
+ if x != nil {
+ return x.ValidationSignature
+ }
+ return nil
+}
+
+var File_inference_bls_types_proto protoreflect.FileDescriptor
+
+var file_inference_bls_types_proto_rawDesc = []byte{
+ 0x0a, 0x19, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x62, 0x6c, 0x73, 0x2f,
+ 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0d, 0x69, 0x6e, 0x66,
+ 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x1a, 0x11, 0x61, 0x6d, 0x69, 0x6e,
+ 0x6f, 0x2f, 0x61, 0x6d, 0x69, 0x6e, 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, 0x1a, 0x14, 0x67, 0x6f, 0x67, 0x6f, 0x70, 0x72,
+ 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x90,
+ 0x02, 0x0a, 0x12, 0x42, 0x4c, 0x53, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e,
+ 0x74, 0x49, 0x6e, 0x66, 0x6f, 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,
+ 0x5e, 0x0a, 0x11, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x5f, 0x77, 0x65,
+ 0x69, 0x67, 0x68, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x31, 0xc8, 0xde, 0x1f, 0x00,
+ 0xda, 0xde, 0x1f, 0x1b, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f,
+ 0x2f, 0x6d, 0x61, 0x74, 0x68, 0x2e, 0x4c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x44, 0x65, 0x63, 0xd2,
+ 0xb4, 0x2d, 0x0a, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x44, 0x65, 0x63, 0x52, 0x10, 0x70,
+ 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12,
+ 0x30, 0x0a, 0x14, 0x73, 0x65, 0x63, 0x70, 0x32, 0x35, 0x36, 0x6b, 0x31, 0x5f, 0x70, 0x75, 0x62,
+ 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x12, 0x73,
+ 0x65, 0x63, 0x70, 0x32, 0x35, 0x36, 0x6b, 0x31, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65,
+ 0x79, 0x12, 0x28, 0x0a, 0x10, 0x73, 0x6c, 0x6f, 0x74, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f,
+ 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0e, 0x73, 0x6c, 0x6f,
+ 0x74, 0x53, 0x74, 0x61, 0x72, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x24, 0x0a, 0x0e, 0x73,
+ 0x6c, 0x6f, 0x74, 0x5f, 0x65, 0x6e, 0x64, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x05, 0x20,
+ 0x01, 0x28, 0x0d, 0x52, 0x0c, 0x73, 0x6c, 0x6f, 0x74, 0x45, 0x6e, 0x64, 0x49, 0x6e, 0x64, 0x65,
+ 0x78, 0x22, 0x4a, 0x0a, 0x1d, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x53, 0x68,
+ 0x61, 0x72, 0x65, 0x73, 0x46, 0x6f, 0x72, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61,
+ 0x6e, 0x74, 0x12, 0x29, 0x0a, 0x10, 0x65, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x5f,
+ 0x73, 0x68, 0x61, 0x72, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x0f, 0x65, 0x6e,
+ 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x53, 0x68, 0x61, 0x72, 0x65, 0x73, 0x22, 0xb9, 0x01,
+ 0x0a, 0x11, 0x44, 0x65, 0x61, 0x6c, 0x65, 0x72, 0x50, 0x61, 0x72, 0x74, 0x53, 0x74, 0x6f, 0x72,
+ 0x61, 0x67, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x64, 0x65, 0x61, 0x6c, 0x65, 0x72, 0x5f, 0x61, 0x64,
+ 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x64, 0x65, 0x61,
+ 0x6c, 0x65, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x20, 0x0a, 0x0b, 0x63, 0x6f,
+ 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0c, 0x52,
+ 0x0b, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x5b, 0x0a, 0x12,
+ 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x5f, 0x73, 0x68, 0x61, 0x72,
+ 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+ 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x2e, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74,
+ 0x65, 0x64, 0x53, 0x68, 0x61, 0x72, 0x65, 0x73, 0x46, 0x6f, 0x72, 0x50, 0x61, 0x72, 0x74, 0x69,
+ 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x52, 0x11, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70,
+ 0x61, 0x6e, 0x74, 0x53, 0x68, 0x61, 0x72, 0x65, 0x73, 0x22, 0x47, 0x0a, 0x1c, 0x56, 0x65, 0x72,
+ 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x53,
+ 0x75, 0x62, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x27, 0x0a, 0x0f, 0x64, 0x65, 0x61,
+ 0x6c, 0x65, 0x72, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x03,
+ 0x28, 0x08, 0x52, 0x0e, 0x64, 0x65, 0x61, 0x6c, 0x65, 0x72, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x69,
+ 0x74, 0x79, 0x22, 0xab, 0x05, 0x0a, 0x0c, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x42, 0x4c, 0x53, 0x44,
+ 0x61, 0x74, 0x61, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x64, 0x18,
+ 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x64, 0x12, 0x22,
+ 0x0a, 0x0d, 0x69, 0x5f, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x73, 0x6c, 0x6f, 0x74, 0x73, 0x18,
+ 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0b, 0x69, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x53, 0x6c, 0x6f,
+ 0x74, 0x73, 0x12, 0x24, 0x0a, 0x0e, 0x74, 0x5f, 0x73, 0x6c, 0x6f, 0x74, 0x73, 0x5f, 0x64, 0x65,
+ 0x67, 0x72, 0x65, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0c, 0x74, 0x53, 0x6c, 0x6f,
+ 0x74, 0x73, 0x44, 0x65, 0x67, 0x72, 0x65, 0x65, 0x12, 0x4b, 0x0a, 0x0c, 0x70, 0x61, 0x72, 0x74,
+ 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21,
+ 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x2e, 0x42,
+ 0x4c, 0x53, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x49, 0x6e, 0x66,
+ 0x6f, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0c, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69,
+ 0x70, 0x61, 0x6e, 0x74, 0x73, 0x12, 0x34, 0x0a, 0x09, 0x64, 0x6b, 0x67, 0x5f, 0x70, 0x68, 0x61,
+ 0x73, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x17, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+ 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x2e, 0x44, 0x4b, 0x47, 0x50, 0x68, 0x61, 0x73,
+ 0x65, 0x52, 0x08, 0x64, 0x6b, 0x67, 0x50, 0x68, 0x61, 0x73, 0x65, 0x12, 0x3f, 0x0a, 0x1c, 0x64,
+ 0x65, 0x61, 0x6c, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x68, 0x61, 0x73, 0x65, 0x5f, 0x64, 0x65, 0x61,
+ 0x64, 0x6c, 0x69, 0x6e, 0x65, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x18, 0x06, 0x20, 0x01, 0x28,
+ 0x03, 0x52, 0x19, 0x64, 0x65, 0x61, 0x6c, 0x69, 0x6e, 0x67, 0x50, 0x68, 0x61, 0x73, 0x65, 0x44,
+ 0x65, 0x61, 0x64, 0x6c, 0x69, 0x6e, 0x65, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x12, 0x43, 0x0a, 0x1e,
+ 0x76, 0x65, 0x72, 0x69, 0x66, 0x79, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x68, 0x61, 0x73, 0x65, 0x5f,
+ 0x64, 0x65, 0x61, 0x64, 0x6c, 0x69, 0x6e, 0x65, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x18, 0x07,
+ 0x20, 0x01, 0x28, 0x03, 0x52, 0x1b, 0x76, 0x65, 0x72, 0x69, 0x66, 0x79, 0x69, 0x6e, 0x67, 0x50,
+ 0x68, 0x61, 0x73, 0x65, 0x44, 0x65, 0x61, 0x64, 0x6c, 0x69, 0x6e, 0x65, 0x42, 0x6c, 0x6f, 0x63,
+ 0x6b, 0x12, 0x28, 0x0a, 0x10, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69,
+ 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0e, 0x67, 0x72, 0x6f,
+ 0x75, 0x70, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x12, 0x43, 0x0a, 0x0c, 0x64,
+ 0x65, 0x61, 0x6c, 0x65, 0x72, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x73, 0x18, 0x09, 0x20, 0x03, 0x28,
+ 0x0b, 0x32, 0x20, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c,
+ 0x73, 0x2e, 0x44, 0x65, 0x61, 0x6c, 0x65, 0x72, 0x50, 0x61, 0x72, 0x74, 0x53, 0x74, 0x6f, 0x72,
+ 0x61, 0x67, 0x65, 0x52, 0x0b, 0x64, 0x65, 0x61, 0x6c, 0x65, 0x72, 0x50, 0x61, 0x72, 0x74, 0x73,
+ 0x12, 0x66, 0x0a, 0x18, 0x76, 0x65, 0x72, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+ 0x5f, 0x73, 0x75, 0x62, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x0a, 0x20, 0x03,
+ 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62,
+ 0x6c, 0x73, 0x2e, 0x56, 0x65, 0x72, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x56,
+ 0x65, 0x63, 0x74, 0x6f, 0x72, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x52,
+ 0x17, 0x76, 0x65, 0x72, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x75, 0x62,
+ 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x76, 0x61, 0x6c, 0x69,
+ 0x64, 0x5f, 0x64, 0x65, 0x61, 0x6c, 0x65, 0x72, 0x73, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x08, 0x52,
+ 0x0c, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x44, 0x65, 0x61, 0x6c, 0x65, 0x72, 0x73, 0x12, 0x31, 0x0a,
+ 0x14, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x69, 0x67, 0x6e,
+ 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x13, 0x76, 0x61, 0x6c,
+ 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65,
+ 0x2a, 0x98, 0x01, 0x0a, 0x08, 0x44, 0x4b, 0x47, 0x50, 0x68, 0x61, 0x73, 0x65, 0x12, 0x17, 0x0a,
+ 0x13, 0x44, 0x4b, 0x47, 0x5f, 0x50, 0x48, 0x41, 0x53, 0x45, 0x5f, 0x55, 0x4e, 0x44, 0x45, 0x46,
+ 0x49, 0x4e, 0x45, 0x44, 0x10, 0x00, 0x12, 0x15, 0x0a, 0x11, 0x44, 0x4b, 0x47, 0x5f, 0x50, 0x48,
+ 0x41, 0x53, 0x45, 0x5f, 0x44, 0x45, 0x41, 0x4c, 0x49, 0x4e, 0x47, 0x10, 0x01, 0x12, 0x17, 0x0a,
+ 0x13, 0x44, 0x4b, 0x47, 0x5f, 0x50, 0x48, 0x41, 0x53, 0x45, 0x5f, 0x56, 0x45, 0x52, 0x49, 0x46,
+ 0x59, 0x49, 0x4e, 0x47, 0x10, 0x02, 0x12, 0x17, 0x0a, 0x13, 0x44, 0x4b, 0x47, 0x5f, 0x50, 0x48,
+ 0x41, 0x53, 0x45, 0x5f, 0x43, 0x4f, 0x4d, 0x50, 0x4c, 0x45, 0x54, 0x45, 0x44, 0x10, 0x03, 0x12,
+ 0x14, 0x0a, 0x10, 0x44, 0x4b, 0x47, 0x5f, 0x50, 0x48, 0x41, 0x53, 0x45, 0x5f, 0x46, 0x41, 0x49,
+ 0x4c, 0x45, 0x44, 0x10, 0x04, 0x12, 0x14, 0x0a, 0x10, 0x44, 0x4b, 0x47, 0x5f, 0x50, 0x48, 0x41,
+ 0x53, 0x45, 0x5f, 0x53, 0x49, 0x47, 0x4e, 0x45, 0x44, 0x10, 0x05, 0x42, 0x94, 0x01, 0x0a, 0x11,
+ 0x63, 0x6f, 0x6d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c,
+ 0x73, 0x42, 0x0a, 0x54, 0x79, 0x70, 0x65, 0x73, 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 (
+ file_inference_bls_types_proto_rawDescOnce sync.Once
+ file_inference_bls_types_proto_rawDescData = file_inference_bls_types_proto_rawDesc
+)
+
+func file_inference_bls_types_proto_rawDescGZIP() []byte {
+ file_inference_bls_types_proto_rawDescOnce.Do(func() {
+ file_inference_bls_types_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_bls_types_proto_rawDescData)
+ })
+ return file_inference_bls_types_proto_rawDescData
+}
+
+var file_inference_bls_types_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
+var file_inference_bls_types_proto_msgTypes = make([]protoimpl.MessageInfo, 5)
+var file_inference_bls_types_proto_goTypes = []interface{}{
+ (DKGPhase)(0), // 0: inference.bls.DKGPhase
+ (*BLSParticipantInfo)(nil), // 1: inference.bls.BLSParticipantInfo
+ (*EncryptedSharesForParticipant)(nil), // 2: inference.bls.EncryptedSharesForParticipant
+ (*DealerPartStorage)(nil), // 3: inference.bls.DealerPartStorage
+ (*VerificationVectorSubmission)(nil), // 4: inference.bls.VerificationVectorSubmission
+ (*EpochBLSData)(nil), // 5: inference.bls.EpochBLSData
+}
+var file_inference_bls_types_proto_depIdxs = []int32{
+ 2, // 0: inference.bls.DealerPartStorage.participant_shares:type_name -> inference.bls.EncryptedSharesForParticipant
+ 1, // 1: inference.bls.EpochBLSData.participants:type_name -> inference.bls.BLSParticipantInfo
+ 0, // 2: inference.bls.EpochBLSData.dkg_phase:type_name -> inference.bls.DKGPhase
+ 3, // 3: inference.bls.EpochBLSData.dealer_parts:type_name -> inference.bls.DealerPartStorage
+ 4, // 4: inference.bls.EpochBLSData.verification_submissions:type_name -> inference.bls.VerificationVectorSubmission
+ 5, // [5:5] is the sub-list for method output_type
+ 5, // [5:5] is the sub-list for method input_type
+ 5, // [5:5] is the sub-list for extension type_name
+ 5, // [5:5] is the sub-list for extension extendee
+ 0, // [0:5] is the sub-list for field type_name
+}
+
+func init() { file_inference_bls_types_proto_init() }
+func file_inference_bls_types_proto_init() {
+ if File_inference_bls_types_proto != nil {
+ return
+ }
+ if !protoimpl.UnsafeEnabled {
+ file_inference_bls_types_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*BLSParticipantInfo); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_bls_types_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*EncryptedSharesForParticipant); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_bls_types_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*DealerPartStorage); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_bls_types_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*VerificationVectorSubmission); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_bls_types_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*EpochBLSData); 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_bls_types_proto_rawDesc,
+ NumEnums: 1,
+ NumMessages: 5,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_bls_types_proto_goTypes,
+ DependencyIndexes: file_inference_bls_types_proto_depIdxs,
+ EnumInfos: file_inference_bls_types_proto_enumTypes,
+ MessageInfos: file_inference_bls_types_proto_msgTypes,
+ }.Build()
+ File_inference_bls_types_proto = out.File
+ file_inference_bls_types_proto_rawDesc = nil
+ file_inference_bls_types_proto_goTypes = nil
+ file_inference_bls_types_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/bookkeeper/genesis.pulsar.go b/inference-chain/api/inference/bookkeeper/genesis.pulsar.go
new file mode 100644
index 000000000..056ca24e7
--- /dev/null
+++ b/inference-chain/api/inference/bookkeeper/genesis.pulsar.go
@@ -0,0 +1,598 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package bookkeeper
+
+import (
+ _ "cosmossdk.io/api/amino"
+ fmt "fmt"
+ runtime "github.com/cosmos/cosmos-proto/runtime"
+ _ "github.com/cosmos/gogoproto/gogoproto"
+ 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_GenesisState protoreflect.MessageDescriptor
+ fd_GenesisState_params protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bookkeeper_genesis_proto_init()
+ md_GenesisState = File_inference_bookkeeper_genesis_proto.Messages().ByName("GenesisState")
+ fd_GenesisState_params = md_GenesisState.Fields().ByName("params")
+}
+
+var _ protoreflect.Message = (*fastReflection_GenesisState)(nil)
+
+type fastReflection_GenesisState GenesisState
+
+func (x *GenesisState) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_GenesisState)(x)
+}
+
+func (x *GenesisState) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bookkeeper_genesis_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_GenesisState_messageType fastReflection_GenesisState_messageType
+var _ protoreflect.MessageType = fastReflection_GenesisState_messageType{}
+
+type fastReflection_GenesisState_messageType struct{}
+
+func (x fastReflection_GenesisState_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_GenesisState)(nil)
+}
+func (x fastReflection_GenesisState_messageType) New() protoreflect.Message {
+ return new(fastReflection_GenesisState)
+}
+func (x fastReflection_GenesisState_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_GenesisState
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_GenesisState) Descriptor() protoreflect.MessageDescriptor {
+ return md_GenesisState
+}
+
+// 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_GenesisState) Type() protoreflect.MessageType {
+ return _fastReflection_GenesisState_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_GenesisState) New() protoreflect.Message {
+ return new(fastReflection_GenesisState)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_GenesisState) Interface() protoreflect.ProtoMessage {
+ return (*GenesisState)(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_GenesisState) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Params != nil {
+ value := protoreflect.ValueOfMessage(x.Params.ProtoReflect())
+ if !f(fd_GenesisState_params, 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_GenesisState) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bookkeeper.GenesisState.params":
+ return x.Params != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.GenesisState"))
+ }
+ panic(fmt.Errorf("message inference.bookkeeper.GenesisState 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_GenesisState) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bookkeeper.GenesisState.params":
+ x.Params = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.GenesisState"))
+ }
+ panic(fmt.Errorf("message inference.bookkeeper.GenesisState 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_GenesisState) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bookkeeper.GenesisState.params":
+ value := x.Params
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.GenesisState"))
+ }
+ panic(fmt.Errorf("message inference.bookkeeper.GenesisState 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_GenesisState) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bookkeeper.GenesisState.params":
+ x.Params = value.Message().Interface().(*Params)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.GenesisState"))
+ }
+ panic(fmt.Errorf("message inference.bookkeeper.GenesisState 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_GenesisState) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bookkeeper.GenesisState.params":
+ if x.Params == nil {
+ x.Params = new(Params)
+ }
+ return protoreflect.ValueOfMessage(x.Params.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.GenesisState"))
+ }
+ panic(fmt.Errorf("message inference.bookkeeper.GenesisState 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_GenesisState) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bookkeeper.GenesisState.params":
+ m := new(Params)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.GenesisState"))
+ }
+ panic(fmt.Errorf("message inference.bookkeeper.GenesisState 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_GenesisState) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bookkeeper.GenesisState", 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_GenesisState) 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_GenesisState) 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_GenesisState) 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_GenesisState) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*GenesisState)
+ 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.Params != nil {
+ l = options.Size(x.Params)
+ 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().(*GenesisState)
+ 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.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] = 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().(*GenesisState)
+ 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: GenesisState: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: GenesisState: 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 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
+ 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/bookkeeper/genesis.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)
+)
+
+// GenesisState defines the bookkeeper module's genesis state.
+type GenesisState struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // params defines all the parameters of the module.
+ Params *Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params,omitempty"`
+}
+
+func (x *GenesisState) Reset() {
+ *x = GenesisState{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bookkeeper_genesis_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *GenesisState) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GenesisState) ProtoMessage() {}
+
+// Deprecated: Use GenesisState.ProtoReflect.Descriptor instead.
+func (*GenesisState) Descriptor() ([]byte, []int) {
+ return file_inference_bookkeeper_genesis_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *GenesisState) GetParams() *Params {
+ if x != nil {
+ return x.Params
+ }
+ return nil
+}
+
+var File_inference_bookkeeper_genesis_proto protoreflect.FileDescriptor
+
+var file_inference_bookkeeper_genesis_proto_rawDesc = []byte{
+ 0x0a, 0x22, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x62, 0x6f, 0x6f, 0x6b,
+ 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0x2f, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x2e, 0x70,
+ 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x14, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+ 0x62, 0x6f, 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0x1a, 0x11, 0x61, 0x6d, 0x69, 0x6e,
+ 0x6f, 0x2f, 0x61, 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, 0x21, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x62,
+ 0x6f, 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0x2f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73,
+ 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x4f, 0x0a, 0x0c, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69,
+ 0x73, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x3f, 0x0a, 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73,
+ 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+ 0x63, 0x65, 0x2e, 0x62, 0x6f, 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 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, 0x42, 0xc0, 0x01, 0x0a, 0x18, 0x63, 0x6f, 0x6d, 0x2e,
+ 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6f, 0x6f, 0x6b, 0x6b, 0x65,
+ 0x65, 0x70, 0x65, 0x72, 0x42, 0x0c, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x50, 0x72, 0x6f,
+ 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x25, 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, 0x6f, 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0xa2, 0x02, 0x03, 0x49, 0x42,
+ 0x58, 0xaa, 0x02, 0x14, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x42, 0x6f,
+ 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0xca, 0x02, 0x14, 0x49, 0x6e, 0x66, 0x65, 0x72,
+ 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x42, 0x6f, 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0xe2,
+ 0x02, 0x20, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x42, 0x6f, 0x6f, 0x6b,
+ 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61,
+ 0x74, 0x61, 0xea, 0x02, 0x15, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x3a, 0x3a,
+ 0x42, 0x6f, 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74,
+ 0x6f, 0x33,
+}
+
+var (
+ file_inference_bookkeeper_genesis_proto_rawDescOnce sync.Once
+ file_inference_bookkeeper_genesis_proto_rawDescData = file_inference_bookkeeper_genesis_proto_rawDesc
+)
+
+func file_inference_bookkeeper_genesis_proto_rawDescGZIP() []byte {
+ file_inference_bookkeeper_genesis_proto_rawDescOnce.Do(func() {
+ file_inference_bookkeeper_genesis_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_bookkeeper_genesis_proto_rawDescData)
+ })
+ return file_inference_bookkeeper_genesis_proto_rawDescData
+}
+
+var file_inference_bookkeeper_genesis_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_inference_bookkeeper_genesis_proto_goTypes = []interface{}{
+ (*GenesisState)(nil), // 0: inference.bookkeeper.GenesisState
+ (*Params)(nil), // 1: inference.bookkeeper.Params
+}
+var file_inference_bookkeeper_genesis_proto_depIdxs = []int32{
+ 1, // 0: inference.bookkeeper.GenesisState.params:type_name -> inference.bookkeeper.Params
+ 1, // [1:1] is the sub-list for method output_type
+ 1, // [1:1] is the sub-list for method input_type
+ 1, // [1:1] is the sub-list for extension type_name
+ 1, // [1:1] is the sub-list for extension extendee
+ 0, // [0:1] is the sub-list for field type_name
+}
+
+func init() { file_inference_bookkeeper_genesis_proto_init() }
+func file_inference_bookkeeper_genesis_proto_init() {
+ if File_inference_bookkeeper_genesis_proto != nil {
+ return
+ }
+ file_inference_bookkeeper_params_proto_init()
+ if !protoimpl.UnsafeEnabled {
+ file_inference_bookkeeper_genesis_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*GenesisState); 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_bookkeeper_genesis_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 1,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_bookkeeper_genesis_proto_goTypes,
+ DependencyIndexes: file_inference_bookkeeper_genesis_proto_depIdxs,
+ MessageInfos: file_inference_bookkeeper_genesis_proto_msgTypes,
+ }.Build()
+ File_inference_bookkeeper_genesis_proto = out.File
+ file_inference_bookkeeper_genesis_proto_rawDesc = nil
+ file_inference_bookkeeper_genesis_proto_goTypes = nil
+ file_inference_bookkeeper_genesis_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/bookkeeper/module/module.pulsar.go b/inference-chain/api/inference/bookkeeper/module/module.pulsar.go
new file mode 100644
index 000000000..854f9a2fd
--- /dev/null
+++ b/inference-chain/api/inference/bookkeeper/module/module.pulsar.go
@@ -0,0 +1,783 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package module
+
+import (
+ _ "cosmossdk.io/api/cosmos/app/v1alpha1"
+ 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_Module protoreflect.MessageDescriptor
+ fd_Module_authority protoreflect.FieldDescriptor
+ fd_Module_double_entry protoreflect.FieldDescriptor
+ fd_Module_simple_entry protoreflect.FieldDescriptor
+ fd_Module_log_level protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bookkeeper_module_module_proto_init()
+ md_Module = File_inference_bookkeeper_module_module_proto.Messages().ByName("Module")
+ fd_Module_authority = md_Module.Fields().ByName("authority")
+ fd_Module_double_entry = md_Module.Fields().ByName("double_entry")
+ fd_Module_simple_entry = md_Module.Fields().ByName("simple_entry")
+ fd_Module_log_level = md_Module.Fields().ByName("log_level")
+}
+
+var _ protoreflect.Message = (*fastReflection_Module)(nil)
+
+type fastReflection_Module Module
+
+func (x *Module) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_Module)(x)
+}
+
+func (x *Module) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bookkeeper_module_module_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_Module_messageType fastReflection_Module_messageType
+var _ protoreflect.MessageType = fastReflection_Module_messageType{}
+
+type fastReflection_Module_messageType struct{}
+
+func (x fastReflection_Module_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_Module)(nil)
+}
+func (x fastReflection_Module_messageType) New() protoreflect.Message {
+ return new(fastReflection_Module)
+}
+func (x fastReflection_Module_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_Module
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_Module) Descriptor() protoreflect.MessageDescriptor {
+ return md_Module
+}
+
+// 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_Module) Type() protoreflect.MessageType {
+ return _fastReflection_Module_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_Module) New() protoreflect.Message {
+ return new(fastReflection_Module)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_Module) Interface() protoreflect.ProtoMessage {
+ return (*Module)(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_Module) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Authority != "" {
+ value := protoreflect.ValueOfString(x.Authority)
+ if !f(fd_Module_authority, value) {
+ return
+ }
+ }
+ if x.DoubleEntry != false {
+ value := protoreflect.ValueOfBool(x.DoubleEntry)
+ if !f(fd_Module_double_entry, value) {
+ return
+ }
+ }
+ if x.SimpleEntry != false {
+ value := protoreflect.ValueOfBool(x.SimpleEntry)
+ if !f(fd_Module_simple_entry, value) {
+ return
+ }
+ }
+ if x.LogLevel != "" {
+ value := protoreflect.ValueOfString(x.LogLevel)
+ if !f(fd_Module_log_level, 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_Module) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bookkeeper.module.Module.authority":
+ return x.Authority != ""
+ case "inference.bookkeeper.module.Module.double_entry":
+ return x.DoubleEntry != false
+ case "inference.bookkeeper.module.Module.simple_entry":
+ return x.SimpleEntry != false
+ case "inference.bookkeeper.module.Module.log_level":
+ return x.LogLevel != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.module.Module"))
+ }
+ panic(fmt.Errorf("message inference.bookkeeper.module.Module 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_Module) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bookkeeper.module.Module.authority":
+ x.Authority = ""
+ case "inference.bookkeeper.module.Module.double_entry":
+ x.DoubleEntry = false
+ case "inference.bookkeeper.module.Module.simple_entry":
+ x.SimpleEntry = false
+ case "inference.bookkeeper.module.Module.log_level":
+ x.LogLevel = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.module.Module"))
+ }
+ panic(fmt.Errorf("message inference.bookkeeper.module.Module 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_Module) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bookkeeper.module.Module.authority":
+ value := x.Authority
+ return protoreflect.ValueOfString(value)
+ case "inference.bookkeeper.module.Module.double_entry":
+ value := x.DoubleEntry
+ return protoreflect.ValueOfBool(value)
+ case "inference.bookkeeper.module.Module.simple_entry":
+ value := x.SimpleEntry
+ return protoreflect.ValueOfBool(value)
+ case "inference.bookkeeper.module.Module.log_level":
+ value := x.LogLevel
+ return protoreflect.ValueOfString(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.module.Module"))
+ }
+ panic(fmt.Errorf("message inference.bookkeeper.module.Module 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_Module) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bookkeeper.module.Module.authority":
+ x.Authority = value.Interface().(string)
+ case "inference.bookkeeper.module.Module.double_entry":
+ x.DoubleEntry = value.Bool()
+ case "inference.bookkeeper.module.Module.simple_entry":
+ x.SimpleEntry = value.Bool()
+ case "inference.bookkeeper.module.Module.log_level":
+ x.LogLevel = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.module.Module"))
+ }
+ panic(fmt.Errorf("message inference.bookkeeper.module.Module 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_Module) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bookkeeper.module.Module.authority":
+ panic(fmt.Errorf("field authority of message inference.bookkeeper.module.Module is not mutable"))
+ case "inference.bookkeeper.module.Module.double_entry":
+ panic(fmt.Errorf("field double_entry of message inference.bookkeeper.module.Module is not mutable"))
+ case "inference.bookkeeper.module.Module.simple_entry":
+ panic(fmt.Errorf("field simple_entry of message inference.bookkeeper.module.Module is not mutable"))
+ case "inference.bookkeeper.module.Module.log_level":
+ panic(fmt.Errorf("field log_level of message inference.bookkeeper.module.Module is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.module.Module"))
+ }
+ panic(fmt.Errorf("message inference.bookkeeper.module.Module 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_Module) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bookkeeper.module.Module.authority":
+ return protoreflect.ValueOfString("")
+ case "inference.bookkeeper.module.Module.double_entry":
+ return protoreflect.ValueOfBool(false)
+ case "inference.bookkeeper.module.Module.simple_entry":
+ return protoreflect.ValueOfBool(false)
+ case "inference.bookkeeper.module.Module.log_level":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.module.Module"))
+ }
+ panic(fmt.Errorf("message inference.bookkeeper.module.Module 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_Module) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bookkeeper.module.Module", 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_Module) 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_Module) 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_Module) 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_Module) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*Module)
+ 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 x.DoubleEntry {
+ n += 2
+ }
+ if x.SimpleEntry {
+ n += 2
+ }
+ l = len(x.LogLevel)
+ 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().(*Module)
+ 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.LogLevel) > 0 {
+ i -= len(x.LogLevel)
+ copy(dAtA[i:], x.LogLevel)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.LogLevel)))
+ i--
+ dAtA[i] = 0x22
+ }
+ if x.SimpleEntry {
+ i--
+ if x.SimpleEntry {
+ dAtA[i] = 1
+ } else {
+ dAtA[i] = 0
+ }
+ i--
+ dAtA[i] = 0x18
+ }
+ if x.DoubleEntry {
+ i--
+ if x.DoubleEntry {
+ dAtA[i] = 1
+ } else {
+ dAtA[i] = 0
+ }
+ 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)))
+ 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().(*Module)
+ 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: Module: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Module: 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 != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DoubleEntry", 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.DoubleEntry = bool(v != 0)
+ case 3:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field SimpleEntry", 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.SimpleEntry = bool(v != 0)
+ case 4:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field LogLevel", 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.LogLevel = 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/bookkeeper/module/module.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)
+)
+
+// Module is the config object for the module.
+type Module struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // authority defines the custom module authority. If not set, defaults to the governance module.
+ Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"`
+ DoubleEntry bool `protobuf:"varint,2,opt,name=double_entry,json=doubleEntry,proto3" json:"double_entry,omitempty"`
+ SimpleEntry bool `protobuf:"varint,3,opt,name=simple_entry,json=simpleEntry,proto3" json:"simple_entry,omitempty"`
+ LogLevel string `protobuf:"bytes,4,opt,name=log_level,json=logLevel,proto3" json:"log_level,omitempty"`
+}
+
+func (x *Module) Reset() {
+ *x = Module{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bookkeeper_module_module_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *Module) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Module) ProtoMessage() {}
+
+// Deprecated: Use Module.ProtoReflect.Descriptor instead.
+func (*Module) Descriptor() ([]byte, []int) {
+ return file_inference_bookkeeper_module_module_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Module) GetAuthority() string {
+ if x != nil {
+ return x.Authority
+ }
+ return ""
+}
+
+func (x *Module) GetDoubleEntry() bool {
+ if x != nil {
+ return x.DoubleEntry
+ }
+ return false
+}
+
+func (x *Module) GetSimpleEntry() bool {
+ if x != nil {
+ return x.SimpleEntry
+ }
+ return false
+}
+
+func (x *Module) GetLogLevel() string {
+ if x != nil {
+ return x.LogLevel
+ }
+ return ""
+}
+
+var File_inference_bookkeeper_module_module_proto protoreflect.FileDescriptor
+
+var file_inference_bookkeeper_module_module_proto_rawDesc = []byte{
+ 0x0a, 0x28, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x62, 0x6f, 0x6f, 0x6b,
+ 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0x2f, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x2f, 0x6d, 0x6f,
+ 0x64, 0x75, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x1b, 0x69, 0x6e, 0x66, 0x65,
+ 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6f, 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72,
+ 0x2e, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x1a, 0x20, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f,
+ 0x61, 0x70, 0x70, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x6d, 0x6f, 0x64,
+ 0x75, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xc3, 0x01, 0x0a, 0x06, 0x4d, 0x6f,
+ 0x64, 0x75, 0x6c, 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, 0x21, 0x0a, 0x0c, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x5f, 0x65, 0x6e, 0x74,
+ 0x72, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65,
+ 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x5f,
+ 0x65, 0x6e, 0x74, 0x72, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x73, 0x69, 0x6d,
+ 0x70, 0x6c, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x1b, 0x0a, 0x09, 0x6c, 0x6f, 0x67, 0x5f,
+ 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6c, 0x6f, 0x67,
+ 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x3a, 0x38, 0xba, 0xc0, 0x96, 0xda, 0x01, 0x32, 0x0a, 0x30, 0x67,
+ 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 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, 0x78, 0x2f, 0x62, 0x6f, 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0x42,
+ 0xea, 0x01, 0x0a, 0x1f, 0x63, 0x6f, 0x6d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+ 0x65, 0x2e, 0x62, 0x6f, 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0x2e, 0x6d, 0x6f, 0x64,
+ 0x75, 0x6c, 0x65, 0x42, 0x0b, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f,
+ 0x50, 0x01, 0x5a, 0x2c, 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,
+ 0x6f, 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0x2f, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65,
+ 0xa2, 0x02, 0x03, 0x49, 0x42, 0x4d, 0xaa, 0x02, 0x1b, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+ 0x63, 0x65, 0x2e, 0x42, 0x6f, 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0x2e, 0x4d, 0x6f,
+ 0x64, 0x75, 0x6c, 0x65, 0xca, 0x02, 0x1b, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+ 0x5c, 0x42, 0x6f, 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0x5c, 0x4d, 0x6f, 0x64, 0x75,
+ 0x6c, 0x65, 0xe2, 0x02, 0x27, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x42,
+ 0x6f, 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0x5c, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65,
+ 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x1d, 0x49,
+ 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x3a, 0x3a, 0x42, 0x6f, 0x6f, 0x6b, 0x6b, 0x65,
+ 0x65, 0x70, 0x65, 0x72, 0x3a, 0x3a, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x62, 0x06, 0x70, 0x72,
+ 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+ file_inference_bookkeeper_module_module_proto_rawDescOnce sync.Once
+ file_inference_bookkeeper_module_module_proto_rawDescData = file_inference_bookkeeper_module_module_proto_rawDesc
+)
+
+func file_inference_bookkeeper_module_module_proto_rawDescGZIP() []byte {
+ file_inference_bookkeeper_module_module_proto_rawDescOnce.Do(func() {
+ file_inference_bookkeeper_module_module_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_bookkeeper_module_module_proto_rawDescData)
+ })
+ return file_inference_bookkeeper_module_module_proto_rawDescData
+}
+
+var file_inference_bookkeeper_module_module_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_inference_bookkeeper_module_module_proto_goTypes = []interface{}{
+ (*Module)(nil), // 0: inference.bookkeeper.module.Module
+}
+var file_inference_bookkeeper_module_module_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_bookkeeper_module_module_proto_init() }
+func file_inference_bookkeeper_module_module_proto_init() {
+ if File_inference_bookkeeper_module_module_proto != nil {
+ return
+ }
+ if !protoimpl.UnsafeEnabled {
+ file_inference_bookkeeper_module_module_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*Module); 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_bookkeeper_module_module_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 1,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_bookkeeper_module_module_proto_goTypes,
+ DependencyIndexes: file_inference_bookkeeper_module_module_proto_depIdxs,
+ MessageInfos: file_inference_bookkeeper_module_module_proto_msgTypes,
+ }.Build()
+ File_inference_bookkeeper_module_module_proto = out.File
+ file_inference_bookkeeper_module_module_proto_rawDesc = nil
+ file_inference_bookkeeper_module_module_proto_goTypes = nil
+ file_inference_bookkeeper_module_module_proto_depIdxs = nil
+}
diff --git a/inference/api/inference/inference/params.pulsar.go b/inference-chain/api/inference/bookkeeper/params.pulsar.go
similarity index 73%
rename from inference/api/inference/inference/params.pulsar.go
rename to inference-chain/api/inference/bookkeeper/params.pulsar.go
index b3115a5ce..dad2f9472 100644
--- a/inference/api/inference/inference/params.pulsar.go
+++ b/inference-chain/api/inference/bookkeeper/params.pulsar.go
@@ -1,18 +1,17 @@
// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
-package inference
+package bookkeeper
import (
- fmt "fmt"
- io "io"
- reflect "reflect"
- sync "sync"
-
_ "cosmossdk.io/api/amino"
+ fmt "fmt"
runtime "github.com/cosmos/cosmos-proto/runtime"
_ "github.com/cosmos/gogoproto/gogoproto"
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 (
@@ -20,8 +19,8 @@ var (
)
func init() {
- file_inference_inference_params_proto_init()
- md_Params = File_inference_inference_params_proto.Messages().ByName("Params")
+ file_inference_bookkeeper_params_proto_init()
+ md_Params = File_inference_bookkeeper_params_proto.Messages().ByName("Params")
}
var _ protoreflect.Message = (*fastReflection_Params)(nil)
@@ -33,7 +32,7 @@ func (x *Params) ProtoReflect() protoreflect.Message {
}
func (x *Params) slowProtoReflect() protoreflect.Message {
- mi := &file_inference_inference_params_proto_msgTypes[0]
+ mi := &file_inference_bookkeeper_params_proto_msgTypes[0]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -106,9 +105,9 @@ func (x *fastReflection_Params) Has(fd protoreflect.FieldDescriptor) bool {
switch fd.FullName() {
default:
if fd.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Params"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.Params"))
}
- panic(fmt.Errorf("message inference.inference.Params does not contain field %s", fd.FullName()))
+ panic(fmt.Errorf("message inference.bookkeeper.Params does not contain field %s", fd.FullName()))
}
}
@@ -122,9 +121,9 @@ func (x *fastReflection_Params) Clear(fd protoreflect.FieldDescriptor) {
switch fd.FullName() {
default:
if fd.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Params"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.Params"))
}
- panic(fmt.Errorf("message inference.inference.Params does not contain field %s", fd.FullName()))
+ panic(fmt.Errorf("message inference.bookkeeper.Params does not contain field %s", fd.FullName()))
}
}
@@ -138,9 +137,9 @@ func (x *fastReflection_Params) Get(descriptor protoreflect.FieldDescriptor) pro
switch descriptor.FullName() {
default:
if descriptor.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Params"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.Params"))
}
- panic(fmt.Errorf("message inference.inference.Params does not contain field %s", descriptor.FullName()))
+ panic(fmt.Errorf("message inference.bookkeeper.Params does not contain field %s", descriptor.FullName()))
}
}
@@ -158,9 +157,9 @@ func (x *fastReflection_Params) Set(fd protoreflect.FieldDescriptor, value proto
switch fd.FullName() {
default:
if fd.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Params"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.Params"))
}
- panic(fmt.Errorf("message inference.inference.Params does not contain field %s", fd.FullName()))
+ panic(fmt.Errorf("message inference.bookkeeper.Params does not contain field %s", fd.FullName()))
}
}
@@ -178,9 +177,9 @@ func (x *fastReflection_Params) Mutable(fd protoreflect.FieldDescriptor) protore
switch fd.FullName() {
default:
if fd.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Params"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.Params"))
}
- panic(fmt.Errorf("message inference.inference.Params does not contain field %s", fd.FullName()))
+ panic(fmt.Errorf("message inference.bookkeeper.Params does not contain field %s", fd.FullName()))
}
}
@@ -191,9 +190,9 @@ func (x *fastReflection_Params) NewField(fd protoreflect.FieldDescriptor) protor
switch fd.FullName() {
default:
if fd.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Params"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.Params"))
}
- panic(fmt.Errorf("message inference.inference.Params does not contain field %s", fd.FullName()))
+ panic(fmt.Errorf("message inference.bookkeeper.Params does not contain field %s", fd.FullName()))
}
}
@@ -203,7 +202,7 @@ func (x *fastReflection_Params) NewField(fd protoreflect.FieldDescriptor) protor
func (x *fastReflection_Params) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
switch d.FullName() {
default:
- panic(fmt.Errorf("%s is not a oneof field in inference.inference.Params", d.FullName()))
+ panic(fmt.Errorf("%s is not a oneof field in inference.bookkeeper.Params", d.FullName()))
}
panic("unreachable")
}
@@ -375,7 +374,7 @@ func (x *fastReflection_Params) ProtoMethods() *protoiface.Methods {
// versions:
// protoc-gen-go v1.27.0
// protoc (unknown)
-// source: inference/inference/params.proto
+// source: inference/bookkeeper/params.proto
const (
// Verify that this generated code is sufficiently up-to-date.
@@ -394,7 +393,7 @@ type Params struct {
func (x *Params) Reset() {
*x = Params{}
if protoimpl.UnsafeEnabled {
- mi := &file_inference_inference_params_proto_msgTypes[0]
+ mi := &file_inference_bookkeeper_params_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -408,53 +407,53 @@ func (*Params) ProtoMessage() {}
// Deprecated: Use Params.ProtoReflect.Descriptor instead.
func (*Params) Descriptor() ([]byte, []int) {
- return file_inference_inference_params_proto_rawDescGZIP(), []int{0}
+ return file_inference_bookkeeper_params_proto_rawDescGZIP(), []int{0}
}
-var File_inference_inference_params_proto protoreflect.FileDescriptor
-
-var file_inference_inference_params_proto_rawDesc = []byte{
- 0x0a, 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, 0x12, 0x13, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
- 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x1a, 0x11, 0x61, 0x6d, 0x69, 0x6e, 0x6f, 0x2f, 0x61,
- 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,
- 0x22, 0x2f, 0x0a, 0x06, 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, 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 File_inference_bookkeeper_params_proto protoreflect.FileDescriptor
+
+var file_inference_bookkeeper_params_proto_rawDesc = []byte{
+ 0x0a, 0x21, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x62, 0x6f, 0x6f, 0x6b,
+ 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0x2f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x70, 0x72,
+ 0x6f, 0x74, 0x6f, 0x12, 0x14, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62,
+ 0x6f, 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0x1a, 0x11, 0x61, 0x6d, 0x69, 0x6e, 0x6f,
+ 0x2f, 0x61, 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, 0x22, 0x30, 0x0a, 0x06, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x3a, 0x26, 0xe8, 0xa0,
+ 0x1f, 0x01, 0x8a, 0xe7, 0xb0, 0x2a, 0x1d, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+ 0x2f, 0x78, 0x2f, 0x62, 0x6f, 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0x2f, 0x50, 0x61,
+ 0x72, 0x61, 0x6d, 0x73, 0x42, 0xbf, 0x01, 0x0a, 0x18, 0x63, 0x6f, 0x6d, 0x2e, 0x69, 0x6e, 0x66,
+ 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6f, 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70, 0x65,
+ 0x72, 0x42, 0x0b, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01,
+ 0x5a, 0x25, 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, 0x6f, 0x6f,
+ 0x6b, 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0xa2, 0x02, 0x03, 0x49, 0x42, 0x58, 0xaa, 0x02, 0x14,
+ 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x42, 0x6f, 0x6f, 0x6b, 0x6b, 0x65,
+ 0x65, 0x70, 0x65, 0x72, 0xca, 0x02, 0x14, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+ 0x5c, 0x42, 0x6f, 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0xe2, 0x02, 0x20, 0x49, 0x6e,
+ 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x42, 0x6f, 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70,
+ 0x65, 0x72, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02,
+ 0x15, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x3a, 0x3a, 0x42, 0x6f, 0x6f, 0x6b,
+ 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}
var (
- file_inference_inference_params_proto_rawDescOnce sync.Once
- file_inference_inference_params_proto_rawDescData = file_inference_inference_params_proto_rawDesc
+ file_inference_bookkeeper_params_proto_rawDescOnce sync.Once
+ file_inference_bookkeeper_params_proto_rawDescData = file_inference_bookkeeper_params_proto_rawDesc
)
-func file_inference_inference_params_proto_rawDescGZIP() []byte {
- file_inference_inference_params_proto_rawDescOnce.Do(func() {
- file_inference_inference_params_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_inference_params_proto_rawDescData)
+func file_inference_bookkeeper_params_proto_rawDescGZIP() []byte {
+ file_inference_bookkeeper_params_proto_rawDescOnce.Do(func() {
+ file_inference_bookkeeper_params_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_bookkeeper_params_proto_rawDescData)
})
- return file_inference_inference_params_proto_rawDescData
+ return file_inference_bookkeeper_params_proto_rawDescData
}
-var file_inference_inference_params_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
-var file_inference_inference_params_proto_goTypes = []interface{}{
- (*Params)(nil), // 0: inference.inference.Params
+var file_inference_bookkeeper_params_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_inference_bookkeeper_params_proto_goTypes = []interface{}{
+ (*Params)(nil), // 0: inference.bookkeeper.Params
}
-var file_inference_inference_params_proto_depIdxs = []int32{
+var file_inference_bookkeeper_params_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
@@ -462,13 +461,13 @@ var file_inference_inference_params_proto_depIdxs = []int32{
0, // [0:0] is the sub-list for field type_name
}
-func init() { file_inference_inference_params_proto_init() }
-func file_inference_inference_params_proto_init() {
- if File_inference_inference_params_proto != nil {
+func init() { file_inference_bookkeeper_params_proto_init() }
+func file_inference_bookkeeper_params_proto_init() {
+ if File_inference_bookkeeper_params_proto != nil {
return
}
if !protoimpl.UnsafeEnabled {
- file_inference_inference_params_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ file_inference_bookkeeper_params_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Params); i {
case 0:
return &v.state
@@ -485,18 +484,18 @@ func file_inference_inference_params_proto_init() {
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
- RawDescriptor: file_inference_inference_params_proto_rawDesc,
+ RawDescriptor: file_inference_bookkeeper_params_proto_rawDesc,
NumEnums: 0,
NumMessages: 1,
NumExtensions: 0,
NumServices: 0,
},
- GoTypes: file_inference_inference_params_proto_goTypes,
- DependencyIndexes: file_inference_inference_params_proto_depIdxs,
- MessageInfos: file_inference_inference_params_proto_msgTypes,
+ GoTypes: file_inference_bookkeeper_params_proto_goTypes,
+ DependencyIndexes: file_inference_bookkeeper_params_proto_depIdxs,
+ MessageInfos: file_inference_bookkeeper_params_proto_msgTypes,
}.Build()
- File_inference_inference_params_proto = out.File
- file_inference_inference_params_proto_rawDesc = nil
- file_inference_inference_params_proto_goTypes = nil
- file_inference_inference_params_proto_depIdxs = nil
+ File_inference_bookkeeper_params_proto = out.File
+ file_inference_bookkeeper_params_proto_rawDesc = nil
+ file_inference_bookkeeper_params_proto_goTypes = nil
+ file_inference_bookkeeper_params_proto_depIdxs = nil
}
diff --git a/inference-chain/api/inference/bookkeeper/query.pulsar.go b/inference-chain/api/inference/bookkeeper/query.pulsar.go
new file mode 100644
index 000000000..5eb2ec23c
--- /dev/null
+++ b/inference-chain/api/inference/bookkeeper/query.pulsar.go
@@ -0,0 +1,1014 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package bookkeeper
+
+import (
+ _ "cosmossdk.io/api/amino"
+ _ "cosmossdk.io/api/cosmos/base/query/v1beta1"
+ fmt "fmt"
+ runtime "github.com/cosmos/cosmos-proto/runtime"
+ _ "github.com/cosmos/gogoproto/gogoproto"
+ _ "google.golang.org/genproto/googleapis/api/annotations"
+ 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_QueryParamsRequest protoreflect.MessageDescriptor
+)
+
+func init() {
+ file_inference_bookkeeper_query_proto_init()
+ md_QueryParamsRequest = File_inference_bookkeeper_query_proto.Messages().ByName("QueryParamsRequest")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryParamsRequest)(nil)
+
+type fastReflection_QueryParamsRequest QueryParamsRequest
+
+func (x *QueryParamsRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryParamsRequest)(x)
+}
+
+func (x *QueryParamsRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bookkeeper_query_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_QueryParamsRequest_messageType fastReflection_QueryParamsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryParamsRequest_messageType{}
+
+type fastReflection_QueryParamsRequest_messageType struct{}
+
+func (x fastReflection_QueryParamsRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryParamsRequest)(nil)
+}
+func (x fastReflection_QueryParamsRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryParamsRequest)
+}
+func (x fastReflection_QueryParamsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryParamsRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryParamsRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryParamsRequest
+}
+
+// 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_QueryParamsRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryParamsRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryParamsRequest) New() protoreflect.Message {
+ return new(fastReflection_QueryParamsRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryParamsRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryParamsRequest)(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_QueryParamsRequest) 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_QueryParamsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.QueryParamsRequest"))
+ }
+ panic(fmt.Errorf("message inference.bookkeeper.QueryParamsRequest 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_QueryParamsRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.QueryParamsRequest"))
+ }
+ panic(fmt.Errorf("message inference.bookkeeper.QueryParamsRequest 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_QueryParamsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.QueryParamsRequest"))
+ }
+ panic(fmt.Errorf("message inference.bookkeeper.QueryParamsRequest 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_QueryParamsRequest) 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.bookkeeper.QueryParamsRequest"))
+ }
+ panic(fmt.Errorf("message inference.bookkeeper.QueryParamsRequest 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_QueryParamsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.QueryParamsRequest"))
+ }
+ panic(fmt.Errorf("message inference.bookkeeper.QueryParamsRequest 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_QueryParamsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.QueryParamsRequest"))
+ }
+ panic(fmt.Errorf("message inference.bookkeeper.QueryParamsRequest 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_QueryParamsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bookkeeper.QueryParamsRequest", 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_QueryParamsRequest) 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_QueryParamsRequest) 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_QueryParamsRequest) 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_QueryParamsRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryParamsRequest)
+ 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().(*QueryParamsRequest)
+ 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().(*QueryParamsRequest)
+ 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: QueryParamsRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryParamsRequest: 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 (
+ md_QueryParamsResponse protoreflect.MessageDescriptor
+ fd_QueryParamsResponse_params protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bookkeeper_query_proto_init()
+ md_QueryParamsResponse = File_inference_bookkeeper_query_proto.Messages().ByName("QueryParamsResponse")
+ fd_QueryParamsResponse_params = md_QueryParamsResponse.Fields().ByName("params")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryParamsResponse)(nil)
+
+type fastReflection_QueryParamsResponse QueryParamsResponse
+
+func (x *QueryParamsResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryParamsResponse)(x)
+}
+
+func (x *QueryParamsResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bookkeeper_query_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_QueryParamsResponse_messageType fastReflection_QueryParamsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryParamsResponse_messageType{}
+
+type fastReflection_QueryParamsResponse_messageType struct{}
+
+func (x fastReflection_QueryParamsResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryParamsResponse)(nil)
+}
+func (x fastReflection_QueryParamsResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryParamsResponse)
+}
+func (x fastReflection_QueryParamsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryParamsResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryParamsResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryParamsResponse
+}
+
+// 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_QueryParamsResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryParamsResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryParamsResponse) New() protoreflect.Message {
+ return new(fastReflection_QueryParamsResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryParamsResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryParamsResponse)(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_QueryParamsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Params != nil {
+ value := protoreflect.ValueOfMessage(x.Params.ProtoReflect())
+ if !f(fd_QueryParamsResponse_params, 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_QueryParamsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bookkeeper.QueryParamsResponse.params":
+ return x.Params != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.QueryParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.bookkeeper.QueryParamsResponse 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_QueryParamsResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bookkeeper.QueryParamsResponse.params":
+ x.Params = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.QueryParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.bookkeeper.QueryParamsResponse 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_QueryParamsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bookkeeper.QueryParamsResponse.params":
+ value := x.Params
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.QueryParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.bookkeeper.QueryParamsResponse 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_QueryParamsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bookkeeper.QueryParamsResponse.params":
+ x.Params = value.Message().Interface().(*Params)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.QueryParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.bookkeeper.QueryParamsResponse 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_QueryParamsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bookkeeper.QueryParamsResponse.params":
+ if x.Params == nil {
+ x.Params = new(Params)
+ }
+ return protoreflect.ValueOfMessage(x.Params.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.QueryParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.bookkeeper.QueryParamsResponse 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_QueryParamsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bookkeeper.QueryParamsResponse.params":
+ m := new(Params)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.QueryParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.bookkeeper.QueryParamsResponse 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_QueryParamsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bookkeeper.QueryParamsResponse", 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_QueryParamsResponse) 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_QueryParamsResponse) 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_QueryParamsResponse) 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_QueryParamsResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryParamsResponse)
+ 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.Params != nil {
+ l = options.Size(x.Params)
+ 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().(*QueryParamsResponse)
+ 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.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] = 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().(*QueryParamsResponse)
+ 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: QueryParamsResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryParamsResponse: 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 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
+ 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/bookkeeper/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_bookkeeper_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_bookkeeper_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_bookkeeper_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_bookkeeper_query_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *QueryParamsResponse) GetParams() *Params {
+ if x != nil {
+ return x.Params
+ }
+ return nil
+}
+
+var File_inference_bookkeeper_query_proto protoreflect.FileDescriptor
+
+var file_inference_bookkeeper_query_proto_rawDesc = []byte{
+ 0x0a, 0x20, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x62, 0x6f, 0x6f, 0x6b,
+ 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0x2f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x70, 0x72, 0x6f,
+ 0x74, 0x6f, 0x12, 0x14, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6f,
+ 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0x1a, 0x11, 0x61, 0x6d, 0x69, 0x6e, 0x6f, 0x2f,
+ 0x61, 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, 0x1c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x61, 0x6e,
+ 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a,
+ 0x2a, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x62, 0x61, 0x73, 0x65, 0x2f, 0x71, 0x75, 0x65,
+ 0x72, 0x79, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x70, 0x61, 0x67, 0x69, 0x6e,
+ 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x21, 0x69, 0x6e, 0x66,
+ 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x62, 0x6f, 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70, 0x65,
+ 0x72, 0x2f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 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, 0x56, 0x0a, 0x13, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72,
+ 0x61, 0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3f, 0x0a, 0x06, 0x70,
+ 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e,
+ 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6f, 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70,
+ 0x65, 0x72, 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, 0x32, 0x9c, 0x01, 0x0a,
+ 0x05, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0x92, 0x01, 0x0a, 0x06, 0x50, 0x61, 0x72, 0x61, 0x6d,
+ 0x73, 0x12, 0x28, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6f,
+ 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61,
+ 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x69, 0x6e,
+ 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6f, 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70,
+ 0x65, 0x72, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65,
+ 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x33, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2d, 0x12, 0x2b,
+ 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, 0x62, 0x6f, 0x6f, 0x6b, 0x6b, 0x65,
+ 0x65, 0x70, 0x65, 0x72, 0x2f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x42, 0xbe, 0x01, 0x0a, 0x18,
+ 0x63, 0x6f, 0x6d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6f,
+ 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0x42, 0x0a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50,
+ 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x25, 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, 0x6f, 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0xa2, 0x02, 0x03,
+ 0x49, 0x42, 0x58, 0xaa, 0x02, 0x14, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+ 0x42, 0x6f, 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0xca, 0x02, 0x14, 0x49, 0x6e, 0x66,
+ 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x42, 0x6f, 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70, 0x65,
+ 0x72, 0xe2, 0x02, 0x20, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x42, 0x6f,
+ 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61,
+ 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x15, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+ 0x3a, 0x3a, 0x42, 0x6f, 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0x62, 0x06, 0x70, 0x72,
+ 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+ file_inference_bookkeeper_query_proto_rawDescOnce sync.Once
+ file_inference_bookkeeper_query_proto_rawDescData = file_inference_bookkeeper_query_proto_rawDesc
+)
+
+func file_inference_bookkeeper_query_proto_rawDescGZIP() []byte {
+ file_inference_bookkeeper_query_proto_rawDescOnce.Do(func() {
+ file_inference_bookkeeper_query_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_bookkeeper_query_proto_rawDescData)
+ })
+ return file_inference_bookkeeper_query_proto_rawDescData
+}
+
+var file_inference_bookkeeper_query_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
+var file_inference_bookkeeper_query_proto_goTypes = []interface{}{
+ (*QueryParamsRequest)(nil), // 0: inference.bookkeeper.QueryParamsRequest
+ (*QueryParamsResponse)(nil), // 1: inference.bookkeeper.QueryParamsResponse
+ (*Params)(nil), // 2: inference.bookkeeper.Params
+}
+var file_inference_bookkeeper_query_proto_depIdxs = []int32{
+ 2, // 0: inference.bookkeeper.QueryParamsResponse.params:type_name -> inference.bookkeeper.Params
+ 0, // 1: inference.bookkeeper.Query.Params:input_type -> inference.bookkeeper.QueryParamsRequest
+ 1, // 2: inference.bookkeeper.Query.Params:output_type -> inference.bookkeeper.QueryParamsResponse
+ 2, // [2:3] is the sub-list for method output_type
+ 1, // [1:2] is the sub-list for method input_type
+ 1, // [1:1] is the sub-list for extension type_name
+ 1, // [1:1] is the sub-list for extension extendee
+ 0, // [0:1] is the sub-list for field type_name
+}
+
+func init() { file_inference_bookkeeper_query_proto_init() }
+func file_inference_bookkeeper_query_proto_init() {
+ if File_inference_bookkeeper_query_proto != nil {
+ return
+ }
+ file_inference_bookkeeper_params_proto_init()
+ if !protoimpl.UnsafeEnabled {
+ file_inference_bookkeeper_query_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*QueryParamsRequest); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_bookkeeper_query_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*QueryParamsResponse); 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_bookkeeper_query_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 2,
+ NumExtensions: 0,
+ NumServices: 1,
+ },
+ GoTypes: file_inference_bookkeeper_query_proto_goTypes,
+ DependencyIndexes: file_inference_bookkeeper_query_proto_depIdxs,
+ MessageInfos: file_inference_bookkeeper_query_proto_msgTypes,
+ }.Build()
+ File_inference_bookkeeper_query_proto = out.File
+ file_inference_bookkeeper_query_proto_rawDesc = nil
+ file_inference_bookkeeper_query_proto_goTypes = nil
+ file_inference_bookkeeper_query_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/bookkeeper/query_grpc.pb.go b/inference-chain/api/inference/bookkeeper/query_grpc.pb.go
new file mode 100644
index 000000000..78703cce5
--- /dev/null
+++ b/inference-chain/api/inference/bookkeeper/query_grpc.pb.go
@@ -0,0 +1,111 @@
+// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
+// versions:
+// - protoc-gen-go-grpc v1.3.0
+// - protoc (unknown)
+// source: inference/bookkeeper/query.proto
+
+package bookkeeper
+
+import (
+ context "context"
+ grpc "google.golang.org/grpc"
+ codes "google.golang.org/grpc/codes"
+ status "google.golang.org/grpc/status"
+)
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+// Requires gRPC-Go v1.32.0 or later.
+const _ = grpc.SupportPackageIsVersion7
+
+const (
+ Query_Params_FullMethodName = "/inference.bookkeeper.Query/Params"
+)
+
+// QueryClient is the client API for Query service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+type QueryClient interface {
+ // Parameters queries the parameters of the module.
+ Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error)
+}
+
+type queryClient struct {
+ cc grpc.ClientConnInterface
+}
+
+func NewQueryClient(cc grpc.ClientConnInterface) 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, Query_Params_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
+type QueryServer interface {
+ // Parameters queries the parameters of the module.
+ Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error)
+ mustEmbedUnimplementedQueryServer()
+}
+
+// UnimplementedQueryServer must be embedded to have forward compatible implementations.
+type UnimplementedQueryServer struct {
+}
+
+func (UnimplementedQueryServer) Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method Params not implemented")
+}
+func (UnimplementedQueryServer) mustEmbedUnimplementedQueryServer() {}
+
+// UnsafeQueryServer may be embedded to opt out of forward compatibility for this service.
+// Use of this interface is not recommended, as added methods to QueryServer will
+// result in compilation errors.
+type UnsafeQueryServer interface {
+ mustEmbedUnimplementedQueryServer()
+}
+
+func RegisterQueryServer(s grpc.ServiceRegistrar, srv QueryServer) {
+ s.RegisterService(&Query_ServiceDesc, srv)
+}
+
+func _Query_Params_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(QueryParamsRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(QueryServer).Params(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: Query_Params_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(QueryServer).Params(ctx, req.(*QueryParamsRequest))
+ }
+ 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)
+var Query_ServiceDesc = grpc.ServiceDesc{
+ ServiceName: "inference.bookkeeper.Query",
+ HandlerType: (*QueryServer)(nil),
+ Methods: []grpc.MethodDesc{
+ {
+ MethodName: "Params",
+ Handler: _Query_Params_Handler,
+ },
+ },
+ Streams: []grpc.StreamDesc{},
+ Metadata: "inference/bookkeeper/query.proto",
+}
diff --git a/inference-chain/api/inference/bookkeeper/tx.pulsar.go b/inference-chain/api/inference/bookkeeper/tx.pulsar.go
new file mode 100644
index 000000000..7c5cf42c6
--- /dev/null
+++ b/inference-chain/api/inference/bookkeeper/tx.pulsar.go
@@ -0,0 +1,1093 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package bookkeeper
+
+import (
+ _ "cosmossdk.io/api/amino"
+ _ "cosmossdk.io/api/cosmos/msg/v1"
+ fmt "fmt"
+ _ "github.com/cosmos/cosmos-proto"
+ runtime "github.com/cosmos/cosmos-proto/runtime"
+ _ "github.com/cosmos/gogoproto/gogoproto"
+ 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_MsgUpdateParams protoreflect.MessageDescriptor
+ fd_MsgUpdateParams_authority protoreflect.FieldDescriptor
+ fd_MsgUpdateParams_params protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_bookkeeper_tx_proto_init()
+ md_MsgUpdateParams = File_inference_bookkeeper_tx_proto.Messages().ByName("MsgUpdateParams")
+ fd_MsgUpdateParams_authority = md_MsgUpdateParams.Fields().ByName("authority")
+ fd_MsgUpdateParams_params = md_MsgUpdateParams.Fields().ByName("params")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgUpdateParams)(nil)
+
+type fastReflection_MsgUpdateParams MsgUpdateParams
+
+func (x *MsgUpdateParams) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_MsgUpdateParams)(x)
+}
+
+func (x *MsgUpdateParams) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bookkeeper_tx_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_MsgUpdateParams_messageType fastReflection_MsgUpdateParams_messageType
+var _ protoreflect.MessageType = fastReflection_MsgUpdateParams_messageType{}
+
+type fastReflection_MsgUpdateParams_messageType struct{}
+
+func (x fastReflection_MsgUpdateParams_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_MsgUpdateParams)(nil)
+}
+func (x fastReflection_MsgUpdateParams_messageType) New() protoreflect.Message {
+ return new(fastReflection_MsgUpdateParams)
+}
+func (x fastReflection_MsgUpdateParams_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgUpdateParams
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgUpdateParams) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgUpdateParams
+}
+
+// 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_MsgUpdateParams) Type() protoreflect.MessageType {
+ return _fastReflection_MsgUpdateParams_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgUpdateParams) New() protoreflect.Message {
+ return new(fastReflection_MsgUpdateParams)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgUpdateParams) Interface() protoreflect.ProtoMessage {
+ return (*MsgUpdateParams)(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_MsgUpdateParams) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Authority != "" {
+ value := protoreflect.ValueOfString(x.Authority)
+ if !f(fd_MsgUpdateParams_authority, value) {
+ return
+ }
+ }
+ if x.Params != nil {
+ value := protoreflect.ValueOfMessage(x.Params.ProtoReflect())
+ if !f(fd_MsgUpdateParams_params, 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_MsgUpdateParams) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.bookkeeper.MsgUpdateParams.authority":
+ return x.Authority != ""
+ case "inference.bookkeeper.MsgUpdateParams.params":
+ return x.Params != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.MsgUpdateParams"))
+ }
+ panic(fmt.Errorf("message inference.bookkeeper.MsgUpdateParams 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_MsgUpdateParams) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.bookkeeper.MsgUpdateParams.authority":
+ x.Authority = ""
+ case "inference.bookkeeper.MsgUpdateParams.params":
+ x.Params = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.MsgUpdateParams"))
+ }
+ panic(fmt.Errorf("message inference.bookkeeper.MsgUpdateParams 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_MsgUpdateParams) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.bookkeeper.MsgUpdateParams.authority":
+ value := x.Authority
+ return protoreflect.ValueOfString(value)
+ case "inference.bookkeeper.MsgUpdateParams.params":
+ value := x.Params
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.MsgUpdateParams"))
+ }
+ panic(fmt.Errorf("message inference.bookkeeper.MsgUpdateParams 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_MsgUpdateParams) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.bookkeeper.MsgUpdateParams.authority":
+ x.Authority = value.Interface().(string)
+ case "inference.bookkeeper.MsgUpdateParams.params":
+ x.Params = value.Message().Interface().(*Params)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.MsgUpdateParams"))
+ }
+ panic(fmt.Errorf("message inference.bookkeeper.MsgUpdateParams 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_MsgUpdateParams) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bookkeeper.MsgUpdateParams.params":
+ if x.Params == nil {
+ x.Params = new(Params)
+ }
+ return protoreflect.ValueOfMessage(x.Params.ProtoReflect())
+ case "inference.bookkeeper.MsgUpdateParams.authority":
+ panic(fmt.Errorf("field authority of message inference.bookkeeper.MsgUpdateParams is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.MsgUpdateParams"))
+ }
+ panic(fmt.Errorf("message inference.bookkeeper.MsgUpdateParams 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_MsgUpdateParams) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.bookkeeper.MsgUpdateParams.authority":
+ return protoreflect.ValueOfString("")
+ case "inference.bookkeeper.MsgUpdateParams.params":
+ m := new(Params)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.MsgUpdateParams"))
+ }
+ panic(fmt.Errorf("message inference.bookkeeper.MsgUpdateParams 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_MsgUpdateParams) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bookkeeper.MsgUpdateParams", 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_MsgUpdateParams) 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_MsgUpdateParams) 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_MsgUpdateParams) 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_MsgUpdateParams) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*MsgUpdateParams)
+ 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 x.Params != nil {
+ l = options.Size(x.Params)
+ 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().(*MsgUpdateParams)
+ 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.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 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().(*MsgUpdateParams)
+ 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: MsgUpdateParams: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUpdateParams: 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 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
+ 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_MsgUpdateParamsResponse protoreflect.MessageDescriptor
+)
+
+func init() {
+ file_inference_bookkeeper_tx_proto_init()
+ md_MsgUpdateParamsResponse = File_inference_bookkeeper_tx_proto.Messages().ByName("MsgUpdateParamsResponse")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgUpdateParamsResponse)(nil)
+
+type fastReflection_MsgUpdateParamsResponse MsgUpdateParamsResponse
+
+func (x *MsgUpdateParamsResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_MsgUpdateParamsResponse)(x)
+}
+
+func (x *MsgUpdateParamsResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_bookkeeper_tx_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_MsgUpdateParamsResponse_messageType fastReflection_MsgUpdateParamsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgUpdateParamsResponse_messageType{}
+
+type fastReflection_MsgUpdateParamsResponse_messageType struct{}
+
+func (x fastReflection_MsgUpdateParamsResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_MsgUpdateParamsResponse)(nil)
+}
+func (x fastReflection_MsgUpdateParamsResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_MsgUpdateParamsResponse)
+}
+func (x fastReflection_MsgUpdateParamsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgUpdateParamsResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgUpdateParamsResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgUpdateParamsResponse
+}
+
+// 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_MsgUpdateParamsResponse) Type() protoreflect.MessageType {
+ return _fastReflection_MsgUpdateParamsResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgUpdateParamsResponse) New() protoreflect.Message {
+ return new(fastReflection_MsgUpdateParamsResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgUpdateParamsResponse) Interface() protoreflect.ProtoMessage {
+ return (*MsgUpdateParamsResponse)(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_MsgUpdateParamsResponse) 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_MsgUpdateParamsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.MsgUpdateParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.bookkeeper.MsgUpdateParamsResponse 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_MsgUpdateParamsResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.MsgUpdateParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.bookkeeper.MsgUpdateParamsResponse 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_MsgUpdateParamsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.MsgUpdateParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.bookkeeper.MsgUpdateParamsResponse 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_MsgUpdateParamsResponse) 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.bookkeeper.MsgUpdateParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.bookkeeper.MsgUpdateParamsResponse 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_MsgUpdateParamsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.MsgUpdateParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.bookkeeper.MsgUpdateParamsResponse 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_MsgUpdateParamsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.bookkeeper.MsgUpdateParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.bookkeeper.MsgUpdateParamsResponse 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_MsgUpdateParamsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.bookkeeper.MsgUpdateParamsResponse", 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_MsgUpdateParamsResponse) 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_MsgUpdateParamsResponse) 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_MsgUpdateParamsResponse) 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_MsgUpdateParamsResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*MsgUpdateParamsResponse)
+ 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().(*MsgUpdateParamsResponse)
+ 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().(*MsgUpdateParamsResponse)
+ 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: MsgUpdateParamsResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUpdateParamsResponse: 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,
+ }
+}
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// protoc-gen-go v1.27.0
+// protoc (unknown)
+// source: inference/bookkeeper/tx.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)
+)
+
+// MsgUpdateParams is the Msg/UpdateParams request type.
+type MsgUpdateParams struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // authority is the address that controls the module (defaults to x/gov unless overwritten).
+ Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"`
+ // params defines the module parameters to update.
+ //
+ // NOTE: All parameters must be supplied.
+ Params *Params `protobuf:"bytes,2,opt,name=params,proto3" json:"params,omitempty"`
+}
+
+func (x *MsgUpdateParams) Reset() {
+ *x = MsgUpdateParams{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bookkeeper_tx_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *MsgUpdateParams) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgUpdateParams) ProtoMessage() {}
+
+// Deprecated: Use MsgUpdateParams.ProtoReflect.Descriptor instead.
+func (*MsgUpdateParams) Descriptor() ([]byte, []int) {
+ return file_inference_bookkeeper_tx_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *MsgUpdateParams) GetAuthority() string {
+ if x != nil {
+ return x.Authority
+ }
+ return ""
+}
+
+func (x *MsgUpdateParams) GetParams() *Params {
+ if x != nil {
+ return x.Params
+ }
+ return nil
+}
+
+// MsgUpdateParamsResponse defines the response structure for executing a
+// MsgUpdateParams message.
+type MsgUpdateParamsResponse struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+}
+
+func (x *MsgUpdateParamsResponse) Reset() {
+ *x = MsgUpdateParamsResponse{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_bookkeeper_tx_proto_msgTypes[1]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *MsgUpdateParamsResponse) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgUpdateParamsResponse) ProtoMessage() {}
+
+// Deprecated: Use MsgUpdateParamsResponse.ProtoReflect.Descriptor instead.
+func (*MsgUpdateParamsResponse) Descriptor() ([]byte, []int) {
+ return file_inference_bookkeeper_tx_proto_rawDescGZIP(), []int{1}
+}
+
+var File_inference_bookkeeper_tx_proto protoreflect.FileDescriptor
+
+var file_inference_bookkeeper_tx_proto_rawDesc = []byte{
+ 0x0a, 0x1d, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x62, 0x6f, 0x6f, 0x6b,
+ 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0x2f, 0x74, 0x78, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12,
+ 0x14, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6f, 0x6f, 0x6b, 0x6b,
+ 0x65, 0x65, 0x70, 0x65, 0x72, 0x1a, 0x11, 0x61, 0x6d, 0x69, 0x6e, 0x6f, 0x2f, 0x61, 0x6d, 0x69,
+ 0x6e, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 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, 0x1a, 0x14, 0x67, 0x6f,
+ 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f,
+ 0x74, 0x6f, 0x1a, 0x21, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x62, 0x6f,
+ 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0x2f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e,
+ 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xc5, 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, 0x3f, 0x0a, 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28,
+ 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6f,
+ 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 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, 0x39, 0x82, 0xe7, 0xb0, 0x2a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69,
+ 0x74, 0x79, 0x8a, 0xe7, 0xb0, 0x2a, 0x26, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+ 0x2f, 0x78, 0x2f, 0x62, 0x6f, 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 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, 0x32, 0x72, 0x0a, 0x03, 0x4d, 0x73, 0x67, 0x12,
+ 0x64, 0x0a, 0x0c, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12,
+ 0x25, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6f, 0x6f, 0x6b,
+ 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65,
+ 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x1a, 0x2d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+ 0x63, 0x65, 0x2e, 0x62, 0x6f, 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0x2e, 0x4d, 0x73,
+ 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x73,
+ 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x1a, 0x05, 0x80, 0xe7, 0xb0, 0x2a, 0x01, 0x42, 0xbb, 0x01, 0x0a,
+ 0x18, 0x63, 0x6f, 0x6d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62,
+ 0x6f, 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0x42, 0x07, 0x54, 0x78, 0x50, 0x72, 0x6f,
+ 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x25, 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, 0x6f, 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0xa2, 0x02, 0x03, 0x49, 0x42,
+ 0x58, 0xaa, 0x02, 0x14, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x42, 0x6f,
+ 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0xca, 0x02, 0x14, 0x49, 0x6e, 0x66, 0x65, 0x72,
+ 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x42, 0x6f, 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0xe2,
+ 0x02, 0x20, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x42, 0x6f, 0x6f, 0x6b,
+ 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61,
+ 0x74, 0x61, 0xea, 0x02, 0x15, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x3a, 0x3a,
+ 0x42, 0x6f, 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70, 0x65, 0x72, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74,
+ 0x6f, 0x33,
+}
+
+var (
+ file_inference_bookkeeper_tx_proto_rawDescOnce sync.Once
+ file_inference_bookkeeper_tx_proto_rawDescData = file_inference_bookkeeper_tx_proto_rawDesc
+)
+
+func file_inference_bookkeeper_tx_proto_rawDescGZIP() []byte {
+ file_inference_bookkeeper_tx_proto_rawDescOnce.Do(func() {
+ file_inference_bookkeeper_tx_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_bookkeeper_tx_proto_rawDescData)
+ })
+ return file_inference_bookkeeper_tx_proto_rawDescData
+}
+
+var file_inference_bookkeeper_tx_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
+var file_inference_bookkeeper_tx_proto_goTypes = []interface{}{
+ (*MsgUpdateParams)(nil), // 0: inference.bookkeeper.MsgUpdateParams
+ (*MsgUpdateParamsResponse)(nil), // 1: inference.bookkeeper.MsgUpdateParamsResponse
+ (*Params)(nil), // 2: inference.bookkeeper.Params
+}
+var file_inference_bookkeeper_tx_proto_depIdxs = []int32{
+ 2, // 0: inference.bookkeeper.MsgUpdateParams.params:type_name -> inference.bookkeeper.Params
+ 0, // 1: inference.bookkeeper.Msg.UpdateParams:input_type -> inference.bookkeeper.MsgUpdateParams
+ 1, // 2: inference.bookkeeper.Msg.UpdateParams:output_type -> inference.bookkeeper.MsgUpdateParamsResponse
+ 2, // [2:3] is the sub-list for method output_type
+ 1, // [1:2] is the sub-list for method input_type
+ 1, // [1:1] is the sub-list for extension type_name
+ 1, // [1:1] is the sub-list for extension extendee
+ 0, // [0:1] is the sub-list for field type_name
+}
+
+func init() { file_inference_bookkeeper_tx_proto_init() }
+func file_inference_bookkeeper_tx_proto_init() {
+ if File_inference_bookkeeper_tx_proto != nil {
+ return
+ }
+ file_inference_bookkeeper_params_proto_init()
+ if !protoimpl.UnsafeEnabled {
+ file_inference_bookkeeper_tx_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*MsgUpdateParams); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_bookkeeper_tx_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*MsgUpdateParamsResponse); 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_bookkeeper_tx_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 2,
+ NumExtensions: 0,
+ NumServices: 1,
+ },
+ GoTypes: file_inference_bookkeeper_tx_proto_goTypes,
+ DependencyIndexes: file_inference_bookkeeper_tx_proto_depIdxs,
+ MessageInfos: file_inference_bookkeeper_tx_proto_msgTypes,
+ }.Build()
+ File_inference_bookkeeper_tx_proto = out.File
+ file_inference_bookkeeper_tx_proto_rawDesc = nil
+ file_inference_bookkeeper_tx_proto_goTypes = nil
+ file_inference_bookkeeper_tx_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/bookkeeper/tx_grpc.pb.go b/inference-chain/api/inference/bookkeeper/tx_grpc.pb.go
new file mode 100644
index 000000000..28cb9dec6
--- /dev/null
+++ b/inference-chain/api/inference/bookkeeper/tx_grpc.pb.go
@@ -0,0 +1,113 @@
+// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
+// versions:
+// - protoc-gen-go-grpc v1.3.0
+// - protoc (unknown)
+// source: inference/bookkeeper/tx.proto
+
+package bookkeeper
+
+import (
+ context "context"
+ grpc "google.golang.org/grpc"
+ codes "google.golang.org/grpc/codes"
+ status "google.golang.org/grpc/status"
+)
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+// Requires gRPC-Go v1.32.0 or later.
+const _ = grpc.SupportPackageIsVersion7
+
+const (
+ Msg_UpdateParams_FullMethodName = "/inference.bookkeeper.Msg/UpdateParams"
+)
+
+// MsgClient is the client API for Msg service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+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)
+}
+
+type msgClient struct {
+ cc grpc.ClientConnInterface
+}
+
+func NewMsgClient(cc grpc.ClientConnInterface) MsgClient {
+ return &msgClient{cc}
+}
+
+func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) {
+ out := new(MsgUpdateParamsResponse)
+ err := c.cc.Invoke(ctx, Msg_UpdateParams_FullMethodName, in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+// MsgServer is the server API for Msg service.
+// All implementations must embed UnimplementedMsgServer
+// for forward compatibility
+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)
+ mustEmbedUnimplementedMsgServer()
+}
+
+// UnimplementedMsgServer must be embedded to have forward compatible implementations.
+type UnimplementedMsgServer struct {
+}
+
+func (UnimplementedMsgServer) UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method UpdateParams not implemented")
+}
+func (UnimplementedMsgServer) mustEmbedUnimplementedMsgServer() {}
+
+// UnsafeMsgServer may be embedded to opt out of forward compatibility for this service.
+// Use of this interface is not recommended, as added methods to MsgServer will
+// result in compilation errors.
+type UnsafeMsgServer interface {
+ mustEmbedUnimplementedMsgServer()
+}
+
+func RegisterMsgServer(s grpc.ServiceRegistrar, srv MsgServer) {
+ s.RegisterService(&Msg_ServiceDesc, srv)
+}
+
+func _Msg_UpdateParams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(MsgUpdateParams)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(MsgServer).UpdateParams(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: Msg_UpdateParams_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(MsgServer).UpdateParams(ctx, req.(*MsgUpdateParams))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+// Msg_ServiceDesc is the grpc.ServiceDesc for Msg service.
+// It's only intended for direct use with grpc.RegisterService,
+// and not to be introspected or modified (even as a copy)
+var Msg_ServiceDesc = grpc.ServiceDesc{
+ ServiceName: "inference.bookkeeper.Msg",
+ HandlerType: (*MsgServer)(nil),
+ Methods: []grpc.MethodDesc{
+ {
+ MethodName: "UpdateParams",
+ Handler: _Msg_UpdateParams_Handler,
+ },
+ },
+ Streams: []grpc.StreamDesc{},
+ Metadata: "inference/bookkeeper/tx.proto",
+}
diff --git a/inference-chain/api/inference/collateral/collateral_balance.pulsar.go b/inference-chain/api/inference/collateral/collateral_balance.pulsar.go
new file mode 100644
index 000000000..f8abb9e36
--- /dev/null
+++ b/inference-chain/api/inference/collateral/collateral_balance.pulsar.go
@@ -0,0 +1,671 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package collateral
+
+import (
+ v1beta1 "cosmossdk.io/api/cosmos/base/v1beta1"
+ fmt "fmt"
+ runtime "github.com/cosmos/cosmos-proto/runtime"
+ _ "github.com/cosmos/gogoproto/gogoproto"
+ 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_CollateralBalance protoreflect.MessageDescriptor
+ fd_CollateralBalance_participant protoreflect.FieldDescriptor
+ fd_CollateralBalance_amount protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_collateral_collateral_balance_proto_init()
+ md_CollateralBalance = File_inference_collateral_collateral_balance_proto.Messages().ByName("CollateralBalance")
+ fd_CollateralBalance_participant = md_CollateralBalance.Fields().ByName("participant")
+ fd_CollateralBalance_amount = md_CollateralBalance.Fields().ByName("amount")
+}
+
+var _ protoreflect.Message = (*fastReflection_CollateralBalance)(nil)
+
+type fastReflection_CollateralBalance CollateralBalance
+
+func (x *CollateralBalance) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_CollateralBalance)(x)
+}
+
+func (x *CollateralBalance) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_collateral_collateral_balance_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_CollateralBalance_messageType fastReflection_CollateralBalance_messageType
+var _ protoreflect.MessageType = fastReflection_CollateralBalance_messageType{}
+
+type fastReflection_CollateralBalance_messageType struct{}
+
+func (x fastReflection_CollateralBalance_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_CollateralBalance)(nil)
+}
+func (x fastReflection_CollateralBalance_messageType) New() protoreflect.Message {
+ return new(fastReflection_CollateralBalance)
+}
+func (x fastReflection_CollateralBalance_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_CollateralBalance
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_CollateralBalance) Descriptor() protoreflect.MessageDescriptor {
+ return md_CollateralBalance
+}
+
+// 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_CollateralBalance) Type() protoreflect.MessageType {
+ return _fastReflection_CollateralBalance_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_CollateralBalance) New() protoreflect.Message {
+ return new(fastReflection_CollateralBalance)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_CollateralBalance) Interface() protoreflect.ProtoMessage {
+ return (*CollateralBalance)(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_CollateralBalance) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Participant != "" {
+ value := protoreflect.ValueOfString(x.Participant)
+ if !f(fd_CollateralBalance_participant, value) {
+ return
+ }
+ }
+ if x.Amount != nil {
+ value := protoreflect.ValueOfMessage(x.Amount.ProtoReflect())
+ if !f(fd_CollateralBalance_amount, 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_CollateralBalance) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.collateral.CollateralBalance.participant":
+ return x.Participant != ""
+ case "inference.collateral.CollateralBalance.amount":
+ return x.Amount != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.CollateralBalance"))
+ }
+ panic(fmt.Errorf("message inference.collateral.CollateralBalance 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_CollateralBalance) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.collateral.CollateralBalance.participant":
+ x.Participant = ""
+ case "inference.collateral.CollateralBalance.amount":
+ x.Amount = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.CollateralBalance"))
+ }
+ panic(fmt.Errorf("message inference.collateral.CollateralBalance 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_CollateralBalance) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.collateral.CollateralBalance.participant":
+ value := x.Participant
+ return protoreflect.ValueOfString(value)
+ case "inference.collateral.CollateralBalance.amount":
+ value := x.Amount
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.CollateralBalance"))
+ }
+ panic(fmt.Errorf("message inference.collateral.CollateralBalance 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_CollateralBalance) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.collateral.CollateralBalance.participant":
+ x.Participant = value.Interface().(string)
+ case "inference.collateral.CollateralBalance.amount":
+ x.Amount = value.Message().Interface().(*v1beta1.Coin)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.CollateralBalance"))
+ }
+ panic(fmt.Errorf("message inference.collateral.CollateralBalance 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_CollateralBalance) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.collateral.CollateralBalance.amount":
+ if x.Amount == nil {
+ x.Amount = new(v1beta1.Coin)
+ }
+ return protoreflect.ValueOfMessage(x.Amount.ProtoReflect())
+ case "inference.collateral.CollateralBalance.participant":
+ panic(fmt.Errorf("field participant of message inference.collateral.CollateralBalance is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.CollateralBalance"))
+ }
+ panic(fmt.Errorf("message inference.collateral.CollateralBalance 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_CollateralBalance) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.collateral.CollateralBalance.participant":
+ return protoreflect.ValueOfString("")
+ case "inference.collateral.CollateralBalance.amount":
+ m := new(v1beta1.Coin)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.CollateralBalance"))
+ }
+ panic(fmt.Errorf("message inference.collateral.CollateralBalance 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_CollateralBalance) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.collateral.CollateralBalance", 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_CollateralBalance) 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_CollateralBalance) 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_CollateralBalance) 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_CollateralBalance) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*CollateralBalance)
+ 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.Amount != nil {
+ l = options.Size(x.Amount)
+ 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().(*CollateralBalance)
+ 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.Amount != nil {
+ encoded, err := options.Marshal(x.Amount)
+ 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().(*CollateralBalance)
+ 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: CollateralBalance: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: CollateralBalance: 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 Amount", 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.Amount == nil {
+ x.Amount = &v1beta1.Coin{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Amount); 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/collateral/collateral_balance.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)
+)
+
+// CollateralBalance represents a participant's collateral balance
+type CollateralBalance struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // participant is the address of the participant
+ Participant string `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
+ // amount is the collateral amount held by the participant
+ Amount *v1beta1.Coin `protobuf:"bytes,2,opt,name=amount,proto3" json:"amount,omitempty"`
+}
+
+func (x *CollateralBalance) Reset() {
+ *x = CollateralBalance{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_collateral_collateral_balance_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *CollateralBalance) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*CollateralBalance) ProtoMessage() {}
+
+// Deprecated: Use CollateralBalance.ProtoReflect.Descriptor instead.
+func (*CollateralBalance) Descriptor() ([]byte, []int) {
+ return file_inference_collateral_collateral_balance_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *CollateralBalance) GetParticipant() string {
+ if x != nil {
+ return x.Participant
+ }
+ return ""
+}
+
+func (x *CollateralBalance) GetAmount() *v1beta1.Coin {
+ if x != nil {
+ return x.Amount
+ }
+ return nil
+}
+
+var File_inference_collateral_collateral_balance_proto protoreflect.FileDescriptor
+
+var file_inference_collateral_collateral_balance_proto_rawDesc = []byte{
+ 0x0a, 0x2d, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x63, 0x6f, 0x6c, 0x6c,
+ 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2f, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61,
+ 0x6c, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12,
+ 0x14, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x63, 0x6f, 0x6c, 0x6c, 0x61,
+ 0x74, 0x65, 0x72, 0x61, 0x6c, 0x1a, 0x14, 0x67, 0x6f, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+ 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x63, 0x6f, 0x73,
+ 0x6d, 0x6f, 0x73, 0x2f, 0x62, 0x61, 0x73, 0x65, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31,
+ 0x2f, 0x63, 0x6f, 0x69, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x6e, 0x0a, 0x11, 0x43,
+ 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 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, 0x37, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01,
+ 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, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0xca, 0x01, 0x0a, 0x18,
+ 0x63, 0x6f, 0x6d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x63, 0x6f,
+ 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x42, 0x16, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74,
+ 0x65, 0x72, 0x61, 0x6c, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f,
+ 0x50, 0x01, 0x5a, 0x25, 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, 0x63,
+ 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0xa2, 0x02, 0x03, 0x49, 0x43, 0x58, 0xaa,
+ 0x02, 0x14, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x43, 0x6f, 0x6c, 0x6c,
+ 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0xca, 0x02, 0x14, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+ 0x63, 0x65, 0x5c, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0xe2, 0x02, 0x20,
+ 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74,
+ 0x65, 0x72, 0x61, 0x6c, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61,
+ 0xea, 0x02, 0x15, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x3a, 0x3a, 0x43, 0x6f,
+ 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+ file_inference_collateral_collateral_balance_proto_rawDescOnce sync.Once
+ file_inference_collateral_collateral_balance_proto_rawDescData = file_inference_collateral_collateral_balance_proto_rawDesc
+)
+
+func file_inference_collateral_collateral_balance_proto_rawDescGZIP() []byte {
+ file_inference_collateral_collateral_balance_proto_rawDescOnce.Do(func() {
+ file_inference_collateral_collateral_balance_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_collateral_collateral_balance_proto_rawDescData)
+ })
+ return file_inference_collateral_collateral_balance_proto_rawDescData
+}
+
+var file_inference_collateral_collateral_balance_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_inference_collateral_collateral_balance_proto_goTypes = []interface{}{
+ (*CollateralBalance)(nil), // 0: inference.collateral.CollateralBalance
+ (*v1beta1.Coin)(nil), // 1: cosmos.base.v1beta1.Coin
+}
+var file_inference_collateral_collateral_balance_proto_depIdxs = []int32{
+ 1, // 0: inference.collateral.CollateralBalance.amount:type_name -> cosmos.base.v1beta1.Coin
+ 1, // [1:1] is the sub-list for method output_type
+ 1, // [1:1] is the sub-list for method input_type
+ 1, // [1:1] is the sub-list for extension type_name
+ 1, // [1:1] is the sub-list for extension extendee
+ 0, // [0:1] is the sub-list for field type_name
+}
+
+func init() { file_inference_collateral_collateral_balance_proto_init() }
+func file_inference_collateral_collateral_balance_proto_init() {
+ if File_inference_collateral_collateral_balance_proto != nil {
+ return
+ }
+ if !protoimpl.UnsafeEnabled {
+ file_inference_collateral_collateral_balance_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*CollateralBalance); 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_collateral_collateral_balance_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 1,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_collateral_collateral_balance_proto_goTypes,
+ DependencyIndexes: file_inference_collateral_collateral_balance_proto_depIdxs,
+ MessageInfos: file_inference_collateral_collateral_balance_proto_msgTypes,
+ }.Build()
+ File_inference_collateral_collateral_balance_proto = out.File
+ file_inference_collateral_collateral_balance_proto_rawDesc = nil
+ file_inference_collateral_collateral_balance_proto_goTypes = nil
+ file_inference_collateral_collateral_balance_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/collateral/genesis.pulsar.go b/inference-chain/api/inference/collateral/genesis.pulsar.go
new file mode 100644
index 000000000..b520c3397
--- /dev/null
+++ b/inference-chain/api/inference/collateral/genesis.pulsar.go
@@ -0,0 +1,1073 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package collateral
+
+import (
+ _ "cosmossdk.io/api/amino"
+ fmt "fmt"
+ runtime "github.com/cosmos/cosmos-proto/runtime"
+ _ "github.com/cosmos/gogoproto/gogoproto"
+ 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 _ protoreflect.List = (*_GenesisState_2_list)(nil)
+
+type _GenesisState_2_list struct {
+ list *[]*CollateralBalance
+}
+
+func (x *_GenesisState_2_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_GenesisState_2_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_GenesisState_2_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*CollateralBalance)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_GenesisState_2_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*CollateralBalance)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_GenesisState_2_list) AppendMutable() protoreflect.Value {
+ v := new(CollateralBalance)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_GenesisState_2_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_GenesisState_2_list) NewElement() protoreflect.Value {
+ v := new(CollateralBalance)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_GenesisState_2_list) IsValid() bool {
+ return x.list != nil
+}
+
+var _ protoreflect.List = (*_GenesisState_3_list)(nil)
+
+type _GenesisState_3_list struct {
+ list *[]*UnbondingCollateral
+}
+
+func (x *_GenesisState_3_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_GenesisState_3_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_GenesisState_3_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*UnbondingCollateral)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_GenesisState_3_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*UnbondingCollateral)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_GenesisState_3_list) AppendMutable() protoreflect.Value {
+ v := new(UnbondingCollateral)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_GenesisState_3_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_GenesisState_3_list) NewElement() protoreflect.Value {
+ v := new(UnbondingCollateral)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_GenesisState_3_list) IsValid() bool {
+ return x.list != nil
+}
+
+var _ protoreflect.List = (*_GenesisState_4_list)(nil)
+
+type _GenesisState_4_list struct {
+ list *[]*JailedParticipant
+}
+
+func (x *_GenesisState_4_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_GenesisState_4_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_GenesisState_4_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*JailedParticipant)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_GenesisState_4_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*JailedParticipant)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_GenesisState_4_list) AppendMutable() protoreflect.Value {
+ v := new(JailedParticipant)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_GenesisState_4_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_GenesisState_4_list) NewElement() protoreflect.Value {
+ v := new(JailedParticipant)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_GenesisState_4_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_GenesisState protoreflect.MessageDescriptor
+ fd_GenesisState_params protoreflect.FieldDescriptor
+ fd_GenesisState_collateral_balance_list protoreflect.FieldDescriptor
+ fd_GenesisState_unbonding_collateral_list protoreflect.FieldDescriptor
+ fd_GenesisState_jailed_participant_list protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_collateral_genesis_proto_init()
+ md_GenesisState = File_inference_collateral_genesis_proto.Messages().ByName("GenesisState")
+ fd_GenesisState_params = md_GenesisState.Fields().ByName("params")
+ fd_GenesisState_collateral_balance_list = md_GenesisState.Fields().ByName("collateral_balance_list")
+ fd_GenesisState_unbonding_collateral_list = md_GenesisState.Fields().ByName("unbonding_collateral_list")
+ fd_GenesisState_jailed_participant_list = md_GenesisState.Fields().ByName("jailed_participant_list")
+}
+
+var _ protoreflect.Message = (*fastReflection_GenesisState)(nil)
+
+type fastReflection_GenesisState GenesisState
+
+func (x *GenesisState) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_GenesisState)(x)
+}
+
+func (x *GenesisState) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_collateral_genesis_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_GenesisState_messageType fastReflection_GenesisState_messageType
+var _ protoreflect.MessageType = fastReflection_GenesisState_messageType{}
+
+type fastReflection_GenesisState_messageType struct{}
+
+func (x fastReflection_GenesisState_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_GenesisState)(nil)
+}
+func (x fastReflection_GenesisState_messageType) New() protoreflect.Message {
+ return new(fastReflection_GenesisState)
+}
+func (x fastReflection_GenesisState_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_GenesisState
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_GenesisState) Descriptor() protoreflect.MessageDescriptor {
+ return md_GenesisState
+}
+
+// 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_GenesisState) Type() protoreflect.MessageType {
+ return _fastReflection_GenesisState_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_GenesisState) New() protoreflect.Message {
+ return new(fastReflection_GenesisState)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_GenesisState) Interface() protoreflect.ProtoMessage {
+ return (*GenesisState)(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_GenesisState) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Params != nil {
+ value := protoreflect.ValueOfMessage(x.Params.ProtoReflect())
+ if !f(fd_GenesisState_params, value) {
+ return
+ }
+ }
+ if len(x.CollateralBalanceList) != 0 {
+ value := protoreflect.ValueOfList(&_GenesisState_2_list{list: &x.CollateralBalanceList})
+ if !f(fd_GenesisState_collateral_balance_list, value) {
+ return
+ }
+ }
+ if len(x.UnbondingCollateralList) != 0 {
+ value := protoreflect.ValueOfList(&_GenesisState_3_list{list: &x.UnbondingCollateralList})
+ if !f(fd_GenesisState_unbonding_collateral_list, value) {
+ return
+ }
+ }
+ if len(x.JailedParticipantList) != 0 {
+ value := protoreflect.ValueOfList(&_GenesisState_4_list{list: &x.JailedParticipantList})
+ if !f(fd_GenesisState_jailed_participant_list, 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_GenesisState) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.collateral.GenesisState.params":
+ return x.Params != nil
+ case "inference.collateral.GenesisState.collateral_balance_list":
+ return len(x.CollateralBalanceList) != 0
+ case "inference.collateral.GenesisState.unbonding_collateral_list":
+ return len(x.UnbondingCollateralList) != 0
+ case "inference.collateral.GenesisState.jailed_participant_list":
+ return len(x.JailedParticipantList) != 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.GenesisState"))
+ }
+ panic(fmt.Errorf("message inference.collateral.GenesisState 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_GenesisState) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.collateral.GenesisState.params":
+ x.Params = nil
+ case "inference.collateral.GenesisState.collateral_balance_list":
+ x.CollateralBalanceList = nil
+ case "inference.collateral.GenesisState.unbonding_collateral_list":
+ x.UnbondingCollateralList = nil
+ case "inference.collateral.GenesisState.jailed_participant_list":
+ x.JailedParticipantList = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.GenesisState"))
+ }
+ panic(fmt.Errorf("message inference.collateral.GenesisState 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_GenesisState) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.collateral.GenesisState.params":
+ value := x.Params
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.collateral.GenesisState.collateral_balance_list":
+ if len(x.CollateralBalanceList) == 0 {
+ return protoreflect.ValueOfList(&_GenesisState_2_list{})
+ }
+ listValue := &_GenesisState_2_list{list: &x.CollateralBalanceList}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.collateral.GenesisState.unbonding_collateral_list":
+ if len(x.UnbondingCollateralList) == 0 {
+ return protoreflect.ValueOfList(&_GenesisState_3_list{})
+ }
+ listValue := &_GenesisState_3_list{list: &x.UnbondingCollateralList}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.collateral.GenesisState.jailed_participant_list":
+ if len(x.JailedParticipantList) == 0 {
+ return protoreflect.ValueOfList(&_GenesisState_4_list{})
+ }
+ listValue := &_GenesisState_4_list{list: &x.JailedParticipantList}
+ return protoreflect.ValueOfList(listValue)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.GenesisState"))
+ }
+ panic(fmt.Errorf("message inference.collateral.GenesisState 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_GenesisState) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.collateral.GenesisState.params":
+ x.Params = value.Message().Interface().(*Params)
+ case "inference.collateral.GenesisState.collateral_balance_list":
+ lv := value.List()
+ clv := lv.(*_GenesisState_2_list)
+ x.CollateralBalanceList = *clv.list
+ case "inference.collateral.GenesisState.unbonding_collateral_list":
+ lv := value.List()
+ clv := lv.(*_GenesisState_3_list)
+ x.UnbondingCollateralList = *clv.list
+ case "inference.collateral.GenesisState.jailed_participant_list":
+ lv := value.List()
+ clv := lv.(*_GenesisState_4_list)
+ x.JailedParticipantList = *clv.list
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.GenesisState"))
+ }
+ panic(fmt.Errorf("message inference.collateral.GenesisState 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_GenesisState) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.collateral.GenesisState.params":
+ if x.Params == nil {
+ x.Params = new(Params)
+ }
+ return protoreflect.ValueOfMessage(x.Params.ProtoReflect())
+ case "inference.collateral.GenesisState.collateral_balance_list":
+ if x.CollateralBalanceList == nil {
+ x.CollateralBalanceList = []*CollateralBalance{}
+ }
+ value := &_GenesisState_2_list{list: &x.CollateralBalanceList}
+ return protoreflect.ValueOfList(value)
+ case "inference.collateral.GenesisState.unbonding_collateral_list":
+ if x.UnbondingCollateralList == nil {
+ x.UnbondingCollateralList = []*UnbondingCollateral{}
+ }
+ value := &_GenesisState_3_list{list: &x.UnbondingCollateralList}
+ return protoreflect.ValueOfList(value)
+ case "inference.collateral.GenesisState.jailed_participant_list":
+ if x.JailedParticipantList == nil {
+ x.JailedParticipantList = []*JailedParticipant{}
+ }
+ value := &_GenesisState_4_list{list: &x.JailedParticipantList}
+ return protoreflect.ValueOfList(value)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.GenesisState"))
+ }
+ panic(fmt.Errorf("message inference.collateral.GenesisState 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_GenesisState) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.collateral.GenesisState.params":
+ m := new(Params)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.collateral.GenesisState.collateral_balance_list":
+ list := []*CollateralBalance{}
+ return protoreflect.ValueOfList(&_GenesisState_2_list{list: &list})
+ case "inference.collateral.GenesisState.unbonding_collateral_list":
+ list := []*UnbondingCollateral{}
+ return protoreflect.ValueOfList(&_GenesisState_3_list{list: &list})
+ case "inference.collateral.GenesisState.jailed_participant_list":
+ list := []*JailedParticipant{}
+ return protoreflect.ValueOfList(&_GenesisState_4_list{list: &list})
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.GenesisState"))
+ }
+ panic(fmt.Errorf("message inference.collateral.GenesisState 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_GenesisState) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.collateral.GenesisState", 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_GenesisState) 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_GenesisState) 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_GenesisState) 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_GenesisState) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*GenesisState)
+ 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.Params != nil {
+ l = options.Size(x.Params)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if len(x.CollateralBalanceList) > 0 {
+ for _, e := range x.CollateralBalanceList {
+ l = options.Size(e)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ }
+ if len(x.UnbondingCollateralList) > 0 {
+ for _, e := range x.UnbondingCollateralList {
+ l = options.Size(e)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ }
+ if len(x.JailedParticipantList) > 0 {
+ for _, e := range x.JailedParticipantList {
+ 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().(*GenesisState)
+ 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.JailedParticipantList) > 0 {
+ for iNdEx := len(x.JailedParticipantList) - 1; iNdEx >= 0; iNdEx-- {
+ encoded, err := options.Marshal(x.JailedParticipantList[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.UnbondingCollateralList) > 0 {
+ for iNdEx := len(x.UnbondingCollateralList) - 1; iNdEx >= 0; iNdEx-- {
+ encoded, err := options.Marshal(x.UnbondingCollateralList[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.CollateralBalanceList) > 0 {
+ for iNdEx := len(x.CollateralBalanceList) - 1; iNdEx >= 0; iNdEx-- {
+ encoded, err := options.Marshal(x.CollateralBalanceList[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.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] = 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().(*GenesisState)
+ 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: GenesisState: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: GenesisState: 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 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 2:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field CollateralBalanceList", 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.CollateralBalanceList = append(x.CollateralBalanceList, &CollateralBalance{})
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.CollateralBalanceList[len(x.CollateralBalanceList)-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 UnbondingCollateralList", 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.UnbondingCollateralList = append(x.UnbondingCollateralList, &UnbondingCollateral{})
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.UnbondingCollateralList[len(x.UnbondingCollateralList)-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 JailedParticipantList", 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.JailedParticipantList = append(x.JailedParticipantList, &JailedParticipant{})
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.JailedParticipantList[len(x.JailedParticipantList)-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/collateral/genesis.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)
+)
+
+// GenesisState defines the collateral module's genesis state.
+type GenesisState struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // params defines all the parameters of the module.
+ Params *Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params,omitempty"`
+ // collateral_balance_list defines all the collateral balances at genesis
+ CollateralBalanceList []*CollateralBalance `protobuf:"bytes,2,rep,name=collateral_balance_list,json=collateralBalanceList,proto3" json:"collateral_balance_list,omitempty"`
+ // unbonding_collateral_list defines all the unbonding collateral entries at genesis
+ UnbondingCollateralList []*UnbondingCollateral `protobuf:"bytes,3,rep,name=unbonding_collateral_list,json=unbondingCollateralList,proto3" json:"unbonding_collateral_list,omitempty"`
+ JailedParticipantList []*JailedParticipant `protobuf:"bytes,4,rep,name=jailed_participant_list,json=jailedParticipantList,proto3" json:"jailed_participant_list,omitempty"`
+}
+
+func (x *GenesisState) Reset() {
+ *x = GenesisState{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_collateral_genesis_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *GenesisState) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GenesisState) ProtoMessage() {}
+
+// Deprecated: Use GenesisState.ProtoReflect.Descriptor instead.
+func (*GenesisState) Descriptor() ([]byte, []int) {
+ return file_inference_collateral_genesis_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *GenesisState) GetParams() *Params {
+ if x != nil {
+ return x.Params
+ }
+ return nil
+}
+
+func (x *GenesisState) GetCollateralBalanceList() []*CollateralBalance {
+ if x != nil {
+ return x.CollateralBalanceList
+ }
+ return nil
+}
+
+func (x *GenesisState) GetUnbondingCollateralList() []*UnbondingCollateral {
+ if x != nil {
+ return x.UnbondingCollateralList
+ }
+ return nil
+}
+
+func (x *GenesisState) GetJailedParticipantList() []*JailedParticipant {
+ if x != nil {
+ return x.JailedParticipantList
+ }
+ return nil
+}
+
+var File_inference_collateral_genesis_proto protoreflect.FileDescriptor
+
+var file_inference_collateral_genesis_proto_rawDesc = []byte{
+ 0x0a, 0x22, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x63, 0x6f, 0x6c, 0x6c,
+ 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2f, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x2e, 0x70,
+ 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x14, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+ 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x1a, 0x11, 0x61, 0x6d, 0x69, 0x6e,
+ 0x6f, 0x2f, 0x61, 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, 0x21, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x63,
+ 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73,
+ 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x2d, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+ 0x65, 0x2f, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2f, 0x63, 0x6f, 0x6c,
+ 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x2e,
+ 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x24, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+ 0x2f, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2f, 0x75, 0x6e, 0x62, 0x6f,
+ 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x21, 0x69, 0x6e, 0x66,
+ 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61,
+ 0x6c, 0x2f, 0x6a, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x84,
+ 0x03, 0x0a, 0x0c, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12,
+ 0x3f, 0x0a, 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32,
+ 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x63, 0x6f, 0x6c, 0x6c,
+ 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 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,
+ 0x12, 0x65, 0x0a, 0x17, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x5f, 0x62,
+ 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x6c, 0x69, 0x73, 0x74, 0x18, 0x02, 0x20, 0x03, 0x28,
+ 0x0b, 0x32, 0x27, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x63, 0x6f,
+ 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2e, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65,
+ 0x72, 0x61, 0x6c, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00,
+ 0x52, 0x15, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x42, 0x61, 0x6c, 0x61,
+ 0x6e, 0x63, 0x65, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x6b, 0x0a, 0x19, 0x75, 0x6e, 0x62, 0x6f, 0x6e,
+ 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x5f,
+ 0x6c, 0x69, 0x73, 0x74, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x69, 0x6e, 0x66,
+ 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61,
+ 0x6c, 0x2e, 0x55, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6c, 0x6c, 0x61,
+ 0x74, 0x65, 0x72, 0x61, 0x6c, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x17, 0x75, 0x6e, 0x62,
+ 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c,
+ 0x4c, 0x69, 0x73, 0x74, 0x12, 0x5f, 0x0a, 0x17, 0x6a, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x5f, 0x70,
+ 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x5f, 0x6c, 0x69, 0x73, 0x74, 0x18,
+ 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+ 0x65, 0x2e, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2e, 0x4a, 0x61, 0x69,
+ 0x6c, 0x65, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x52, 0x15,
+ 0x6a, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e,
+ 0x74, 0x4c, 0x69, 0x73, 0x74, 0x42, 0xc0, 0x01, 0x0a, 0x18, 0x63, 0x6f, 0x6d, 0x2e, 0x69, 0x6e,
+ 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72,
+ 0x61, 0x6c, 0x42, 0x0c, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f,
+ 0x50, 0x01, 0x5a, 0x25, 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, 0x63,
+ 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0xa2, 0x02, 0x03, 0x49, 0x43, 0x58, 0xaa,
+ 0x02, 0x14, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x43, 0x6f, 0x6c, 0x6c,
+ 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0xca, 0x02, 0x14, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+ 0x63, 0x65, 0x5c, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0xe2, 0x02, 0x20,
+ 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74,
+ 0x65, 0x72, 0x61, 0x6c, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61,
+ 0xea, 0x02, 0x15, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x3a, 0x3a, 0x43, 0x6f,
+ 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+ file_inference_collateral_genesis_proto_rawDescOnce sync.Once
+ file_inference_collateral_genesis_proto_rawDescData = file_inference_collateral_genesis_proto_rawDesc
+)
+
+func file_inference_collateral_genesis_proto_rawDescGZIP() []byte {
+ file_inference_collateral_genesis_proto_rawDescOnce.Do(func() {
+ file_inference_collateral_genesis_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_collateral_genesis_proto_rawDescData)
+ })
+ return file_inference_collateral_genesis_proto_rawDescData
+}
+
+var file_inference_collateral_genesis_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_inference_collateral_genesis_proto_goTypes = []interface{}{
+ (*GenesisState)(nil), // 0: inference.collateral.GenesisState
+ (*Params)(nil), // 1: inference.collateral.Params
+ (*CollateralBalance)(nil), // 2: inference.collateral.CollateralBalance
+ (*UnbondingCollateral)(nil), // 3: inference.collateral.UnbondingCollateral
+ (*JailedParticipant)(nil), // 4: inference.collateral.JailedParticipant
+}
+var file_inference_collateral_genesis_proto_depIdxs = []int32{
+ 1, // 0: inference.collateral.GenesisState.params:type_name -> inference.collateral.Params
+ 2, // 1: inference.collateral.GenesisState.collateral_balance_list:type_name -> inference.collateral.CollateralBalance
+ 3, // 2: inference.collateral.GenesisState.unbonding_collateral_list:type_name -> inference.collateral.UnbondingCollateral
+ 4, // 3: inference.collateral.GenesisState.jailed_participant_list:type_name -> inference.collateral.JailedParticipant
+ 4, // [4:4] is the sub-list for method output_type
+ 4, // [4:4] is the sub-list for method input_type
+ 4, // [4:4] is the sub-list for extension type_name
+ 4, // [4:4] is the sub-list for extension extendee
+ 0, // [0:4] is the sub-list for field type_name
+}
+
+func init() { file_inference_collateral_genesis_proto_init() }
+func file_inference_collateral_genesis_proto_init() {
+ if File_inference_collateral_genesis_proto != nil {
+ return
+ }
+ file_inference_collateral_params_proto_init()
+ file_inference_collateral_collateral_balance_proto_init()
+ file_inference_collateral_unbonding_proto_init()
+ file_inference_collateral_jailed_proto_init()
+ if !protoimpl.UnsafeEnabled {
+ file_inference_collateral_genesis_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*GenesisState); 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_collateral_genesis_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 1,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_collateral_genesis_proto_goTypes,
+ DependencyIndexes: file_inference_collateral_genesis_proto_depIdxs,
+ MessageInfos: file_inference_collateral_genesis_proto_msgTypes,
+ }.Build()
+ File_inference_collateral_genesis_proto = out.File
+ file_inference_collateral_genesis_proto_rawDesc = nil
+ file_inference_collateral_genesis_proto_goTypes = nil
+ file_inference_collateral_genesis_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/collateral/jailed.pulsar.go b/inference-chain/api/inference/collateral/jailed.pulsar.go
new file mode 100644
index 000000000..7de3fd652
--- /dev/null
+++ b/inference-chain/api/inference/collateral/jailed.pulsar.go
@@ -0,0 +1,571 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package collateral
+
+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_JailedParticipant protoreflect.MessageDescriptor
+ fd_JailedParticipant_address protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_collateral_jailed_proto_init()
+ md_JailedParticipant = File_inference_collateral_jailed_proto.Messages().ByName("JailedParticipant")
+ fd_JailedParticipant_address = md_JailedParticipant.Fields().ByName("address")
+}
+
+var _ protoreflect.Message = (*fastReflection_JailedParticipant)(nil)
+
+type fastReflection_JailedParticipant JailedParticipant
+
+func (x *JailedParticipant) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_JailedParticipant)(x)
+}
+
+func (x *JailedParticipant) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_collateral_jailed_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_JailedParticipant_messageType fastReflection_JailedParticipant_messageType
+var _ protoreflect.MessageType = fastReflection_JailedParticipant_messageType{}
+
+type fastReflection_JailedParticipant_messageType struct{}
+
+func (x fastReflection_JailedParticipant_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_JailedParticipant)(nil)
+}
+func (x fastReflection_JailedParticipant_messageType) New() protoreflect.Message {
+ return new(fastReflection_JailedParticipant)
+}
+func (x fastReflection_JailedParticipant_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_JailedParticipant
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_JailedParticipant) Descriptor() protoreflect.MessageDescriptor {
+ return md_JailedParticipant
+}
+
+// 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_JailedParticipant) Type() protoreflect.MessageType {
+ return _fastReflection_JailedParticipant_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_JailedParticipant) New() protoreflect.Message {
+ return new(fastReflection_JailedParticipant)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_JailedParticipant) Interface() protoreflect.ProtoMessage {
+ return (*JailedParticipant)(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_JailedParticipant) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Address != "" {
+ value := protoreflect.ValueOfString(x.Address)
+ if !f(fd_JailedParticipant_address, 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_JailedParticipant) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.collateral.JailedParticipant.address":
+ return x.Address != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.JailedParticipant"))
+ }
+ panic(fmt.Errorf("message inference.collateral.JailedParticipant 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_JailedParticipant) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.collateral.JailedParticipant.address":
+ x.Address = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.JailedParticipant"))
+ }
+ panic(fmt.Errorf("message inference.collateral.JailedParticipant 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_JailedParticipant) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.collateral.JailedParticipant.address":
+ value := x.Address
+ return protoreflect.ValueOfString(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.JailedParticipant"))
+ }
+ panic(fmt.Errorf("message inference.collateral.JailedParticipant 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_JailedParticipant) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.collateral.JailedParticipant.address":
+ x.Address = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.JailedParticipant"))
+ }
+ panic(fmt.Errorf("message inference.collateral.JailedParticipant 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_JailedParticipant) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.collateral.JailedParticipant.address":
+ panic(fmt.Errorf("field address of message inference.collateral.JailedParticipant is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.JailedParticipant"))
+ }
+ panic(fmt.Errorf("message inference.collateral.JailedParticipant 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_JailedParticipant) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.collateral.JailedParticipant.address":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.JailedParticipant"))
+ }
+ panic(fmt.Errorf("message inference.collateral.JailedParticipant 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_JailedParticipant) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.collateral.JailedParticipant", 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_JailedParticipant) 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_JailedParticipant) 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_JailedParticipant) 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_JailedParticipant) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*JailedParticipant)
+ 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.Address)
+ 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().(*JailedParticipant)
+ 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.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 {
+ 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().(*JailedParticipant)
+ 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: JailedParticipant: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: JailedParticipant: 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
+ 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/collateral/jailed.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)
+)
+
+// JailedParticipant defines a participant who is currently jailed at the consensus level.
+// Their presence in the store indicates a jailed state.
+type JailedParticipant struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
+}
+
+func (x *JailedParticipant) Reset() {
+ *x = JailedParticipant{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_collateral_jailed_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *JailedParticipant) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*JailedParticipant) ProtoMessage() {}
+
+// Deprecated: Use JailedParticipant.ProtoReflect.Descriptor instead.
+func (*JailedParticipant) Descriptor() ([]byte, []int) {
+ return file_inference_collateral_jailed_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *JailedParticipant) GetAddress() string {
+ if x != nil {
+ return x.Address
+ }
+ return ""
+}
+
+var File_inference_collateral_jailed_proto protoreflect.FileDescriptor
+
+var file_inference_collateral_jailed_proto_rawDesc = []byte{
+ 0x0a, 0x21, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x63, 0x6f, 0x6c, 0x6c,
+ 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2f, 0x6a, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x2e, 0x70, 0x72,
+ 0x6f, 0x74, 0x6f, 0x12, 0x14, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x63,
+ 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x22, 0x2d, 0x0a, 0x11, 0x4a, 0x61, 0x69,
+ 0x6c, 0x65, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 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, 0x42, 0xbf, 0x01, 0x0a, 0x18, 0x63, 0x6f, 0x6d,
+ 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x63, 0x6f, 0x6c, 0x6c, 0x61,
+ 0x74, 0x65, 0x72, 0x61, 0x6c, 0x42, 0x0b, 0x4a, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x50, 0x72, 0x6f,
+ 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x25, 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, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0xa2, 0x02, 0x03, 0x49, 0x43,
+ 0x58, 0xaa, 0x02, 0x14, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x43, 0x6f,
+ 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0xca, 0x02, 0x14, 0x49, 0x6e, 0x66, 0x65, 0x72,
+ 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0xe2,
+ 0x02, 0x20, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x43, 0x6f, 0x6c, 0x6c,
+ 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61,
+ 0x74, 0x61, 0xea, 0x02, 0x15, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x3a, 0x3a,
+ 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74,
+ 0x6f, 0x33,
+}
+
+var (
+ file_inference_collateral_jailed_proto_rawDescOnce sync.Once
+ file_inference_collateral_jailed_proto_rawDescData = file_inference_collateral_jailed_proto_rawDesc
+)
+
+func file_inference_collateral_jailed_proto_rawDescGZIP() []byte {
+ file_inference_collateral_jailed_proto_rawDescOnce.Do(func() {
+ file_inference_collateral_jailed_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_collateral_jailed_proto_rawDescData)
+ })
+ return file_inference_collateral_jailed_proto_rawDescData
+}
+
+var file_inference_collateral_jailed_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_inference_collateral_jailed_proto_goTypes = []interface{}{
+ (*JailedParticipant)(nil), // 0: inference.collateral.JailedParticipant
+}
+var file_inference_collateral_jailed_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_collateral_jailed_proto_init() }
+func file_inference_collateral_jailed_proto_init() {
+ if File_inference_collateral_jailed_proto != nil {
+ return
+ }
+ if !protoimpl.UnsafeEnabled {
+ file_inference_collateral_jailed_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*JailedParticipant); 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_collateral_jailed_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 1,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_collateral_jailed_proto_goTypes,
+ DependencyIndexes: file_inference_collateral_jailed_proto_depIdxs,
+ MessageInfos: file_inference_collateral_jailed_proto_msgTypes,
+ }.Build()
+ File_inference_collateral_jailed_proto = out.File
+ file_inference_collateral_jailed_proto_rawDesc = nil
+ file_inference_collateral_jailed_proto_goTypes = nil
+ file_inference_collateral_jailed_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/collateral/module/module.pulsar.go b/inference-chain/api/inference/collateral/module/module.pulsar.go
new file mode 100644
index 000000000..8396c2f62
--- /dev/null
+++ b/inference-chain/api/inference/collateral/module/module.pulsar.go
@@ -0,0 +1,580 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package module
+
+import (
+ _ "cosmossdk.io/api/cosmos/app/v1alpha1"
+ 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_Module protoreflect.MessageDescriptor
+ fd_Module_authority protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_collateral_module_module_proto_init()
+ md_Module = File_inference_collateral_module_module_proto.Messages().ByName("Module")
+ fd_Module_authority = md_Module.Fields().ByName("authority")
+}
+
+var _ protoreflect.Message = (*fastReflection_Module)(nil)
+
+type fastReflection_Module Module
+
+func (x *Module) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_Module)(x)
+}
+
+func (x *Module) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_collateral_module_module_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_Module_messageType fastReflection_Module_messageType
+var _ protoreflect.MessageType = fastReflection_Module_messageType{}
+
+type fastReflection_Module_messageType struct{}
+
+func (x fastReflection_Module_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_Module)(nil)
+}
+func (x fastReflection_Module_messageType) New() protoreflect.Message {
+ return new(fastReflection_Module)
+}
+func (x fastReflection_Module_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_Module
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_Module) Descriptor() protoreflect.MessageDescriptor {
+ return md_Module
+}
+
+// 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_Module) Type() protoreflect.MessageType {
+ return _fastReflection_Module_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_Module) New() protoreflect.Message {
+ return new(fastReflection_Module)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_Module) Interface() protoreflect.ProtoMessage {
+ return (*Module)(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_Module) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Authority != "" {
+ value := protoreflect.ValueOfString(x.Authority)
+ if !f(fd_Module_authority, 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_Module) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.collateral.module.Module.authority":
+ return x.Authority != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.module.Module"))
+ }
+ panic(fmt.Errorf("message inference.collateral.module.Module 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_Module) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.collateral.module.Module.authority":
+ x.Authority = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.module.Module"))
+ }
+ panic(fmt.Errorf("message inference.collateral.module.Module 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_Module) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.collateral.module.Module.authority":
+ value := x.Authority
+ return protoreflect.ValueOfString(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.module.Module"))
+ }
+ panic(fmt.Errorf("message inference.collateral.module.Module 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_Module) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.collateral.module.Module.authority":
+ x.Authority = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.module.Module"))
+ }
+ panic(fmt.Errorf("message inference.collateral.module.Module 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_Module) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.collateral.module.Module.authority":
+ panic(fmt.Errorf("field authority of message inference.collateral.module.Module is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.module.Module"))
+ }
+ panic(fmt.Errorf("message inference.collateral.module.Module 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_Module) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.collateral.module.Module.authority":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.module.Module"))
+ }
+ panic(fmt.Errorf("message inference.collateral.module.Module 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_Module) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.collateral.module.Module", 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_Module) 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_Module) 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_Module) 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_Module) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*Module)
+ 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 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().(*Module)
+ 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.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().(*Module)
+ 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: Module: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Module: 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
+ 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/collateral/module/module.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)
+)
+
+// Module is the config object for the module.
+type Module struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // authority defines the custom module authority. If not set, defaults to the governance module.
+ Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"`
+}
+
+func (x *Module) Reset() {
+ *x = Module{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_collateral_module_module_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *Module) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Module) ProtoMessage() {}
+
+// Deprecated: Use Module.ProtoReflect.Descriptor instead.
+func (*Module) Descriptor() ([]byte, []int) {
+ return file_inference_collateral_module_module_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Module) GetAuthority() string {
+ if x != nil {
+ return x.Authority
+ }
+ return ""
+}
+
+var File_inference_collateral_module_module_proto protoreflect.FileDescriptor
+
+var file_inference_collateral_module_module_proto_rawDesc = []byte{
+ 0x0a, 0x28, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x63, 0x6f, 0x6c, 0x6c,
+ 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2f, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x2f, 0x6d, 0x6f,
+ 0x64, 0x75, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x1b, 0x69, 0x6e, 0x66, 0x65,
+ 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c,
+ 0x2e, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x1a, 0x20, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f,
+ 0x61, 0x70, 0x70, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x6d, 0x6f, 0x64,
+ 0x75, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x60, 0x0a, 0x06, 0x4d, 0x6f, 0x64,
+ 0x75, 0x6c, 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, 0x3a, 0x38, 0xba, 0xc0, 0x96, 0xda, 0x01, 0x32, 0x0a, 0x30, 0x67, 0x69, 0x74, 0x68, 0x75,
+ 0x62, 0x2e, 0x63, 0x6f, 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, 0x78,
+ 0x2f, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x42, 0xea, 0x01, 0x0a, 0x1f,
+ 0x63, 0x6f, 0x6d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x63, 0x6f,
+ 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2e, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x42,
+ 0x0b, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x2c,
+ 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, 0x63, 0x6f, 0x6c, 0x6c, 0x61,
+ 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2f, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0xa2, 0x02, 0x03, 0x49,
+ 0x43, 0x4d, 0xaa, 0x02, 0x1b, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x43,
+ 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2e, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65,
+ 0xca, 0x02, 0x1b, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x43, 0x6f, 0x6c,
+ 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x5c, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0xe2, 0x02,
+ 0x27, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x43, 0x6f, 0x6c, 0x6c, 0x61,
+ 0x74, 0x65, 0x72, 0x61, 0x6c, 0x5c, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x5c, 0x47, 0x50, 0x42,
+ 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x1d, 0x49, 0x6e, 0x66, 0x65, 0x72,
+ 0x65, 0x6e, 0x63, 0x65, 0x3a, 0x3a, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c,
+ 0x3a, 0x3a, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+ file_inference_collateral_module_module_proto_rawDescOnce sync.Once
+ file_inference_collateral_module_module_proto_rawDescData = file_inference_collateral_module_module_proto_rawDesc
+)
+
+func file_inference_collateral_module_module_proto_rawDescGZIP() []byte {
+ file_inference_collateral_module_module_proto_rawDescOnce.Do(func() {
+ file_inference_collateral_module_module_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_collateral_module_module_proto_rawDescData)
+ })
+ return file_inference_collateral_module_module_proto_rawDescData
+}
+
+var file_inference_collateral_module_module_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_inference_collateral_module_module_proto_goTypes = []interface{}{
+ (*Module)(nil), // 0: inference.collateral.module.Module
+}
+var file_inference_collateral_module_module_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_collateral_module_module_proto_init() }
+func file_inference_collateral_module_module_proto_init() {
+ if File_inference_collateral_module_module_proto != nil {
+ return
+ }
+ if !protoimpl.UnsafeEnabled {
+ file_inference_collateral_module_module_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*Module); 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_collateral_module_module_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 1,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_collateral_module_module_proto_goTypes,
+ DependencyIndexes: file_inference_collateral_module_module_proto_depIdxs,
+ MessageInfos: file_inference_collateral_module_module_proto_msgTypes,
+ }.Build()
+ File_inference_collateral_module_module_proto = out.File
+ file_inference_collateral_module_module_proto_rawDesc = nil
+ file_inference_collateral_module_module_proto_goTypes = nil
+ file_inference_collateral_module_module_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/collateral/params.pulsar.go b/inference-chain/api/inference/collateral/params.pulsar.go
new file mode 100644
index 000000000..955cfaeaa
--- /dev/null
+++ b/inference-chain/api/inference/collateral/params.pulsar.go
@@ -0,0 +1,563 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package collateral
+
+import (
+ _ "cosmossdk.io/api/amino"
+ fmt "fmt"
+ runtime "github.com/cosmos/cosmos-proto/runtime"
+ _ "github.com/cosmos/gogoproto/gogoproto"
+ 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_Params protoreflect.MessageDescriptor
+ fd_Params_unbonding_period_epochs protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_collateral_params_proto_init()
+ md_Params = File_inference_collateral_params_proto.Messages().ByName("Params")
+ fd_Params_unbonding_period_epochs = md_Params.Fields().ByName("unbonding_period_epochs")
+}
+
+var _ protoreflect.Message = (*fastReflection_Params)(nil)
+
+type fastReflection_Params Params
+
+func (x *Params) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_Params)(x)
+}
+
+func (x *Params) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_collateral_params_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_Params_messageType fastReflection_Params_messageType
+var _ protoreflect.MessageType = fastReflection_Params_messageType{}
+
+type fastReflection_Params_messageType struct{}
+
+func (x fastReflection_Params_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_Params)(nil)
+}
+func (x fastReflection_Params_messageType) New() protoreflect.Message {
+ return new(fastReflection_Params)
+}
+func (x fastReflection_Params_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_Params
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_Params) Descriptor() protoreflect.MessageDescriptor {
+ return md_Params
+}
+
+// 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_Params) Type() protoreflect.MessageType {
+ return _fastReflection_Params_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_Params) New() protoreflect.Message {
+ return new(fastReflection_Params)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_Params) Interface() protoreflect.ProtoMessage {
+ return (*Params)(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_Params) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.UnbondingPeriodEpochs != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.UnbondingPeriodEpochs)
+ if !f(fd_Params_unbonding_period_epochs, 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_Params) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.collateral.Params.unbonding_period_epochs":
+ return x.UnbondingPeriodEpochs != uint64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.Params"))
+ }
+ panic(fmt.Errorf("message inference.collateral.Params 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_Params) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.collateral.Params.unbonding_period_epochs":
+ x.UnbondingPeriodEpochs = uint64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.Params"))
+ }
+ panic(fmt.Errorf("message inference.collateral.Params 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_Params) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.collateral.Params.unbonding_period_epochs":
+ value := x.UnbondingPeriodEpochs
+ return protoreflect.ValueOfUint64(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.Params"))
+ }
+ panic(fmt.Errorf("message inference.collateral.Params 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_Params) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.collateral.Params.unbonding_period_epochs":
+ x.UnbondingPeriodEpochs = value.Uint()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.Params"))
+ }
+ panic(fmt.Errorf("message inference.collateral.Params 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_Params) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.collateral.Params.unbonding_period_epochs":
+ panic(fmt.Errorf("field unbonding_period_epochs of message inference.collateral.Params is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.Params"))
+ }
+ panic(fmt.Errorf("message inference.collateral.Params 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_Params) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.collateral.Params.unbonding_period_epochs":
+ return protoreflect.ValueOfUint64(uint64(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.Params"))
+ }
+ panic(fmt.Errorf("message inference.collateral.Params 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_Params) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.collateral.Params", 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_Params) 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_Params) 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_Params) 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_Params) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*Params)
+ 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.UnbondingPeriodEpochs != 0 {
+ n += 1 + runtime.Sov(uint64(x.UnbondingPeriodEpochs))
+ }
+ 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().(*Params)
+ 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.UnbondingPeriodEpochs != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.UnbondingPeriodEpochs))
+ 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().(*Params)
+ 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: Params: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Params: 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 UnbondingPeriodEpochs", wireType)
+ }
+ x.UnbondingPeriodEpochs = 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.UnbondingPeriodEpochs |= 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,
+ }
+}
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// protoc-gen-go v1.27.0
+// protoc (unknown)
+// source: inference/collateral/params.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)
+)
+
+// Params defines the parameters for the module.
+type Params struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // UnbondingPeriodEpochs is the number of epochs a withdrawal must wait before being released
+ UnbondingPeriodEpochs uint64 `protobuf:"varint,1,opt,name=unbonding_period_epochs,json=unbondingPeriodEpochs,proto3" json:"unbonding_period_epochs,omitempty"`
+}
+
+func (x *Params) Reset() {
+ *x = Params{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_collateral_params_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *Params) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Params) ProtoMessage() {}
+
+// Deprecated: Use Params.ProtoReflect.Descriptor instead.
+func (*Params) Descriptor() ([]byte, []int) {
+ return file_inference_collateral_params_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Params) GetUnbondingPeriodEpochs() uint64 {
+ if x != nil {
+ return x.UnbondingPeriodEpochs
+ }
+ return 0
+}
+
+var File_inference_collateral_params_proto protoreflect.FileDescriptor
+
+var file_inference_collateral_params_proto_rawDesc = []byte{
+ 0x0a, 0x21, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x63, 0x6f, 0x6c, 0x6c,
+ 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x70, 0x72,
+ 0x6f, 0x74, 0x6f, 0x12, 0x14, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x63,
+ 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x1a, 0x11, 0x61, 0x6d, 0x69, 0x6e, 0x6f,
+ 0x2f, 0x61, 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, 0x22, 0x68, 0x0a, 0x06, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x36, 0x0a, 0x17,
+ 0x75, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64,
+ 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x15, 0x75,
+ 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x45, 0x70,
+ 0x6f, 0x63, 0x68, 0x73, 0x3a, 0x26, 0xe8, 0xa0, 0x1f, 0x01, 0x8a, 0xe7, 0xb0, 0x2a, 0x1d, 0x69,
+ 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x78, 0x2f, 0x63, 0x6f, 0x6c, 0x6c, 0x61,
+ 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2f, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x42, 0xbf, 0x01, 0x0a,
+ 0x18, 0x63, 0x6f, 0x6d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x63,
+ 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x42, 0x0b, 0x50, 0x61, 0x72, 0x61, 0x6d,
+ 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x25, 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, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0xa2,
+ 0x02, 0x03, 0x49, 0x43, 0x58, 0xaa, 0x02, 0x14, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+ 0x65, 0x2e, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0xca, 0x02, 0x14, 0x49,
+ 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65,
+ 0x72, 0x61, 0x6c, 0xe2, 0x02, 0x20, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c,
+ 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65,
+ 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x15, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+ 0x63, 0x65, 0x3a, 0x3a, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x62, 0x06,
+ 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+ file_inference_collateral_params_proto_rawDescOnce sync.Once
+ file_inference_collateral_params_proto_rawDescData = file_inference_collateral_params_proto_rawDesc
+)
+
+func file_inference_collateral_params_proto_rawDescGZIP() []byte {
+ file_inference_collateral_params_proto_rawDescOnce.Do(func() {
+ file_inference_collateral_params_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_collateral_params_proto_rawDescData)
+ })
+ return file_inference_collateral_params_proto_rawDescData
+}
+
+var file_inference_collateral_params_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_inference_collateral_params_proto_goTypes = []interface{}{
+ (*Params)(nil), // 0: inference.collateral.Params
+}
+var file_inference_collateral_params_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_collateral_params_proto_init() }
+func file_inference_collateral_params_proto_init() {
+ if File_inference_collateral_params_proto != nil {
+ return
+ }
+ if !protoimpl.UnsafeEnabled {
+ file_inference_collateral_params_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*Params); 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_collateral_params_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 1,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_collateral_params_proto_goTypes,
+ DependencyIndexes: file_inference_collateral_params_proto_depIdxs,
+ MessageInfos: file_inference_collateral_params_proto_msgTypes,
+ }.Build()
+ File_inference_collateral_params_proto = out.File
+ file_inference_collateral_params_proto_rawDesc = nil
+ file_inference_collateral_params_proto_goTypes = nil
+ file_inference_collateral_params_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/collateral/query.pulsar.go b/inference-chain/api/inference/collateral/query.pulsar.go
new file mode 100644
index 000000000..6fd9b00f1
--- /dev/null
+++ b/inference-chain/api/inference/collateral/query.pulsar.go
@@ -0,0 +1,5341 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package collateral
+
+import (
+ v1beta11 "cosmossdk.io/api/cosmos/base/query/v1beta1"
+ v1beta1 "cosmossdk.io/api/cosmos/base/v1beta1"
+ fmt "fmt"
+ runtime "github.com/cosmos/cosmos-proto/runtime"
+ _ "github.com/cosmos/gogoproto/gogoproto"
+ _ "google.golang.org/genproto/googleapis/api/annotations"
+ 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_QueryParamsRequest protoreflect.MessageDescriptor
+)
+
+func init() {
+ file_inference_collateral_query_proto_init()
+ md_QueryParamsRequest = File_inference_collateral_query_proto.Messages().ByName("QueryParamsRequest")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryParamsRequest)(nil)
+
+type fastReflection_QueryParamsRequest QueryParamsRequest
+
+func (x *QueryParamsRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryParamsRequest)(x)
+}
+
+func (x *QueryParamsRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_collateral_query_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_QueryParamsRequest_messageType fastReflection_QueryParamsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryParamsRequest_messageType{}
+
+type fastReflection_QueryParamsRequest_messageType struct{}
+
+func (x fastReflection_QueryParamsRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryParamsRequest)(nil)
+}
+func (x fastReflection_QueryParamsRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryParamsRequest)
+}
+func (x fastReflection_QueryParamsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryParamsRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryParamsRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryParamsRequest
+}
+
+// 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_QueryParamsRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryParamsRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryParamsRequest) New() protoreflect.Message {
+ return new(fastReflection_QueryParamsRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryParamsRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryParamsRequest)(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_QueryParamsRequest) 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_QueryParamsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryParamsRequest"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryParamsRequest 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_QueryParamsRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryParamsRequest"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryParamsRequest 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_QueryParamsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryParamsRequest"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryParamsRequest 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_QueryParamsRequest) 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.collateral.QueryParamsRequest"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryParamsRequest 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_QueryParamsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryParamsRequest"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryParamsRequest 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_QueryParamsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryParamsRequest"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryParamsRequest 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_QueryParamsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.collateral.QueryParamsRequest", 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_QueryParamsRequest) 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_QueryParamsRequest) 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_QueryParamsRequest) 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_QueryParamsRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryParamsRequest)
+ 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().(*QueryParamsRequest)
+ 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().(*QueryParamsRequest)
+ 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: QueryParamsRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryParamsRequest: 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 (
+ md_QueryParamsResponse protoreflect.MessageDescriptor
+ fd_QueryParamsResponse_params protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_collateral_query_proto_init()
+ md_QueryParamsResponse = File_inference_collateral_query_proto.Messages().ByName("QueryParamsResponse")
+ fd_QueryParamsResponse_params = md_QueryParamsResponse.Fields().ByName("params")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryParamsResponse)(nil)
+
+type fastReflection_QueryParamsResponse QueryParamsResponse
+
+func (x *QueryParamsResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryParamsResponse)(x)
+}
+
+func (x *QueryParamsResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_collateral_query_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_QueryParamsResponse_messageType fastReflection_QueryParamsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryParamsResponse_messageType{}
+
+type fastReflection_QueryParamsResponse_messageType struct{}
+
+func (x fastReflection_QueryParamsResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryParamsResponse)(nil)
+}
+func (x fastReflection_QueryParamsResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryParamsResponse)
+}
+func (x fastReflection_QueryParamsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryParamsResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryParamsResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryParamsResponse
+}
+
+// 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_QueryParamsResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryParamsResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryParamsResponse) New() protoreflect.Message {
+ return new(fastReflection_QueryParamsResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryParamsResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryParamsResponse)(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_QueryParamsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Params != nil {
+ value := protoreflect.ValueOfMessage(x.Params.ProtoReflect())
+ if !f(fd_QueryParamsResponse_params, 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_QueryParamsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.collateral.QueryParamsResponse.params":
+ return x.Params != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryParamsResponse 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_QueryParamsResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.collateral.QueryParamsResponse.params":
+ x.Params = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryParamsResponse 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_QueryParamsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.collateral.QueryParamsResponse.params":
+ value := x.Params
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryParamsResponse 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_QueryParamsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.collateral.QueryParamsResponse.params":
+ x.Params = value.Message().Interface().(*Params)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryParamsResponse 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_QueryParamsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.collateral.QueryParamsResponse.params":
+ if x.Params == nil {
+ x.Params = new(Params)
+ }
+ return protoreflect.ValueOfMessage(x.Params.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryParamsResponse 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_QueryParamsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.collateral.QueryParamsResponse.params":
+ m := new(Params)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryParamsResponse 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_QueryParamsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.collateral.QueryParamsResponse", 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_QueryParamsResponse) 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_QueryParamsResponse) 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_QueryParamsResponse) 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_QueryParamsResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryParamsResponse)
+ 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.Params != nil {
+ l = options.Size(x.Params)
+ 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().(*QueryParamsResponse)
+ 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.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] = 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().(*QueryParamsResponse)
+ 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: QueryParamsResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryParamsResponse: 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 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
+ 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_QueryCollateralRequest protoreflect.MessageDescriptor
+ fd_QueryCollateralRequest_participant protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_collateral_query_proto_init()
+ md_QueryCollateralRequest = File_inference_collateral_query_proto.Messages().ByName("QueryCollateralRequest")
+ fd_QueryCollateralRequest_participant = md_QueryCollateralRequest.Fields().ByName("participant")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryCollateralRequest)(nil)
+
+type fastReflection_QueryCollateralRequest QueryCollateralRequest
+
+func (x *QueryCollateralRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryCollateralRequest)(x)
+}
+
+func (x *QueryCollateralRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_collateral_query_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_QueryCollateralRequest_messageType fastReflection_QueryCollateralRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryCollateralRequest_messageType{}
+
+type fastReflection_QueryCollateralRequest_messageType struct{}
+
+func (x fastReflection_QueryCollateralRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryCollateralRequest)(nil)
+}
+func (x fastReflection_QueryCollateralRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryCollateralRequest)
+}
+func (x fastReflection_QueryCollateralRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryCollateralRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryCollateralRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryCollateralRequest
+}
+
+// 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_QueryCollateralRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryCollateralRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryCollateralRequest) New() protoreflect.Message {
+ return new(fastReflection_QueryCollateralRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryCollateralRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryCollateralRequest)(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_QueryCollateralRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Participant != "" {
+ value := protoreflect.ValueOfString(x.Participant)
+ if !f(fd_QueryCollateralRequest_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_QueryCollateralRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.collateral.QueryCollateralRequest.participant":
+ return x.Participant != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryCollateralRequest"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryCollateralRequest 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_QueryCollateralRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.collateral.QueryCollateralRequest.participant":
+ x.Participant = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryCollateralRequest"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryCollateralRequest 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_QueryCollateralRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.collateral.QueryCollateralRequest.participant":
+ value := x.Participant
+ return protoreflect.ValueOfString(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryCollateralRequest"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryCollateralRequest 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_QueryCollateralRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.collateral.QueryCollateralRequest.participant":
+ x.Participant = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryCollateralRequest"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryCollateralRequest 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_QueryCollateralRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.collateral.QueryCollateralRequest.participant":
+ panic(fmt.Errorf("field participant of message inference.collateral.QueryCollateralRequest is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryCollateralRequest"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryCollateralRequest 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_QueryCollateralRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.collateral.QueryCollateralRequest.participant":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryCollateralRequest"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryCollateralRequest 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_QueryCollateralRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.collateral.QueryCollateralRequest", 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_QueryCollateralRequest) 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_QueryCollateralRequest) 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_QueryCollateralRequest) 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_QueryCollateralRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryCollateralRequest)
+ 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().(*QueryCollateralRequest)
+ 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().(*QueryCollateralRequest)
+ 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: QueryCollateralRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryCollateralRequest: 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_QueryCollateralResponse protoreflect.MessageDescriptor
+ fd_QueryCollateralResponse_amount protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_collateral_query_proto_init()
+ md_QueryCollateralResponse = File_inference_collateral_query_proto.Messages().ByName("QueryCollateralResponse")
+ fd_QueryCollateralResponse_amount = md_QueryCollateralResponse.Fields().ByName("amount")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryCollateralResponse)(nil)
+
+type fastReflection_QueryCollateralResponse QueryCollateralResponse
+
+func (x *QueryCollateralResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryCollateralResponse)(x)
+}
+
+func (x *QueryCollateralResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_collateral_query_proto_msgTypes[3]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryCollateralResponse_messageType fastReflection_QueryCollateralResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryCollateralResponse_messageType{}
+
+type fastReflection_QueryCollateralResponse_messageType struct{}
+
+func (x fastReflection_QueryCollateralResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryCollateralResponse)(nil)
+}
+func (x fastReflection_QueryCollateralResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryCollateralResponse)
+}
+func (x fastReflection_QueryCollateralResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryCollateralResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryCollateralResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryCollateralResponse
+}
+
+// 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_QueryCollateralResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryCollateralResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryCollateralResponse) New() protoreflect.Message {
+ return new(fastReflection_QueryCollateralResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryCollateralResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryCollateralResponse)(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_QueryCollateralResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Amount != nil {
+ value := protoreflect.ValueOfMessage(x.Amount.ProtoReflect())
+ if !f(fd_QueryCollateralResponse_amount, 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_QueryCollateralResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.collateral.QueryCollateralResponse.amount":
+ return x.Amount != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryCollateralResponse"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryCollateralResponse 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_QueryCollateralResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.collateral.QueryCollateralResponse.amount":
+ x.Amount = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryCollateralResponse"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryCollateralResponse 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_QueryCollateralResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.collateral.QueryCollateralResponse.amount":
+ value := x.Amount
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryCollateralResponse"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryCollateralResponse 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_QueryCollateralResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.collateral.QueryCollateralResponse.amount":
+ x.Amount = value.Message().Interface().(*v1beta1.Coin)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryCollateralResponse"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryCollateralResponse 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_QueryCollateralResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.collateral.QueryCollateralResponse.amount":
+ if x.Amount == nil {
+ x.Amount = new(v1beta1.Coin)
+ }
+ return protoreflect.ValueOfMessage(x.Amount.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryCollateralResponse"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryCollateralResponse 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_QueryCollateralResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.collateral.QueryCollateralResponse.amount":
+ m := new(v1beta1.Coin)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryCollateralResponse"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryCollateralResponse 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_QueryCollateralResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.collateral.QueryCollateralResponse", 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_QueryCollateralResponse) 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_QueryCollateralResponse) 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_QueryCollateralResponse) 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_QueryCollateralResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryCollateralResponse)
+ 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.Amount != nil {
+ l = options.Size(x.Amount)
+ 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().(*QueryCollateralResponse)
+ 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.Amount != nil {
+ encoded, err := options.Marshal(x.Amount)
+ 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().(*QueryCollateralResponse)
+ 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: QueryCollateralResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryCollateralResponse: 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 Amount", 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.Amount == nil {
+ x.Amount = &v1beta1.Coin{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Amount); 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_QueryAllCollateralsRequest protoreflect.MessageDescriptor
+ fd_QueryAllCollateralsRequest_pagination protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_collateral_query_proto_init()
+ md_QueryAllCollateralsRequest = File_inference_collateral_query_proto.Messages().ByName("QueryAllCollateralsRequest")
+ fd_QueryAllCollateralsRequest_pagination = md_QueryAllCollateralsRequest.Fields().ByName("pagination")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryAllCollateralsRequest)(nil)
+
+type fastReflection_QueryAllCollateralsRequest QueryAllCollateralsRequest
+
+func (x *QueryAllCollateralsRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryAllCollateralsRequest)(x)
+}
+
+func (x *QueryAllCollateralsRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_collateral_query_proto_msgTypes[4]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryAllCollateralsRequest_messageType fastReflection_QueryAllCollateralsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllCollateralsRequest_messageType{}
+
+type fastReflection_QueryAllCollateralsRequest_messageType struct{}
+
+func (x fastReflection_QueryAllCollateralsRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryAllCollateralsRequest)(nil)
+}
+func (x fastReflection_QueryAllCollateralsRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryAllCollateralsRequest)
+}
+func (x fastReflection_QueryAllCollateralsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryAllCollateralsRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryAllCollateralsRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryAllCollateralsRequest
+}
+
+// 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_QueryAllCollateralsRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryAllCollateralsRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryAllCollateralsRequest) New() protoreflect.Message {
+ return new(fastReflection_QueryAllCollateralsRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryAllCollateralsRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryAllCollateralsRequest)(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_QueryAllCollateralsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Pagination != nil {
+ value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+ if !f(fd_QueryAllCollateralsRequest_pagination, 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_QueryAllCollateralsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.collateral.QueryAllCollateralsRequest.pagination":
+ return x.Pagination != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryAllCollateralsRequest"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryAllCollateralsRequest 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_QueryAllCollateralsRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.collateral.QueryAllCollateralsRequest.pagination":
+ x.Pagination = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryAllCollateralsRequest"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryAllCollateralsRequest 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_QueryAllCollateralsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.collateral.QueryAllCollateralsRequest.pagination":
+ value := x.Pagination
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryAllCollateralsRequest"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryAllCollateralsRequest 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_QueryAllCollateralsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.collateral.QueryAllCollateralsRequest.pagination":
+ x.Pagination = value.Message().Interface().(*v1beta11.PageRequest)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryAllCollateralsRequest"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryAllCollateralsRequest 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_QueryAllCollateralsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.collateral.QueryAllCollateralsRequest.pagination":
+ if x.Pagination == nil {
+ x.Pagination = new(v1beta11.PageRequest)
+ }
+ return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryAllCollateralsRequest"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryAllCollateralsRequest 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_QueryAllCollateralsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.collateral.QueryAllCollateralsRequest.pagination":
+ m := new(v1beta11.PageRequest)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryAllCollateralsRequest"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryAllCollateralsRequest 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_QueryAllCollateralsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.collateral.QueryAllCollateralsRequest", 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_QueryAllCollateralsRequest) 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_QueryAllCollateralsRequest) 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_QueryAllCollateralsRequest) 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_QueryAllCollateralsRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryAllCollateralsRequest)
+ 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.Pagination != nil {
+ l = options.Size(x.Pagination)
+ 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().(*QueryAllCollateralsRequest)
+ 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.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 {
+ 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().(*QueryAllCollateralsRequest)
+ 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: QueryAllCollateralsRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllCollateralsRequest: 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 = &v1beta11.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 {
+ 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 = (*_QueryAllCollateralsResponse_1_list)(nil)
+
+type _QueryAllCollateralsResponse_1_list struct {
+ list *[]*CollateralBalance
+}
+
+func (x *_QueryAllCollateralsResponse_1_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_QueryAllCollateralsResponse_1_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryAllCollateralsResponse_1_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*CollateralBalance)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_QueryAllCollateralsResponse_1_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*CollateralBalance)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryAllCollateralsResponse_1_list) AppendMutable() protoreflect.Value {
+ v := new(CollateralBalance)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryAllCollateralsResponse_1_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_QueryAllCollateralsResponse_1_list) NewElement() protoreflect.Value {
+ v := new(CollateralBalance)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryAllCollateralsResponse_1_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_QueryAllCollateralsResponse protoreflect.MessageDescriptor
+ fd_QueryAllCollateralsResponse_collateral protoreflect.FieldDescriptor
+ fd_QueryAllCollateralsResponse_pagination protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_collateral_query_proto_init()
+ md_QueryAllCollateralsResponse = File_inference_collateral_query_proto.Messages().ByName("QueryAllCollateralsResponse")
+ fd_QueryAllCollateralsResponse_collateral = md_QueryAllCollateralsResponse.Fields().ByName("collateral")
+ fd_QueryAllCollateralsResponse_pagination = md_QueryAllCollateralsResponse.Fields().ByName("pagination")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryAllCollateralsResponse)(nil)
+
+type fastReflection_QueryAllCollateralsResponse QueryAllCollateralsResponse
+
+func (x *QueryAllCollateralsResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryAllCollateralsResponse)(x)
+}
+
+func (x *QueryAllCollateralsResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_collateral_query_proto_msgTypes[5]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryAllCollateralsResponse_messageType fastReflection_QueryAllCollateralsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllCollateralsResponse_messageType{}
+
+type fastReflection_QueryAllCollateralsResponse_messageType struct{}
+
+func (x fastReflection_QueryAllCollateralsResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryAllCollateralsResponse)(nil)
+}
+func (x fastReflection_QueryAllCollateralsResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryAllCollateralsResponse)
+}
+func (x fastReflection_QueryAllCollateralsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryAllCollateralsResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryAllCollateralsResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryAllCollateralsResponse
+}
+
+// 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_QueryAllCollateralsResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryAllCollateralsResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryAllCollateralsResponse) New() protoreflect.Message {
+ return new(fastReflection_QueryAllCollateralsResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryAllCollateralsResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryAllCollateralsResponse)(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_QueryAllCollateralsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if len(x.Collateral) != 0 {
+ value := protoreflect.ValueOfList(&_QueryAllCollateralsResponse_1_list{list: &x.Collateral})
+ if !f(fd_QueryAllCollateralsResponse_collateral, value) {
+ return
+ }
+ }
+ if x.Pagination != nil {
+ value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+ if !f(fd_QueryAllCollateralsResponse_pagination, 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_QueryAllCollateralsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.collateral.QueryAllCollateralsResponse.collateral":
+ return len(x.Collateral) != 0
+ case "inference.collateral.QueryAllCollateralsResponse.pagination":
+ return x.Pagination != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryAllCollateralsResponse"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryAllCollateralsResponse 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_QueryAllCollateralsResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.collateral.QueryAllCollateralsResponse.collateral":
+ x.Collateral = nil
+ case "inference.collateral.QueryAllCollateralsResponse.pagination":
+ x.Pagination = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryAllCollateralsResponse"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryAllCollateralsResponse 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_QueryAllCollateralsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.collateral.QueryAllCollateralsResponse.collateral":
+ if len(x.Collateral) == 0 {
+ return protoreflect.ValueOfList(&_QueryAllCollateralsResponse_1_list{})
+ }
+ listValue := &_QueryAllCollateralsResponse_1_list{list: &x.Collateral}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.collateral.QueryAllCollateralsResponse.pagination":
+ value := x.Pagination
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryAllCollateralsResponse"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryAllCollateralsResponse 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_QueryAllCollateralsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.collateral.QueryAllCollateralsResponse.collateral":
+ lv := value.List()
+ clv := lv.(*_QueryAllCollateralsResponse_1_list)
+ x.Collateral = *clv.list
+ case "inference.collateral.QueryAllCollateralsResponse.pagination":
+ x.Pagination = value.Message().Interface().(*v1beta11.PageResponse)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryAllCollateralsResponse"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryAllCollateralsResponse 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_QueryAllCollateralsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.collateral.QueryAllCollateralsResponse.collateral":
+ if x.Collateral == nil {
+ x.Collateral = []*CollateralBalance{}
+ }
+ value := &_QueryAllCollateralsResponse_1_list{list: &x.Collateral}
+ return protoreflect.ValueOfList(value)
+ case "inference.collateral.QueryAllCollateralsResponse.pagination":
+ if x.Pagination == nil {
+ x.Pagination = new(v1beta11.PageResponse)
+ }
+ return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryAllCollateralsResponse"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryAllCollateralsResponse 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_QueryAllCollateralsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.collateral.QueryAllCollateralsResponse.collateral":
+ list := []*CollateralBalance{}
+ return protoreflect.ValueOfList(&_QueryAllCollateralsResponse_1_list{list: &list})
+ case "inference.collateral.QueryAllCollateralsResponse.pagination":
+ m := new(v1beta11.PageResponse)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryAllCollateralsResponse"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryAllCollateralsResponse 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_QueryAllCollateralsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.collateral.QueryAllCollateralsResponse", 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_QueryAllCollateralsResponse) 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_QueryAllCollateralsResponse) 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_QueryAllCollateralsResponse) 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_QueryAllCollateralsResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryAllCollateralsResponse)
+ 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.Collateral) > 0 {
+ for _, e := range x.Collateral {
+ 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)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*QueryAllCollateralsResponse)
+ 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.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.Collateral) > 0 {
+ for iNdEx := len(x.Collateral) - 1; iNdEx >= 0; iNdEx-- {
+ encoded, err := options.Marshal(x.Collateral[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().(*QueryAllCollateralsResponse)
+ 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: QueryAllCollateralsResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllCollateralsResponse: 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 Collateral", 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.Collateral = append(x.Collateral, &CollateralBalance{})
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Collateral[len(x.Collateral)-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 = &v1beta11.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:])
+ 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_QueryUnbondingCollateralRequest protoreflect.MessageDescriptor
+ fd_QueryUnbondingCollateralRequest_participant protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_collateral_query_proto_init()
+ md_QueryUnbondingCollateralRequest = File_inference_collateral_query_proto.Messages().ByName("QueryUnbondingCollateralRequest")
+ fd_QueryUnbondingCollateralRequest_participant = md_QueryUnbondingCollateralRequest.Fields().ByName("participant")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryUnbondingCollateralRequest)(nil)
+
+type fastReflection_QueryUnbondingCollateralRequest QueryUnbondingCollateralRequest
+
+func (x *QueryUnbondingCollateralRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryUnbondingCollateralRequest)(x)
+}
+
+func (x *QueryUnbondingCollateralRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_collateral_query_proto_msgTypes[6]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryUnbondingCollateralRequest_messageType fastReflection_QueryUnbondingCollateralRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryUnbondingCollateralRequest_messageType{}
+
+type fastReflection_QueryUnbondingCollateralRequest_messageType struct{}
+
+func (x fastReflection_QueryUnbondingCollateralRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryUnbondingCollateralRequest)(nil)
+}
+func (x fastReflection_QueryUnbondingCollateralRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryUnbondingCollateralRequest)
+}
+func (x fastReflection_QueryUnbondingCollateralRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryUnbondingCollateralRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryUnbondingCollateralRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryUnbondingCollateralRequest
+}
+
+// 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_QueryUnbondingCollateralRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryUnbondingCollateralRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryUnbondingCollateralRequest) New() protoreflect.Message {
+ return new(fastReflection_QueryUnbondingCollateralRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryUnbondingCollateralRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryUnbondingCollateralRequest)(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_QueryUnbondingCollateralRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Participant != "" {
+ value := protoreflect.ValueOfString(x.Participant)
+ if !f(fd_QueryUnbondingCollateralRequest_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_QueryUnbondingCollateralRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.collateral.QueryUnbondingCollateralRequest.participant":
+ return x.Participant != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryUnbondingCollateralRequest"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryUnbondingCollateralRequest 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_QueryUnbondingCollateralRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.collateral.QueryUnbondingCollateralRequest.participant":
+ x.Participant = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryUnbondingCollateralRequest"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryUnbondingCollateralRequest 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_QueryUnbondingCollateralRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.collateral.QueryUnbondingCollateralRequest.participant":
+ value := x.Participant
+ return protoreflect.ValueOfString(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryUnbondingCollateralRequest"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryUnbondingCollateralRequest 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_QueryUnbondingCollateralRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.collateral.QueryUnbondingCollateralRequest.participant":
+ x.Participant = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryUnbondingCollateralRequest"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryUnbondingCollateralRequest 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_QueryUnbondingCollateralRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.collateral.QueryUnbondingCollateralRequest.participant":
+ panic(fmt.Errorf("field participant of message inference.collateral.QueryUnbondingCollateralRequest is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryUnbondingCollateralRequest"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryUnbondingCollateralRequest 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_QueryUnbondingCollateralRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.collateral.QueryUnbondingCollateralRequest.participant":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryUnbondingCollateralRequest"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryUnbondingCollateralRequest 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_QueryUnbondingCollateralRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.collateral.QueryUnbondingCollateralRequest", 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_QueryUnbondingCollateralRequest) 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_QueryUnbondingCollateralRequest) 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_QueryUnbondingCollateralRequest) 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_QueryUnbondingCollateralRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryUnbondingCollateralRequest)
+ 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().(*QueryUnbondingCollateralRequest)
+ 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().(*QueryUnbondingCollateralRequest)
+ 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: QueryUnbondingCollateralRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryUnbondingCollateralRequest: 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 = (*_QueryUnbondingCollateralResponse_1_list)(nil)
+
+type _QueryUnbondingCollateralResponse_1_list struct {
+ list *[]*UnbondingCollateral
+}
+
+func (x *_QueryUnbondingCollateralResponse_1_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_QueryUnbondingCollateralResponse_1_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryUnbondingCollateralResponse_1_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*UnbondingCollateral)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_QueryUnbondingCollateralResponse_1_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*UnbondingCollateral)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryUnbondingCollateralResponse_1_list) AppendMutable() protoreflect.Value {
+ v := new(UnbondingCollateral)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryUnbondingCollateralResponse_1_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_QueryUnbondingCollateralResponse_1_list) NewElement() protoreflect.Value {
+ v := new(UnbondingCollateral)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryUnbondingCollateralResponse_1_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_QueryUnbondingCollateralResponse protoreflect.MessageDescriptor
+ fd_QueryUnbondingCollateralResponse_unbondings protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_collateral_query_proto_init()
+ md_QueryUnbondingCollateralResponse = File_inference_collateral_query_proto.Messages().ByName("QueryUnbondingCollateralResponse")
+ fd_QueryUnbondingCollateralResponse_unbondings = md_QueryUnbondingCollateralResponse.Fields().ByName("unbondings")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryUnbondingCollateralResponse)(nil)
+
+type fastReflection_QueryUnbondingCollateralResponse QueryUnbondingCollateralResponse
+
+func (x *QueryUnbondingCollateralResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryUnbondingCollateralResponse)(x)
+}
+
+func (x *QueryUnbondingCollateralResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_collateral_query_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_QueryUnbondingCollateralResponse_messageType fastReflection_QueryUnbondingCollateralResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryUnbondingCollateralResponse_messageType{}
+
+type fastReflection_QueryUnbondingCollateralResponse_messageType struct{}
+
+func (x fastReflection_QueryUnbondingCollateralResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryUnbondingCollateralResponse)(nil)
+}
+func (x fastReflection_QueryUnbondingCollateralResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryUnbondingCollateralResponse)
+}
+func (x fastReflection_QueryUnbondingCollateralResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryUnbondingCollateralResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryUnbondingCollateralResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryUnbondingCollateralResponse
+}
+
+// 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_QueryUnbondingCollateralResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryUnbondingCollateralResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryUnbondingCollateralResponse) New() protoreflect.Message {
+ return new(fastReflection_QueryUnbondingCollateralResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryUnbondingCollateralResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryUnbondingCollateralResponse)(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_QueryUnbondingCollateralResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if len(x.Unbondings) != 0 {
+ value := protoreflect.ValueOfList(&_QueryUnbondingCollateralResponse_1_list{list: &x.Unbondings})
+ if !f(fd_QueryUnbondingCollateralResponse_unbondings, 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_QueryUnbondingCollateralResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.collateral.QueryUnbondingCollateralResponse.unbondings":
+ return len(x.Unbondings) != 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryUnbondingCollateralResponse"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryUnbondingCollateralResponse 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_QueryUnbondingCollateralResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.collateral.QueryUnbondingCollateralResponse.unbondings":
+ x.Unbondings = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryUnbondingCollateralResponse"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryUnbondingCollateralResponse 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_QueryUnbondingCollateralResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.collateral.QueryUnbondingCollateralResponse.unbondings":
+ if len(x.Unbondings) == 0 {
+ return protoreflect.ValueOfList(&_QueryUnbondingCollateralResponse_1_list{})
+ }
+ listValue := &_QueryUnbondingCollateralResponse_1_list{list: &x.Unbondings}
+ return protoreflect.ValueOfList(listValue)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryUnbondingCollateralResponse"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryUnbondingCollateralResponse 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_QueryUnbondingCollateralResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.collateral.QueryUnbondingCollateralResponse.unbondings":
+ lv := value.List()
+ clv := lv.(*_QueryUnbondingCollateralResponse_1_list)
+ x.Unbondings = *clv.list
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryUnbondingCollateralResponse"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryUnbondingCollateralResponse 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_QueryUnbondingCollateralResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.collateral.QueryUnbondingCollateralResponse.unbondings":
+ if x.Unbondings == nil {
+ x.Unbondings = []*UnbondingCollateral{}
+ }
+ value := &_QueryUnbondingCollateralResponse_1_list{list: &x.Unbondings}
+ return protoreflect.ValueOfList(value)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryUnbondingCollateralResponse"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryUnbondingCollateralResponse 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_QueryUnbondingCollateralResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.collateral.QueryUnbondingCollateralResponse.unbondings":
+ list := []*UnbondingCollateral{}
+ return protoreflect.ValueOfList(&_QueryUnbondingCollateralResponse_1_list{list: &list})
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryUnbondingCollateralResponse"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryUnbondingCollateralResponse 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_QueryUnbondingCollateralResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.collateral.QueryUnbondingCollateralResponse", 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_QueryUnbondingCollateralResponse) 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_QueryUnbondingCollateralResponse) 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_QueryUnbondingCollateralResponse) 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_QueryUnbondingCollateralResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryUnbondingCollateralResponse)
+ 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.Unbondings) > 0 {
+ for _, e := range x.Unbondings {
+ 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().(*QueryUnbondingCollateralResponse)
+ 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.Unbondings) > 0 {
+ for iNdEx := len(x.Unbondings) - 1; iNdEx >= 0; iNdEx-- {
+ encoded, err := options.Marshal(x.Unbondings[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().(*QueryUnbondingCollateralResponse)
+ 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: QueryUnbondingCollateralResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryUnbondingCollateralResponse: 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 Unbondings", 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.Unbondings = append(x.Unbondings, &UnbondingCollateral{})
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Unbondings[len(x.Unbondings)-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_QueryAllUnbondingCollateralsRequest protoreflect.MessageDescriptor
+ fd_QueryAllUnbondingCollateralsRequest_pagination protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_collateral_query_proto_init()
+ md_QueryAllUnbondingCollateralsRequest = File_inference_collateral_query_proto.Messages().ByName("QueryAllUnbondingCollateralsRequest")
+ fd_QueryAllUnbondingCollateralsRequest_pagination = md_QueryAllUnbondingCollateralsRequest.Fields().ByName("pagination")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryAllUnbondingCollateralsRequest)(nil)
+
+type fastReflection_QueryAllUnbondingCollateralsRequest QueryAllUnbondingCollateralsRequest
+
+func (x *QueryAllUnbondingCollateralsRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryAllUnbondingCollateralsRequest)(x)
+}
+
+func (x *QueryAllUnbondingCollateralsRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_collateral_query_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_QueryAllUnbondingCollateralsRequest_messageType fastReflection_QueryAllUnbondingCollateralsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllUnbondingCollateralsRequest_messageType{}
+
+type fastReflection_QueryAllUnbondingCollateralsRequest_messageType struct{}
+
+func (x fastReflection_QueryAllUnbondingCollateralsRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryAllUnbondingCollateralsRequest)(nil)
+}
+func (x fastReflection_QueryAllUnbondingCollateralsRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryAllUnbondingCollateralsRequest)
+}
+func (x fastReflection_QueryAllUnbondingCollateralsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryAllUnbondingCollateralsRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryAllUnbondingCollateralsRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryAllUnbondingCollateralsRequest
+}
+
+// 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_QueryAllUnbondingCollateralsRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryAllUnbondingCollateralsRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryAllUnbondingCollateralsRequest) New() protoreflect.Message {
+ return new(fastReflection_QueryAllUnbondingCollateralsRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryAllUnbondingCollateralsRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryAllUnbondingCollateralsRequest)(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_QueryAllUnbondingCollateralsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Pagination != nil {
+ value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+ if !f(fd_QueryAllUnbondingCollateralsRequest_pagination, 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_QueryAllUnbondingCollateralsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.collateral.QueryAllUnbondingCollateralsRequest.pagination":
+ return x.Pagination != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryAllUnbondingCollateralsRequest"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryAllUnbondingCollateralsRequest 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_QueryAllUnbondingCollateralsRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.collateral.QueryAllUnbondingCollateralsRequest.pagination":
+ x.Pagination = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryAllUnbondingCollateralsRequest"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryAllUnbondingCollateralsRequest 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_QueryAllUnbondingCollateralsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.collateral.QueryAllUnbondingCollateralsRequest.pagination":
+ value := x.Pagination
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryAllUnbondingCollateralsRequest"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryAllUnbondingCollateralsRequest 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_QueryAllUnbondingCollateralsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.collateral.QueryAllUnbondingCollateralsRequest.pagination":
+ x.Pagination = value.Message().Interface().(*v1beta11.PageRequest)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryAllUnbondingCollateralsRequest"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryAllUnbondingCollateralsRequest 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_QueryAllUnbondingCollateralsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.collateral.QueryAllUnbondingCollateralsRequest.pagination":
+ if x.Pagination == nil {
+ x.Pagination = new(v1beta11.PageRequest)
+ }
+ return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryAllUnbondingCollateralsRequest"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryAllUnbondingCollateralsRequest 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_QueryAllUnbondingCollateralsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.collateral.QueryAllUnbondingCollateralsRequest.pagination":
+ m := new(v1beta11.PageRequest)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryAllUnbondingCollateralsRequest"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryAllUnbondingCollateralsRequest 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_QueryAllUnbondingCollateralsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.collateral.QueryAllUnbondingCollateralsRequest", 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_QueryAllUnbondingCollateralsRequest) 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_QueryAllUnbondingCollateralsRequest) 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_QueryAllUnbondingCollateralsRequest) 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_QueryAllUnbondingCollateralsRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryAllUnbondingCollateralsRequest)
+ 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.Pagination != nil {
+ l = options.Size(x.Pagination)
+ 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().(*QueryAllUnbondingCollateralsRequest)
+ 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.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 {
+ 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().(*QueryAllUnbondingCollateralsRequest)
+ 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: QueryAllUnbondingCollateralsRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllUnbondingCollateralsRequest: 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 = &v1beta11.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 {
+ 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 = (*_QueryAllUnbondingCollateralsResponse_1_list)(nil)
+
+type _QueryAllUnbondingCollateralsResponse_1_list struct {
+ list *[]*UnbondingCollateral
+}
+
+func (x *_QueryAllUnbondingCollateralsResponse_1_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_QueryAllUnbondingCollateralsResponse_1_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryAllUnbondingCollateralsResponse_1_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*UnbondingCollateral)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_QueryAllUnbondingCollateralsResponse_1_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*UnbondingCollateral)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryAllUnbondingCollateralsResponse_1_list) AppendMutable() protoreflect.Value {
+ v := new(UnbondingCollateral)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryAllUnbondingCollateralsResponse_1_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_QueryAllUnbondingCollateralsResponse_1_list) NewElement() protoreflect.Value {
+ v := new(UnbondingCollateral)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryAllUnbondingCollateralsResponse_1_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_QueryAllUnbondingCollateralsResponse protoreflect.MessageDescriptor
+ fd_QueryAllUnbondingCollateralsResponse_unbondings protoreflect.FieldDescriptor
+ fd_QueryAllUnbondingCollateralsResponse_pagination protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_collateral_query_proto_init()
+ md_QueryAllUnbondingCollateralsResponse = File_inference_collateral_query_proto.Messages().ByName("QueryAllUnbondingCollateralsResponse")
+ fd_QueryAllUnbondingCollateralsResponse_unbondings = md_QueryAllUnbondingCollateralsResponse.Fields().ByName("unbondings")
+ fd_QueryAllUnbondingCollateralsResponse_pagination = md_QueryAllUnbondingCollateralsResponse.Fields().ByName("pagination")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryAllUnbondingCollateralsResponse)(nil)
+
+type fastReflection_QueryAllUnbondingCollateralsResponse QueryAllUnbondingCollateralsResponse
+
+func (x *QueryAllUnbondingCollateralsResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryAllUnbondingCollateralsResponse)(x)
+}
+
+func (x *QueryAllUnbondingCollateralsResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_collateral_query_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_QueryAllUnbondingCollateralsResponse_messageType fastReflection_QueryAllUnbondingCollateralsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllUnbondingCollateralsResponse_messageType{}
+
+type fastReflection_QueryAllUnbondingCollateralsResponse_messageType struct{}
+
+func (x fastReflection_QueryAllUnbondingCollateralsResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryAllUnbondingCollateralsResponse)(nil)
+}
+func (x fastReflection_QueryAllUnbondingCollateralsResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryAllUnbondingCollateralsResponse)
+}
+func (x fastReflection_QueryAllUnbondingCollateralsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryAllUnbondingCollateralsResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryAllUnbondingCollateralsResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryAllUnbondingCollateralsResponse
+}
+
+// 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_QueryAllUnbondingCollateralsResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryAllUnbondingCollateralsResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryAllUnbondingCollateralsResponse) New() protoreflect.Message {
+ return new(fastReflection_QueryAllUnbondingCollateralsResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryAllUnbondingCollateralsResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryAllUnbondingCollateralsResponse)(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_QueryAllUnbondingCollateralsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if len(x.Unbondings) != 0 {
+ value := protoreflect.ValueOfList(&_QueryAllUnbondingCollateralsResponse_1_list{list: &x.Unbondings})
+ if !f(fd_QueryAllUnbondingCollateralsResponse_unbondings, value) {
+ return
+ }
+ }
+ if x.Pagination != nil {
+ value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+ if !f(fd_QueryAllUnbondingCollateralsResponse_pagination, 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_QueryAllUnbondingCollateralsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.collateral.QueryAllUnbondingCollateralsResponse.unbondings":
+ return len(x.Unbondings) != 0
+ case "inference.collateral.QueryAllUnbondingCollateralsResponse.pagination":
+ return x.Pagination != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryAllUnbondingCollateralsResponse"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryAllUnbondingCollateralsResponse 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_QueryAllUnbondingCollateralsResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.collateral.QueryAllUnbondingCollateralsResponse.unbondings":
+ x.Unbondings = nil
+ case "inference.collateral.QueryAllUnbondingCollateralsResponse.pagination":
+ x.Pagination = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryAllUnbondingCollateralsResponse"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryAllUnbondingCollateralsResponse 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_QueryAllUnbondingCollateralsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.collateral.QueryAllUnbondingCollateralsResponse.unbondings":
+ if len(x.Unbondings) == 0 {
+ return protoreflect.ValueOfList(&_QueryAllUnbondingCollateralsResponse_1_list{})
+ }
+ listValue := &_QueryAllUnbondingCollateralsResponse_1_list{list: &x.Unbondings}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.collateral.QueryAllUnbondingCollateralsResponse.pagination":
+ value := x.Pagination
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryAllUnbondingCollateralsResponse"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryAllUnbondingCollateralsResponse 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_QueryAllUnbondingCollateralsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.collateral.QueryAllUnbondingCollateralsResponse.unbondings":
+ lv := value.List()
+ clv := lv.(*_QueryAllUnbondingCollateralsResponse_1_list)
+ x.Unbondings = *clv.list
+ case "inference.collateral.QueryAllUnbondingCollateralsResponse.pagination":
+ x.Pagination = value.Message().Interface().(*v1beta11.PageResponse)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryAllUnbondingCollateralsResponse"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryAllUnbondingCollateralsResponse 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_QueryAllUnbondingCollateralsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.collateral.QueryAllUnbondingCollateralsResponse.unbondings":
+ if x.Unbondings == nil {
+ x.Unbondings = []*UnbondingCollateral{}
+ }
+ value := &_QueryAllUnbondingCollateralsResponse_1_list{list: &x.Unbondings}
+ return protoreflect.ValueOfList(value)
+ case "inference.collateral.QueryAllUnbondingCollateralsResponse.pagination":
+ if x.Pagination == nil {
+ x.Pagination = new(v1beta11.PageResponse)
+ }
+ return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryAllUnbondingCollateralsResponse"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryAllUnbondingCollateralsResponse 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_QueryAllUnbondingCollateralsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.collateral.QueryAllUnbondingCollateralsResponse.unbondings":
+ list := []*UnbondingCollateral{}
+ return protoreflect.ValueOfList(&_QueryAllUnbondingCollateralsResponse_1_list{list: &list})
+ case "inference.collateral.QueryAllUnbondingCollateralsResponse.pagination":
+ m := new(v1beta11.PageResponse)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.QueryAllUnbondingCollateralsResponse"))
+ }
+ panic(fmt.Errorf("message inference.collateral.QueryAllUnbondingCollateralsResponse 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_QueryAllUnbondingCollateralsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.collateral.QueryAllUnbondingCollateralsResponse", 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_QueryAllUnbondingCollateralsResponse) 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_QueryAllUnbondingCollateralsResponse) 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_QueryAllUnbondingCollateralsResponse) 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_QueryAllUnbondingCollateralsResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryAllUnbondingCollateralsResponse)
+ 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.Unbondings) > 0 {
+ for _, e := range x.Unbondings {
+ 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)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*QueryAllUnbondingCollateralsResponse)
+ 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.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.Unbondings) > 0 {
+ for iNdEx := len(x.Unbondings) - 1; iNdEx >= 0; iNdEx-- {
+ encoded, err := options.Marshal(x.Unbondings[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().(*QueryAllUnbondingCollateralsResponse)
+ 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: QueryAllUnbondingCollateralsResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllUnbondingCollateralsResponse: 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 Unbondings", 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.Unbondings = append(x.Unbondings, &UnbondingCollateral{})
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Unbondings[len(x.Unbondings)-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 = &v1beta11.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:])
+ 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/collateral/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_collateral_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_collateral_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_collateral_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_collateral_query_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *QueryParamsResponse) GetParams() *Params {
+ if x != nil {
+ return x.Params
+ }
+ return nil
+}
+
+// QueryCollateralRequest is the request type for the Query/Collateral RPC method.
+type QueryCollateralRequest struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Participant string `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
+}
+
+func (x *QueryCollateralRequest) Reset() {
+ *x = QueryCollateralRequest{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_collateral_query_proto_msgTypes[2]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *QueryCollateralRequest) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryCollateralRequest) ProtoMessage() {}
+
+// Deprecated: Use QueryCollateralRequest.ProtoReflect.Descriptor instead.
+func (*QueryCollateralRequest) Descriptor() ([]byte, []int) {
+ return file_inference_collateral_query_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *QueryCollateralRequest) GetParticipant() string {
+ if x != nil {
+ return x.Participant
+ }
+ return ""
+}
+
+// QueryCollateralResponse is the response type for the Query/Collateral RPC method.
+type QueryCollateralResponse struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Amount *v1beta1.Coin `protobuf:"bytes,1,opt,name=amount,proto3" json:"amount,omitempty"`
+}
+
+func (x *QueryCollateralResponse) Reset() {
+ *x = QueryCollateralResponse{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_collateral_query_proto_msgTypes[3]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *QueryCollateralResponse) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryCollateralResponse) ProtoMessage() {}
+
+// Deprecated: Use QueryCollateralResponse.ProtoReflect.Descriptor instead.
+func (*QueryCollateralResponse) Descriptor() ([]byte, []int) {
+ return file_inference_collateral_query_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *QueryCollateralResponse) GetAmount() *v1beta1.Coin {
+ if x != nil {
+ return x.Amount
+ }
+ return nil
+}
+
+// QueryAllCollateralsRequest is the request type for the Query/AllCollaterals RPC method.
+type QueryAllCollateralsRequest struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Pagination *v1beta11.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
+}
+
+func (x *QueryAllCollateralsRequest) Reset() {
+ *x = QueryAllCollateralsRequest{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_collateral_query_proto_msgTypes[4]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *QueryAllCollateralsRequest) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryAllCollateralsRequest) ProtoMessage() {}
+
+// Deprecated: Use QueryAllCollateralsRequest.ProtoReflect.Descriptor instead.
+func (*QueryAllCollateralsRequest) Descriptor() ([]byte, []int) {
+ return file_inference_collateral_query_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *QueryAllCollateralsRequest) GetPagination() *v1beta11.PageRequest {
+ if x != nil {
+ return x.Pagination
+ }
+ return nil
+}
+
+// QueryAllCollateralsResponse is the response type for the Query/AllCollaterals RPC method.
+type QueryAllCollateralsResponse struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Collateral []*CollateralBalance `protobuf:"bytes,1,rep,name=collateral,proto3" json:"collateral,omitempty"`
+ Pagination *v1beta11.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
+}
+
+func (x *QueryAllCollateralsResponse) Reset() {
+ *x = QueryAllCollateralsResponse{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_collateral_query_proto_msgTypes[5]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *QueryAllCollateralsResponse) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryAllCollateralsResponse) ProtoMessage() {}
+
+// Deprecated: Use QueryAllCollateralsResponse.ProtoReflect.Descriptor instead.
+func (*QueryAllCollateralsResponse) Descriptor() ([]byte, []int) {
+ return file_inference_collateral_query_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *QueryAllCollateralsResponse) GetCollateral() []*CollateralBalance {
+ if x != nil {
+ return x.Collateral
+ }
+ return nil
+}
+
+func (x *QueryAllCollateralsResponse) GetPagination() *v1beta11.PageResponse {
+ if x != nil {
+ return x.Pagination
+ }
+ return nil
+}
+
+// QueryUnbondingCollateralRequest is the request type for the Query/UnbondingCollateral RPC method.
+type QueryUnbondingCollateralRequest struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Participant string `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
+}
+
+func (x *QueryUnbondingCollateralRequest) Reset() {
+ *x = QueryUnbondingCollateralRequest{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_collateral_query_proto_msgTypes[6]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *QueryUnbondingCollateralRequest) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryUnbondingCollateralRequest) ProtoMessage() {}
+
+// Deprecated: Use QueryUnbondingCollateralRequest.ProtoReflect.Descriptor instead.
+func (*QueryUnbondingCollateralRequest) Descriptor() ([]byte, []int) {
+ return file_inference_collateral_query_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *QueryUnbondingCollateralRequest) GetParticipant() string {
+ if x != nil {
+ return x.Participant
+ }
+ return ""
+}
+
+// QueryUnbondingCollateralResponse is the response type for the Query/UnbondingCollateral RPC method.
+type QueryUnbondingCollateralResponse struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Unbondings []*UnbondingCollateral `protobuf:"bytes,1,rep,name=unbondings,proto3" json:"unbondings,omitempty"`
+}
+
+func (x *QueryUnbondingCollateralResponse) Reset() {
+ *x = QueryUnbondingCollateralResponse{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_collateral_query_proto_msgTypes[7]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *QueryUnbondingCollateralResponse) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryUnbondingCollateralResponse) ProtoMessage() {}
+
+// Deprecated: Use QueryUnbondingCollateralResponse.ProtoReflect.Descriptor instead.
+func (*QueryUnbondingCollateralResponse) Descriptor() ([]byte, []int) {
+ return file_inference_collateral_query_proto_rawDescGZIP(), []int{7}
+}
+
+func (x *QueryUnbondingCollateralResponse) GetUnbondings() []*UnbondingCollateral {
+ if x != nil {
+ return x.Unbondings
+ }
+ return nil
+}
+
+// QueryAllUnbondingCollateralsRequest is the request type for the Query/AllUnbondingCollaterals RPC method.
+type QueryAllUnbondingCollateralsRequest struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Pagination *v1beta11.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
+}
+
+func (x *QueryAllUnbondingCollateralsRequest) Reset() {
+ *x = QueryAllUnbondingCollateralsRequest{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_collateral_query_proto_msgTypes[8]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *QueryAllUnbondingCollateralsRequest) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryAllUnbondingCollateralsRequest) ProtoMessage() {}
+
+// Deprecated: Use QueryAllUnbondingCollateralsRequest.ProtoReflect.Descriptor instead.
+func (*QueryAllUnbondingCollateralsRequest) Descriptor() ([]byte, []int) {
+ return file_inference_collateral_query_proto_rawDescGZIP(), []int{8}
+}
+
+func (x *QueryAllUnbondingCollateralsRequest) GetPagination() *v1beta11.PageRequest {
+ if x != nil {
+ return x.Pagination
+ }
+ return nil
+}
+
+// QueryAllUnbondingCollateralsResponse is the response type for the Query/AllUnbondingCollaterals RPC method.
+type QueryAllUnbondingCollateralsResponse struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Unbondings []*UnbondingCollateral `protobuf:"bytes,1,rep,name=unbondings,proto3" json:"unbondings,omitempty"`
+ Pagination *v1beta11.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
+}
+
+func (x *QueryAllUnbondingCollateralsResponse) Reset() {
+ *x = QueryAllUnbondingCollateralsResponse{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_collateral_query_proto_msgTypes[9]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *QueryAllUnbondingCollateralsResponse) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryAllUnbondingCollateralsResponse) ProtoMessage() {}
+
+// Deprecated: Use QueryAllUnbondingCollateralsResponse.ProtoReflect.Descriptor instead.
+func (*QueryAllUnbondingCollateralsResponse) Descriptor() ([]byte, []int) {
+ return file_inference_collateral_query_proto_rawDescGZIP(), []int{9}
+}
+
+func (x *QueryAllUnbondingCollateralsResponse) GetUnbondings() []*UnbondingCollateral {
+ if x != nil {
+ return x.Unbondings
+ }
+ return nil
+}
+
+func (x *QueryAllUnbondingCollateralsResponse) GetPagination() *v1beta11.PageResponse {
+ if x != nil {
+ return x.Pagination
+ }
+ return nil
+}
+
+var File_inference_collateral_query_proto protoreflect.FileDescriptor
+
+var file_inference_collateral_query_proto_rawDesc = []byte{
+ 0x0a, 0x20, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x63, 0x6f, 0x6c, 0x6c,
+ 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x70, 0x72, 0x6f,
+ 0x74, 0x6f, 0x12, 0x14, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x63, 0x6f,
+ 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x1a, 0x14, 0x67, 0x6f, 0x67, 0x6f, 0x70, 0x72,
+ 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1c,
+ 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x61, 0x6e, 0x6e, 0x6f, 0x74,
+ 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x2a, 0x63, 0x6f,
+ 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x62, 0x61, 0x73, 0x65, 0x2f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2f,
+ 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69,
+ 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x21, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+ 0x6e, 0x63, 0x65, 0x2f, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2f, 0x70,
+ 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x63, 0x6f, 0x73,
+ 0x6d, 0x6f, 0x73, 0x2f, 0x62, 0x61, 0x73, 0x65, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31,
+ 0x2f, 0x63, 0x6f, 0x69, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x24, 0x69, 0x6e, 0x66,
+ 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61,
+ 0x6c, 0x2f, 0x75, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+ 0x6f, 0x1a, 0x2d, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x63, 0x6f, 0x6c,
+ 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2f, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72,
+ 0x61, 0x6c, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 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, 0x51, 0x0a, 0x13, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50,
+ 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3a, 0x0a,
+ 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e,
+ 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74,
+ 0x65, 0x72, 0x61, 0x6c, 0x2e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x42, 0x04, 0xc8, 0xde, 0x1f,
+ 0x00, 0x52, 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x0a, 0x16, 0x51, 0x75, 0x65,
+ 0x72, 0x79, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 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, 0x52, 0x0a, 0x17, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6f,
+ 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+ 0x12, 0x37, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 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, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x64, 0x0a, 0x1a, 0x51, 0x75, 0x65,
+ 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 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,
+ 0xb5, 0x01, 0x0a, 0x1b, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x43, 0x6f, 0x6c, 0x6c,
+ 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12,
+ 0x4d, 0x0a, 0x0a, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x18, 0x01, 0x20,
+ 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+ 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2e, 0x43, 0x6f, 0x6c, 0x6c, 0x61,
+ 0x74, 0x65, 0x72, 0x61, 0x6c, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x42, 0x04, 0xc8, 0xde,
+ 0x1f, 0x00, 0x52, 0x0a, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 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, 0x43, 0x0a, 0x1f, 0x51, 0x75, 0x65, 0x72, 0x79,
+ 0x55, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65,
+ 0x72, 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, 0x73, 0x0a, 0x20,
+ 0x51, 0x75, 0x65, 0x72, 0x79, 0x55, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x6f,
+ 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+ 0x12, 0x4f, 0x0a, 0x0a, 0x75, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x73, 0x18, 0x01,
+ 0x20, 0x03, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+ 0x2e, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2e, 0x55, 0x6e, 0x62, 0x6f,
+ 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x42,
+ 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0a, 0x75, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67,
+ 0x73, 0x22, 0x6d, 0x0a, 0x23, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x55, 0x6e, 0x62,
+ 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 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, 0xc0, 0x01, 0x0a, 0x24, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x55, 0x6e, 0x62,
+ 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c,
+ 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4f, 0x0a, 0x0a, 0x75, 0x6e, 0x62,
+ 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x29, 0x2e,
+ 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74,
+ 0x65, 0x72, 0x61, 0x6c, 0x2e, 0x55, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x6f,
+ 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0a,
+ 0x75, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 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, 0x32, 0x98, 0x07, 0x0a, 0x05, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0x92, 0x01,
+ 0x0a, 0x06, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x28, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+ 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2e,
+ 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65,
+ 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x63,
+ 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50,
+ 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x33, 0x82,
+ 0xd3, 0xe4, 0x93, 0x02, 0x2d, 0x12, 0x2b, 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, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2f, 0x70, 0x61, 0x72, 0x61,
+ 0x6d, 0x73, 0x12, 0xb0, 0x01, 0x0a, 0x0a, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61,
+ 0x6c, 0x12, 0x2c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x63, 0x6f,
+ 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6f,
+ 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
+ 0x2d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x63, 0x6f, 0x6c, 0x6c,
+ 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x6c, 0x6c,
+ 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 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, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2f, 0x63, 0x6f, 0x6c,
+ 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2f, 0x7b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69,
+ 0x70, 0x61, 0x6e, 0x74, 0x7d, 0x12, 0xae, 0x01, 0x0a, 0x0e, 0x41, 0x6c, 0x6c, 0x43, 0x6f, 0x6c,
+ 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x12, 0x30, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+ 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2e,
+ 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72,
+ 0x61, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x31, 0x2e, 0x69, 0x6e, 0x66,
+ 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61,
+ 0x6c, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74,
+ 0x65, 0x72, 0x61, 0x6c, 0x73, 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, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2f, 0x63, 0x6f, 0x6c, 0x6c,
+ 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x12, 0xca, 0x01, 0x0a, 0x13, 0x55, 0x6e, 0x62, 0x6f, 0x6e,
+ 0x64, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x12, 0x35,
+ 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x63, 0x6f, 0x6c, 0x6c, 0x61,
+ 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x55, 0x6e, 0x62, 0x6f, 0x6e,
+ 0x64, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x52, 0x65,
+ 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x36, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+ 0x65, 0x2e, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2e, 0x51, 0x75, 0x65,
+ 0x72, 0x79, 0x55, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6c, 0x6c, 0x61,
+ 0x74, 0x65, 0x72, 0x61, 0x6c, 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, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2f, 0x75, 0x6e, 0x62, 0x6f,
+ 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x2f, 0x7b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61,
+ 0x6e, 0x74, 0x7d, 0x12, 0xc8, 0x01, 0x0a, 0x17, 0x41, 0x6c, 0x6c, 0x55, 0x6e, 0x62, 0x6f, 0x6e,
+ 0x64, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x12,
+ 0x39, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x63, 0x6f, 0x6c, 0x6c,
+ 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x55,
+ 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72,
+ 0x61, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x3a, 0x2e, 0x69, 0x6e, 0x66,
+ 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61,
+ 0x6c, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x55, 0x6e, 0x62, 0x6f, 0x6e, 0x64,
+ 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 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, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74,
+ 0x65, 0x72, 0x61, 0x6c, 0x2f, 0x75, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x42, 0xbe,
+ 0x01, 0x0a, 0x18, 0x63, 0x6f, 0x6d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+ 0x2e, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x42, 0x0a, 0x51, 0x75, 0x65,
+ 0x72, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x25, 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, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c,
+ 0xa2, 0x02, 0x03, 0x49, 0x43, 0x58, 0xaa, 0x02, 0x14, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+ 0x63, 0x65, 0x2e, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0xca, 0x02, 0x14,
+ 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74,
+ 0x65, 0x72, 0x61, 0x6c, 0xe2, 0x02, 0x20, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+ 0x5c, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x5c, 0x47, 0x50, 0x42, 0x4d,
+ 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x15, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65,
+ 0x6e, 0x63, 0x65, 0x3a, 0x3a, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x62,
+ 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+ file_inference_collateral_query_proto_rawDescOnce sync.Once
+ file_inference_collateral_query_proto_rawDescData = file_inference_collateral_query_proto_rawDesc
+)
+
+func file_inference_collateral_query_proto_rawDescGZIP() []byte {
+ file_inference_collateral_query_proto_rawDescOnce.Do(func() {
+ file_inference_collateral_query_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_collateral_query_proto_rawDescData)
+ })
+ return file_inference_collateral_query_proto_rawDescData
+}
+
+var file_inference_collateral_query_proto_msgTypes = make([]protoimpl.MessageInfo, 10)
+var file_inference_collateral_query_proto_goTypes = []interface{}{
+ (*QueryParamsRequest)(nil), // 0: inference.collateral.QueryParamsRequest
+ (*QueryParamsResponse)(nil), // 1: inference.collateral.QueryParamsResponse
+ (*QueryCollateralRequest)(nil), // 2: inference.collateral.QueryCollateralRequest
+ (*QueryCollateralResponse)(nil), // 3: inference.collateral.QueryCollateralResponse
+ (*QueryAllCollateralsRequest)(nil), // 4: inference.collateral.QueryAllCollateralsRequest
+ (*QueryAllCollateralsResponse)(nil), // 5: inference.collateral.QueryAllCollateralsResponse
+ (*QueryUnbondingCollateralRequest)(nil), // 6: inference.collateral.QueryUnbondingCollateralRequest
+ (*QueryUnbondingCollateralResponse)(nil), // 7: inference.collateral.QueryUnbondingCollateralResponse
+ (*QueryAllUnbondingCollateralsRequest)(nil), // 8: inference.collateral.QueryAllUnbondingCollateralsRequest
+ (*QueryAllUnbondingCollateralsResponse)(nil), // 9: inference.collateral.QueryAllUnbondingCollateralsResponse
+ (*Params)(nil), // 10: inference.collateral.Params
+ (*v1beta1.Coin)(nil), // 11: cosmos.base.v1beta1.Coin
+ (*v1beta11.PageRequest)(nil), // 12: cosmos.base.query.v1beta1.PageRequest
+ (*CollateralBalance)(nil), // 13: inference.collateral.CollateralBalance
+ (*v1beta11.PageResponse)(nil), // 14: cosmos.base.query.v1beta1.PageResponse
+ (*UnbondingCollateral)(nil), // 15: inference.collateral.UnbondingCollateral
+}
+var file_inference_collateral_query_proto_depIdxs = []int32{
+ 10, // 0: inference.collateral.QueryParamsResponse.params:type_name -> inference.collateral.Params
+ 11, // 1: inference.collateral.QueryCollateralResponse.amount:type_name -> cosmos.base.v1beta1.Coin
+ 12, // 2: inference.collateral.QueryAllCollateralsRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest
+ 13, // 3: inference.collateral.QueryAllCollateralsResponse.collateral:type_name -> inference.collateral.CollateralBalance
+ 14, // 4: inference.collateral.QueryAllCollateralsResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse
+ 15, // 5: inference.collateral.QueryUnbondingCollateralResponse.unbondings:type_name -> inference.collateral.UnbondingCollateral
+ 12, // 6: inference.collateral.QueryAllUnbondingCollateralsRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest
+ 15, // 7: inference.collateral.QueryAllUnbondingCollateralsResponse.unbondings:type_name -> inference.collateral.UnbondingCollateral
+ 14, // 8: inference.collateral.QueryAllUnbondingCollateralsResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse
+ 0, // 9: inference.collateral.Query.Params:input_type -> inference.collateral.QueryParamsRequest
+ 2, // 10: inference.collateral.Query.Collateral:input_type -> inference.collateral.QueryCollateralRequest
+ 4, // 11: inference.collateral.Query.AllCollaterals:input_type -> inference.collateral.QueryAllCollateralsRequest
+ 6, // 12: inference.collateral.Query.UnbondingCollateral:input_type -> inference.collateral.QueryUnbondingCollateralRequest
+ 8, // 13: inference.collateral.Query.AllUnbondingCollaterals:input_type -> inference.collateral.QueryAllUnbondingCollateralsRequest
+ 1, // 14: inference.collateral.Query.Params:output_type -> inference.collateral.QueryParamsResponse
+ 3, // 15: inference.collateral.Query.Collateral:output_type -> inference.collateral.QueryCollateralResponse
+ 5, // 16: inference.collateral.Query.AllCollaterals:output_type -> inference.collateral.QueryAllCollateralsResponse
+ 7, // 17: inference.collateral.Query.UnbondingCollateral:output_type -> inference.collateral.QueryUnbondingCollateralResponse
+ 9, // 18: inference.collateral.Query.AllUnbondingCollaterals:output_type -> inference.collateral.QueryAllUnbondingCollateralsResponse
+ 14, // [14:19] is the sub-list for method output_type
+ 9, // [9:14] is the sub-list for method input_type
+ 9, // [9:9] is the sub-list for extension type_name
+ 9, // [9:9] is the sub-list for extension extendee
+ 0, // [0:9] is the sub-list for field type_name
+}
+
+func init() { file_inference_collateral_query_proto_init() }
+func file_inference_collateral_query_proto_init() {
+ if File_inference_collateral_query_proto != nil {
+ return
+ }
+ file_inference_collateral_params_proto_init()
+ file_inference_collateral_unbonding_proto_init()
+ file_inference_collateral_collateral_balance_proto_init()
+ if !protoimpl.UnsafeEnabled {
+ file_inference_collateral_query_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*QueryParamsRequest); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_collateral_query_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*QueryParamsResponse); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_collateral_query_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*QueryCollateralRequest); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_collateral_query_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*QueryCollateralResponse); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_collateral_query_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*QueryAllCollateralsRequest); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_collateral_query_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*QueryAllCollateralsResponse); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_collateral_query_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*QueryUnbondingCollateralRequest); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_collateral_query_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*QueryUnbondingCollateralResponse); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_collateral_query_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*QueryAllUnbondingCollateralsRequest); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_collateral_query_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*QueryAllUnbondingCollateralsResponse); 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_collateral_query_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 10,
+ NumExtensions: 0,
+ NumServices: 1,
+ },
+ GoTypes: file_inference_collateral_query_proto_goTypes,
+ DependencyIndexes: file_inference_collateral_query_proto_depIdxs,
+ MessageInfos: file_inference_collateral_query_proto_msgTypes,
+ }.Build()
+ File_inference_collateral_query_proto = out.File
+ file_inference_collateral_query_proto_rawDesc = nil
+ file_inference_collateral_query_proto_goTypes = nil
+ file_inference_collateral_query_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/collateral/query_grpc.pb.go b/inference-chain/api/inference/collateral/query_grpc.pb.go
new file mode 100644
index 000000000..baafe8baf
--- /dev/null
+++ b/inference-chain/api/inference/collateral/query_grpc.pb.go
@@ -0,0 +1,267 @@
+// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
+// versions:
+// - protoc-gen-go-grpc v1.3.0
+// - protoc (unknown)
+// source: inference/collateral/query.proto
+
+package collateral
+
+import (
+ context "context"
+ grpc "google.golang.org/grpc"
+ codes "google.golang.org/grpc/codes"
+ status "google.golang.org/grpc/status"
+)
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+// Requires gRPC-Go v1.32.0 or later.
+const _ = grpc.SupportPackageIsVersion7
+
+const (
+ Query_Params_FullMethodName = "/inference.collateral.Query/Params"
+ Query_Collateral_FullMethodName = "/inference.collateral.Query/Collateral"
+ Query_AllCollaterals_FullMethodName = "/inference.collateral.Query/AllCollaterals"
+ Query_UnbondingCollateral_FullMethodName = "/inference.collateral.Query/UnbondingCollateral"
+ Query_AllUnbondingCollaterals_FullMethodName = "/inference.collateral.Query/AllUnbondingCollaterals"
+)
+
+// QueryClient is the client API for Query service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+type QueryClient interface {
+ // Parameters queries the parameters of the module.
+ Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error)
+ // Queries a specific participant's active collateral.
+ Collateral(ctx context.Context, in *QueryCollateralRequest, opts ...grpc.CallOption) (*QueryCollateralResponse, error)
+ // Queries all active collateral.
+ AllCollaterals(ctx context.Context, in *QueryAllCollateralsRequest, opts ...grpc.CallOption) (*QueryAllCollateralsResponse, error)
+ // Queries a specific participant's unbonding collateral.
+ UnbondingCollateral(ctx context.Context, in *QueryUnbondingCollateralRequest, opts ...grpc.CallOption) (*QueryUnbondingCollateralResponse, error)
+ // Queries all unbonding collateral.
+ AllUnbondingCollaterals(ctx context.Context, in *QueryAllUnbondingCollateralsRequest, opts ...grpc.CallOption) (*QueryAllUnbondingCollateralsResponse, error)
+}
+
+type queryClient struct {
+ cc grpc.ClientConnInterface
+}
+
+func NewQueryClient(cc grpc.ClientConnInterface) 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, Query_Params_FullMethodName, in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *queryClient) Collateral(ctx context.Context, in *QueryCollateralRequest, opts ...grpc.CallOption) (*QueryCollateralResponse, error) {
+ out := new(QueryCollateralResponse)
+ err := c.cc.Invoke(ctx, Query_Collateral_FullMethodName, in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *queryClient) AllCollaterals(ctx context.Context, in *QueryAllCollateralsRequest, opts ...grpc.CallOption) (*QueryAllCollateralsResponse, error) {
+ out := new(QueryAllCollateralsResponse)
+ err := c.cc.Invoke(ctx, Query_AllCollaterals_FullMethodName, in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *queryClient) UnbondingCollateral(ctx context.Context, in *QueryUnbondingCollateralRequest, opts ...grpc.CallOption) (*QueryUnbondingCollateralResponse, error) {
+ out := new(QueryUnbondingCollateralResponse)
+ err := c.cc.Invoke(ctx, Query_UnbondingCollateral_FullMethodName, in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *queryClient) AllUnbondingCollaterals(ctx context.Context, in *QueryAllUnbondingCollateralsRequest, opts ...grpc.CallOption) (*QueryAllUnbondingCollateralsResponse, error) {
+ out := new(QueryAllUnbondingCollateralsResponse)
+ err := c.cc.Invoke(ctx, Query_AllUnbondingCollaterals_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
+type QueryServer interface {
+ // Parameters queries the parameters of the module.
+ Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error)
+ // Queries a specific participant's active collateral.
+ Collateral(context.Context, *QueryCollateralRequest) (*QueryCollateralResponse, error)
+ // Queries all active collateral.
+ AllCollaterals(context.Context, *QueryAllCollateralsRequest) (*QueryAllCollateralsResponse, error)
+ // Queries a specific participant's unbonding collateral.
+ UnbondingCollateral(context.Context, *QueryUnbondingCollateralRequest) (*QueryUnbondingCollateralResponse, error)
+ // Queries all unbonding collateral.
+ AllUnbondingCollaterals(context.Context, *QueryAllUnbondingCollateralsRequest) (*QueryAllUnbondingCollateralsResponse, error)
+ mustEmbedUnimplementedQueryServer()
+}
+
+// UnimplementedQueryServer must be embedded to have forward compatible implementations.
+type UnimplementedQueryServer struct {
+}
+
+func (UnimplementedQueryServer) Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method Params not implemented")
+}
+func (UnimplementedQueryServer) Collateral(context.Context, *QueryCollateralRequest) (*QueryCollateralResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method Collateral not implemented")
+}
+func (UnimplementedQueryServer) AllCollaterals(context.Context, *QueryAllCollateralsRequest) (*QueryAllCollateralsResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method AllCollaterals not implemented")
+}
+func (UnimplementedQueryServer) UnbondingCollateral(context.Context, *QueryUnbondingCollateralRequest) (*QueryUnbondingCollateralResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method UnbondingCollateral not implemented")
+}
+func (UnimplementedQueryServer) AllUnbondingCollaterals(context.Context, *QueryAllUnbondingCollateralsRequest) (*QueryAllUnbondingCollateralsResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method AllUnbondingCollaterals not implemented")
+}
+func (UnimplementedQueryServer) mustEmbedUnimplementedQueryServer() {}
+
+// UnsafeQueryServer may be embedded to opt out of forward compatibility for this service.
+// Use of this interface is not recommended, as added methods to QueryServer will
+// result in compilation errors.
+type UnsafeQueryServer interface {
+ mustEmbedUnimplementedQueryServer()
+}
+
+func RegisterQueryServer(s grpc.ServiceRegistrar, srv QueryServer) {
+ s.RegisterService(&Query_ServiceDesc, srv)
+}
+
+func _Query_Params_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(QueryParamsRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(QueryServer).Params(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: Query_Params_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(QueryServer).Params(ctx, req.(*QueryParamsRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _Query_Collateral_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(QueryCollateralRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(QueryServer).Collateral(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: Query_Collateral_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(QueryServer).Collateral(ctx, req.(*QueryCollateralRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _Query_AllCollaterals_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(QueryAllCollateralsRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(QueryServer).AllCollaterals(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: Query_AllCollaterals_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(QueryServer).AllCollaterals(ctx, req.(*QueryAllCollateralsRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _Query_UnbondingCollateral_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(QueryUnbondingCollateralRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(QueryServer).UnbondingCollateral(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: Query_UnbondingCollateral_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(QueryServer).UnbondingCollateral(ctx, req.(*QueryUnbondingCollateralRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _Query_AllUnbondingCollaterals_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(QueryAllUnbondingCollateralsRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(QueryServer).AllUnbondingCollaterals(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: Query_AllUnbondingCollaterals_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(QueryServer).AllUnbondingCollaterals(ctx, req.(*QueryAllUnbondingCollateralsRequest))
+ }
+ 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)
+var Query_ServiceDesc = grpc.ServiceDesc{
+ ServiceName: "inference.collateral.Query",
+ HandlerType: (*QueryServer)(nil),
+ Methods: []grpc.MethodDesc{
+ {
+ MethodName: "Params",
+ Handler: _Query_Params_Handler,
+ },
+ {
+ MethodName: "Collateral",
+ Handler: _Query_Collateral_Handler,
+ },
+ {
+ MethodName: "AllCollaterals",
+ Handler: _Query_AllCollaterals_Handler,
+ },
+ {
+ MethodName: "UnbondingCollateral",
+ Handler: _Query_UnbondingCollateral_Handler,
+ },
+ {
+ MethodName: "AllUnbondingCollaterals",
+ Handler: _Query_AllUnbondingCollaterals_Handler,
+ },
+ },
+ Streams: []grpc.StreamDesc{},
+ Metadata: "inference/collateral/query.proto",
+}
diff --git a/inference/api/inference/inference/tx.pulsar.go b/inference-chain/api/inference/collateral/tx.pulsar.go
similarity index 53%
rename from inference/api/inference/inference/tx.pulsar.go
rename to inference-chain/api/inference/collateral/tx.pulsar.go
index 7a43d16fd..cfea66ba2 100644
--- a/inference/api/inference/inference/tx.pulsar.go
+++ b/inference-chain/api/inference/collateral/tx.pulsar.go
@@ -1,20 +1,20 @@
// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
-package inference
+package collateral
import (
- fmt "fmt"
- io "io"
- reflect "reflect"
- sync "sync"
-
_ "cosmossdk.io/api/amino"
+ v1beta1 "cosmossdk.io/api/cosmos/base/v1beta1"
_ "cosmossdk.io/api/cosmos/msg/v1"
+ fmt "fmt"
_ "github.com/cosmos/cosmos-proto"
runtime "github.com/cosmos/cosmos-proto/runtime"
_ "github.com/cosmos/gogoproto/gogoproto"
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 (
@@ -24,8 +24,8 @@ var (
)
func init() {
- file_inference_inference_tx_proto_init()
- md_MsgUpdateParams = File_inference_inference_tx_proto.Messages().ByName("MsgUpdateParams")
+ file_inference_collateral_tx_proto_init()
+ md_MsgUpdateParams = File_inference_collateral_tx_proto.Messages().ByName("MsgUpdateParams")
fd_MsgUpdateParams_authority = md_MsgUpdateParams.Fields().ByName("authority")
fd_MsgUpdateParams_params = md_MsgUpdateParams.Fields().ByName("params")
}
@@ -39,7 +39,7 @@ func (x *MsgUpdateParams) ProtoReflect() protoreflect.Message {
}
func (x *MsgUpdateParams) slowProtoReflect() protoreflect.Message {
- mi := &file_inference_inference_tx_proto_msgTypes[0]
+ mi := &file_inference_collateral_tx_proto_msgTypes[0]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -122,15 +122,15 @@ func (x *fastReflection_MsgUpdateParams) Range(f func(protoreflect.FieldDescript
// a repeated field is populated if it is non-empty.
func (x *fastReflection_MsgUpdateParams) Has(fd protoreflect.FieldDescriptor) bool {
switch fd.FullName() {
- case "inference.inference.MsgUpdateParams.authority":
+ case "inference.collateral.MsgUpdateParams.authority":
return x.Authority != ""
- case "inference.inference.MsgUpdateParams.params":
+ case "inference.collateral.MsgUpdateParams.params":
return x.Params != nil
default:
if fd.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgUpdateParams"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.MsgUpdateParams"))
}
- panic(fmt.Errorf("message inference.inference.MsgUpdateParams does not contain field %s", fd.FullName()))
+ panic(fmt.Errorf("message inference.collateral.MsgUpdateParams does not contain field %s", fd.FullName()))
}
}
@@ -142,15 +142,15 @@ func (x *fastReflection_MsgUpdateParams) Has(fd protoreflect.FieldDescriptor) bo
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgUpdateParams) Clear(fd protoreflect.FieldDescriptor) {
switch fd.FullName() {
- case "inference.inference.MsgUpdateParams.authority":
+ case "inference.collateral.MsgUpdateParams.authority":
x.Authority = ""
- case "inference.inference.MsgUpdateParams.params":
+ case "inference.collateral.MsgUpdateParams.params":
x.Params = nil
default:
if fd.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgUpdateParams"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.MsgUpdateParams"))
}
- panic(fmt.Errorf("message inference.inference.MsgUpdateParams does not contain field %s", fd.FullName()))
+ panic(fmt.Errorf("message inference.collateral.MsgUpdateParams does not contain field %s", fd.FullName()))
}
}
@@ -162,17 +162,17 @@ func (x *fastReflection_MsgUpdateParams) Clear(fd protoreflect.FieldDescriptor)
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_MsgUpdateParams) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
switch descriptor.FullName() {
- case "inference.inference.MsgUpdateParams.authority":
+ case "inference.collateral.MsgUpdateParams.authority":
value := x.Authority
return protoreflect.ValueOfString(value)
- case "inference.inference.MsgUpdateParams.params":
+ case "inference.collateral.MsgUpdateParams.params":
value := x.Params
return protoreflect.ValueOfMessage(value.ProtoReflect())
default:
if descriptor.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgUpdateParams"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.MsgUpdateParams"))
}
- panic(fmt.Errorf("message inference.inference.MsgUpdateParams does not contain field %s", descriptor.FullName()))
+ panic(fmt.Errorf("message inference.collateral.MsgUpdateParams does not contain field %s", descriptor.FullName()))
}
}
@@ -188,15 +188,15 @@ func (x *fastReflection_MsgUpdateParams) Get(descriptor protoreflect.FieldDescri
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgUpdateParams) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
switch fd.FullName() {
- case "inference.inference.MsgUpdateParams.authority":
+ case "inference.collateral.MsgUpdateParams.authority":
x.Authority = value.Interface().(string)
- case "inference.inference.MsgUpdateParams.params":
+ case "inference.collateral.MsgUpdateParams.params":
x.Params = value.Message().Interface().(*Params)
default:
if fd.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgUpdateParams"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.MsgUpdateParams"))
}
- panic(fmt.Errorf("message inference.inference.MsgUpdateParams does not contain field %s", fd.FullName()))
+ panic(fmt.Errorf("message inference.collateral.MsgUpdateParams does not contain field %s", fd.FullName()))
}
}
@@ -212,18 +212,18 @@ func (x *fastReflection_MsgUpdateParams) Set(fd protoreflect.FieldDescriptor, va
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgUpdateParams) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
switch fd.FullName() {
- case "inference.inference.MsgUpdateParams.params":
+ case "inference.collateral.MsgUpdateParams.params":
if x.Params == nil {
x.Params = new(Params)
}
return protoreflect.ValueOfMessage(x.Params.ProtoReflect())
- case "inference.inference.MsgUpdateParams.authority":
- panic(fmt.Errorf("field authority of message inference.inference.MsgUpdateParams is not mutable"))
+ case "inference.collateral.MsgUpdateParams.authority":
+ panic(fmt.Errorf("field authority of message inference.collateral.MsgUpdateParams is not mutable"))
default:
if fd.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgUpdateParams"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.MsgUpdateParams"))
}
- panic(fmt.Errorf("message inference.inference.MsgUpdateParams does not contain field %s", fd.FullName()))
+ panic(fmt.Errorf("message inference.collateral.MsgUpdateParams does not contain field %s", fd.FullName()))
}
}
@@ -232,16 +232,16 @@ func (x *fastReflection_MsgUpdateParams) Mutable(fd protoreflect.FieldDescriptor
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_MsgUpdateParams) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
switch fd.FullName() {
- case "inference.inference.MsgUpdateParams.authority":
+ case "inference.collateral.MsgUpdateParams.authority":
return protoreflect.ValueOfString("")
- case "inference.inference.MsgUpdateParams.params":
+ case "inference.collateral.MsgUpdateParams.params":
m := new(Params)
return protoreflect.ValueOfMessage(m.ProtoReflect())
default:
if fd.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgUpdateParams"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.MsgUpdateParams"))
}
- panic(fmt.Errorf("message inference.inference.MsgUpdateParams does not contain field %s", fd.FullName()))
+ panic(fmt.Errorf("message inference.collateral.MsgUpdateParams does not contain field %s", fd.FullName()))
}
}
@@ -251,7 +251,7 @@ func (x *fastReflection_MsgUpdateParams) NewField(fd protoreflect.FieldDescripto
func (x *fastReflection_MsgUpdateParams) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
switch d.FullName() {
default:
- panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgUpdateParams", d.FullName()))
+ panic(fmt.Errorf("%s is not a oneof field in inference.collateral.MsgUpdateParams", d.FullName()))
}
panic("unreachable")
}
@@ -521,8 +521,8 @@ var (
)
func init() {
- file_inference_inference_tx_proto_init()
- md_MsgUpdateParamsResponse = File_inference_inference_tx_proto.Messages().ByName("MsgUpdateParamsResponse")
+ file_inference_collateral_tx_proto_init()
+ md_MsgUpdateParamsResponse = File_inference_collateral_tx_proto.Messages().ByName("MsgUpdateParamsResponse")
}
var _ protoreflect.Message = (*fastReflection_MsgUpdateParamsResponse)(nil)
@@ -534,7 +534,7 @@ func (x *MsgUpdateParamsResponse) ProtoReflect() protoreflect.Message {
}
func (x *MsgUpdateParamsResponse) slowProtoReflect() protoreflect.Message {
- mi := &file_inference_inference_tx_proto_msgTypes[1]
+ mi := &file_inference_collateral_tx_proto_msgTypes[1]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -607,9 +607,9 @@ func (x *fastReflection_MsgUpdateParamsResponse) Has(fd protoreflect.FieldDescri
switch fd.FullName() {
default:
if fd.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgUpdateParamsResponse"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.MsgUpdateParamsResponse"))
}
- panic(fmt.Errorf("message inference.inference.MsgUpdateParamsResponse does not contain field %s", fd.FullName()))
+ panic(fmt.Errorf("message inference.collateral.MsgUpdateParamsResponse does not contain field %s", fd.FullName()))
}
}
@@ -623,9 +623,9 @@ func (x *fastReflection_MsgUpdateParamsResponse) Clear(fd protoreflect.FieldDesc
switch fd.FullName() {
default:
if fd.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgUpdateParamsResponse"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.MsgUpdateParamsResponse"))
}
- panic(fmt.Errorf("message inference.inference.MsgUpdateParamsResponse does not contain field %s", fd.FullName()))
+ panic(fmt.Errorf("message inference.collateral.MsgUpdateParamsResponse does not contain field %s", fd.FullName()))
}
}
@@ -639,9 +639,9 @@ func (x *fastReflection_MsgUpdateParamsResponse) Get(descriptor protoreflect.Fie
switch descriptor.FullName() {
default:
if descriptor.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgUpdateParamsResponse"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.MsgUpdateParamsResponse"))
}
- panic(fmt.Errorf("message inference.inference.MsgUpdateParamsResponse does not contain field %s", descriptor.FullName()))
+ panic(fmt.Errorf("message inference.collateral.MsgUpdateParamsResponse does not contain field %s", descriptor.FullName()))
}
}
@@ -659,9 +659,9 @@ func (x *fastReflection_MsgUpdateParamsResponse) Set(fd protoreflect.FieldDescri
switch fd.FullName() {
default:
if fd.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgUpdateParamsResponse"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.MsgUpdateParamsResponse"))
}
- panic(fmt.Errorf("message inference.inference.MsgUpdateParamsResponse does not contain field %s", fd.FullName()))
+ panic(fmt.Errorf("message inference.collateral.MsgUpdateParamsResponse does not contain field %s", fd.FullName()))
}
}
@@ -679,9 +679,9 @@ func (x *fastReflection_MsgUpdateParamsResponse) Mutable(fd protoreflect.FieldDe
switch fd.FullName() {
default:
if fd.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgUpdateParamsResponse"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.MsgUpdateParamsResponse"))
}
- panic(fmt.Errorf("message inference.inference.MsgUpdateParamsResponse does not contain field %s", fd.FullName()))
+ panic(fmt.Errorf("message inference.collateral.MsgUpdateParamsResponse does not contain field %s", fd.FullName()))
}
}
@@ -692,9 +692,9 @@ func (x *fastReflection_MsgUpdateParamsResponse) NewField(fd protoreflect.FieldD
switch fd.FullName() {
default:
if fd.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgUpdateParamsResponse"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.MsgUpdateParamsResponse"))
}
- panic(fmt.Errorf("message inference.inference.MsgUpdateParamsResponse does not contain field %s", fd.FullName()))
+ panic(fmt.Errorf("message inference.collateral.MsgUpdateParamsResponse does not contain field %s", fd.FullName()))
}
}
@@ -704,7 +704,7 @@ func (x *fastReflection_MsgUpdateParamsResponse) NewField(fd protoreflect.FieldD
func (x *fastReflection_MsgUpdateParamsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
switch d.FullName() {
default:
- panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgUpdateParamsResponse", d.FullName()))
+ panic(fmt.Errorf("%s is not a oneof field in inference.collateral.MsgUpdateParamsResponse", d.FullName()))
}
panic("unreachable")
}
@@ -873,34 +873,28 @@ func (x *fastReflection_MsgUpdateParamsResponse) ProtoMethods() *protoiface.Meth
}
var (
- md_MsgStartInference protoreflect.MessageDescriptor
- fd_MsgStartInference_creator protoreflect.FieldDescriptor
- fd_MsgStartInference_inferenceId protoreflect.FieldDescriptor
- fd_MsgStartInference_promptHash protoreflect.FieldDescriptor
- fd_MsgStartInference_promptPayload protoreflect.FieldDescriptor
- fd_MsgStartInference_receivedBy protoreflect.FieldDescriptor
+ md_MsgDepositCollateral protoreflect.MessageDescriptor
+ fd_MsgDepositCollateral_participant protoreflect.FieldDescriptor
+ fd_MsgDepositCollateral_amount protoreflect.FieldDescriptor
)
func init() {
- file_inference_inference_tx_proto_init()
- md_MsgStartInference = File_inference_inference_tx_proto.Messages().ByName("MsgStartInference")
- fd_MsgStartInference_creator = md_MsgStartInference.Fields().ByName("creator")
- fd_MsgStartInference_inferenceId = md_MsgStartInference.Fields().ByName("inferenceId")
- fd_MsgStartInference_promptHash = md_MsgStartInference.Fields().ByName("promptHash")
- fd_MsgStartInference_promptPayload = md_MsgStartInference.Fields().ByName("promptPayload")
- fd_MsgStartInference_receivedBy = md_MsgStartInference.Fields().ByName("receivedBy")
+ file_inference_collateral_tx_proto_init()
+ md_MsgDepositCollateral = File_inference_collateral_tx_proto.Messages().ByName("MsgDepositCollateral")
+ fd_MsgDepositCollateral_participant = md_MsgDepositCollateral.Fields().ByName("participant")
+ fd_MsgDepositCollateral_amount = md_MsgDepositCollateral.Fields().ByName("amount")
}
-var _ protoreflect.Message = (*fastReflection_MsgStartInference)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgDepositCollateral)(nil)
-type fastReflection_MsgStartInference MsgStartInference
+type fastReflection_MsgDepositCollateral MsgDepositCollateral
-func (x *MsgStartInference) ProtoReflect() protoreflect.Message {
- return (*fastReflection_MsgStartInference)(x)
+func (x *MsgDepositCollateral) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_MsgDepositCollateral)(x)
}
-func (x *MsgStartInference) slowProtoReflect() protoreflect.Message {
- mi := &file_inference_inference_tx_proto_msgTypes[2]
+func (x *MsgDepositCollateral) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_collateral_tx_proto_msgTypes[2]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -911,43 +905,43 @@ func (x *MsgStartInference) slowProtoReflect() protoreflect.Message {
return mi.MessageOf(x)
}
-var _fastReflection_MsgStartInference_messageType fastReflection_MsgStartInference_messageType
-var _ protoreflect.MessageType = fastReflection_MsgStartInference_messageType{}
+var _fastReflection_MsgDepositCollateral_messageType fastReflection_MsgDepositCollateral_messageType
+var _ protoreflect.MessageType = fastReflection_MsgDepositCollateral_messageType{}
-type fastReflection_MsgStartInference_messageType struct{}
+type fastReflection_MsgDepositCollateral_messageType struct{}
-func (x fastReflection_MsgStartInference_messageType) Zero() protoreflect.Message {
- return (*fastReflection_MsgStartInference)(nil)
+func (x fastReflection_MsgDepositCollateral_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_MsgDepositCollateral)(nil)
}
-func (x fastReflection_MsgStartInference_messageType) New() protoreflect.Message {
- return new(fastReflection_MsgStartInference)
+func (x fastReflection_MsgDepositCollateral_messageType) New() protoreflect.Message {
+ return new(fastReflection_MsgDepositCollateral)
}
-func (x fastReflection_MsgStartInference_messageType) Descriptor() protoreflect.MessageDescriptor {
- return md_MsgStartInference
+func (x fastReflection_MsgDepositCollateral_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgDepositCollateral
}
// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
-func (x *fastReflection_MsgStartInference) Descriptor() protoreflect.MessageDescriptor {
- return md_MsgStartInference
+func (x *fastReflection_MsgDepositCollateral) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgDepositCollateral
}
// 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_MsgStartInference) Type() protoreflect.MessageType {
- return _fastReflection_MsgStartInference_messageType
+func (x *fastReflection_MsgDepositCollateral) Type() protoreflect.MessageType {
+ return _fastReflection_MsgDepositCollateral_messageType
}
// New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgStartInference) New() protoreflect.Message {
- return new(fastReflection_MsgStartInference)
+func (x *fastReflection_MsgDepositCollateral) New() protoreflect.Message {
+ return new(fastReflection_MsgDepositCollateral)
}
// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgStartInference) Interface() protoreflect.ProtoMessage {
- return (*MsgStartInference)(x)
+func (x *fastReflection_MsgDepositCollateral) Interface() protoreflect.ProtoMessage {
+ return (*MsgDepositCollateral)(x)
}
// Range iterates over every populated field in an undefined order,
@@ -955,34 +949,16 @@ func (x *fastReflection_MsgStartInference) 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_MsgStartInference) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
- if x.Creator != "" {
- value := protoreflect.ValueOfString(x.Creator)
- if !f(fd_MsgStartInference_creator, value) {
- return
- }
- }
- if x.InferenceId != "" {
- value := protoreflect.ValueOfString(x.InferenceId)
- if !f(fd_MsgStartInference_inferenceId, value) {
- return
- }
- }
- if x.PromptHash != "" {
- value := protoreflect.ValueOfString(x.PromptHash)
- if !f(fd_MsgStartInference_promptHash, value) {
+func (x *fastReflection_MsgDepositCollateral) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Participant != "" {
+ value := protoreflect.ValueOfString(x.Participant)
+ if !f(fd_MsgDepositCollateral_participant, value) {
return
}
}
- if x.PromptPayload != "" {
- value := protoreflect.ValueOfString(x.PromptPayload)
- if !f(fd_MsgStartInference_promptPayload, value) {
- return
- }
- }
- if x.ReceivedBy != "" {
- value := protoreflect.ValueOfString(x.ReceivedBy)
- if !f(fd_MsgStartInference_receivedBy, value) {
+ if x.Amount != nil {
+ value := protoreflect.ValueOfMessage(x.Amount.ProtoReflect())
+ if !f(fd_MsgDepositCollateral_amount, value) {
return
}
}
@@ -999,23 +975,17 @@ func (x *fastReflection_MsgStartInference) 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_MsgStartInference) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgDepositCollateral) Has(fd protoreflect.FieldDescriptor) bool {
switch fd.FullName() {
- case "inference.inference.MsgStartInference.creator":
- return x.Creator != ""
- case "inference.inference.MsgStartInference.inferenceId":
- return x.InferenceId != ""
- case "inference.inference.MsgStartInference.promptHash":
- return x.PromptHash != ""
- case "inference.inference.MsgStartInference.promptPayload":
- return x.PromptPayload != ""
- case "inference.inference.MsgStartInference.receivedBy":
- return x.ReceivedBy != ""
+ case "inference.collateral.MsgDepositCollateral.participant":
+ return x.Participant != ""
+ case "inference.collateral.MsgDepositCollateral.amount":
+ return x.Amount != nil
default:
if fd.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgStartInference"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.MsgDepositCollateral"))
}
- panic(fmt.Errorf("message inference.inference.MsgStartInference does not contain field %s", fd.FullName()))
+ panic(fmt.Errorf("message inference.collateral.MsgDepositCollateral does not contain field %s", fd.FullName()))
}
}
@@ -1025,23 +995,17 @@ func (x *fastReflection_MsgStartInference) Has(fd protoreflect.FieldDescriptor)
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgStartInference) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgDepositCollateral) Clear(fd protoreflect.FieldDescriptor) {
switch fd.FullName() {
- case "inference.inference.MsgStartInference.creator":
- x.Creator = ""
- case "inference.inference.MsgStartInference.inferenceId":
- x.InferenceId = ""
- case "inference.inference.MsgStartInference.promptHash":
- x.PromptHash = ""
- case "inference.inference.MsgStartInference.promptPayload":
- x.PromptPayload = ""
- case "inference.inference.MsgStartInference.receivedBy":
- x.ReceivedBy = ""
+ case "inference.collateral.MsgDepositCollateral.participant":
+ x.Participant = ""
+ case "inference.collateral.MsgDepositCollateral.amount":
+ x.Amount = nil
default:
if fd.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgStartInference"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.MsgDepositCollateral"))
}
- panic(fmt.Errorf("message inference.inference.MsgStartInference does not contain field %s", fd.FullName()))
+ panic(fmt.Errorf("message inference.collateral.MsgDepositCollateral does not contain field %s", fd.FullName()))
}
}
@@ -1051,28 +1015,19 @@ func (x *fastReflection_MsgStartInference) 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_MsgStartInference) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgDepositCollateral) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
switch descriptor.FullName() {
- case "inference.inference.MsgStartInference.creator":
- value := x.Creator
- return protoreflect.ValueOfString(value)
- case "inference.inference.MsgStartInference.inferenceId":
- value := x.InferenceId
- return protoreflect.ValueOfString(value)
- case "inference.inference.MsgStartInference.promptHash":
- value := x.PromptHash
- return protoreflect.ValueOfString(value)
- case "inference.inference.MsgStartInference.promptPayload":
- value := x.PromptPayload
- return protoreflect.ValueOfString(value)
- case "inference.inference.MsgStartInference.receivedBy":
- value := x.ReceivedBy
+ case "inference.collateral.MsgDepositCollateral.participant":
+ value := x.Participant
return protoreflect.ValueOfString(value)
+ case "inference.collateral.MsgDepositCollateral.amount":
+ value := x.Amount
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
default:
if descriptor.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgStartInference"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.MsgDepositCollateral"))
}
- panic(fmt.Errorf("message inference.inference.MsgStartInference does not contain field %s", descriptor.FullName()))
+ panic(fmt.Errorf("message inference.collateral.MsgDepositCollateral does not contain field %s", descriptor.FullName()))
}
}
@@ -1086,23 +1041,17 @@ func (x *fastReflection_MsgStartInference) Get(descriptor protoreflect.FieldDesc
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgStartInference) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgDepositCollateral) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
switch fd.FullName() {
- case "inference.inference.MsgStartInference.creator":
- x.Creator = value.Interface().(string)
- case "inference.inference.MsgStartInference.inferenceId":
- x.InferenceId = value.Interface().(string)
- case "inference.inference.MsgStartInference.promptHash":
- x.PromptHash = value.Interface().(string)
- case "inference.inference.MsgStartInference.promptPayload":
- x.PromptPayload = value.Interface().(string)
- case "inference.inference.MsgStartInference.receivedBy":
- x.ReceivedBy = value.Interface().(string)
+ case "inference.collateral.MsgDepositCollateral.participant":
+ x.Participant = value.Interface().(string)
+ case "inference.collateral.MsgDepositCollateral.amount":
+ x.Amount = value.Message().Interface().(*v1beta1.Coin)
default:
if fd.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgStartInference"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.MsgDepositCollateral"))
}
- panic(fmt.Errorf("message inference.inference.MsgStartInference does not contain field %s", fd.FullName()))
+ panic(fmt.Errorf("message inference.collateral.MsgDepositCollateral does not contain field %s", fd.FullName()))
}
}
@@ -1116,56 +1065,48 @@ func (x *fastReflection_MsgStartInference) 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_MsgStartInference) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgDepositCollateral) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
switch fd.FullName() {
- case "inference.inference.MsgStartInference.creator":
- panic(fmt.Errorf("field creator of message inference.inference.MsgStartInference is not mutable"))
- case "inference.inference.MsgStartInference.inferenceId":
- panic(fmt.Errorf("field inferenceId of message inference.inference.MsgStartInference is not mutable"))
- case "inference.inference.MsgStartInference.promptHash":
- panic(fmt.Errorf("field promptHash of message inference.inference.MsgStartInference is not mutable"))
- case "inference.inference.MsgStartInference.promptPayload":
- panic(fmt.Errorf("field promptPayload of message inference.inference.MsgStartInference is not mutable"))
- case "inference.inference.MsgStartInference.receivedBy":
- panic(fmt.Errorf("field receivedBy of message inference.inference.MsgStartInference is not mutable"))
+ case "inference.collateral.MsgDepositCollateral.amount":
+ if x.Amount == nil {
+ x.Amount = new(v1beta1.Coin)
+ }
+ return protoreflect.ValueOfMessage(x.Amount.ProtoReflect())
+ case "inference.collateral.MsgDepositCollateral.participant":
+ panic(fmt.Errorf("field participant of message inference.collateral.MsgDepositCollateral is not mutable"))
default:
if fd.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgStartInference"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.MsgDepositCollateral"))
}
- panic(fmt.Errorf("message inference.inference.MsgStartInference does not contain field %s", fd.FullName()))
+ panic(fmt.Errorf("message inference.collateral.MsgDepositCollateral 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_MsgStartInference) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgDepositCollateral) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
switch fd.FullName() {
- case "inference.inference.MsgStartInference.creator":
- return protoreflect.ValueOfString("")
- case "inference.inference.MsgStartInference.inferenceId":
- return protoreflect.ValueOfString("")
- case "inference.inference.MsgStartInference.promptHash":
- return protoreflect.ValueOfString("")
- case "inference.inference.MsgStartInference.promptPayload":
- return protoreflect.ValueOfString("")
- case "inference.inference.MsgStartInference.receivedBy":
+ case "inference.collateral.MsgDepositCollateral.participant":
return protoreflect.ValueOfString("")
+ case "inference.collateral.MsgDepositCollateral.amount":
+ m := new(v1beta1.Coin)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
default:
if fd.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgStartInference"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.MsgDepositCollateral"))
}
- panic(fmt.Errorf("message inference.inference.MsgStartInference does not contain field %s", fd.FullName()))
+ panic(fmt.Errorf("message inference.collateral.MsgDepositCollateral 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_MsgStartInference) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgDepositCollateral) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
switch d.FullName() {
default:
- panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgStartInference", d.FullName()))
+ panic(fmt.Errorf("%s is not a oneof field in inference.collateral.MsgDepositCollateral", d.FullName()))
}
panic("unreachable")
}
@@ -1173,7 +1114,7 @@ func (x *fastReflection_MsgStartInference) 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_MsgStartInference) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgDepositCollateral) GetUnknown() protoreflect.RawFields {
return x.unknownFields
}
@@ -1184,7 +1125,7 @@ func (x *fastReflection_MsgStartInference) 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_MsgStartInference) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgDepositCollateral) SetUnknown(fields protoreflect.RawFields) {
x.unknownFields = fields
}
@@ -1196,7 +1137,7 @@ func (x *fastReflection_MsgStartInference) 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_MsgStartInference) IsValid() bool {
+func (x *fastReflection_MsgDepositCollateral) IsValid() bool {
return x != nil
}
@@ -1206,9 +1147,9 @@ func (x *fastReflection_MsgStartInference) 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_MsgStartInference) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgDepositCollateral) ProtoMethods() *protoiface.Methods {
size := func(input protoiface.SizeInput) protoiface.SizeOutput {
- x := input.Message.Interface().(*MsgStartInference)
+ x := input.Message.Interface().(*MsgDepositCollateral)
if x == nil {
return protoiface.SizeOutput{
NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -1220,24 +1161,12 @@ func (x *fastReflection_MsgStartInference) ProtoMethods() *protoiface.Methods {
var n int
var l int
_ = l
- l = len(x.Creator)
+ l = len(x.Participant)
if l > 0 {
n += 1 + l + runtime.Sov(uint64(l))
}
- l = len(x.InferenceId)
- if l > 0 {
- n += 1 + l + runtime.Sov(uint64(l))
- }
- l = len(x.PromptHash)
- if l > 0 {
- n += 1 + l + runtime.Sov(uint64(l))
- }
- l = len(x.PromptPayload)
- if l > 0 {
- n += 1 + l + runtime.Sov(uint64(l))
- }
- l = len(x.ReceivedBy)
- if l > 0 {
+ if x.Amount != nil {
+ l = options.Size(x.Amount)
n += 1 + l + runtime.Sov(uint64(l))
}
if x.unknownFields != nil {
@@ -1250,7 +1179,7 @@ func (x *fastReflection_MsgStartInference) ProtoMethods() *protoiface.Methods {
}
marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
- x := input.Message.Interface().(*MsgStartInference)
+ x := input.Message.Interface().(*MsgDepositCollateral)
if x == nil {
return protoiface.MarshalOutput{
NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -1269,38 +1198,24 @@ func (x *fastReflection_MsgStartInference) ProtoMethods() *protoiface.Methods {
i -= len(x.unknownFields)
copy(dAtA[i:], x.unknownFields)
}
- if len(x.ReceivedBy) > 0 {
- i -= len(x.ReceivedBy)
- copy(dAtA[i:], x.ReceivedBy)
- i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ReceivedBy)))
- i--
- dAtA[i] = 0x2a
- }
- if len(x.PromptPayload) > 0 {
- i -= len(x.PromptPayload)
- copy(dAtA[i:], x.PromptPayload)
- i = runtime.EncodeVarint(dAtA, i, uint64(len(x.PromptPayload)))
- i--
- dAtA[i] = 0x22
- }
- if len(x.PromptHash) > 0 {
- i -= len(x.PromptHash)
- copy(dAtA[i:], x.PromptHash)
- i = runtime.EncodeVarint(dAtA, i, uint64(len(x.PromptHash)))
- i--
- dAtA[i] = 0x1a
- }
- if len(x.InferenceId) > 0 {
- i -= len(x.InferenceId)
- copy(dAtA[i:], x.InferenceId)
- i = runtime.EncodeVarint(dAtA, i, uint64(len(x.InferenceId)))
+ if x.Amount != nil {
+ encoded, err := options.Marshal(x.Amount)
+ 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.Creator) > 0 {
- i -= len(x.Creator)
- copy(dAtA[i:], x.Creator)
- i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Creator)))
+ 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
}
@@ -1315,7 +1230,7 @@ func (x *fastReflection_MsgStartInference) ProtoMethods() *protoiface.Methods {
}, nil
}
unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
- x := input.Message.Interface().(*MsgStartInference)
+ x := input.Message.Interface().(*MsgDepositCollateral)
if x == nil {
return protoiface.UnmarshalOutput{
NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -1347,15 +1262,15 @@ func (x *fastReflection_MsgStartInference) 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: MsgStartInference: wiretype end group for non-group")
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgDepositCollateral: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgStartInference: illegal tag %d (wire type %d)", fieldNum, wire)
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgDepositCollateral: 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 Participant", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
@@ -1383,77 +1298,13 @@ func (x *fastReflection_MsgStartInference) ProtoMethods() *protoiface.Methods {
if postIndex > l {
return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
}
- x.Creator = string(dAtA[iNdEx:postIndex])
+ 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 InferenceId", 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 {
- if shift >= 64 {
- return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.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.InferenceId = 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 PromptHash", 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.PromptHash = 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 PromptPayload", 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
@@ -1463,55 +1314,27 @@ func (x *fastReflection_MsgStartInference) 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.PromptPayload = 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 ReceivedBy", 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
+ if x.Amount == nil {
+ x.Amount = &v1beta1.Coin{}
}
- 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 err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Amount); err != nil {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
}
- x.ReceivedBy = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
default:
iNdEx = preIndex
@@ -1549,26 +1372,24 @@ func (x *fastReflection_MsgStartInference) ProtoMethods() *protoiface.Methods {
}
var (
- md_MsgStartInferenceResponse protoreflect.MessageDescriptor
- fd_MsgStartInferenceResponse_inferenceIndex protoreflect.FieldDescriptor
+ md_MsgDepositCollateralResponse protoreflect.MessageDescriptor
)
func init() {
- file_inference_inference_tx_proto_init()
- md_MsgStartInferenceResponse = File_inference_inference_tx_proto.Messages().ByName("MsgStartInferenceResponse")
- fd_MsgStartInferenceResponse_inferenceIndex = md_MsgStartInferenceResponse.Fields().ByName("inferenceIndex")
+ file_inference_collateral_tx_proto_init()
+ md_MsgDepositCollateralResponse = File_inference_collateral_tx_proto.Messages().ByName("MsgDepositCollateralResponse")
}
-var _ protoreflect.Message = (*fastReflection_MsgStartInferenceResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgDepositCollateralResponse)(nil)
-type fastReflection_MsgStartInferenceResponse MsgStartInferenceResponse
+type fastReflection_MsgDepositCollateralResponse MsgDepositCollateralResponse
-func (x *MsgStartInferenceResponse) ProtoReflect() protoreflect.Message {
- return (*fastReflection_MsgStartInferenceResponse)(x)
+func (x *MsgDepositCollateralResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_MsgDepositCollateralResponse)(x)
}
-func (x *MsgStartInferenceResponse) slowProtoReflect() protoreflect.Message {
- mi := &file_inference_inference_tx_proto_msgTypes[3]
+func (x *MsgDepositCollateralResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_collateral_tx_proto_msgTypes[3]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -1579,43 +1400,43 @@ func (x *MsgStartInferenceResponse) slowProtoReflect() protoreflect.Message {
return mi.MessageOf(x)
}
-var _fastReflection_MsgStartInferenceResponse_messageType fastReflection_MsgStartInferenceResponse_messageType
-var _ protoreflect.MessageType = fastReflection_MsgStartInferenceResponse_messageType{}
+var _fastReflection_MsgDepositCollateralResponse_messageType fastReflection_MsgDepositCollateralResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgDepositCollateralResponse_messageType{}
-type fastReflection_MsgStartInferenceResponse_messageType struct{}
+type fastReflection_MsgDepositCollateralResponse_messageType struct{}
-func (x fastReflection_MsgStartInferenceResponse_messageType) Zero() protoreflect.Message {
- return (*fastReflection_MsgStartInferenceResponse)(nil)
+func (x fastReflection_MsgDepositCollateralResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_MsgDepositCollateralResponse)(nil)
}
-func (x fastReflection_MsgStartInferenceResponse_messageType) New() protoreflect.Message {
- return new(fastReflection_MsgStartInferenceResponse)
+func (x fastReflection_MsgDepositCollateralResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_MsgDepositCollateralResponse)
}
-func (x fastReflection_MsgStartInferenceResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
- return md_MsgStartInferenceResponse
+func (x fastReflection_MsgDepositCollateralResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgDepositCollateralResponse
}
// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
-func (x *fastReflection_MsgStartInferenceResponse) Descriptor() protoreflect.MessageDescriptor {
- return md_MsgStartInferenceResponse
+func (x *fastReflection_MsgDepositCollateralResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgDepositCollateralResponse
}
// 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_MsgStartInferenceResponse) Type() protoreflect.MessageType {
- return _fastReflection_MsgStartInferenceResponse_messageType
+func (x *fastReflection_MsgDepositCollateralResponse) Type() protoreflect.MessageType {
+ return _fastReflection_MsgDepositCollateralResponse_messageType
}
// New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgStartInferenceResponse) New() protoreflect.Message {
- return new(fastReflection_MsgStartInferenceResponse)
+func (x *fastReflection_MsgDepositCollateralResponse) New() protoreflect.Message {
+ return new(fastReflection_MsgDepositCollateralResponse)
}
// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgStartInferenceResponse) Interface() protoreflect.ProtoMessage {
- return (*MsgStartInferenceResponse)(x)
+func (x *fastReflection_MsgDepositCollateralResponse) Interface() protoreflect.ProtoMessage {
+ return (*MsgDepositCollateralResponse)(x)
}
// Range iterates over every populated field in an undefined order,
@@ -1623,13 +1444,7 @@ func (x *fastReflection_MsgStartInferenceResponse) 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_MsgStartInferenceResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
- if x.InferenceIndex != "" {
- value := protoreflect.ValueOfString(x.InferenceIndex)
- if !f(fd_MsgStartInferenceResponse_inferenceIndex, value) {
- return
- }
- }
+func (x *fastReflection_MsgDepositCollateralResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
}
// Has reports whether a field is populated.
@@ -1643,15 +1458,13 @@ func (x *fastReflection_MsgStartInferenceResponse) 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_MsgStartInferenceResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgDepositCollateralResponse) Has(fd protoreflect.FieldDescriptor) bool {
switch fd.FullName() {
- case "inference.inference.MsgStartInferenceResponse.inferenceIndex":
- return x.InferenceIndex != ""
default:
if fd.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgStartInferenceResponse"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.MsgDepositCollateralResponse"))
}
- panic(fmt.Errorf("message inference.inference.MsgStartInferenceResponse does not contain field %s", fd.FullName()))
+ panic(fmt.Errorf("message inference.collateral.MsgDepositCollateralResponse does not contain field %s", fd.FullName()))
}
}
@@ -1661,15 +1474,13 @@ func (x *fastReflection_MsgStartInferenceResponse) Has(fd protoreflect.FieldDesc
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgStartInferenceResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgDepositCollateralResponse) Clear(fd protoreflect.FieldDescriptor) {
switch fd.FullName() {
- case "inference.inference.MsgStartInferenceResponse.inferenceIndex":
- x.InferenceIndex = ""
default:
if fd.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgStartInferenceResponse"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.MsgDepositCollateralResponse"))
}
- panic(fmt.Errorf("message inference.inference.MsgStartInferenceResponse does not contain field %s", fd.FullName()))
+ panic(fmt.Errorf("message inference.collateral.MsgDepositCollateralResponse does not contain field %s", fd.FullName()))
}
}
@@ -1679,16 +1490,13 @@ func (x *fastReflection_MsgStartInferenceResponse) 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_MsgStartInferenceResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgDepositCollateralResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
switch descriptor.FullName() {
- case "inference.inference.MsgStartInferenceResponse.inferenceIndex":
- value := x.InferenceIndex
- return protoreflect.ValueOfString(value)
default:
if descriptor.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgStartInferenceResponse"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.MsgDepositCollateralResponse"))
}
- panic(fmt.Errorf("message inference.inference.MsgStartInferenceResponse does not contain field %s", descriptor.FullName()))
+ panic(fmt.Errorf("message inference.collateral.MsgDepositCollateralResponse does not contain field %s", descriptor.FullName()))
}
}
@@ -1702,15 +1510,13 @@ func (x *fastReflection_MsgStartInferenceResponse) Get(descriptor protoreflect.F
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgStartInferenceResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgDepositCollateralResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
switch fd.FullName() {
- case "inference.inference.MsgStartInferenceResponse.inferenceIndex":
- x.InferenceIndex = value.Interface().(string)
default:
if fd.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgStartInferenceResponse"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.MsgDepositCollateralResponse"))
}
- panic(fmt.Errorf("message inference.inference.MsgStartInferenceResponse does not contain field %s", fd.FullName()))
+ panic(fmt.Errorf("message inference.collateral.MsgDepositCollateralResponse does not contain field %s", fd.FullName()))
}
}
@@ -1724,40 +1530,36 @@ func (x *fastReflection_MsgStartInferenceResponse) 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_MsgStartInferenceResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgDepositCollateralResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
switch fd.FullName() {
- case "inference.inference.MsgStartInferenceResponse.inferenceIndex":
- panic(fmt.Errorf("field inferenceIndex of message inference.inference.MsgStartInferenceResponse is not mutable"))
default:
if fd.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgStartInferenceResponse"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.MsgDepositCollateralResponse"))
}
- panic(fmt.Errorf("message inference.inference.MsgStartInferenceResponse does not contain field %s", fd.FullName()))
+ panic(fmt.Errorf("message inference.collateral.MsgDepositCollateralResponse 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_MsgStartInferenceResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgDepositCollateralResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
switch fd.FullName() {
- case "inference.inference.MsgStartInferenceResponse.inferenceIndex":
- return protoreflect.ValueOfString("")
default:
if fd.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgStartInferenceResponse"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.MsgDepositCollateralResponse"))
}
- panic(fmt.Errorf("message inference.inference.MsgStartInferenceResponse does not contain field %s", fd.FullName()))
+ panic(fmt.Errorf("message inference.collateral.MsgDepositCollateralResponse 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_MsgStartInferenceResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgDepositCollateralResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
switch d.FullName() {
default:
- panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgStartInferenceResponse", d.FullName()))
+ panic(fmt.Errorf("%s is not a oneof field in inference.collateral.MsgDepositCollateralResponse", d.FullName()))
}
panic("unreachable")
}
@@ -1765,7 +1567,7 @@ func (x *fastReflection_MsgStartInferenceResponse) 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_MsgStartInferenceResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgDepositCollateralResponse) GetUnknown() protoreflect.RawFields {
return x.unknownFields
}
@@ -1776,7 +1578,7 @@ func (x *fastReflection_MsgStartInferenceResponse) 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_MsgStartInferenceResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgDepositCollateralResponse) SetUnknown(fields protoreflect.RawFields) {
x.unknownFields = fields
}
@@ -1788,7 +1590,7 @@ func (x *fastReflection_MsgStartInferenceResponse) 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_MsgStartInferenceResponse) IsValid() bool {
+func (x *fastReflection_MsgDepositCollateralResponse) IsValid() bool {
return x != nil
}
@@ -1798,9 +1600,9 @@ func (x *fastReflection_MsgStartInferenceResponse) 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_MsgStartInferenceResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgDepositCollateralResponse) ProtoMethods() *protoiface.Methods {
size := func(input protoiface.SizeInput) protoiface.SizeOutput {
- x := input.Message.Interface().(*MsgStartInferenceResponse)
+ x := input.Message.Interface().(*MsgDepositCollateralResponse)
if x == nil {
return protoiface.SizeOutput{
NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -1812,10 +1614,6 @@ func (x *fastReflection_MsgStartInferenceResponse) ProtoMethods() *protoiface.Me
var n int
var l int
_ = l
- l = len(x.InferenceIndex)
- if l > 0 {
- n += 1 + l + runtime.Sov(uint64(l))
- }
if x.unknownFields != nil {
n += len(x.unknownFields)
}
@@ -1826,7 +1624,7 @@ func (x *fastReflection_MsgStartInferenceResponse) ProtoMethods() *protoiface.Me
}
marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
- x := input.Message.Interface().(*MsgStartInferenceResponse)
+ x := input.Message.Interface().(*MsgDepositCollateralResponse)
if x == nil {
return protoiface.MarshalOutput{
NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -1845,13 +1643,6 @@ func (x *fastReflection_MsgStartInferenceResponse) ProtoMethods() *protoiface.Me
i -= len(x.unknownFields)
copy(dAtA[i:], x.unknownFields)
}
- if len(x.InferenceIndex) > 0 {
- i -= len(x.InferenceIndex)
- copy(dAtA[i:], x.InferenceIndex)
- i = runtime.EncodeVarint(dAtA, i, uint64(len(x.InferenceIndex)))
- i--
- dAtA[i] = 0xa
- }
if input.Buf != nil {
input.Buf = append(input.Buf, dAtA...)
} else {
@@ -1863,7 +1654,7 @@ func (x *fastReflection_MsgStartInferenceResponse) ProtoMethods() *protoiface.Me
}, nil
}
unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
- x := input.Message.Interface().(*MsgStartInferenceResponse)
+ x := input.Message.Interface().(*MsgDepositCollateralResponse)
if x == nil {
return protoiface.UnmarshalOutput{
NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -1895,44 +1686,12 @@ func (x *fastReflection_MsgStartInferenceResponse) 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: MsgStartInferenceResponse: wiretype end group for non-group")
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgDepositCollateralResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgStartInferenceResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgDepositCollateralResponse: 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 InferenceIndex", 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.InferenceIndex = string(dAtA[iNdEx:postIndex])
- iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -1969,38 +1728,28 @@ func (x *fastReflection_MsgStartInferenceResponse) ProtoMethods() *protoiface.Me
}
var (
- md_MsgFinishInference protoreflect.MessageDescriptor
- fd_MsgFinishInference_creator protoreflect.FieldDescriptor
- fd_MsgFinishInference_inferenceId protoreflect.FieldDescriptor
- fd_MsgFinishInference_responseHash protoreflect.FieldDescriptor
- fd_MsgFinishInference_responsePayload protoreflect.FieldDescriptor
- fd_MsgFinishInference_promptTokenCount protoreflect.FieldDescriptor
- fd_MsgFinishInference_completionTokenCount protoreflect.FieldDescriptor
- fd_MsgFinishInference_executedBy protoreflect.FieldDescriptor
+ md_MsgWithdrawCollateral protoreflect.MessageDescriptor
+ fd_MsgWithdrawCollateral_participant protoreflect.FieldDescriptor
+ fd_MsgWithdrawCollateral_amount protoreflect.FieldDescriptor
)
func init() {
- file_inference_inference_tx_proto_init()
- md_MsgFinishInference = File_inference_inference_tx_proto.Messages().ByName("MsgFinishInference")
- fd_MsgFinishInference_creator = md_MsgFinishInference.Fields().ByName("creator")
- fd_MsgFinishInference_inferenceId = md_MsgFinishInference.Fields().ByName("inferenceId")
- fd_MsgFinishInference_responseHash = md_MsgFinishInference.Fields().ByName("responseHash")
- fd_MsgFinishInference_responsePayload = md_MsgFinishInference.Fields().ByName("responsePayload")
- fd_MsgFinishInference_promptTokenCount = md_MsgFinishInference.Fields().ByName("promptTokenCount")
- fd_MsgFinishInference_completionTokenCount = md_MsgFinishInference.Fields().ByName("completionTokenCount")
- fd_MsgFinishInference_executedBy = md_MsgFinishInference.Fields().ByName("executedBy")
+ file_inference_collateral_tx_proto_init()
+ md_MsgWithdrawCollateral = File_inference_collateral_tx_proto.Messages().ByName("MsgWithdrawCollateral")
+ fd_MsgWithdrawCollateral_participant = md_MsgWithdrawCollateral.Fields().ByName("participant")
+ fd_MsgWithdrawCollateral_amount = md_MsgWithdrawCollateral.Fields().ByName("amount")
}
-var _ protoreflect.Message = (*fastReflection_MsgFinishInference)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgWithdrawCollateral)(nil)
-type fastReflection_MsgFinishInference MsgFinishInference
+type fastReflection_MsgWithdrawCollateral MsgWithdrawCollateral
-func (x *MsgFinishInference) ProtoReflect() protoreflect.Message {
- return (*fastReflection_MsgFinishInference)(x)
+func (x *MsgWithdrawCollateral) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_MsgWithdrawCollateral)(x)
}
-func (x *MsgFinishInference) slowProtoReflect() protoreflect.Message {
- mi := &file_inference_inference_tx_proto_msgTypes[4]
+func (x *MsgWithdrawCollateral) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_collateral_tx_proto_msgTypes[4]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -2011,43 +1760,43 @@ func (x *MsgFinishInference) slowProtoReflect() protoreflect.Message {
return mi.MessageOf(x)
}
-var _fastReflection_MsgFinishInference_messageType fastReflection_MsgFinishInference_messageType
-var _ protoreflect.MessageType = fastReflection_MsgFinishInference_messageType{}
+var _fastReflection_MsgWithdrawCollateral_messageType fastReflection_MsgWithdrawCollateral_messageType
+var _ protoreflect.MessageType = fastReflection_MsgWithdrawCollateral_messageType{}
-type fastReflection_MsgFinishInference_messageType struct{}
+type fastReflection_MsgWithdrawCollateral_messageType struct{}
-func (x fastReflection_MsgFinishInference_messageType) Zero() protoreflect.Message {
- return (*fastReflection_MsgFinishInference)(nil)
+func (x fastReflection_MsgWithdrawCollateral_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_MsgWithdrawCollateral)(nil)
}
-func (x fastReflection_MsgFinishInference_messageType) New() protoreflect.Message {
- return new(fastReflection_MsgFinishInference)
+func (x fastReflection_MsgWithdrawCollateral_messageType) New() protoreflect.Message {
+ return new(fastReflection_MsgWithdrawCollateral)
}
-func (x fastReflection_MsgFinishInference_messageType) Descriptor() protoreflect.MessageDescriptor {
- return md_MsgFinishInference
+func (x fastReflection_MsgWithdrawCollateral_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgWithdrawCollateral
}
// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
-func (x *fastReflection_MsgFinishInference) Descriptor() protoreflect.MessageDescriptor {
- return md_MsgFinishInference
+func (x *fastReflection_MsgWithdrawCollateral) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgWithdrawCollateral
}
// 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_MsgFinishInference) Type() protoreflect.MessageType {
- return _fastReflection_MsgFinishInference_messageType
+func (x *fastReflection_MsgWithdrawCollateral) Type() protoreflect.MessageType {
+ return _fastReflection_MsgWithdrawCollateral_messageType
}
// New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgFinishInference) New() protoreflect.Message {
- return new(fastReflection_MsgFinishInference)
+func (x *fastReflection_MsgWithdrawCollateral) New() protoreflect.Message {
+ return new(fastReflection_MsgWithdrawCollateral)
}
// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgFinishInference) Interface() protoreflect.ProtoMessage {
- return (*MsgFinishInference)(x)
+func (x *fastReflection_MsgWithdrawCollateral) Interface() protoreflect.ProtoMessage {
+ return (*MsgWithdrawCollateral)(x)
}
// Range iterates over every populated field in an undefined order,
@@ -2055,46 +1804,16 @@ func (x *fastReflection_MsgFinishInference) Interface() protoreflect.ProtoMessag
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
-func (x *fastReflection_MsgFinishInference) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
- if x.Creator != "" {
- value := protoreflect.ValueOfString(x.Creator)
- if !f(fd_MsgFinishInference_creator, value) {
- return
- }
- }
- if x.InferenceId != "" {
- value := protoreflect.ValueOfString(x.InferenceId)
- if !f(fd_MsgFinishInference_inferenceId, value) {
- return
- }
- }
- if x.ResponseHash != "" {
- value := protoreflect.ValueOfString(x.ResponseHash)
- if !f(fd_MsgFinishInference_responseHash, value) {
- return
- }
- }
- if x.ResponsePayload != "" {
- value := protoreflect.ValueOfString(x.ResponsePayload)
- if !f(fd_MsgFinishInference_responsePayload, value) {
- return
- }
- }
- if x.PromptTokenCount != uint64(0) {
- value := protoreflect.ValueOfUint64(x.PromptTokenCount)
- if !f(fd_MsgFinishInference_promptTokenCount, value) {
- return
- }
- }
- if x.CompletionTokenCount != uint64(0) {
- value := protoreflect.ValueOfUint64(x.CompletionTokenCount)
- if !f(fd_MsgFinishInference_completionTokenCount, value) {
+func (x *fastReflection_MsgWithdrawCollateral) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Participant != "" {
+ value := protoreflect.ValueOfString(x.Participant)
+ if !f(fd_MsgWithdrawCollateral_participant, value) {
return
}
}
- if x.ExecutedBy != "" {
- value := protoreflect.ValueOfString(x.ExecutedBy)
- if !f(fd_MsgFinishInference_executedBy, value) {
+ if x.Amount != nil {
+ value := protoreflect.ValueOfMessage(x.Amount.ProtoReflect())
+ if !f(fd_MsgWithdrawCollateral_amount, value) {
return
}
}
@@ -2111,27 +1830,17 @@ func (x *fastReflection_MsgFinishInference) Range(f func(protoreflect.FieldDescr
// 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_MsgFinishInference) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgWithdrawCollateral) Has(fd protoreflect.FieldDescriptor) bool {
switch fd.FullName() {
- case "inference.inference.MsgFinishInference.creator":
- return x.Creator != ""
- case "inference.inference.MsgFinishInference.inferenceId":
- return x.InferenceId != ""
- case "inference.inference.MsgFinishInference.responseHash":
- return x.ResponseHash != ""
- case "inference.inference.MsgFinishInference.responsePayload":
- return x.ResponsePayload != ""
- case "inference.inference.MsgFinishInference.promptTokenCount":
- return x.PromptTokenCount != uint64(0)
- case "inference.inference.MsgFinishInference.completionTokenCount":
- return x.CompletionTokenCount != uint64(0)
- case "inference.inference.MsgFinishInference.executedBy":
- return x.ExecutedBy != ""
+ case "inference.collateral.MsgWithdrawCollateral.participant":
+ return x.Participant != ""
+ case "inference.collateral.MsgWithdrawCollateral.amount":
+ return x.Amount != nil
default:
if fd.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgFinishInference"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.MsgWithdrawCollateral"))
}
- panic(fmt.Errorf("message inference.inference.MsgFinishInference does not contain field %s", fd.FullName()))
+ panic(fmt.Errorf("message inference.collateral.MsgWithdrawCollateral does not contain field %s", fd.FullName()))
}
}
@@ -2141,27 +1850,17 @@ func (x *fastReflection_MsgFinishInference) Has(fd protoreflect.FieldDescriptor)
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgFinishInference) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgWithdrawCollateral) Clear(fd protoreflect.FieldDescriptor) {
switch fd.FullName() {
- case "inference.inference.MsgFinishInference.creator":
- x.Creator = ""
- case "inference.inference.MsgFinishInference.inferenceId":
- x.InferenceId = ""
- case "inference.inference.MsgFinishInference.responseHash":
- x.ResponseHash = ""
- case "inference.inference.MsgFinishInference.responsePayload":
- x.ResponsePayload = ""
- case "inference.inference.MsgFinishInference.promptTokenCount":
- x.PromptTokenCount = uint64(0)
- case "inference.inference.MsgFinishInference.completionTokenCount":
- x.CompletionTokenCount = uint64(0)
- case "inference.inference.MsgFinishInference.executedBy":
- x.ExecutedBy = ""
+ case "inference.collateral.MsgWithdrawCollateral.participant":
+ x.Participant = ""
+ case "inference.collateral.MsgWithdrawCollateral.amount":
+ x.Amount = nil
default:
if fd.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgFinishInference"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.MsgWithdrawCollateral"))
}
- panic(fmt.Errorf("message inference.inference.MsgFinishInference does not contain field %s", fd.FullName()))
+ panic(fmt.Errorf("message inference.collateral.MsgWithdrawCollateral does not contain field %s", fd.FullName()))
}
}
@@ -2171,34 +1870,19 @@ func (x *fastReflection_MsgFinishInference) Clear(fd protoreflect.FieldDescripto
// 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_MsgFinishInference) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgWithdrawCollateral) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
switch descriptor.FullName() {
- case "inference.inference.MsgFinishInference.creator":
- value := x.Creator
- return protoreflect.ValueOfString(value)
- case "inference.inference.MsgFinishInference.inferenceId":
- value := x.InferenceId
- return protoreflect.ValueOfString(value)
- case "inference.inference.MsgFinishInference.responseHash":
- value := x.ResponseHash
- return protoreflect.ValueOfString(value)
- case "inference.inference.MsgFinishInference.responsePayload":
- value := x.ResponsePayload
- return protoreflect.ValueOfString(value)
- case "inference.inference.MsgFinishInference.promptTokenCount":
- value := x.PromptTokenCount
- return protoreflect.ValueOfUint64(value)
- case "inference.inference.MsgFinishInference.completionTokenCount":
- value := x.CompletionTokenCount
- return protoreflect.ValueOfUint64(value)
- case "inference.inference.MsgFinishInference.executedBy":
- value := x.ExecutedBy
+ case "inference.collateral.MsgWithdrawCollateral.participant":
+ value := x.Participant
return protoreflect.ValueOfString(value)
+ case "inference.collateral.MsgWithdrawCollateral.amount":
+ value := x.Amount
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
default:
if descriptor.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgFinishInference"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.MsgWithdrawCollateral"))
}
- panic(fmt.Errorf("message inference.inference.MsgFinishInference does not contain field %s", descriptor.FullName()))
+ panic(fmt.Errorf("message inference.collateral.MsgWithdrawCollateral does not contain field %s", descriptor.FullName()))
}
}
@@ -2212,27 +1896,17 @@ func (x *fastReflection_MsgFinishInference) Get(descriptor protoreflect.FieldDes
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgFinishInference) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgWithdrawCollateral) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
switch fd.FullName() {
- case "inference.inference.MsgFinishInference.creator":
- x.Creator = value.Interface().(string)
- case "inference.inference.MsgFinishInference.inferenceId":
- x.InferenceId = value.Interface().(string)
- case "inference.inference.MsgFinishInference.responseHash":
- x.ResponseHash = value.Interface().(string)
- case "inference.inference.MsgFinishInference.responsePayload":
- x.ResponsePayload = value.Interface().(string)
- case "inference.inference.MsgFinishInference.promptTokenCount":
- x.PromptTokenCount = value.Uint()
- case "inference.inference.MsgFinishInference.completionTokenCount":
- x.CompletionTokenCount = value.Uint()
- case "inference.inference.MsgFinishInference.executedBy":
- x.ExecutedBy = value.Interface().(string)
+ case "inference.collateral.MsgWithdrawCollateral.participant":
+ x.Participant = value.Interface().(string)
+ case "inference.collateral.MsgWithdrawCollateral.amount":
+ x.Amount = value.Message().Interface().(*v1beta1.Coin)
default:
if fd.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgFinishInference"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.MsgWithdrawCollateral"))
}
- panic(fmt.Errorf("message inference.inference.MsgFinishInference does not contain field %s", fd.FullName()))
+ panic(fmt.Errorf("message inference.collateral.MsgWithdrawCollateral does not contain field %s", fd.FullName()))
}
}
@@ -2246,64 +1920,48 @@ func (x *fastReflection_MsgFinishInference) 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_MsgFinishInference) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgWithdrawCollateral) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
switch fd.FullName() {
- case "inference.inference.MsgFinishInference.creator":
- panic(fmt.Errorf("field creator of message inference.inference.MsgFinishInference is not mutable"))
- case "inference.inference.MsgFinishInference.inferenceId":
- panic(fmt.Errorf("field inferenceId of message inference.inference.MsgFinishInference is not mutable"))
- case "inference.inference.MsgFinishInference.responseHash":
- panic(fmt.Errorf("field responseHash of message inference.inference.MsgFinishInference is not mutable"))
- case "inference.inference.MsgFinishInference.responsePayload":
- panic(fmt.Errorf("field responsePayload of message inference.inference.MsgFinishInference is not mutable"))
- case "inference.inference.MsgFinishInference.promptTokenCount":
- panic(fmt.Errorf("field promptTokenCount of message inference.inference.MsgFinishInference is not mutable"))
- case "inference.inference.MsgFinishInference.completionTokenCount":
- panic(fmt.Errorf("field completionTokenCount of message inference.inference.MsgFinishInference is not mutable"))
- case "inference.inference.MsgFinishInference.executedBy":
- panic(fmt.Errorf("field executedBy of message inference.inference.MsgFinishInference is not mutable"))
+ case "inference.collateral.MsgWithdrawCollateral.amount":
+ if x.Amount == nil {
+ x.Amount = new(v1beta1.Coin)
+ }
+ return protoreflect.ValueOfMessage(x.Amount.ProtoReflect())
+ case "inference.collateral.MsgWithdrawCollateral.participant":
+ panic(fmt.Errorf("field participant of message inference.collateral.MsgWithdrawCollateral is not mutable"))
default:
if fd.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgFinishInference"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.MsgWithdrawCollateral"))
}
- panic(fmt.Errorf("message inference.inference.MsgFinishInference does not contain field %s", fd.FullName()))
+ panic(fmt.Errorf("message inference.collateral.MsgWithdrawCollateral 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_MsgFinishInference) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgWithdrawCollateral) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
switch fd.FullName() {
- case "inference.inference.MsgFinishInference.creator":
- return protoreflect.ValueOfString("")
- case "inference.inference.MsgFinishInference.inferenceId":
- return protoreflect.ValueOfString("")
- case "inference.inference.MsgFinishInference.responseHash":
- return protoreflect.ValueOfString("")
- case "inference.inference.MsgFinishInference.responsePayload":
- return protoreflect.ValueOfString("")
- case "inference.inference.MsgFinishInference.promptTokenCount":
- return protoreflect.ValueOfUint64(uint64(0))
- case "inference.inference.MsgFinishInference.completionTokenCount":
- return protoreflect.ValueOfUint64(uint64(0))
- case "inference.inference.MsgFinishInference.executedBy":
+ case "inference.collateral.MsgWithdrawCollateral.participant":
return protoreflect.ValueOfString("")
+ case "inference.collateral.MsgWithdrawCollateral.amount":
+ m := new(v1beta1.Coin)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
default:
if fd.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgFinishInference"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.MsgWithdrawCollateral"))
}
- panic(fmt.Errorf("message inference.inference.MsgFinishInference does not contain field %s", fd.FullName()))
+ panic(fmt.Errorf("message inference.collateral.MsgWithdrawCollateral 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_MsgFinishInference) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgWithdrawCollateral) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
switch d.FullName() {
default:
- panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgFinishInference", d.FullName()))
+ panic(fmt.Errorf("%s is not a oneof field in inference.collateral.MsgWithdrawCollateral", d.FullName()))
}
panic("unreachable")
}
@@ -2311,7 +1969,7 @@ func (x *fastReflection_MsgFinishInference) WhichOneof(d protoreflect.OneofDescr
// 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_MsgFinishInference) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgWithdrawCollateral) GetUnknown() protoreflect.RawFields {
return x.unknownFields
}
@@ -2322,7 +1980,7 @@ func (x *fastReflection_MsgFinishInference) 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_MsgFinishInference) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgWithdrawCollateral) SetUnknown(fields protoreflect.RawFields) {
x.unknownFields = fields
}
@@ -2334,7 +1992,7 @@ func (x *fastReflection_MsgFinishInference) SetUnknown(fields protoreflect.RawFi
// 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_MsgFinishInference) IsValid() bool {
+func (x *fastReflection_MsgWithdrawCollateral) IsValid() bool {
return x != nil
}
@@ -2344,9 +2002,9 @@ func (x *fastReflection_MsgFinishInference) 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_MsgFinishInference) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgWithdrawCollateral) ProtoMethods() *protoiface.Methods {
size := func(input protoiface.SizeInput) protoiface.SizeOutput {
- x := input.Message.Interface().(*MsgFinishInference)
+ x := input.Message.Interface().(*MsgWithdrawCollateral)
if x == nil {
return protoiface.SizeOutput{
NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -2358,30 +2016,12 @@ func (x *fastReflection_MsgFinishInference) ProtoMethods() *protoiface.Methods {
var n int
var l int
_ = l
- l = len(x.Creator)
+ l = len(x.Participant)
if l > 0 {
n += 1 + l + runtime.Sov(uint64(l))
}
- l = len(x.InferenceId)
- if l > 0 {
- n += 1 + l + runtime.Sov(uint64(l))
- }
- l = len(x.ResponseHash)
- if l > 0 {
- n += 1 + l + runtime.Sov(uint64(l))
- }
- l = len(x.ResponsePayload)
- if l > 0 {
- n += 1 + l + runtime.Sov(uint64(l))
- }
- if x.PromptTokenCount != 0 {
- n += 1 + runtime.Sov(uint64(x.PromptTokenCount))
- }
- if x.CompletionTokenCount != 0 {
- n += 1 + runtime.Sov(uint64(x.CompletionTokenCount))
- }
- l = len(x.ExecutedBy)
- if l > 0 {
+ if x.Amount != nil {
+ l = options.Size(x.Amount)
n += 1 + l + runtime.Sov(uint64(l))
}
if x.unknownFields != nil {
@@ -2394,7 +2034,7 @@ func (x *fastReflection_MsgFinishInference) ProtoMethods() *protoiface.Methods {
}
marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
- x := input.Message.Interface().(*MsgFinishInference)
+ x := input.Message.Interface().(*MsgWithdrawCollateral)
if x == nil {
return protoiface.MarshalOutput{
NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -2413,48 +2053,24 @@ func (x *fastReflection_MsgFinishInference) ProtoMethods() *protoiface.Methods {
i -= len(x.unknownFields)
copy(dAtA[i:], x.unknownFields)
}
- if len(x.ExecutedBy) > 0 {
- i -= len(x.ExecutedBy)
- copy(dAtA[i:], x.ExecutedBy)
- i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ExecutedBy)))
- i--
- dAtA[i] = 0x3a
- }
- if x.CompletionTokenCount != 0 {
- i = runtime.EncodeVarint(dAtA, i, uint64(x.CompletionTokenCount))
- i--
- dAtA[i] = 0x30
- }
- if x.PromptTokenCount != 0 {
- i = runtime.EncodeVarint(dAtA, i, uint64(x.PromptTokenCount))
- i--
- dAtA[i] = 0x28
- }
- if len(x.ResponsePayload) > 0 {
- i -= len(x.ResponsePayload)
- copy(dAtA[i:], x.ResponsePayload)
- i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ResponsePayload)))
- i--
- dAtA[i] = 0x22
- }
- if len(x.ResponseHash) > 0 {
- i -= len(x.ResponseHash)
- copy(dAtA[i:], x.ResponseHash)
- i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ResponseHash)))
- i--
- dAtA[i] = 0x1a
- }
- if len(x.InferenceId) > 0 {
- i -= len(x.InferenceId)
- copy(dAtA[i:], x.InferenceId)
- i = runtime.EncodeVarint(dAtA, i, uint64(len(x.InferenceId)))
+ if x.Amount != nil {
+ encoded, err := options.Marshal(x.Amount)
+ 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.Creator) > 0 {
- i -= len(x.Creator)
- copy(dAtA[i:], x.Creator)
- i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Creator)))
+ 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
}
@@ -2469,7 +2085,7 @@ func (x *fastReflection_MsgFinishInference) ProtoMethods() *protoiface.Methods {
}, nil
}
unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
- x := input.Message.Interface().(*MsgFinishInference)
+ x := input.Message.Interface().(*MsgWithdrawCollateral)
if x == nil {
return protoiface.UnmarshalOutput{
NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -2501,15 +2117,15 @@ func (x *fastReflection_MsgFinishInference) 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: MsgFinishInference: wiretype end group for non-group")
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgWithdrawCollateral: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgFinishInference: illegal tag %d (wire type %d)", fieldNum, wire)
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgWithdrawCollateral: 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 Participant", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
@@ -2537,77 +2153,13 @@ func (x *fastReflection_MsgFinishInference) ProtoMethods() *protoiface.Methods {
if postIndex > l {
return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
}
- x.Creator = string(dAtA[iNdEx:postIndex])
+ 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 InferenceId", 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 {
- if shift >= 64 {
- return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.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.InferenceId = 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 ResponseHash", 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.ResponseHash = 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 ResponsePayload", 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
@@ -2617,93 +2169,27 @@ func (x *fastReflection_MsgFinishInference) 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.ResponsePayload = string(dAtA[iNdEx:postIndex])
- iNdEx = postIndex
- case 5:
- if wireType != 0 {
- return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PromptTokenCount", wireType)
- }
- x.PromptTokenCount = 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.PromptTokenCount |= 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 CompletionTokenCount", wireType)
+ if x.Amount == nil {
+ x.Amount = &v1beta1.Coin{}
}
- x.CompletionTokenCount = 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.CompletionTokenCount |= uint64(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 ExecutedBy", 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
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Amount); err != nil {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
}
- x.ExecutedBy = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
default:
iNdEx = preIndex
@@ -2741,26 +2227,26 @@ func (x *fastReflection_MsgFinishInference) ProtoMethods() *protoiface.Methods {
}
var (
- md_MsgFinishInferenceResponse protoreflect.MessageDescriptor
- fd_MsgFinishInferenceResponse_inferenceIndex protoreflect.FieldDescriptor
+ md_MsgWithdrawCollateralResponse protoreflect.MessageDescriptor
+ fd_MsgWithdrawCollateralResponse_completion_epoch protoreflect.FieldDescriptor
)
func init() {
- file_inference_inference_tx_proto_init()
- md_MsgFinishInferenceResponse = File_inference_inference_tx_proto.Messages().ByName("MsgFinishInferenceResponse")
- fd_MsgFinishInferenceResponse_inferenceIndex = md_MsgFinishInferenceResponse.Fields().ByName("inferenceIndex")
+ file_inference_collateral_tx_proto_init()
+ md_MsgWithdrawCollateralResponse = File_inference_collateral_tx_proto.Messages().ByName("MsgWithdrawCollateralResponse")
+ fd_MsgWithdrawCollateralResponse_completion_epoch = md_MsgWithdrawCollateralResponse.Fields().ByName("completion_epoch")
}
-var _ protoreflect.Message = (*fastReflection_MsgFinishInferenceResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgWithdrawCollateralResponse)(nil)
-type fastReflection_MsgFinishInferenceResponse MsgFinishInferenceResponse
+type fastReflection_MsgWithdrawCollateralResponse MsgWithdrawCollateralResponse
-func (x *MsgFinishInferenceResponse) ProtoReflect() protoreflect.Message {
- return (*fastReflection_MsgFinishInferenceResponse)(x)
+func (x *MsgWithdrawCollateralResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_MsgWithdrawCollateralResponse)(x)
}
-func (x *MsgFinishInferenceResponse) slowProtoReflect() protoreflect.Message {
- mi := &file_inference_inference_tx_proto_msgTypes[5]
+func (x *MsgWithdrawCollateralResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_collateral_tx_proto_msgTypes[5]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -2771,43 +2257,43 @@ func (x *MsgFinishInferenceResponse) slowProtoReflect() protoreflect.Message {
return mi.MessageOf(x)
}
-var _fastReflection_MsgFinishInferenceResponse_messageType fastReflection_MsgFinishInferenceResponse_messageType
-var _ protoreflect.MessageType = fastReflection_MsgFinishInferenceResponse_messageType{}
+var _fastReflection_MsgWithdrawCollateralResponse_messageType fastReflection_MsgWithdrawCollateralResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgWithdrawCollateralResponse_messageType{}
-type fastReflection_MsgFinishInferenceResponse_messageType struct{}
+type fastReflection_MsgWithdrawCollateralResponse_messageType struct{}
-func (x fastReflection_MsgFinishInferenceResponse_messageType) Zero() protoreflect.Message {
- return (*fastReflection_MsgFinishInferenceResponse)(nil)
+func (x fastReflection_MsgWithdrawCollateralResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_MsgWithdrawCollateralResponse)(nil)
}
-func (x fastReflection_MsgFinishInferenceResponse_messageType) New() protoreflect.Message {
- return new(fastReflection_MsgFinishInferenceResponse)
+func (x fastReflection_MsgWithdrawCollateralResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_MsgWithdrawCollateralResponse)
}
-func (x fastReflection_MsgFinishInferenceResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
- return md_MsgFinishInferenceResponse
+func (x fastReflection_MsgWithdrawCollateralResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgWithdrawCollateralResponse
}
// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
-func (x *fastReflection_MsgFinishInferenceResponse) Descriptor() protoreflect.MessageDescriptor {
- return md_MsgFinishInferenceResponse
+func (x *fastReflection_MsgWithdrawCollateralResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgWithdrawCollateralResponse
}
// 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_MsgFinishInferenceResponse) Type() protoreflect.MessageType {
- return _fastReflection_MsgFinishInferenceResponse_messageType
+func (x *fastReflection_MsgWithdrawCollateralResponse) Type() protoreflect.MessageType {
+ return _fastReflection_MsgWithdrawCollateralResponse_messageType
}
// New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgFinishInferenceResponse) New() protoreflect.Message {
- return new(fastReflection_MsgFinishInferenceResponse)
+func (x *fastReflection_MsgWithdrawCollateralResponse) New() protoreflect.Message {
+ return new(fastReflection_MsgWithdrawCollateralResponse)
}
// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgFinishInferenceResponse) Interface() protoreflect.ProtoMessage {
- return (*MsgFinishInferenceResponse)(x)
+func (x *fastReflection_MsgWithdrawCollateralResponse) Interface() protoreflect.ProtoMessage {
+ return (*MsgWithdrawCollateralResponse)(x)
}
// Range iterates over every populated field in an undefined order,
@@ -2815,10 +2301,10 @@ func (x *fastReflection_MsgFinishInferenceResponse) 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_MsgFinishInferenceResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
- if x.InferenceIndex != "" {
- value := protoreflect.ValueOfString(x.InferenceIndex)
- if !f(fd_MsgFinishInferenceResponse_inferenceIndex, value) {
+func (x *fastReflection_MsgWithdrawCollateralResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.CompletionEpoch != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.CompletionEpoch)
+ if !f(fd_MsgWithdrawCollateralResponse_completion_epoch, value) {
return
}
}
@@ -2835,15 +2321,15 @@ func (x *fastReflection_MsgFinishInferenceResponse) 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_MsgFinishInferenceResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgWithdrawCollateralResponse) Has(fd protoreflect.FieldDescriptor) bool {
switch fd.FullName() {
- case "inference.inference.MsgFinishInferenceResponse.inferenceIndex":
- return x.InferenceIndex != ""
+ case "inference.collateral.MsgWithdrawCollateralResponse.completion_epoch":
+ return x.CompletionEpoch != uint64(0)
default:
if fd.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgFinishInferenceResponse"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.MsgWithdrawCollateralResponse"))
}
- panic(fmt.Errorf("message inference.inference.MsgFinishInferenceResponse does not contain field %s", fd.FullName()))
+ panic(fmt.Errorf("message inference.collateral.MsgWithdrawCollateralResponse does not contain field %s", fd.FullName()))
}
}
@@ -2853,15 +2339,15 @@ func (x *fastReflection_MsgFinishInferenceResponse) Has(fd protoreflect.FieldDes
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgFinishInferenceResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgWithdrawCollateralResponse) Clear(fd protoreflect.FieldDescriptor) {
switch fd.FullName() {
- case "inference.inference.MsgFinishInferenceResponse.inferenceIndex":
- x.InferenceIndex = ""
+ case "inference.collateral.MsgWithdrawCollateralResponse.completion_epoch":
+ x.CompletionEpoch = uint64(0)
default:
if fd.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgFinishInferenceResponse"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.MsgWithdrawCollateralResponse"))
}
- panic(fmt.Errorf("message inference.inference.MsgFinishInferenceResponse does not contain field %s", fd.FullName()))
+ panic(fmt.Errorf("message inference.collateral.MsgWithdrawCollateralResponse does not contain field %s", fd.FullName()))
}
}
@@ -2871,16 +2357,16 @@ func (x *fastReflection_MsgFinishInferenceResponse) 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_MsgFinishInferenceResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgWithdrawCollateralResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
switch descriptor.FullName() {
- case "inference.inference.MsgFinishInferenceResponse.inferenceIndex":
- value := x.InferenceIndex
- return protoreflect.ValueOfString(value)
+ case "inference.collateral.MsgWithdrawCollateralResponse.completion_epoch":
+ value := x.CompletionEpoch
+ return protoreflect.ValueOfUint64(value)
default:
if descriptor.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgFinishInferenceResponse"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.MsgWithdrawCollateralResponse"))
}
- panic(fmt.Errorf("message inference.inference.MsgFinishInferenceResponse does not contain field %s", descriptor.FullName()))
+ panic(fmt.Errorf("message inference.collateral.MsgWithdrawCollateralResponse does not contain field %s", descriptor.FullName()))
}
}
@@ -2894,15 +2380,15 @@ func (x *fastReflection_MsgFinishInferenceResponse) Get(descriptor protoreflect.
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgFinishInferenceResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgWithdrawCollateralResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
switch fd.FullName() {
- case "inference.inference.MsgFinishInferenceResponse.inferenceIndex":
- x.InferenceIndex = value.Interface().(string)
+ case "inference.collateral.MsgWithdrawCollateralResponse.completion_epoch":
+ x.CompletionEpoch = value.Uint()
default:
if fd.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgFinishInferenceResponse"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.MsgWithdrawCollateralResponse"))
}
- panic(fmt.Errorf("message inference.inference.MsgFinishInferenceResponse does not contain field %s", fd.FullName()))
+ panic(fmt.Errorf("message inference.collateral.MsgWithdrawCollateralResponse does not contain field %s", fd.FullName()))
}
}
@@ -2916,40 +2402,40 @@ func (x *fastReflection_MsgFinishInferenceResponse) 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_MsgFinishInferenceResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgWithdrawCollateralResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
switch fd.FullName() {
- case "inference.inference.MsgFinishInferenceResponse.inferenceIndex":
- panic(fmt.Errorf("field inferenceIndex of message inference.inference.MsgFinishInferenceResponse is not mutable"))
+ case "inference.collateral.MsgWithdrawCollateralResponse.completion_epoch":
+ panic(fmt.Errorf("field completion_epoch of message inference.collateral.MsgWithdrawCollateralResponse is not mutable"))
default:
if fd.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgFinishInferenceResponse"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.MsgWithdrawCollateralResponse"))
}
- panic(fmt.Errorf("message inference.inference.MsgFinishInferenceResponse does not contain field %s", fd.FullName()))
+ panic(fmt.Errorf("message inference.collateral.MsgWithdrawCollateralResponse 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_MsgFinishInferenceResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgWithdrawCollateralResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
switch fd.FullName() {
- case "inference.inference.MsgFinishInferenceResponse.inferenceIndex":
- return protoreflect.ValueOfString("")
+ case "inference.collateral.MsgWithdrawCollateralResponse.completion_epoch":
+ return protoreflect.ValueOfUint64(uint64(0))
default:
if fd.IsExtension() {
- panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgFinishInferenceResponse"))
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.MsgWithdrawCollateralResponse"))
}
- panic(fmt.Errorf("message inference.inference.MsgFinishInferenceResponse does not contain field %s", fd.FullName()))
+ panic(fmt.Errorf("message inference.collateral.MsgWithdrawCollateralResponse 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_MsgFinishInferenceResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgWithdrawCollateralResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
switch d.FullName() {
default:
- panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgFinishInferenceResponse", d.FullName()))
+ panic(fmt.Errorf("%s is not a oneof field in inference.collateral.MsgWithdrawCollateralResponse", d.FullName()))
}
panic("unreachable")
}
@@ -2957,7 +2443,7 @@ func (x *fastReflection_MsgFinishInferenceResponse) 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_MsgFinishInferenceResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgWithdrawCollateralResponse) GetUnknown() protoreflect.RawFields {
return x.unknownFields
}
@@ -2968,7 +2454,7 @@ func (x *fastReflection_MsgFinishInferenceResponse) 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_MsgFinishInferenceResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgWithdrawCollateralResponse) SetUnknown(fields protoreflect.RawFields) {
x.unknownFields = fields
}
@@ -2980,7 +2466,7 @@ func (x *fastReflection_MsgFinishInferenceResponse) 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_MsgFinishInferenceResponse) IsValid() bool {
+func (x *fastReflection_MsgWithdrawCollateralResponse) IsValid() bool {
return x != nil
}
@@ -2990,9 +2476,9 @@ func (x *fastReflection_MsgFinishInferenceResponse) 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_MsgFinishInferenceResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgWithdrawCollateralResponse) ProtoMethods() *protoiface.Methods {
size := func(input protoiface.SizeInput) protoiface.SizeOutput {
- x := input.Message.Interface().(*MsgFinishInferenceResponse)
+ x := input.Message.Interface().(*MsgWithdrawCollateralResponse)
if x == nil {
return protoiface.SizeOutput{
NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -3004,9 +2490,8 @@ func (x *fastReflection_MsgFinishInferenceResponse) ProtoMethods() *protoiface.M
var n int
var l int
_ = l
- l = len(x.InferenceIndex)
- if l > 0 {
- n += 1 + l + runtime.Sov(uint64(l))
+ if x.CompletionEpoch != 0 {
+ n += 1 + runtime.Sov(uint64(x.CompletionEpoch))
}
if x.unknownFields != nil {
n += len(x.unknownFields)
@@ -3018,7 +2503,7 @@ func (x *fastReflection_MsgFinishInferenceResponse) ProtoMethods() *protoiface.M
}
marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
- x := input.Message.Interface().(*MsgFinishInferenceResponse)
+ x := input.Message.Interface().(*MsgWithdrawCollateralResponse)
if x == nil {
return protoiface.MarshalOutput{
NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -3037,12 +2522,10 @@ func (x *fastReflection_MsgFinishInferenceResponse) ProtoMethods() *protoiface.M
i -= len(x.unknownFields)
copy(dAtA[i:], x.unknownFields)
}
- if len(x.InferenceIndex) > 0 {
- i -= len(x.InferenceIndex)
- copy(dAtA[i:], x.InferenceIndex)
- i = runtime.EncodeVarint(dAtA, i, uint64(len(x.InferenceIndex)))
+ if x.CompletionEpoch != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.CompletionEpoch))
i--
- dAtA[i] = 0xa
+ dAtA[i] = 0x8
}
if input.Buf != nil {
input.Buf = append(input.Buf, dAtA...)
@@ -3055,7 +2538,7 @@ func (x *fastReflection_MsgFinishInferenceResponse) ProtoMethods() *protoiface.M
}, nil
}
unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
- x := input.Message.Interface().(*MsgFinishInferenceResponse)
+ x := input.Message.Interface().(*MsgWithdrawCollateralResponse)
if x == nil {
return protoiface.UnmarshalOutput{
NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -3087,17 +2570,17 @@ func (x *fastReflection_MsgFinishInferenceResponse) 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: MsgFinishInferenceResponse: wiretype end group for non-group")
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgWithdrawCollateralResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgFinishInferenceResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgWithdrawCollateralResponse: 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 InferenceIndex", wireType)
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field CompletionEpoch", wireType)
}
- var stringLen uint64
+ x.CompletionEpoch = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -3107,24 +2590,11 @@ func (x *fastReflection_MsgFinishInferenceResponse) ProtoMethods() *protoiface.M
}
b := dAtA[iNdEx]
iNdEx++
- stringLen |= uint64(b&0x7F) << shift
+ x.CompletionEpoch |= 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.InferenceIndex = string(dAtA[iNdEx:postIndex])
- iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -3164,7 +2634,7 @@ func (x *fastReflection_MsgFinishInferenceResponse) ProtoMethods() *protoiface.M
// versions:
// protoc-gen-go v1.27.0
// protoc (unknown)
-// source: inference/inference/tx.proto
+// source: inference/collateral/tx.proto
const (
// Verify that this generated code is sufficiently up-to-date.
@@ -3181,6 +2651,8 @@ type MsgUpdateParams struct {
// authority is the address that controls the module (defaults to x/gov unless overwritten).
Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"`
+ // params defines the module parameters to update.
+ //
// NOTE: All parameters must be supplied.
Params *Params `protobuf:"bytes,2,opt,name=params,proto3" json:"params,omitempty"`
}
@@ -3188,7 +2660,7 @@ type MsgUpdateParams struct {
func (x *MsgUpdateParams) Reset() {
*x = MsgUpdateParams{}
if protoimpl.UnsafeEnabled {
- mi := &file_inference_inference_tx_proto_msgTypes[0]
+ mi := &file_inference_collateral_tx_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -3202,7 +2674,7 @@ func (*MsgUpdateParams) ProtoMessage() {}
// Deprecated: Use MsgUpdateParams.ProtoReflect.Descriptor instead.
func (*MsgUpdateParams) Descriptor() ([]byte, []int) {
- return file_inference_inference_tx_proto_rawDescGZIP(), []int{0}
+ return file_inference_collateral_tx_proto_rawDescGZIP(), []int{0}
}
func (x *MsgUpdateParams) GetAuthority() string {
@@ -3230,7 +2702,7 @@ type MsgUpdateParamsResponse struct {
func (x *MsgUpdateParamsResponse) Reset() {
*x = MsgUpdateParamsResponse{}
if protoimpl.UnsafeEnabled {
- mi := &file_inference_inference_tx_proto_msgTypes[1]
+ mi := &file_inference_collateral_tx_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -3244,377 +2716,316 @@ func (*MsgUpdateParamsResponse) ProtoMessage() {}
// Deprecated: Use MsgUpdateParamsResponse.ProtoReflect.Descriptor instead.
func (*MsgUpdateParamsResponse) Descriptor() ([]byte, []int) {
- return file_inference_inference_tx_proto_rawDescGZIP(), []int{1}
+ return file_inference_collateral_tx_proto_rawDescGZIP(), []int{1}
}
-type MsgStartInference struct {
+// MsgDepositCollateral defines a message to deposit collateral
+type MsgDepositCollateral struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
- Creator string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
- InferenceId string `protobuf:"bytes,2,opt,name=inferenceId,proto3" json:"inferenceId,omitempty"`
- PromptHash string `protobuf:"bytes,3,opt,name=promptHash,proto3" json:"promptHash,omitempty"`
- PromptPayload string `protobuf:"bytes,4,opt,name=promptPayload,proto3" json:"promptPayload,omitempty"`
- ReceivedBy string `protobuf:"bytes,5,opt,name=receivedBy,proto3" json:"receivedBy,omitempty"`
+ // participant is the address depositing collateral
+ Participant string `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
+ // amount is the collateral to deposit
+ Amount *v1beta1.Coin `protobuf:"bytes,2,opt,name=amount,proto3" json:"amount,omitempty"`
}
-func (x *MsgStartInference) Reset() {
- *x = MsgStartInference{}
+func (x *MsgDepositCollateral) Reset() {
+ *x = MsgDepositCollateral{}
if protoimpl.UnsafeEnabled {
- mi := &file_inference_inference_tx_proto_msgTypes[2]
+ mi := &file_inference_collateral_tx_proto_msgTypes[2]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
-func (x *MsgStartInference) String() string {
+func (x *MsgDepositCollateral) String() string {
return protoimpl.X.MessageStringOf(x)
}
-func (*MsgStartInference) ProtoMessage() {}
-
-// Deprecated: Use MsgStartInference.ProtoReflect.Descriptor instead.
-func (*MsgStartInference) Descriptor() ([]byte, []int) {
- return file_inference_inference_tx_proto_rawDescGZIP(), []int{2}
-}
-
-func (x *MsgStartInference) GetCreator() string {
- if x != nil {
- return x.Creator
- }
- return ""
-}
-
-func (x *MsgStartInference) GetInferenceId() string {
- if x != nil {
- return x.InferenceId
- }
- return ""
-}
+func (*MsgDepositCollateral) ProtoMessage() {}
-func (x *MsgStartInference) GetPromptHash() string {
- if x != nil {
- return x.PromptHash
- }
- return ""
+// Deprecated: Use MsgDepositCollateral.ProtoReflect.Descriptor instead.
+func (*MsgDepositCollateral) Descriptor() ([]byte, []int) {
+ return file_inference_collateral_tx_proto_rawDescGZIP(), []int{2}
}
-func (x *MsgStartInference) GetPromptPayload() string {
+func (x *MsgDepositCollateral) GetParticipant() string {
if x != nil {
- return x.PromptPayload
+ return x.Participant
}
return ""
}
-func (x *MsgStartInference) GetReceivedBy() string {
+func (x *MsgDepositCollateral) GetAmount() *v1beta1.Coin {
if x != nil {
- return x.ReceivedBy
+ return x.Amount
}
- return ""
+ return nil
}
-type MsgStartInferenceResponse struct {
+// MsgDepositCollateralResponse defines the response structure for executing a
+// MsgDepositCollateral message.
+type MsgDepositCollateralResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
-
- InferenceIndex string `protobuf:"bytes,1,opt,name=inferenceIndex,proto3" json:"inferenceIndex,omitempty"`
}
-func (x *MsgStartInferenceResponse) Reset() {
- *x = MsgStartInferenceResponse{}
+func (x *MsgDepositCollateralResponse) Reset() {
+ *x = MsgDepositCollateralResponse{}
if protoimpl.UnsafeEnabled {
- mi := &file_inference_inference_tx_proto_msgTypes[3]
+ mi := &file_inference_collateral_tx_proto_msgTypes[3]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
-func (x *MsgStartInferenceResponse) String() string {
+func (x *MsgDepositCollateralResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
-func (*MsgStartInferenceResponse) ProtoMessage() {}
+func (*MsgDepositCollateralResponse) ProtoMessage() {}
-// Deprecated: Use MsgStartInferenceResponse.ProtoReflect.Descriptor instead.
-func (*MsgStartInferenceResponse) Descriptor() ([]byte, []int) {
- return file_inference_inference_tx_proto_rawDescGZIP(), []int{3}
+// Deprecated: Use MsgDepositCollateralResponse.ProtoReflect.Descriptor instead.
+func (*MsgDepositCollateralResponse) Descriptor() ([]byte, []int) {
+ return file_inference_collateral_tx_proto_rawDescGZIP(), []int{3}
}
-func (x *MsgStartInferenceResponse) GetInferenceIndex() string {
- if x != nil {
- return x.InferenceIndex
- }
- return ""
-}
-
-type MsgFinishInference struct {
+// MsgWithdrawCollateral defines a message to withdraw collateral
+type MsgWithdrawCollateral struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
- Creator string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
- InferenceId string `protobuf:"bytes,2,opt,name=inferenceId,proto3" json:"inferenceId,omitempty"`
- ResponseHash string `protobuf:"bytes,3,opt,name=responseHash,proto3" json:"responseHash,omitempty"`
- ResponsePayload string `protobuf:"bytes,4,opt,name=responsePayload,proto3" json:"responsePayload,omitempty"`
- PromptTokenCount uint64 `protobuf:"varint,5,opt,name=promptTokenCount,proto3" json:"promptTokenCount,omitempty"`
- CompletionTokenCount uint64 `protobuf:"varint,6,opt,name=completionTokenCount,proto3" json:"completionTokenCount,omitempty"`
- ExecutedBy string `protobuf:"bytes,7,opt,name=executedBy,proto3" json:"executedBy,omitempty"`
+ // participant is the address withdrawing collateral
+ Participant string `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
+ // amount is the collateral to withdraw
+ Amount *v1beta1.Coin `protobuf:"bytes,2,opt,name=amount,proto3" json:"amount,omitempty"`
}
-func (x *MsgFinishInference) Reset() {
- *x = MsgFinishInference{}
+func (x *MsgWithdrawCollateral) Reset() {
+ *x = MsgWithdrawCollateral{}
if protoimpl.UnsafeEnabled {
- mi := &file_inference_inference_tx_proto_msgTypes[4]
+ mi := &file_inference_collateral_tx_proto_msgTypes[4]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
-func (x *MsgFinishInference) String() string {
+func (x *MsgWithdrawCollateral) String() string {
return protoimpl.X.MessageStringOf(x)
}
-func (*MsgFinishInference) ProtoMessage() {}
-
-// Deprecated: Use MsgFinishInference.ProtoReflect.Descriptor instead.
-func (*MsgFinishInference) Descriptor() ([]byte, []int) {
- return file_inference_inference_tx_proto_rawDescGZIP(), []int{4}
-}
-
-func (x *MsgFinishInference) GetCreator() string {
- if x != nil {
- return x.Creator
- }
- return ""
-}
-
-func (x *MsgFinishInference) GetInferenceId() string {
- if x != nil {
- return x.InferenceId
- }
- return ""
-}
+func (*MsgWithdrawCollateral) ProtoMessage() {}
-func (x *MsgFinishInference) GetResponseHash() string {
- if x != nil {
- return x.ResponseHash
- }
- return ""
+// Deprecated: Use MsgWithdrawCollateral.ProtoReflect.Descriptor instead.
+func (*MsgWithdrawCollateral) Descriptor() ([]byte, []int) {
+ return file_inference_collateral_tx_proto_rawDescGZIP(), []int{4}
}
-func (x *MsgFinishInference) GetResponsePayload() string {
+func (x *MsgWithdrawCollateral) GetParticipant() string {
if x != nil {
- return x.ResponsePayload
+ return x.Participant
}
return ""
}
-func (x *MsgFinishInference) GetPromptTokenCount() uint64 {
+func (x *MsgWithdrawCollateral) GetAmount() *v1beta1.Coin {
if x != nil {
- return x.PromptTokenCount
+ return x.Amount
}
- return 0
-}
-
-func (x *MsgFinishInference) GetCompletionTokenCount() uint64 {
- if x != nil {
- return x.CompletionTokenCount
- }
- return 0
-}
-
-func (x *MsgFinishInference) GetExecutedBy() string {
- if x != nil {
- return x.ExecutedBy
- }
- return ""
+ return nil
}
-type MsgFinishInferenceResponse struct {
+// MsgWithdrawCollateralResponse defines the response structure for executing a
+// MsgWithdrawCollateral message.
+type MsgWithdrawCollateralResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
- InferenceIndex string `protobuf:"bytes,1,opt,name=inferenceIndex,proto3" json:"inferenceIndex,omitempty"`
+ // completion_epoch is the epoch when the withdrawal will complete
+ CompletionEpoch uint64 `protobuf:"varint,1,opt,name=completion_epoch,json=completionEpoch,proto3" json:"completion_epoch,omitempty"`
}
-func (x *MsgFinishInferenceResponse) Reset() {
- *x = MsgFinishInferenceResponse{}
+func (x *MsgWithdrawCollateralResponse) Reset() {
+ *x = MsgWithdrawCollateralResponse{}
if protoimpl.UnsafeEnabled {
- mi := &file_inference_inference_tx_proto_msgTypes[5]
+ mi := &file_inference_collateral_tx_proto_msgTypes[5]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
-func (x *MsgFinishInferenceResponse) String() string {
+func (x *MsgWithdrawCollateralResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
-func (*MsgFinishInferenceResponse) ProtoMessage() {}
+func (*MsgWithdrawCollateralResponse) ProtoMessage() {}
-// Deprecated: Use MsgFinishInferenceResponse.ProtoReflect.Descriptor instead.
-func (*MsgFinishInferenceResponse) Descriptor() ([]byte, []int) {
- return file_inference_inference_tx_proto_rawDescGZIP(), []int{5}
+// Deprecated: Use MsgWithdrawCollateralResponse.ProtoReflect.Descriptor instead.
+func (*MsgWithdrawCollateralResponse) Descriptor() ([]byte, []int) {
+ return file_inference_collateral_tx_proto_rawDescGZIP(), []int{5}
}
-func (x *MsgFinishInferenceResponse) GetInferenceIndex() string {
+func (x *MsgWithdrawCollateralResponse) GetCompletionEpoch() uint64 {
if x != nil {
- return x.InferenceIndex
+ return x.CompletionEpoch
}
- return ""
+ return 0
}
-var File_inference_inference_tx_proto protoreflect.FileDescriptor
-
-var file_inference_inference_tx_proto_rawDesc = []byte{
- 0x0a, 0x1c, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65,
- 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x74, 0x78, 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, 0x1a, 0x11, 0x61, 0x6d, 0x69, 0x6e, 0x6f, 0x2f, 0x61, 0x6d, 0x69, 0x6e, 0x6f,
- 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 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, 0x1a, 0x14, 0x67, 0x6f, 0x67, 0x6f,
- 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2e, 0x70, 0x72, 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, 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, 0xc3, 0x01, 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, 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, 0x12, 0x1e, 0x0a, 0x0a, 0x70, 0x72, 0x6f, 0x6d, 0x70, 0x74, 0x48,
- 0x61, 0x73, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x70, 0x72, 0x6f, 0x6d, 0x70,
- 0x74, 0x48, 0x61, 0x73, 0x68, 0x12, 0x24, 0x0a, 0x0d, 0x70, 0x72, 0x6f, 0x6d, 0x70, 0x74, 0x50,
- 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x70, 0x72,
- 0x6f, 0x6d, 0x70, 0x74, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x12, 0x1e, 0x0a, 0x0a, 0x72,
- 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, 0x42, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52,
- 0x0a, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, 0x42, 0x79, 0x3a, 0x0c, 0x82, 0xe7, 0xb0,
- 0x2a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x22, 0x43, 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, 0x26, 0x0a, 0x0e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
- 0x6e, 0x63, 0x65, 0x49, 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, 0x22, 0xac,
- 0x02, 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,
- 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, 0x12, 0x22, 0x0a, 0x0c, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x48, 0x61, 0x73,
- 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
- 0x65, 0x48, 0x61, 0x73, 0x68, 0x12, 0x28, 0x0a, 0x0f, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
- 0x65, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f,
- 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x12,
- 0x2a, 0x0a, 0x10, 0x70, 0x72, 0x6f, 0x6d, 0x70, 0x74, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x43, 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, 0x32, 0x0a, 0x14, 0x63,
- 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x43, 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,
- 0x1e, 0x0a, 0x0a, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x64, 0x42, 0x79, 0x18, 0x07, 0x20,
- 0x01, 0x28, 0x09, 0x52, 0x0a, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x64, 0x42, 0x79, 0x3a,
- 0x0c, 0x82, 0xe7, 0xb0, 0x2a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x22, 0x44, 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, 0x26, 0x0a, 0x0e, 0x69,
- 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x49, 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, 0x32, 0xc7, 0x02, 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, 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, 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, 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 File_inference_collateral_tx_proto protoreflect.FileDescriptor
+
+var file_inference_collateral_tx_proto_rawDesc = []byte{
+ 0x0a, 0x1d, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x63, 0x6f, 0x6c, 0x6c,
+ 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2f, 0x74, 0x78, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12,
+ 0x14, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x63, 0x6f, 0x6c, 0x6c, 0x61,
+ 0x74, 0x65, 0x72, 0x61, 0x6c, 0x1a, 0x11, 0x61, 0x6d, 0x69, 0x6e, 0x6f, 0x2f, 0x61, 0x6d, 0x69,
+ 0x6e, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 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, 0x1a, 0x14, 0x67, 0x6f,
+ 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f,
+ 0x74, 0x6f, 0x1a, 0x21, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x63, 0x6f,
+ 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e,
+ 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x62, 0x61,
+ 0x73, 0x65, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x63, 0x6f, 0x69, 0x6e, 0x2e,
+ 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xc5, 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, 0x3f, 0x0a, 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28,
+ 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x63, 0x6f,
+ 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 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, 0x39, 0x82, 0xe7, 0xb0, 0x2a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69,
+ 0x74, 0x79, 0x8a, 0xe7, 0xb0, 0x2a, 0x26, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+ 0x2f, 0x78, 0x2f, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 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, 0xd2, 0x01, 0x0a, 0x14, 0x4d, 0x73, 0x67,
+ 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61,
+ 0x6c, 0x12, 0x3a, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74,
+ 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, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x12, 0x3c, 0x0a,
+ 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 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, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7,
+ 0xb0, 0x2a, 0x01, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x3a, 0x40, 0x82, 0xe7, 0xb0,
+ 0x2a, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x8a, 0xe7, 0xb0,
+ 0x2a, 0x2b, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x78, 0x2f, 0x63, 0x6f,
+ 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2f, 0x4d, 0x73, 0x67, 0x44, 0x65, 0x70, 0x6f,
+ 0x73, 0x69, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x22, 0x1e, 0x0a,
+ 0x1c, 0x4d, 0x73, 0x67, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x61,
+ 0x74, 0x65, 0x72, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xd4, 0x01,
+ 0x0a, 0x15, 0x4d, 0x73, 0x67, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x43, 0x6f, 0x6c,
+ 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x12, 0x3a, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69,
+ 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 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, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70,
+ 0x61, 0x6e, 0x74, 0x12, 0x3c, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20,
+ 0x01, 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, 0x09,
+ 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e,
+ 0x74, 0x3a, 0x41, 0x82, 0xe7, 0xb0, 0x2a, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70,
+ 0x61, 0x6e, 0x74, 0x8a, 0xe7, 0xb0, 0x2a, 0x2c, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+ 0x65, 0x2f, 0x78, 0x2f, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2f, 0x4d,
+ 0x73, 0x67, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74,
+ 0x65, 0x72, 0x61, 0x6c, 0x22, 0x4a, 0x0a, 0x1d, 0x4d, 0x73, 0x67, 0x57, 0x69, 0x74, 0x68, 0x64,
+ 0x72, 0x61, 0x77, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x52, 0x65, 0x73,
+ 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x29, 0x0a, 0x10, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74,
+ 0x69, 0x6f, 0x6e, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52,
+ 0x0f, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x70, 0x6f, 0x63, 0x68,
+ 0x32, 0xdf, 0x02, 0x0a, 0x03, 0x4d, 0x73, 0x67, 0x12, 0x64, 0x0a, 0x0c, 0x55, 0x70, 0x64, 0x61,
+ 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x25, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+ 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2e,
+ 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x1a,
+ 0x2d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x63, 0x6f, 0x6c, 0x6c,
+ 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 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, 0x73,
+ 0x0a, 0x11, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65,
+ 0x72, 0x61, 0x6c, 0x12, 0x2a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+ 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2e, 0x4d, 0x73, 0x67, 0x44, 0x65,
+ 0x70, 0x6f, 0x73, 0x69, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x1a,
+ 0x32, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x63, 0x6f, 0x6c, 0x6c,
+ 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2e, 0x4d, 0x73, 0x67, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69,
+ 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f,
+ 0x6e, 0x73, 0x65, 0x12, 0x76, 0x0a, 0x12, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x43,
+ 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x12, 0x2b, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+ 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c,
+ 0x2e, 0x4d, 0x73, 0x67, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x43, 0x6f, 0x6c, 0x6c,
+ 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x1a, 0x33, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+ 0x63, 0x65, 0x2e, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2e, 0x4d, 0x73,
+ 0x67, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65,
+ 0x72, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x1a, 0x05, 0x80, 0xe7, 0xb0,
+ 0x2a, 0x01, 0x42, 0xbb, 0x01, 0x0a, 0x18, 0x63, 0x6f, 0x6d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+ 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x42,
+ 0x07, 0x54, 0x78, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x25, 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, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61,
+ 0x6c, 0xa2, 0x02, 0x03, 0x49, 0x43, 0x58, 0xaa, 0x02, 0x14, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65,
+ 0x6e, 0x63, 0x65, 0x2e, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0xca, 0x02,
+ 0x14, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x43, 0x6f, 0x6c, 0x6c, 0x61,
+ 0x74, 0x65, 0x72, 0x61, 0x6c, 0xe2, 0x02, 0x20, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+ 0x65, 0x5c, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x5c, 0x47, 0x50, 0x42,
+ 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x15, 0x49, 0x6e, 0x66, 0x65, 0x72,
+ 0x65, 0x6e, 0x63, 0x65, 0x3a, 0x3a, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c,
+ 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}
var (
- file_inference_inference_tx_proto_rawDescOnce sync.Once
- file_inference_inference_tx_proto_rawDescData = file_inference_inference_tx_proto_rawDesc
+ file_inference_collateral_tx_proto_rawDescOnce sync.Once
+ file_inference_collateral_tx_proto_rawDescData = file_inference_collateral_tx_proto_rawDesc
)
-func file_inference_inference_tx_proto_rawDescGZIP() []byte {
- file_inference_inference_tx_proto_rawDescOnce.Do(func() {
- file_inference_inference_tx_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_inference_tx_proto_rawDescData)
+func file_inference_collateral_tx_proto_rawDescGZIP() []byte {
+ file_inference_collateral_tx_proto_rawDescOnce.Do(func() {
+ file_inference_collateral_tx_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_collateral_tx_proto_rawDescData)
})
- return file_inference_inference_tx_proto_rawDescData
-}
-
-var file_inference_inference_tx_proto_msgTypes = make([]protoimpl.MessageInfo, 6)
-var file_inference_inference_tx_proto_goTypes = []interface{}{
- (*MsgUpdateParams)(nil), // 0: inference.inference.MsgUpdateParams
- (*MsgUpdateParamsResponse)(nil), // 1: inference.inference.MsgUpdateParamsResponse
- (*MsgStartInference)(nil), // 2: inference.inference.MsgStartInference
- (*MsgStartInferenceResponse)(nil), // 3: inference.inference.MsgStartInferenceResponse
- (*MsgFinishInference)(nil), // 4: inference.inference.MsgFinishInference
- (*MsgFinishInferenceResponse)(nil), // 5: inference.inference.MsgFinishInferenceResponse
- (*Params)(nil), // 6: inference.inference.Params
-}
-var file_inference_inference_tx_proto_depIdxs = []int32{
- 6, // 0: inference.inference.MsgUpdateParams.params:type_name -> inference.inference.Params
- 0, // 1: inference.inference.Msg.UpdateParams:input_type -> inference.inference.MsgUpdateParams
- 2, // 2: inference.inference.Msg.StartInference:input_type -> inference.inference.MsgStartInference
- 4, // 3: inference.inference.Msg.FinishInference:input_type -> inference.inference.MsgFinishInference
- 1, // 4: inference.inference.Msg.UpdateParams:output_type -> inference.inference.MsgUpdateParamsResponse
- 3, // 5: inference.inference.Msg.StartInference:output_type -> inference.inference.MsgStartInferenceResponse
- 5, // 6: inference.inference.Msg.FinishInference:output_type -> inference.inference.MsgFinishInferenceResponse
- 4, // [4:7] is the sub-list for method output_type
- 1, // [1:4] is the sub-list for method input_type
- 1, // [1:1] is the sub-list for extension type_name
- 1, // [1:1] is the sub-list for extension extendee
- 0, // [0:1] is the sub-list for field type_name
-}
-
-func init() { file_inference_inference_tx_proto_init() }
-func file_inference_inference_tx_proto_init() {
- if File_inference_inference_tx_proto != nil {
+ return file_inference_collateral_tx_proto_rawDescData
+}
+
+var file_inference_collateral_tx_proto_msgTypes = make([]protoimpl.MessageInfo, 6)
+var file_inference_collateral_tx_proto_goTypes = []interface{}{
+ (*MsgUpdateParams)(nil), // 0: inference.collateral.MsgUpdateParams
+ (*MsgUpdateParamsResponse)(nil), // 1: inference.collateral.MsgUpdateParamsResponse
+ (*MsgDepositCollateral)(nil), // 2: inference.collateral.MsgDepositCollateral
+ (*MsgDepositCollateralResponse)(nil), // 3: inference.collateral.MsgDepositCollateralResponse
+ (*MsgWithdrawCollateral)(nil), // 4: inference.collateral.MsgWithdrawCollateral
+ (*MsgWithdrawCollateralResponse)(nil), // 5: inference.collateral.MsgWithdrawCollateralResponse
+ (*Params)(nil), // 6: inference.collateral.Params
+ (*v1beta1.Coin)(nil), // 7: cosmos.base.v1beta1.Coin
+}
+var file_inference_collateral_tx_proto_depIdxs = []int32{
+ 6, // 0: inference.collateral.MsgUpdateParams.params:type_name -> inference.collateral.Params
+ 7, // 1: inference.collateral.MsgDepositCollateral.amount:type_name -> cosmos.base.v1beta1.Coin
+ 7, // 2: inference.collateral.MsgWithdrawCollateral.amount:type_name -> cosmos.base.v1beta1.Coin
+ 0, // 3: inference.collateral.Msg.UpdateParams:input_type -> inference.collateral.MsgUpdateParams
+ 2, // 4: inference.collateral.Msg.DepositCollateral:input_type -> inference.collateral.MsgDepositCollateral
+ 4, // 5: inference.collateral.Msg.WithdrawCollateral:input_type -> inference.collateral.MsgWithdrawCollateral
+ 1, // 6: inference.collateral.Msg.UpdateParams:output_type -> inference.collateral.MsgUpdateParamsResponse
+ 3, // 7: inference.collateral.Msg.DepositCollateral:output_type -> inference.collateral.MsgDepositCollateralResponse
+ 5, // 8: inference.collateral.Msg.WithdrawCollateral:output_type -> inference.collateral.MsgWithdrawCollateralResponse
+ 6, // [6:9] is the sub-list for method output_type
+ 3, // [3:6] is the sub-list for method input_type
+ 3, // [3:3] is the sub-list for extension type_name
+ 3, // [3:3] is the sub-list for extension extendee
+ 0, // [0:3] is the sub-list for field type_name
+}
+
+func init() { file_inference_collateral_tx_proto_init() }
+func file_inference_collateral_tx_proto_init() {
+ if File_inference_collateral_tx_proto != nil {
return
}
- file_inference_inference_params_proto_init()
+ file_inference_collateral_params_proto_init()
if !protoimpl.UnsafeEnabled {
- file_inference_inference_tx_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ file_inference_collateral_tx_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*MsgUpdateParams); i {
case 0:
return &v.state
@@ -3626,7 +3037,7 @@ func file_inference_inference_tx_proto_init() {
return nil
}
}
- file_inference_inference_tx_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+ file_inference_collateral_tx_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*MsgUpdateParamsResponse); i {
case 0:
return &v.state
@@ -3638,8 +3049,8 @@ func file_inference_inference_tx_proto_init() {
return nil
}
}
- file_inference_inference_tx_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
- switch v := v.(*MsgStartInference); i {
+ file_inference_collateral_tx_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*MsgDepositCollateral); i {
case 0:
return &v.state
case 1:
@@ -3650,8 +3061,8 @@ func file_inference_inference_tx_proto_init() {
return nil
}
}
- file_inference_inference_tx_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
- switch v := v.(*MsgStartInferenceResponse); i {
+ file_inference_collateral_tx_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*MsgDepositCollateralResponse); i {
case 0:
return &v.state
case 1:
@@ -3662,8 +3073,8 @@ func file_inference_inference_tx_proto_init() {
return nil
}
}
- file_inference_inference_tx_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
- switch v := v.(*MsgFinishInference); i {
+ file_inference_collateral_tx_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*MsgWithdrawCollateral); i {
case 0:
return &v.state
case 1:
@@ -3674,8 +3085,8 @@ func file_inference_inference_tx_proto_init() {
return nil
}
}
- file_inference_inference_tx_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
- switch v := v.(*MsgFinishInferenceResponse); i {
+ file_inference_collateral_tx_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*MsgWithdrawCollateralResponse); i {
case 0:
return &v.state
case 1:
@@ -3691,18 +3102,18 @@ func file_inference_inference_tx_proto_init() {
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
- RawDescriptor: file_inference_inference_tx_proto_rawDesc,
+ RawDescriptor: file_inference_collateral_tx_proto_rawDesc,
NumEnums: 0,
NumMessages: 6,
NumExtensions: 0,
NumServices: 1,
},
- GoTypes: file_inference_inference_tx_proto_goTypes,
- DependencyIndexes: file_inference_inference_tx_proto_depIdxs,
- MessageInfos: file_inference_inference_tx_proto_msgTypes,
+ GoTypes: file_inference_collateral_tx_proto_goTypes,
+ DependencyIndexes: file_inference_collateral_tx_proto_depIdxs,
+ MessageInfos: file_inference_collateral_tx_proto_msgTypes,
}.Build()
- File_inference_inference_tx_proto = out.File
- file_inference_inference_tx_proto_rawDesc = nil
- file_inference_inference_tx_proto_goTypes = nil
- file_inference_inference_tx_proto_depIdxs = nil
+ File_inference_collateral_tx_proto = out.File
+ file_inference_collateral_tx_proto_rawDesc = nil
+ file_inference_collateral_tx_proto_goTypes = nil
+ file_inference_collateral_tx_proto_depIdxs = nil
}
diff --git a/inference/api/inference/inference/tx_grpc.pb.go b/inference-chain/api/inference/collateral/tx_grpc.pb.go
similarity index 58%
rename from inference/api/inference/inference/tx_grpc.pb.go
rename to inference-chain/api/inference/collateral/tx_grpc.pb.go
index 9b62af131..889f74f84 100644
--- a/inference/api/inference/inference/tx_grpc.pb.go
+++ b/inference-chain/api/inference/collateral/tx_grpc.pb.go
@@ -2,13 +2,12 @@
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc (unknown)
-// source: inference/inference/tx.proto
+// source: inference/collateral/tx.proto
-package inference
+package collateral
import (
context "context"
-
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
@@ -20,9 +19,9 @@ import (
const _ = grpc.SupportPackageIsVersion7
const (
- Msg_UpdateParams_FullMethodName = "/inference.inference.Msg/UpdateParams"
- Msg_StartInference_FullMethodName = "/inference.inference.Msg/StartInference"
- Msg_FinishInference_FullMethodName = "/inference.inference.Msg/FinishInference"
+ Msg_UpdateParams_FullMethodName = "/inference.collateral.Msg/UpdateParams"
+ Msg_DepositCollateral_FullMethodName = "/inference.collateral.Msg/DepositCollateral"
+ Msg_WithdrawCollateral_FullMethodName = "/inference.collateral.Msg/WithdrawCollateral"
)
// MsgClient is the client API for Msg service.
@@ -32,8 +31,10 @@ 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)
- StartInference(ctx context.Context, in *MsgStartInference, opts ...grpc.CallOption) (*MsgStartInferenceResponse, error)
- FinishInference(ctx context.Context, in *MsgFinishInference, opts ...grpc.CallOption) (*MsgFinishInferenceResponse, error)
+ // DepositCollateral deposits collateral for the participant
+ DepositCollateral(ctx context.Context, in *MsgDepositCollateral, opts ...grpc.CallOption) (*MsgDepositCollateralResponse, error)
+ // WithdrawCollateral initiates withdrawal of collateral (subject to unbonding period)
+ WithdrawCollateral(ctx context.Context, in *MsgWithdrawCollateral, opts ...grpc.CallOption) (*MsgWithdrawCollateralResponse, error)
}
type msgClient struct {
@@ -53,18 +54,18 @@ func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts
return out, nil
}
-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...)
+func (c *msgClient) DepositCollateral(ctx context.Context, in *MsgDepositCollateral, opts ...grpc.CallOption) (*MsgDepositCollateralResponse, error) {
+ out := new(MsgDepositCollateralResponse)
+ err := c.cc.Invoke(ctx, Msg_DepositCollateral_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
-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...)
+func (c *msgClient) WithdrawCollateral(ctx context.Context, in *MsgWithdrawCollateral, opts ...grpc.CallOption) (*MsgWithdrawCollateralResponse, error) {
+ out := new(MsgWithdrawCollateralResponse)
+ err := c.cc.Invoke(ctx, Msg_WithdrawCollateral_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
@@ -78,8 +79,10 @@ 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)
- StartInference(context.Context, *MsgStartInference) (*MsgStartInferenceResponse, error)
- FinishInference(context.Context, *MsgFinishInference) (*MsgFinishInferenceResponse, error)
+ // DepositCollateral deposits collateral for the participant
+ DepositCollateral(context.Context, *MsgDepositCollateral) (*MsgDepositCollateralResponse, error)
+ // WithdrawCollateral initiates withdrawal of collateral (subject to unbonding period)
+ WithdrawCollateral(context.Context, *MsgWithdrawCollateral) (*MsgWithdrawCollateralResponse, error)
mustEmbedUnimplementedMsgServer()
}
@@ -90,11 +93,11 @@ type UnimplementedMsgServer struct {
func (UnimplementedMsgServer) UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method UpdateParams not implemented")
}
-func (UnimplementedMsgServer) StartInference(context.Context, *MsgStartInference) (*MsgStartInferenceResponse, error) {
- return nil, status.Errorf(codes.Unimplemented, "method StartInference not implemented")
+func (UnimplementedMsgServer) DepositCollateral(context.Context, *MsgDepositCollateral) (*MsgDepositCollateralResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method DepositCollateral not implemented")
}
-func (UnimplementedMsgServer) FinishInference(context.Context, *MsgFinishInference) (*MsgFinishInferenceResponse, error) {
- return nil, status.Errorf(codes.Unimplemented, "method FinishInference not implemented")
+func (UnimplementedMsgServer) WithdrawCollateral(context.Context, *MsgWithdrawCollateral) (*MsgWithdrawCollateralResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method WithdrawCollateral not implemented")
}
func (UnimplementedMsgServer) mustEmbedUnimplementedMsgServer() {}
@@ -127,38 +130,38 @@ func _Msg_UpdateParams_Handler(srv interface{}, ctx context.Context, dec func(in
return interceptor(ctx, in, info, handler)
}
-func _Msg_StartInference_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(MsgStartInference)
+func _Msg_DepositCollateral_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(MsgDepositCollateral)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
- return srv.(MsgServer).StartInference(ctx, in)
+ return srv.(MsgServer).DepositCollateral(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
- FullMethod: Msg_StartInference_FullMethodName,
+ FullMethod: Msg_DepositCollateral_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(MsgServer).StartInference(ctx, req.(*MsgStartInference))
+ return srv.(MsgServer).DepositCollateral(ctx, req.(*MsgDepositCollateral))
}
return interceptor(ctx, in, info, handler)
}
-func _Msg_FinishInference_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(MsgFinishInference)
+func _Msg_WithdrawCollateral_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(MsgWithdrawCollateral)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
- return srv.(MsgServer).FinishInference(ctx, in)
+ return srv.(MsgServer).WithdrawCollateral(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
- FullMethod: Msg_FinishInference_FullMethodName,
+ FullMethod: Msg_WithdrawCollateral_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(MsgServer).FinishInference(ctx, req.(*MsgFinishInference))
+ return srv.(MsgServer).WithdrawCollateral(ctx, req.(*MsgWithdrawCollateral))
}
return interceptor(ctx, in, info, handler)
}
@@ -167,7 +170,7 @@ func _Msg_FinishInference_Handler(srv interface{}, ctx context.Context, dec func
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var Msg_ServiceDesc = grpc.ServiceDesc{
- ServiceName: "inference.inference.Msg",
+ ServiceName: "inference.collateral.Msg",
HandlerType: (*MsgServer)(nil),
Methods: []grpc.MethodDesc{
{
@@ -175,14 +178,14 @@ var Msg_ServiceDesc = grpc.ServiceDesc{
Handler: _Msg_UpdateParams_Handler,
},
{
- MethodName: "StartInference",
- Handler: _Msg_StartInference_Handler,
+ MethodName: "DepositCollateral",
+ Handler: _Msg_DepositCollateral_Handler,
},
{
- MethodName: "FinishInference",
- Handler: _Msg_FinishInference_Handler,
+ MethodName: "WithdrawCollateral",
+ Handler: _Msg_WithdrawCollateral_Handler,
},
},
Streams: []grpc.StreamDesc{},
- Metadata: "inference/inference/tx.proto",
+ Metadata: "inference/collateral/tx.proto",
}
diff --git a/inference-chain/api/inference/collateral/unbonding.pulsar.go b/inference-chain/api/inference/collateral/unbonding.pulsar.go
new file mode 100644
index 000000000..45020ce3f
--- /dev/null
+++ b/inference-chain/api/inference/collateral/unbonding.pulsar.go
@@ -0,0 +1,730 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package collateral
+
+import (
+ v1beta1 "cosmossdk.io/api/cosmos/base/v1beta1"
+ fmt "fmt"
+ runtime "github.com/cosmos/cosmos-proto/runtime"
+ _ "github.com/cosmos/gogoproto/gogoproto"
+ 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_UnbondingCollateral protoreflect.MessageDescriptor
+ fd_UnbondingCollateral_participant protoreflect.FieldDescriptor
+ fd_UnbondingCollateral_amount protoreflect.FieldDescriptor
+ fd_UnbondingCollateral_completion_epoch protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_collateral_unbonding_proto_init()
+ md_UnbondingCollateral = File_inference_collateral_unbonding_proto.Messages().ByName("UnbondingCollateral")
+ fd_UnbondingCollateral_participant = md_UnbondingCollateral.Fields().ByName("participant")
+ fd_UnbondingCollateral_amount = md_UnbondingCollateral.Fields().ByName("amount")
+ fd_UnbondingCollateral_completion_epoch = md_UnbondingCollateral.Fields().ByName("completion_epoch")
+}
+
+var _ protoreflect.Message = (*fastReflection_UnbondingCollateral)(nil)
+
+type fastReflection_UnbondingCollateral UnbondingCollateral
+
+func (x *UnbondingCollateral) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_UnbondingCollateral)(x)
+}
+
+func (x *UnbondingCollateral) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_collateral_unbonding_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_UnbondingCollateral_messageType fastReflection_UnbondingCollateral_messageType
+var _ protoreflect.MessageType = fastReflection_UnbondingCollateral_messageType{}
+
+type fastReflection_UnbondingCollateral_messageType struct{}
+
+func (x fastReflection_UnbondingCollateral_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_UnbondingCollateral)(nil)
+}
+func (x fastReflection_UnbondingCollateral_messageType) New() protoreflect.Message {
+ return new(fastReflection_UnbondingCollateral)
+}
+func (x fastReflection_UnbondingCollateral_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_UnbondingCollateral
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_UnbondingCollateral) Descriptor() protoreflect.MessageDescriptor {
+ return md_UnbondingCollateral
+}
+
+// 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_UnbondingCollateral) Type() protoreflect.MessageType {
+ return _fastReflection_UnbondingCollateral_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_UnbondingCollateral) New() protoreflect.Message {
+ return new(fastReflection_UnbondingCollateral)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_UnbondingCollateral) Interface() protoreflect.ProtoMessage {
+ return (*UnbondingCollateral)(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_UnbondingCollateral) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Participant != "" {
+ value := protoreflect.ValueOfString(x.Participant)
+ if !f(fd_UnbondingCollateral_participant, value) {
+ return
+ }
+ }
+ if x.Amount != nil {
+ value := protoreflect.ValueOfMessage(x.Amount.ProtoReflect())
+ if !f(fd_UnbondingCollateral_amount, value) {
+ return
+ }
+ }
+ if x.CompletionEpoch != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.CompletionEpoch)
+ if !f(fd_UnbondingCollateral_completion_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_UnbondingCollateral) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.collateral.UnbondingCollateral.participant":
+ return x.Participant != ""
+ case "inference.collateral.UnbondingCollateral.amount":
+ return x.Amount != nil
+ case "inference.collateral.UnbondingCollateral.completion_epoch":
+ return x.CompletionEpoch != uint64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.UnbondingCollateral"))
+ }
+ panic(fmt.Errorf("message inference.collateral.UnbondingCollateral 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_UnbondingCollateral) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.collateral.UnbondingCollateral.participant":
+ x.Participant = ""
+ case "inference.collateral.UnbondingCollateral.amount":
+ x.Amount = nil
+ case "inference.collateral.UnbondingCollateral.completion_epoch":
+ x.CompletionEpoch = uint64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.UnbondingCollateral"))
+ }
+ panic(fmt.Errorf("message inference.collateral.UnbondingCollateral 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_UnbondingCollateral) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.collateral.UnbondingCollateral.participant":
+ value := x.Participant
+ return protoreflect.ValueOfString(value)
+ case "inference.collateral.UnbondingCollateral.amount":
+ value := x.Amount
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.collateral.UnbondingCollateral.completion_epoch":
+ value := x.CompletionEpoch
+ return protoreflect.ValueOfUint64(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.UnbondingCollateral"))
+ }
+ panic(fmt.Errorf("message inference.collateral.UnbondingCollateral 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_UnbondingCollateral) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.collateral.UnbondingCollateral.participant":
+ x.Participant = value.Interface().(string)
+ case "inference.collateral.UnbondingCollateral.amount":
+ x.Amount = value.Message().Interface().(*v1beta1.Coin)
+ case "inference.collateral.UnbondingCollateral.completion_epoch":
+ x.CompletionEpoch = value.Uint()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.UnbondingCollateral"))
+ }
+ panic(fmt.Errorf("message inference.collateral.UnbondingCollateral 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_UnbondingCollateral) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.collateral.UnbondingCollateral.amount":
+ if x.Amount == nil {
+ x.Amount = new(v1beta1.Coin)
+ }
+ return protoreflect.ValueOfMessage(x.Amount.ProtoReflect())
+ case "inference.collateral.UnbondingCollateral.participant":
+ panic(fmt.Errorf("field participant of message inference.collateral.UnbondingCollateral is not mutable"))
+ case "inference.collateral.UnbondingCollateral.completion_epoch":
+ panic(fmt.Errorf("field completion_epoch of message inference.collateral.UnbondingCollateral is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.UnbondingCollateral"))
+ }
+ panic(fmt.Errorf("message inference.collateral.UnbondingCollateral 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_UnbondingCollateral) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.collateral.UnbondingCollateral.participant":
+ return protoreflect.ValueOfString("")
+ case "inference.collateral.UnbondingCollateral.amount":
+ m := new(v1beta1.Coin)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.collateral.UnbondingCollateral.completion_epoch":
+ return protoreflect.ValueOfUint64(uint64(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.collateral.UnbondingCollateral"))
+ }
+ panic(fmt.Errorf("message inference.collateral.UnbondingCollateral 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_UnbondingCollateral) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.collateral.UnbondingCollateral", 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_UnbondingCollateral) 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_UnbondingCollateral) 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_UnbondingCollateral) 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_UnbondingCollateral) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*UnbondingCollateral)
+ 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.Amount != nil {
+ l = options.Size(x.Amount)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.CompletionEpoch != 0 {
+ n += 1 + runtime.Sov(uint64(x.CompletionEpoch))
+ }
+ 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().(*UnbondingCollateral)
+ 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.CompletionEpoch != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.CompletionEpoch))
+ i--
+ dAtA[i] = 0x18
+ }
+ if x.Amount != nil {
+ encoded, err := options.Marshal(x.Amount)
+ 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().(*UnbondingCollateral)
+ 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: UnbondingCollateral: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: UnbondingCollateral: 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 Amount", 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.Amount == nil {
+ x.Amount = &v1beta1.Coin{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Amount); 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 CompletionEpoch", wireType)
+ }
+ x.CompletionEpoch = 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.CompletionEpoch |= 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,
+ }
+}
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// protoc-gen-go v1.27.0
+// protoc (unknown)
+// source: inference/collateral/unbonding.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)
+)
+
+// UnbondingCollateral represents collateral that is in the process of being withdrawn
+type UnbondingCollateral struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // participant is the address of the participant withdrawing collateral
+ Participant string `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
+ // amount is the collateral amount being withdrawn
+ Amount *v1beta1.Coin `protobuf:"bytes,2,opt,name=amount,proto3" json:"amount,omitempty"`
+ // completion_epoch is the epoch when the funds will be released
+ CompletionEpoch uint64 `protobuf:"varint,3,opt,name=completion_epoch,json=completionEpoch,proto3" json:"completion_epoch,omitempty"`
+}
+
+func (x *UnbondingCollateral) Reset() {
+ *x = UnbondingCollateral{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_collateral_unbonding_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *UnbondingCollateral) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*UnbondingCollateral) ProtoMessage() {}
+
+// Deprecated: Use UnbondingCollateral.ProtoReflect.Descriptor instead.
+func (*UnbondingCollateral) Descriptor() ([]byte, []int) {
+ return file_inference_collateral_unbonding_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *UnbondingCollateral) GetParticipant() string {
+ if x != nil {
+ return x.Participant
+ }
+ return ""
+}
+
+func (x *UnbondingCollateral) GetAmount() *v1beta1.Coin {
+ if x != nil {
+ return x.Amount
+ }
+ return nil
+}
+
+func (x *UnbondingCollateral) GetCompletionEpoch() uint64 {
+ if x != nil {
+ return x.CompletionEpoch
+ }
+ return 0
+}
+
+var File_inference_collateral_unbonding_proto protoreflect.FileDescriptor
+
+var file_inference_collateral_unbonding_proto_rawDesc = []byte{
+ 0x0a, 0x24, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x63, 0x6f, 0x6c, 0x6c,
+ 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2f, 0x75, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67,
+ 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x14, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+ 0x65, 0x2e, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x1a, 0x14, 0x67, 0x6f,
+ 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f,
+ 0x74, 0x6f, 0x1a, 0x1e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x62, 0x61, 0x73, 0x65, 0x2f,
+ 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x63, 0x6f, 0x69, 0x6e, 0x2e, 0x70, 0x72, 0x6f,
+ 0x74, 0x6f, 0x22, 0x9b, 0x01, 0x0a, 0x13, 0x55, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67,
+ 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 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, 0x37, 0x0a, 0x06,
+ 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 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, 0x06, 0x61,
+ 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x29, 0x0a, 0x10, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74,
+ 0x69, 0x6f, 0x6e, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52,
+ 0x0f, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x70, 0x6f, 0x63, 0x68,
+ 0x42, 0xc2, 0x01, 0x0a, 0x18, 0x63, 0x6f, 0x6d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+ 0x63, 0x65, 0x2e, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x42, 0x0e, 0x55,
+ 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a,
+ 0x25, 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, 0x63, 0x6f, 0x6c, 0x6c,
+ 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0xa2, 0x02, 0x03, 0x49, 0x43, 0x58, 0xaa, 0x02, 0x14, 0x49,
+ 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65,
+ 0x72, 0x61, 0x6c, 0xca, 0x02, 0x14, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c,
+ 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0xe2, 0x02, 0x20, 0x49, 0x6e, 0x66,
+ 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61,
+ 0x6c, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x15,
+ 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x3a, 0x3a, 0x43, 0x6f, 0x6c, 0x6c, 0x61,
+ 0x74, 0x65, 0x72, 0x61, 0x6c, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+ file_inference_collateral_unbonding_proto_rawDescOnce sync.Once
+ file_inference_collateral_unbonding_proto_rawDescData = file_inference_collateral_unbonding_proto_rawDesc
+)
+
+func file_inference_collateral_unbonding_proto_rawDescGZIP() []byte {
+ file_inference_collateral_unbonding_proto_rawDescOnce.Do(func() {
+ file_inference_collateral_unbonding_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_collateral_unbonding_proto_rawDescData)
+ })
+ return file_inference_collateral_unbonding_proto_rawDescData
+}
+
+var file_inference_collateral_unbonding_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_inference_collateral_unbonding_proto_goTypes = []interface{}{
+ (*UnbondingCollateral)(nil), // 0: inference.collateral.UnbondingCollateral
+ (*v1beta1.Coin)(nil), // 1: cosmos.base.v1beta1.Coin
+}
+var file_inference_collateral_unbonding_proto_depIdxs = []int32{
+ 1, // 0: inference.collateral.UnbondingCollateral.amount:type_name -> cosmos.base.v1beta1.Coin
+ 1, // [1:1] is the sub-list for method output_type
+ 1, // [1:1] is the sub-list for method input_type
+ 1, // [1:1] is the sub-list for extension type_name
+ 1, // [1:1] is the sub-list for extension extendee
+ 0, // [0:1] is the sub-list for field type_name
+}
+
+func init() { file_inference_collateral_unbonding_proto_init() }
+func file_inference_collateral_unbonding_proto_init() {
+ if File_inference_collateral_unbonding_proto != nil {
+ return
+ }
+ if !protoimpl.UnsafeEnabled {
+ file_inference_collateral_unbonding_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*UnbondingCollateral); 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_collateral_unbonding_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 1,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_collateral_unbonding_proto_goTypes,
+ DependencyIndexes: file_inference_collateral_unbonding_proto_depIdxs,
+ MessageInfos: file_inference_collateral_unbonding_proto_msgTypes,
+ }.Build()
+ File_inference_collateral_unbonding_proto = out.File
+ file_inference_collateral_unbonding_proto_rawDesc = nil
+ file_inference_collateral_unbonding_proto_goTypes = nil
+ file_inference_collateral_unbonding_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/genesistransfer/genesis.pulsar.go b/inference-chain/api/inference/genesistransfer/genesis.pulsar.go
new file mode 100644
index 000000000..0000e46ce
--- /dev/null
+++ b/inference-chain/api/inference/genesistransfer/genesis.pulsar.go
@@ -0,0 +1,1635 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package genesistransfer
+
+import (
+ _ "cosmossdk.io/api/amino"
+ fmt "fmt"
+ runtime "github.com/cosmos/cosmos-proto/runtime"
+ _ "github.com/cosmos/gogoproto/gogoproto"
+ 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 _ protoreflect.List = (*_TransferRecord_5_list)(nil)
+
+type _TransferRecord_5_list struct {
+ list *[]string
+}
+
+func (x *_TransferRecord_5_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_TransferRecord_5_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfString((*x.list)[i])
+}
+
+func (x *_TransferRecord_5_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.String()
+ concreteValue := valueUnwrapped
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_TransferRecord_5_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.String()
+ concreteValue := valueUnwrapped
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_TransferRecord_5_list) AppendMutable() protoreflect.Value {
+ panic(fmt.Errorf("AppendMutable can not be called on message TransferRecord at list field TransferredDenoms as it is not of Message kind"))
+}
+
+func (x *_TransferRecord_5_list) Truncate(n int) {
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_TransferRecord_5_list) NewElement() protoreflect.Value {
+ v := ""
+ return protoreflect.ValueOfString(v)
+}
+
+func (x *_TransferRecord_5_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_TransferRecord protoreflect.MessageDescriptor
+ fd_TransferRecord_genesis_address protoreflect.FieldDescriptor
+ fd_TransferRecord_recipient_address protoreflect.FieldDescriptor
+ fd_TransferRecord_transfer_height protoreflect.FieldDescriptor
+ fd_TransferRecord_completed protoreflect.FieldDescriptor
+ fd_TransferRecord_transferred_denoms protoreflect.FieldDescriptor
+ fd_TransferRecord_transfer_amount protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_genesistransfer_genesis_proto_init()
+ md_TransferRecord = File_inference_genesistransfer_genesis_proto.Messages().ByName("TransferRecord")
+ fd_TransferRecord_genesis_address = md_TransferRecord.Fields().ByName("genesis_address")
+ fd_TransferRecord_recipient_address = md_TransferRecord.Fields().ByName("recipient_address")
+ fd_TransferRecord_transfer_height = md_TransferRecord.Fields().ByName("transfer_height")
+ fd_TransferRecord_completed = md_TransferRecord.Fields().ByName("completed")
+ fd_TransferRecord_transferred_denoms = md_TransferRecord.Fields().ByName("transferred_denoms")
+ fd_TransferRecord_transfer_amount = md_TransferRecord.Fields().ByName("transfer_amount")
+}
+
+var _ protoreflect.Message = (*fastReflection_TransferRecord)(nil)
+
+type fastReflection_TransferRecord TransferRecord
+
+func (x *TransferRecord) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_TransferRecord)(x)
+}
+
+func (x *TransferRecord) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_genesistransfer_genesis_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_TransferRecord_messageType fastReflection_TransferRecord_messageType
+var _ protoreflect.MessageType = fastReflection_TransferRecord_messageType{}
+
+type fastReflection_TransferRecord_messageType struct{}
+
+func (x fastReflection_TransferRecord_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_TransferRecord)(nil)
+}
+func (x fastReflection_TransferRecord_messageType) New() protoreflect.Message {
+ return new(fastReflection_TransferRecord)
+}
+func (x fastReflection_TransferRecord_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_TransferRecord
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_TransferRecord) Descriptor() protoreflect.MessageDescriptor {
+ return md_TransferRecord
+}
+
+// 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_TransferRecord) Type() protoreflect.MessageType {
+ return _fastReflection_TransferRecord_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_TransferRecord) New() protoreflect.Message {
+ return new(fastReflection_TransferRecord)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_TransferRecord) Interface() protoreflect.ProtoMessage {
+ return (*TransferRecord)(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_TransferRecord) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.GenesisAddress != "" {
+ value := protoreflect.ValueOfString(x.GenesisAddress)
+ if !f(fd_TransferRecord_genesis_address, value) {
+ return
+ }
+ }
+ if x.RecipientAddress != "" {
+ value := protoreflect.ValueOfString(x.RecipientAddress)
+ if !f(fd_TransferRecord_recipient_address, value) {
+ return
+ }
+ }
+ if x.TransferHeight != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.TransferHeight)
+ if !f(fd_TransferRecord_transfer_height, value) {
+ return
+ }
+ }
+ if x.Completed != false {
+ value := protoreflect.ValueOfBool(x.Completed)
+ if !f(fd_TransferRecord_completed, value) {
+ return
+ }
+ }
+ if len(x.TransferredDenoms) != 0 {
+ value := protoreflect.ValueOfList(&_TransferRecord_5_list{list: &x.TransferredDenoms})
+ if !f(fd_TransferRecord_transferred_denoms, value) {
+ return
+ }
+ }
+ if x.TransferAmount != "" {
+ value := protoreflect.ValueOfString(x.TransferAmount)
+ if !f(fd_TransferRecord_transfer_amount, 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_TransferRecord) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.genesistransfer.TransferRecord.genesis_address":
+ return x.GenesisAddress != ""
+ case "inference.genesistransfer.TransferRecord.recipient_address":
+ return x.RecipientAddress != ""
+ case "inference.genesistransfer.TransferRecord.transfer_height":
+ return x.TransferHeight != uint64(0)
+ case "inference.genesistransfer.TransferRecord.completed":
+ return x.Completed != false
+ case "inference.genesistransfer.TransferRecord.transferred_denoms":
+ return len(x.TransferredDenoms) != 0
+ case "inference.genesistransfer.TransferRecord.transfer_amount":
+ return x.TransferAmount != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.TransferRecord"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.TransferRecord 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_TransferRecord) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.genesistransfer.TransferRecord.genesis_address":
+ x.GenesisAddress = ""
+ case "inference.genesistransfer.TransferRecord.recipient_address":
+ x.RecipientAddress = ""
+ case "inference.genesistransfer.TransferRecord.transfer_height":
+ x.TransferHeight = uint64(0)
+ case "inference.genesistransfer.TransferRecord.completed":
+ x.Completed = false
+ case "inference.genesistransfer.TransferRecord.transferred_denoms":
+ x.TransferredDenoms = nil
+ case "inference.genesistransfer.TransferRecord.transfer_amount":
+ x.TransferAmount = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.TransferRecord"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.TransferRecord 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_TransferRecord) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.genesistransfer.TransferRecord.genesis_address":
+ value := x.GenesisAddress
+ return protoreflect.ValueOfString(value)
+ case "inference.genesistransfer.TransferRecord.recipient_address":
+ value := x.RecipientAddress
+ return protoreflect.ValueOfString(value)
+ case "inference.genesistransfer.TransferRecord.transfer_height":
+ value := x.TransferHeight
+ return protoreflect.ValueOfUint64(value)
+ case "inference.genesistransfer.TransferRecord.completed":
+ value := x.Completed
+ return protoreflect.ValueOfBool(value)
+ case "inference.genesistransfer.TransferRecord.transferred_denoms":
+ if len(x.TransferredDenoms) == 0 {
+ return protoreflect.ValueOfList(&_TransferRecord_5_list{})
+ }
+ listValue := &_TransferRecord_5_list{list: &x.TransferredDenoms}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.genesistransfer.TransferRecord.transfer_amount":
+ value := x.TransferAmount
+ return protoreflect.ValueOfString(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.TransferRecord"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.TransferRecord 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_TransferRecord) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.genesistransfer.TransferRecord.genesis_address":
+ x.GenesisAddress = value.Interface().(string)
+ case "inference.genesistransfer.TransferRecord.recipient_address":
+ x.RecipientAddress = value.Interface().(string)
+ case "inference.genesistransfer.TransferRecord.transfer_height":
+ x.TransferHeight = value.Uint()
+ case "inference.genesistransfer.TransferRecord.completed":
+ x.Completed = value.Bool()
+ case "inference.genesistransfer.TransferRecord.transferred_denoms":
+ lv := value.List()
+ clv := lv.(*_TransferRecord_5_list)
+ x.TransferredDenoms = *clv.list
+ case "inference.genesistransfer.TransferRecord.transfer_amount":
+ x.TransferAmount = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.TransferRecord"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.TransferRecord 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_TransferRecord) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.genesistransfer.TransferRecord.transferred_denoms":
+ if x.TransferredDenoms == nil {
+ x.TransferredDenoms = []string{}
+ }
+ value := &_TransferRecord_5_list{list: &x.TransferredDenoms}
+ return protoreflect.ValueOfList(value)
+ case "inference.genesistransfer.TransferRecord.genesis_address":
+ panic(fmt.Errorf("field genesis_address of message inference.genesistransfer.TransferRecord is not mutable"))
+ case "inference.genesistransfer.TransferRecord.recipient_address":
+ panic(fmt.Errorf("field recipient_address of message inference.genesistransfer.TransferRecord is not mutable"))
+ case "inference.genesistransfer.TransferRecord.transfer_height":
+ panic(fmt.Errorf("field transfer_height of message inference.genesistransfer.TransferRecord is not mutable"))
+ case "inference.genesistransfer.TransferRecord.completed":
+ panic(fmt.Errorf("field completed of message inference.genesistransfer.TransferRecord is not mutable"))
+ case "inference.genesistransfer.TransferRecord.transfer_amount":
+ panic(fmt.Errorf("field transfer_amount of message inference.genesistransfer.TransferRecord is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.TransferRecord"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.TransferRecord 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_TransferRecord) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.genesistransfer.TransferRecord.genesis_address":
+ return protoreflect.ValueOfString("")
+ case "inference.genesistransfer.TransferRecord.recipient_address":
+ return protoreflect.ValueOfString("")
+ case "inference.genesistransfer.TransferRecord.transfer_height":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.genesistransfer.TransferRecord.completed":
+ return protoreflect.ValueOfBool(false)
+ case "inference.genesistransfer.TransferRecord.transferred_denoms":
+ list := []string{}
+ return protoreflect.ValueOfList(&_TransferRecord_5_list{list: &list})
+ case "inference.genesistransfer.TransferRecord.transfer_amount":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.TransferRecord"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.TransferRecord 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_TransferRecord) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.genesistransfer.TransferRecord", 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_TransferRecord) 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_TransferRecord) 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_TransferRecord) 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_TransferRecord) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*TransferRecord)
+ 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.GenesisAddress)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ l = len(x.RecipientAddress)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.TransferHeight != 0 {
+ n += 1 + runtime.Sov(uint64(x.TransferHeight))
+ }
+ if x.Completed {
+ n += 2
+ }
+ if len(x.TransferredDenoms) > 0 {
+ for _, s := range x.TransferredDenoms {
+ l = len(s)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ }
+ l = len(x.TransferAmount)
+ 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().(*TransferRecord)
+ 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.TransferAmount) > 0 {
+ i -= len(x.TransferAmount)
+ copy(dAtA[i:], x.TransferAmount)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.TransferAmount)))
+ i--
+ dAtA[i] = 0x32
+ }
+ if len(x.TransferredDenoms) > 0 {
+ for iNdEx := len(x.TransferredDenoms) - 1; iNdEx >= 0; iNdEx-- {
+ i -= len(x.TransferredDenoms[iNdEx])
+ copy(dAtA[i:], x.TransferredDenoms[iNdEx])
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.TransferredDenoms[iNdEx])))
+ i--
+ dAtA[i] = 0x2a
+ }
+ }
+ if x.Completed {
+ i--
+ if x.Completed {
+ dAtA[i] = 1
+ } else {
+ dAtA[i] = 0
+ }
+ i--
+ dAtA[i] = 0x20
+ }
+ if x.TransferHeight != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.TransferHeight))
+ i--
+ dAtA[i] = 0x18
+ }
+ if len(x.RecipientAddress) > 0 {
+ i -= len(x.RecipientAddress)
+ copy(dAtA[i:], x.RecipientAddress)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.RecipientAddress)))
+ i--
+ dAtA[i] = 0x12
+ }
+ if len(x.GenesisAddress) > 0 {
+ i -= len(x.GenesisAddress)
+ copy(dAtA[i:], x.GenesisAddress)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.GenesisAddress)))
+ 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().(*TransferRecord)
+ 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: TransferRecord: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TransferRecord: 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 GenesisAddress", 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.GenesisAddress = 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 RecipientAddress", 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.RecipientAddress = 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 TransferHeight", wireType)
+ }
+ x.TransferHeight = 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.TransferHeight |= 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 Completed", 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.Completed = 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 TransferredDenoms", 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.TransferredDenoms = append(x.TransferredDenoms, 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 TransferAmount", 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.TransferAmount = 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 = (*_GenesisState_2_list)(nil)
+
+type _GenesisState_2_list struct {
+ list *[]*TransferRecord
+}
+
+func (x *_GenesisState_2_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_GenesisState_2_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_GenesisState_2_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*TransferRecord)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_GenesisState_2_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*TransferRecord)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_GenesisState_2_list) AppendMutable() protoreflect.Value {
+ v := new(TransferRecord)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_GenesisState_2_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_GenesisState_2_list) NewElement() protoreflect.Value {
+ v := new(TransferRecord)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_GenesisState_2_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_GenesisState protoreflect.MessageDescriptor
+ fd_GenesisState_params protoreflect.FieldDescriptor
+ fd_GenesisState_transfer_records protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_genesistransfer_genesis_proto_init()
+ md_GenesisState = File_inference_genesistransfer_genesis_proto.Messages().ByName("GenesisState")
+ fd_GenesisState_params = md_GenesisState.Fields().ByName("params")
+ fd_GenesisState_transfer_records = md_GenesisState.Fields().ByName("transfer_records")
+}
+
+var _ protoreflect.Message = (*fastReflection_GenesisState)(nil)
+
+type fastReflection_GenesisState GenesisState
+
+func (x *GenesisState) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_GenesisState)(x)
+}
+
+func (x *GenesisState) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_genesistransfer_genesis_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_GenesisState_messageType fastReflection_GenesisState_messageType
+var _ protoreflect.MessageType = fastReflection_GenesisState_messageType{}
+
+type fastReflection_GenesisState_messageType struct{}
+
+func (x fastReflection_GenesisState_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_GenesisState)(nil)
+}
+func (x fastReflection_GenesisState_messageType) New() protoreflect.Message {
+ return new(fastReflection_GenesisState)
+}
+func (x fastReflection_GenesisState_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_GenesisState
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_GenesisState) Descriptor() protoreflect.MessageDescriptor {
+ return md_GenesisState
+}
+
+// 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_GenesisState) Type() protoreflect.MessageType {
+ return _fastReflection_GenesisState_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_GenesisState) New() protoreflect.Message {
+ return new(fastReflection_GenesisState)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_GenesisState) Interface() protoreflect.ProtoMessage {
+ return (*GenesisState)(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_GenesisState) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Params != nil {
+ value := protoreflect.ValueOfMessage(x.Params.ProtoReflect())
+ if !f(fd_GenesisState_params, value) {
+ return
+ }
+ }
+ if len(x.TransferRecords) != 0 {
+ value := protoreflect.ValueOfList(&_GenesisState_2_list{list: &x.TransferRecords})
+ if !f(fd_GenesisState_transfer_records, 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_GenesisState) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.genesistransfer.GenesisState.params":
+ return x.Params != nil
+ case "inference.genesistransfer.GenesisState.transfer_records":
+ return len(x.TransferRecords) != 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.GenesisState"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.GenesisState 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_GenesisState) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.genesistransfer.GenesisState.params":
+ x.Params = nil
+ case "inference.genesistransfer.GenesisState.transfer_records":
+ x.TransferRecords = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.GenesisState"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.GenesisState 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_GenesisState) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.genesistransfer.GenesisState.params":
+ value := x.Params
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.genesistransfer.GenesisState.transfer_records":
+ if len(x.TransferRecords) == 0 {
+ return protoreflect.ValueOfList(&_GenesisState_2_list{})
+ }
+ listValue := &_GenesisState_2_list{list: &x.TransferRecords}
+ return protoreflect.ValueOfList(listValue)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.GenesisState"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.GenesisState 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_GenesisState) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.genesistransfer.GenesisState.params":
+ x.Params = value.Message().Interface().(*Params)
+ case "inference.genesistransfer.GenesisState.transfer_records":
+ lv := value.List()
+ clv := lv.(*_GenesisState_2_list)
+ x.TransferRecords = *clv.list
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.GenesisState"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.GenesisState 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_GenesisState) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.genesistransfer.GenesisState.params":
+ if x.Params == nil {
+ x.Params = new(Params)
+ }
+ return protoreflect.ValueOfMessage(x.Params.ProtoReflect())
+ case "inference.genesistransfer.GenesisState.transfer_records":
+ if x.TransferRecords == nil {
+ x.TransferRecords = []*TransferRecord{}
+ }
+ value := &_GenesisState_2_list{list: &x.TransferRecords}
+ return protoreflect.ValueOfList(value)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.GenesisState"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.GenesisState 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_GenesisState) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.genesistransfer.GenesisState.params":
+ m := new(Params)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.genesistransfer.GenesisState.transfer_records":
+ list := []*TransferRecord{}
+ return protoreflect.ValueOfList(&_GenesisState_2_list{list: &list})
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.GenesisState"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.GenesisState 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_GenesisState) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.genesistransfer.GenesisState", 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_GenesisState) 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_GenesisState) 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_GenesisState) 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_GenesisState) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*GenesisState)
+ 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.Params != nil {
+ l = options.Size(x.Params)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if len(x.TransferRecords) > 0 {
+ for _, e := range x.TransferRecords {
+ 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().(*GenesisState)
+ 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.TransferRecords) > 0 {
+ for iNdEx := len(x.TransferRecords) - 1; iNdEx >= 0; iNdEx-- {
+ encoded, err := options.Marshal(x.TransferRecords[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.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] = 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().(*GenesisState)
+ 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: GenesisState: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: GenesisState: 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 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 2:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TransferRecords", 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.TransferRecords = append(x.TransferRecords, &TransferRecord{})
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.TransferRecords[len(x.TransferRecords)-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/genesistransfer/genesis.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)
+)
+
+// TransferRecord tracks completed ownership transfers for audit trail and one-time enforcement
+type TransferRecord struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ GenesisAddress string `protobuf:"bytes,1,opt,name=genesis_address,json=genesisAddress,proto3" json:"genesis_address,omitempty"` // Source genesis account that was transferred
+ RecipientAddress string `protobuf:"bytes,2,opt,name=recipient_address,json=recipientAddress,proto3" json:"recipient_address,omitempty"` // Destination account that received the transfer
+ TransferHeight uint64 `protobuf:"varint,3,opt,name=transfer_height,json=transferHeight,proto3" json:"transfer_height,omitempty"` // Block height when transfer was executed
+ Completed bool `protobuf:"varint,4,opt,name=completed,proto3" json:"completed,omitempty"` // Transfer completion status
+ TransferredDenoms []string `protobuf:"bytes,5,rep,name=transferred_denoms,json=transferredDenoms,proto3" json:"transferred_denoms,omitempty"` // List of token denoms that were transferred
+ TransferAmount string `protobuf:"bytes,6,opt,name=transfer_amount,json=transferAmount,proto3" json:"transfer_amount,omitempty"` // Total amount transferred (for audit)
+}
+
+func (x *TransferRecord) Reset() {
+ *x = TransferRecord{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_genesistransfer_genesis_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *TransferRecord) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TransferRecord) ProtoMessage() {}
+
+// Deprecated: Use TransferRecord.ProtoReflect.Descriptor instead.
+func (*TransferRecord) Descriptor() ([]byte, []int) {
+ return file_inference_genesistransfer_genesis_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *TransferRecord) GetGenesisAddress() string {
+ if x != nil {
+ return x.GenesisAddress
+ }
+ return ""
+}
+
+func (x *TransferRecord) GetRecipientAddress() string {
+ if x != nil {
+ return x.RecipientAddress
+ }
+ return ""
+}
+
+func (x *TransferRecord) GetTransferHeight() uint64 {
+ if x != nil {
+ return x.TransferHeight
+ }
+ return 0
+}
+
+func (x *TransferRecord) GetCompleted() bool {
+ if x != nil {
+ return x.Completed
+ }
+ return false
+}
+
+func (x *TransferRecord) GetTransferredDenoms() []string {
+ if x != nil {
+ return x.TransferredDenoms
+ }
+ return nil
+}
+
+func (x *TransferRecord) GetTransferAmount() string {
+ if x != nil {
+ return x.TransferAmount
+ }
+ return ""
+}
+
+// GenesisState defines the genesistransfer module's genesis state.
+type GenesisState struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // params defines all the parameters of the module.
+ Params *Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params,omitempty"`
+ // transfer_records list of completed transfers for state persistence
+ TransferRecords []*TransferRecord `protobuf:"bytes,2,rep,name=transfer_records,json=transferRecords,proto3" json:"transfer_records,omitempty"`
+}
+
+func (x *GenesisState) Reset() {
+ *x = GenesisState{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_genesistransfer_genesis_proto_msgTypes[1]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *GenesisState) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GenesisState) ProtoMessage() {}
+
+// Deprecated: Use GenesisState.ProtoReflect.Descriptor instead.
+func (*GenesisState) Descriptor() ([]byte, []int) {
+ return file_inference_genesistransfer_genesis_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *GenesisState) GetParams() *Params {
+ if x != nil {
+ return x.Params
+ }
+ return nil
+}
+
+func (x *GenesisState) GetTransferRecords() []*TransferRecord {
+ if x != nil {
+ return x.TransferRecords
+ }
+ return nil
+}
+
+var File_inference_genesistransfer_genesis_proto protoreflect.FileDescriptor
+
+var file_inference_genesistransfer_genesis_proto_rawDesc = []byte{
+ 0x0a, 0x27, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x67, 0x65, 0x6e, 0x65,
+ 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2f, 0x67, 0x65, 0x6e, 0x65,
+ 0x73, 0x69, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x19, 0x69, 0x6e, 0x66, 0x65, 0x72,
+ 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e,
+ 0x73, 0x66, 0x65, 0x72, 0x1a, 0x11, 0x61, 0x6d, 0x69, 0x6e, 0x6f, 0x2f, 0x61, 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, 0x26, 0x69,
+ 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73,
+ 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e,
+ 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x8b, 0x02, 0x0a, 0x0e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66,
+ 0x65, 0x72, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x12, 0x27, 0x0a, 0x0f, 0x67, 0x65, 0x6e, 0x65,
+ 0x73, 0x69, 0x73, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28,
+ 0x09, 0x52, 0x0e, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73,
+ 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x72, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x5f, 0x61,
+ 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x72, 0x65,
+ 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x27,
+ 0x0a, 0x0f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68,
+ 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65,
+ 0x72, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x63, 0x6f, 0x6d, 0x70, 0x6c,
+ 0x65, 0x74, 0x65, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x63, 0x6f, 0x6d, 0x70,
+ 0x6c, 0x65, 0x74, 0x65, 0x64, 0x12, 0x2d, 0x0a, 0x12, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65,
+ 0x72, 0x72, 0x65, 0x64, 0x5f, 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28,
+ 0x09, 0x52, 0x11, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x72, 0x65, 0x64, 0x44, 0x65,
+ 0x6e, 0x6f, 0x6d, 0x73, 0x12, 0x27, 0x0a, 0x0f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72,
+ 0x5f, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x74,
+ 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x3a, 0x04, 0xe8,
+ 0xa0, 0x1f, 0x01, 0x22, 0xb5, 0x01, 0x0a, 0x0c, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x53,
+ 0x74, 0x61, 0x74, 0x65, 0x12, 0x44, 0x0a, 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x01,
+ 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+ 0x2e, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72,
+ 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, 0x12, 0x5f, 0x0a, 0x10, 0x74, 0x72,
+ 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x5f, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x73, 0x18, 0x02,
+ 0x20, 0x03, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+ 0x2e, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72,
+ 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x42,
+ 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x0f, 0x74, 0x72, 0x61, 0x6e,
+ 0x73, 0x66, 0x65, 0x72, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x73, 0x42, 0xde, 0x01, 0x0a, 0x1d,
+ 0x63, 0x6f, 0x6d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x67, 0x65,
+ 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x42, 0x0c, 0x47,
+ 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x2a, 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, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69,
+ 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0xa2, 0x02, 0x03, 0x49, 0x47, 0x58, 0xaa,
+ 0x02, 0x19, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x47, 0x65, 0x6e, 0x65,
+ 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0xca, 0x02, 0x19, 0x49, 0x6e,
+ 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74,
+ 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0xe2, 0x02, 0x25, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65,
+ 0x6e, 0x63, 0x65, 0x5c, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73,
+ 0x66, 0x65, 0x72, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea,
+ 0x02, 0x1a, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x3a, 0x3a, 0x47, 0x65, 0x6e,
+ 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x62, 0x06, 0x70, 0x72,
+ 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+ file_inference_genesistransfer_genesis_proto_rawDescOnce sync.Once
+ file_inference_genesistransfer_genesis_proto_rawDescData = file_inference_genesistransfer_genesis_proto_rawDesc
+)
+
+func file_inference_genesistransfer_genesis_proto_rawDescGZIP() []byte {
+ file_inference_genesistransfer_genesis_proto_rawDescOnce.Do(func() {
+ file_inference_genesistransfer_genesis_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_genesistransfer_genesis_proto_rawDescData)
+ })
+ return file_inference_genesistransfer_genesis_proto_rawDescData
+}
+
+var file_inference_genesistransfer_genesis_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
+var file_inference_genesistransfer_genesis_proto_goTypes = []interface{}{
+ (*TransferRecord)(nil), // 0: inference.genesistransfer.TransferRecord
+ (*GenesisState)(nil), // 1: inference.genesistransfer.GenesisState
+ (*Params)(nil), // 2: inference.genesistransfer.Params
+}
+var file_inference_genesistransfer_genesis_proto_depIdxs = []int32{
+ 2, // 0: inference.genesistransfer.GenesisState.params:type_name -> inference.genesistransfer.Params
+ 0, // 1: inference.genesistransfer.GenesisState.transfer_records:type_name -> inference.genesistransfer.TransferRecord
+ 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_genesistransfer_genesis_proto_init() }
+func file_inference_genesistransfer_genesis_proto_init() {
+ if File_inference_genesistransfer_genesis_proto != nil {
+ return
+ }
+ file_inference_genesistransfer_params_proto_init()
+ if !protoimpl.UnsafeEnabled {
+ file_inference_genesistransfer_genesis_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*TransferRecord); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_genesistransfer_genesis_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*GenesisState); 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_genesistransfer_genesis_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 2,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_genesistransfer_genesis_proto_goTypes,
+ DependencyIndexes: file_inference_genesistransfer_genesis_proto_depIdxs,
+ MessageInfos: file_inference_genesistransfer_genesis_proto_msgTypes,
+ }.Build()
+ File_inference_genesistransfer_genesis_proto = out.File
+ file_inference_genesistransfer_genesis_proto_rawDesc = nil
+ file_inference_genesistransfer_genesis_proto_goTypes = nil
+ file_inference_genesistransfer_genesis_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/genesistransfer/module/module.pulsar.go b/inference-chain/api/inference/genesistransfer/module/module.pulsar.go
new file mode 100644
index 000000000..126f441fe
--- /dev/null
+++ b/inference-chain/api/inference/genesistransfer/module/module.pulsar.go
@@ -0,0 +1,583 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package module
+
+import (
+ _ "cosmossdk.io/api/cosmos/app/v1alpha1"
+ 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_Module protoreflect.MessageDescriptor
+ fd_Module_authority protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_genesistransfer_module_module_proto_init()
+ md_Module = File_inference_genesistransfer_module_module_proto.Messages().ByName("Module")
+ fd_Module_authority = md_Module.Fields().ByName("authority")
+}
+
+var _ protoreflect.Message = (*fastReflection_Module)(nil)
+
+type fastReflection_Module Module
+
+func (x *Module) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_Module)(x)
+}
+
+func (x *Module) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_genesistransfer_module_module_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_Module_messageType fastReflection_Module_messageType
+var _ protoreflect.MessageType = fastReflection_Module_messageType{}
+
+type fastReflection_Module_messageType struct{}
+
+func (x fastReflection_Module_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_Module)(nil)
+}
+func (x fastReflection_Module_messageType) New() protoreflect.Message {
+ return new(fastReflection_Module)
+}
+func (x fastReflection_Module_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_Module
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_Module) Descriptor() protoreflect.MessageDescriptor {
+ return md_Module
+}
+
+// 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_Module) Type() protoreflect.MessageType {
+ return _fastReflection_Module_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_Module) New() protoreflect.Message {
+ return new(fastReflection_Module)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_Module) Interface() protoreflect.ProtoMessage {
+ return (*Module)(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_Module) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Authority != "" {
+ value := protoreflect.ValueOfString(x.Authority)
+ if !f(fd_Module_authority, 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_Module) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.genesistransfer.module.Module.authority":
+ return x.Authority != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.module.Module"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.module.Module 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_Module) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.genesistransfer.module.Module.authority":
+ x.Authority = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.module.Module"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.module.Module 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_Module) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.genesistransfer.module.Module.authority":
+ value := x.Authority
+ return protoreflect.ValueOfString(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.module.Module"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.module.Module 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_Module) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.genesistransfer.module.Module.authority":
+ x.Authority = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.module.Module"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.module.Module 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_Module) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.genesistransfer.module.Module.authority":
+ panic(fmt.Errorf("field authority of message inference.genesistransfer.module.Module is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.module.Module"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.module.Module 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_Module) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.genesistransfer.module.Module.authority":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.module.Module"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.module.Module 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_Module) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.genesistransfer.module.Module", 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_Module) 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_Module) 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_Module) 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_Module) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*Module)
+ 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 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().(*Module)
+ 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.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().(*Module)
+ 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: Module: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Module: 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
+ 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/genesistransfer/module/module.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)
+)
+
+// Module is the config object for the module.
+type Module struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // authority defines the custom module authority. If not set, defaults to the governance module.
+ Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"`
+}
+
+func (x *Module) Reset() {
+ *x = Module{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_genesistransfer_module_module_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *Module) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Module) ProtoMessage() {}
+
+// Deprecated: Use Module.ProtoReflect.Descriptor instead.
+func (*Module) Descriptor() ([]byte, []int) {
+ return file_inference_genesistransfer_module_module_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Module) GetAuthority() string {
+ if x != nil {
+ return x.Authority
+ }
+ return ""
+}
+
+var File_inference_genesistransfer_module_module_proto protoreflect.FileDescriptor
+
+var file_inference_genesistransfer_module_module_proto_rawDesc = []byte{
+ 0x0a, 0x2d, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x67, 0x65, 0x6e, 0x65,
+ 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2f, 0x6d, 0x6f, 0x64, 0x75,
+ 0x6c, 0x65, 0x2f, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12,
+ 0x20, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x67, 0x65, 0x6e, 0x65, 0x73,
+ 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x6d, 0x6f, 0x64, 0x75, 0x6c,
+ 0x65, 0x1a, 0x20, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x61, 0x70, 0x70, 0x2f, 0x76, 0x31,
+ 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x2e, 0x70, 0x72,
+ 0x6f, 0x74, 0x6f, 0x22, 0x65, 0x0a, 0x06, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 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, 0x3a, 0x3d, 0xba, 0xc0, 0x96,
+ 0xda, 0x01, 0x37, 0x0a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 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, 0x78, 0x2f, 0x67, 0x65, 0x6e, 0x65, 0x73,
+ 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x42, 0x88, 0x02, 0x0a, 0x24, 0x63,
+ 0x6f, 0x6d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x67, 0x65, 0x6e,
+ 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x6d, 0x6f, 0x64,
+ 0x75, 0x6c, 0x65, 0x42, 0x0b, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f,
+ 0x50, 0x01, 0x5a, 0x31, 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, 0x67,
+ 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2f, 0x6d,
+ 0x6f, 0x64, 0x75, 0x6c, 0x65, 0xa2, 0x02, 0x03, 0x49, 0x47, 0x4d, 0xaa, 0x02, 0x20, 0x49, 0x6e,
+ 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74,
+ 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0xca, 0x02,
+ 0x20, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x47, 0x65, 0x6e, 0x65, 0x73,
+ 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x5c, 0x4d, 0x6f, 0x64, 0x75, 0x6c,
+ 0x65, 0xe2, 0x02, 0x2c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x47, 0x65,
+ 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x5c, 0x4d, 0x6f,
+ 0x64, 0x75, 0x6c, 0x65, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61,
+ 0xea, 0x02, 0x22, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x3a, 0x3a, 0x47, 0x65,
+ 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x3a, 0x3a, 0x4d,
+ 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+ file_inference_genesistransfer_module_module_proto_rawDescOnce sync.Once
+ file_inference_genesistransfer_module_module_proto_rawDescData = file_inference_genesistransfer_module_module_proto_rawDesc
+)
+
+func file_inference_genesistransfer_module_module_proto_rawDescGZIP() []byte {
+ file_inference_genesistransfer_module_module_proto_rawDescOnce.Do(func() {
+ file_inference_genesistransfer_module_module_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_genesistransfer_module_module_proto_rawDescData)
+ })
+ return file_inference_genesistransfer_module_module_proto_rawDescData
+}
+
+var file_inference_genesistransfer_module_module_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_inference_genesistransfer_module_module_proto_goTypes = []interface{}{
+ (*Module)(nil), // 0: inference.genesistransfer.module.Module
+}
+var file_inference_genesistransfer_module_module_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_genesistransfer_module_module_proto_init() }
+func file_inference_genesistransfer_module_module_proto_init() {
+ if File_inference_genesistransfer_module_module_proto != nil {
+ return
+ }
+ if !protoimpl.UnsafeEnabled {
+ file_inference_genesistransfer_module_module_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*Module); 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_genesistransfer_module_module_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 1,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_genesistransfer_module_module_proto_goTypes,
+ DependencyIndexes: file_inference_genesistransfer_module_module_proto_depIdxs,
+ MessageInfos: file_inference_genesistransfer_module_module_proto_msgTypes,
+ }.Build()
+ File_inference_genesistransfer_module_module_proto = out.File
+ file_inference_genesistransfer_module_module_proto_rawDesc = nil
+ file_inference_genesistransfer_module_module_proto_goTypes = nil
+ file_inference_genesistransfer_module_module_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/genesistransfer/params.pulsar.go b/inference-chain/api/inference/genesistransfer/params.pulsar.go
new file mode 100644
index 000000000..94e7df5bf
--- /dev/null
+++ b/inference-chain/api/inference/genesistransfer/params.pulsar.go
@@ -0,0 +1,707 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package genesistransfer
+
+import (
+ _ "cosmossdk.io/api/amino"
+ fmt "fmt"
+ runtime "github.com/cosmos/cosmos-proto/runtime"
+ _ "github.com/cosmos/gogoproto/gogoproto"
+ 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 _ protoreflect.List = (*_Params_1_list)(nil)
+
+type _Params_1_list struct {
+ list *[]string
+}
+
+func (x *_Params_1_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_Params_1_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfString((*x.list)[i])
+}
+
+func (x *_Params_1_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.String()
+ concreteValue := valueUnwrapped
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_Params_1_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.String()
+ concreteValue := valueUnwrapped
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_Params_1_list) AppendMutable() protoreflect.Value {
+ panic(fmt.Errorf("AppendMutable can not be called on message Params at list field AllowedAccounts as it is not of Message kind"))
+}
+
+func (x *_Params_1_list) Truncate(n int) {
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_Params_1_list) NewElement() protoreflect.Value {
+ v := ""
+ return protoreflect.ValueOfString(v)
+}
+
+func (x *_Params_1_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_Params protoreflect.MessageDescriptor
+ fd_Params_allowed_accounts protoreflect.FieldDescriptor
+ fd_Params_restrict_to_list protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_genesistransfer_params_proto_init()
+ md_Params = File_inference_genesistransfer_params_proto.Messages().ByName("Params")
+ fd_Params_allowed_accounts = md_Params.Fields().ByName("allowed_accounts")
+ fd_Params_restrict_to_list = md_Params.Fields().ByName("restrict_to_list")
+}
+
+var _ protoreflect.Message = (*fastReflection_Params)(nil)
+
+type fastReflection_Params Params
+
+func (x *Params) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_Params)(x)
+}
+
+func (x *Params) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_genesistransfer_params_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_Params_messageType fastReflection_Params_messageType
+var _ protoreflect.MessageType = fastReflection_Params_messageType{}
+
+type fastReflection_Params_messageType struct{}
+
+func (x fastReflection_Params_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_Params)(nil)
+}
+func (x fastReflection_Params_messageType) New() protoreflect.Message {
+ return new(fastReflection_Params)
+}
+func (x fastReflection_Params_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_Params
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_Params) Descriptor() protoreflect.MessageDescriptor {
+ return md_Params
+}
+
+// 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_Params) Type() protoreflect.MessageType {
+ return _fastReflection_Params_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_Params) New() protoreflect.Message {
+ return new(fastReflection_Params)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_Params) Interface() protoreflect.ProtoMessage {
+ return (*Params)(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_Params) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if len(x.AllowedAccounts) != 0 {
+ value := protoreflect.ValueOfList(&_Params_1_list{list: &x.AllowedAccounts})
+ if !f(fd_Params_allowed_accounts, value) {
+ return
+ }
+ }
+ if x.RestrictToList != false {
+ value := protoreflect.ValueOfBool(x.RestrictToList)
+ if !f(fd_Params_restrict_to_list, 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_Params) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.genesistransfer.Params.allowed_accounts":
+ return len(x.AllowedAccounts) != 0
+ case "inference.genesistransfer.Params.restrict_to_list":
+ return x.RestrictToList != false
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.Params"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.Params 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_Params) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.genesistransfer.Params.allowed_accounts":
+ x.AllowedAccounts = nil
+ case "inference.genesistransfer.Params.restrict_to_list":
+ x.RestrictToList = false
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.Params"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.Params 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_Params) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.genesistransfer.Params.allowed_accounts":
+ if len(x.AllowedAccounts) == 0 {
+ return protoreflect.ValueOfList(&_Params_1_list{})
+ }
+ listValue := &_Params_1_list{list: &x.AllowedAccounts}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.genesistransfer.Params.restrict_to_list":
+ value := x.RestrictToList
+ return protoreflect.ValueOfBool(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.Params"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.Params 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_Params) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.genesistransfer.Params.allowed_accounts":
+ lv := value.List()
+ clv := lv.(*_Params_1_list)
+ x.AllowedAccounts = *clv.list
+ case "inference.genesistransfer.Params.restrict_to_list":
+ x.RestrictToList = value.Bool()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.Params"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.Params 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_Params) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.genesistransfer.Params.allowed_accounts":
+ if x.AllowedAccounts == nil {
+ x.AllowedAccounts = []string{}
+ }
+ value := &_Params_1_list{list: &x.AllowedAccounts}
+ return protoreflect.ValueOfList(value)
+ case "inference.genesistransfer.Params.restrict_to_list":
+ panic(fmt.Errorf("field restrict_to_list of message inference.genesistransfer.Params is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.Params"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.Params 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_Params) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.genesistransfer.Params.allowed_accounts":
+ list := []string{}
+ return protoreflect.ValueOfList(&_Params_1_list{list: &list})
+ case "inference.genesistransfer.Params.restrict_to_list":
+ return protoreflect.ValueOfBool(false)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.Params"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.Params 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_Params) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.genesistransfer.Params", 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_Params) 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_Params) 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_Params) 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_Params) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*Params)
+ 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.AllowedAccounts) > 0 {
+ for _, s := range x.AllowedAccounts {
+ l = len(s)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ }
+ if x.RestrictToList {
+ 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().(*Params)
+ 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.RestrictToList {
+ i--
+ if x.RestrictToList {
+ dAtA[i] = 1
+ } else {
+ dAtA[i] = 0
+ }
+ i--
+ dAtA[i] = 0x10
+ }
+ if len(x.AllowedAccounts) > 0 {
+ for iNdEx := len(x.AllowedAccounts) - 1; iNdEx >= 0; iNdEx-- {
+ i -= len(x.AllowedAccounts[iNdEx])
+ copy(dAtA[i:], x.AllowedAccounts[iNdEx])
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.AllowedAccounts[iNdEx])))
+ 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().(*Params)
+ 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: Params: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Params: 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 AllowedAccounts", 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.AllowedAccounts = append(x.AllowedAccounts, 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 RestrictToList", 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.RestrictToList = 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,
+ }
+}
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// protoc-gen-go v1.27.0
+// protoc (unknown)
+// source: inference/genesistransfer/params.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)
+)
+
+// Params defines the parameters for the module.
+type Params struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // allowed_accounts is a whitelist of genesis account addresses that can be transferred
+ AllowedAccounts []string `protobuf:"bytes,1,rep,name=allowed_accounts,json=allowedAccounts,proto3" json:"allowed_accounts,omitempty"`
+ // restrict_to_list enables whitelist enforcement - if false, any account can be transferred
+ RestrictToList bool `protobuf:"varint,2,opt,name=restrict_to_list,json=restrictToList,proto3" json:"restrict_to_list,omitempty"`
+}
+
+func (x *Params) Reset() {
+ *x = Params{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_genesistransfer_params_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *Params) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Params) ProtoMessage() {}
+
+// Deprecated: Use Params.ProtoReflect.Descriptor instead.
+func (*Params) Descriptor() ([]byte, []int) {
+ return file_inference_genesistransfer_params_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Params) GetAllowedAccounts() []string {
+ if x != nil {
+ return x.AllowedAccounts
+ }
+ return nil
+}
+
+func (x *Params) GetRestrictToList() bool {
+ if x != nil {
+ return x.RestrictToList
+ }
+ return false
+}
+
+var File_inference_genesistransfer_params_proto protoreflect.FileDescriptor
+
+var file_inference_genesistransfer_params_proto_rawDesc = []byte{
+ 0x0a, 0x26, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x67, 0x65, 0x6e, 0x65,
+ 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2f, 0x70, 0x61, 0x72, 0x61,
+ 0x6d, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x19, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+ 0x6e, 0x63, 0x65, 0x2e, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73,
+ 0x66, 0x65, 0x72, 0x1a, 0x11, 0x61, 0x6d, 0x69, 0x6e, 0x6f, 0x2f, 0x61, 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, 0x22, 0x95, 0x01, 0x0a,
+ 0x06, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x34, 0x0a, 0x10, 0x61, 0x6c, 0x6c, 0x6f, 0x77,
+ 0x65, 0x64, 0x5f, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28,
+ 0x09, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x0f, 0x61, 0x6c,
+ 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x12, 0x28, 0x0a,
+ 0x10, 0x72, 0x65, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x5f, 0x74, 0x6f, 0x5f, 0x6c, 0x69, 0x73,
+ 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x72, 0x65, 0x73, 0x74, 0x72, 0x69, 0x63,
+ 0x74, 0x54, 0x6f, 0x4c, 0x69, 0x73, 0x74, 0x3a, 0x2b, 0xe8, 0xa0, 0x1f, 0x01, 0x8a, 0xe7, 0xb0,
+ 0x2a, 0x22, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x78, 0x2f, 0x67, 0x65,
+ 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2f, 0x50, 0x61,
+ 0x72, 0x61, 0x6d, 0x73, 0x42, 0xdd, 0x01, 0x0a, 0x1d, 0x63, 0x6f, 0x6d, 0x2e, 0x69, 0x6e, 0x66,
+ 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72,
+ 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x42, 0x0b, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x50, 0x72,
+ 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x2a, 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, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65,
+ 0x72, 0xa2, 0x02, 0x03, 0x49, 0x47, 0x58, 0xaa, 0x02, 0x19, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65,
+ 0x6e, 0x63, 0x65, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73,
+ 0x66, 0x65, 0x72, 0xca, 0x02, 0x19, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c,
+ 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0xe2,
+ 0x02, 0x25, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x47, 0x65, 0x6e, 0x65,
+ 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x5c, 0x47, 0x50, 0x42, 0x4d,
+ 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x1a, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65,
+ 0x6e, 0x63, 0x65, 0x3a, 0x3a, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e,
+ 0x73, 0x66, 0x65, 0x72, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+ file_inference_genesistransfer_params_proto_rawDescOnce sync.Once
+ file_inference_genesistransfer_params_proto_rawDescData = file_inference_genesistransfer_params_proto_rawDesc
+)
+
+func file_inference_genesistransfer_params_proto_rawDescGZIP() []byte {
+ file_inference_genesistransfer_params_proto_rawDescOnce.Do(func() {
+ file_inference_genesistransfer_params_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_genesistransfer_params_proto_rawDescData)
+ })
+ return file_inference_genesistransfer_params_proto_rawDescData
+}
+
+var file_inference_genesistransfer_params_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_inference_genesistransfer_params_proto_goTypes = []interface{}{
+ (*Params)(nil), // 0: inference.genesistransfer.Params
+}
+var file_inference_genesistransfer_params_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_genesistransfer_params_proto_init() }
+func file_inference_genesistransfer_params_proto_init() {
+ if File_inference_genesistransfer_params_proto != nil {
+ return
+ }
+ if !protoimpl.UnsafeEnabled {
+ file_inference_genesistransfer_params_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*Params); 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_genesistransfer_params_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 1,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_genesistransfer_params_proto_goTypes,
+ DependencyIndexes: file_inference_genesistransfer_params_proto_depIdxs,
+ MessageInfos: file_inference_genesistransfer_params_proto_msgTypes,
+ }.Build()
+ File_inference_genesistransfer_params_proto = out.File
+ file_inference_genesistransfer_params_proto_rawDesc = nil
+ file_inference_genesistransfer_params_proto_goTypes = nil
+ file_inference_genesistransfer_params_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/genesistransfer/query.pulsar.go b/inference-chain/api/inference/genesistransfer/query.pulsar.go
new file mode 100644
index 000000000..44484a0c9
--- /dev/null
+++ b/inference-chain/api/inference/genesistransfer/query.pulsar.go
@@ -0,0 +1,5324 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package genesistransfer
+
+import (
+ _ "cosmossdk.io/api/amino"
+ v1beta1 "cosmossdk.io/api/cosmos/base/query/v1beta1"
+ fmt "fmt"
+ runtime "github.com/cosmos/cosmos-proto/runtime"
+ _ "github.com/cosmos/gogoproto/gogoproto"
+ _ "google.golang.org/genproto/googleapis/api/annotations"
+ 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_QueryParamsRequest protoreflect.MessageDescriptor
+)
+
+func init() {
+ file_inference_genesistransfer_query_proto_init()
+ md_QueryParamsRequest = File_inference_genesistransfer_query_proto.Messages().ByName("QueryParamsRequest")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryParamsRequest)(nil)
+
+type fastReflection_QueryParamsRequest QueryParamsRequest
+
+func (x *QueryParamsRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryParamsRequest)(x)
+}
+
+func (x *QueryParamsRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_genesistransfer_query_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_QueryParamsRequest_messageType fastReflection_QueryParamsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryParamsRequest_messageType{}
+
+type fastReflection_QueryParamsRequest_messageType struct{}
+
+func (x fastReflection_QueryParamsRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryParamsRequest)(nil)
+}
+func (x fastReflection_QueryParamsRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryParamsRequest)
+}
+func (x fastReflection_QueryParamsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryParamsRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryParamsRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryParamsRequest
+}
+
+// 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_QueryParamsRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryParamsRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryParamsRequest) New() protoreflect.Message {
+ return new(fastReflection_QueryParamsRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryParamsRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryParamsRequest)(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_QueryParamsRequest) 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_QueryParamsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryParamsRequest"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryParamsRequest 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_QueryParamsRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryParamsRequest"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryParamsRequest 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_QueryParamsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryParamsRequest"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryParamsRequest 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_QueryParamsRequest) 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.genesistransfer.QueryParamsRequest"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryParamsRequest 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_QueryParamsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryParamsRequest"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryParamsRequest 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_QueryParamsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryParamsRequest"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryParamsRequest 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_QueryParamsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.genesistransfer.QueryParamsRequest", 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_QueryParamsRequest) 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_QueryParamsRequest) 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_QueryParamsRequest) 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_QueryParamsRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryParamsRequest)
+ 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().(*QueryParamsRequest)
+ 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().(*QueryParamsRequest)
+ 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: QueryParamsRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryParamsRequest: 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 (
+ md_QueryParamsResponse protoreflect.MessageDescriptor
+ fd_QueryParamsResponse_params protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_genesistransfer_query_proto_init()
+ md_QueryParamsResponse = File_inference_genesistransfer_query_proto.Messages().ByName("QueryParamsResponse")
+ fd_QueryParamsResponse_params = md_QueryParamsResponse.Fields().ByName("params")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryParamsResponse)(nil)
+
+type fastReflection_QueryParamsResponse QueryParamsResponse
+
+func (x *QueryParamsResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryParamsResponse)(x)
+}
+
+func (x *QueryParamsResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_genesistransfer_query_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_QueryParamsResponse_messageType fastReflection_QueryParamsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryParamsResponse_messageType{}
+
+type fastReflection_QueryParamsResponse_messageType struct{}
+
+func (x fastReflection_QueryParamsResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryParamsResponse)(nil)
+}
+func (x fastReflection_QueryParamsResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryParamsResponse)
+}
+func (x fastReflection_QueryParamsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryParamsResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryParamsResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryParamsResponse
+}
+
+// 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_QueryParamsResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryParamsResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryParamsResponse) New() protoreflect.Message {
+ return new(fastReflection_QueryParamsResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryParamsResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryParamsResponse)(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_QueryParamsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Params != nil {
+ value := protoreflect.ValueOfMessage(x.Params.ProtoReflect())
+ if !f(fd_QueryParamsResponse_params, 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_QueryParamsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryParamsResponse.params":
+ return x.Params != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryParamsResponse 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_QueryParamsResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryParamsResponse.params":
+ x.Params = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryParamsResponse 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_QueryParamsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.genesistransfer.QueryParamsResponse.params":
+ value := x.Params
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryParamsResponse 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_QueryParamsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryParamsResponse.params":
+ x.Params = value.Message().Interface().(*Params)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryParamsResponse 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_QueryParamsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryParamsResponse.params":
+ if x.Params == nil {
+ x.Params = new(Params)
+ }
+ return protoreflect.ValueOfMessage(x.Params.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryParamsResponse 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_QueryParamsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryParamsResponse.params":
+ m := new(Params)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryParamsResponse 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_QueryParamsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.genesistransfer.QueryParamsResponse", 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_QueryParamsResponse) 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_QueryParamsResponse) 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_QueryParamsResponse) 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_QueryParamsResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryParamsResponse)
+ 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.Params != nil {
+ l = options.Size(x.Params)
+ 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().(*QueryParamsResponse)
+ 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.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] = 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().(*QueryParamsResponse)
+ 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: QueryParamsResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryParamsResponse: 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 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
+ 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_QueryTransferStatusRequest protoreflect.MessageDescriptor
+ fd_QueryTransferStatusRequest_genesis_address protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_genesistransfer_query_proto_init()
+ md_QueryTransferStatusRequest = File_inference_genesistransfer_query_proto.Messages().ByName("QueryTransferStatusRequest")
+ fd_QueryTransferStatusRequest_genesis_address = md_QueryTransferStatusRequest.Fields().ByName("genesis_address")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryTransferStatusRequest)(nil)
+
+type fastReflection_QueryTransferStatusRequest QueryTransferStatusRequest
+
+func (x *QueryTransferStatusRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryTransferStatusRequest)(x)
+}
+
+func (x *QueryTransferStatusRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_genesistransfer_query_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_QueryTransferStatusRequest_messageType fastReflection_QueryTransferStatusRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryTransferStatusRequest_messageType{}
+
+type fastReflection_QueryTransferStatusRequest_messageType struct{}
+
+func (x fastReflection_QueryTransferStatusRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryTransferStatusRequest)(nil)
+}
+func (x fastReflection_QueryTransferStatusRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryTransferStatusRequest)
+}
+func (x fastReflection_QueryTransferStatusRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryTransferStatusRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryTransferStatusRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryTransferStatusRequest
+}
+
+// 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_QueryTransferStatusRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryTransferStatusRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryTransferStatusRequest) New() protoreflect.Message {
+ return new(fastReflection_QueryTransferStatusRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryTransferStatusRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryTransferStatusRequest)(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_QueryTransferStatusRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.GenesisAddress != "" {
+ value := protoreflect.ValueOfString(x.GenesisAddress)
+ if !f(fd_QueryTransferStatusRequest_genesis_address, 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_QueryTransferStatusRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryTransferStatusRequest.genesis_address":
+ return x.GenesisAddress != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryTransferStatusRequest"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryTransferStatusRequest 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_QueryTransferStatusRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryTransferStatusRequest.genesis_address":
+ x.GenesisAddress = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryTransferStatusRequest"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryTransferStatusRequest 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_QueryTransferStatusRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.genesistransfer.QueryTransferStatusRequest.genesis_address":
+ value := x.GenesisAddress
+ return protoreflect.ValueOfString(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryTransferStatusRequest"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryTransferStatusRequest 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_QueryTransferStatusRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryTransferStatusRequest.genesis_address":
+ x.GenesisAddress = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryTransferStatusRequest"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryTransferStatusRequest 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_QueryTransferStatusRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryTransferStatusRequest.genesis_address":
+ panic(fmt.Errorf("field genesis_address of message inference.genesistransfer.QueryTransferStatusRequest is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryTransferStatusRequest"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryTransferStatusRequest 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_QueryTransferStatusRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryTransferStatusRequest.genesis_address":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryTransferStatusRequest"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryTransferStatusRequest 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_QueryTransferStatusRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.genesistransfer.QueryTransferStatusRequest", 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_QueryTransferStatusRequest) 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_QueryTransferStatusRequest) 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_QueryTransferStatusRequest) 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_QueryTransferStatusRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryTransferStatusRequest)
+ 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.GenesisAddress)
+ 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().(*QueryTransferStatusRequest)
+ 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.GenesisAddress) > 0 {
+ i -= len(x.GenesisAddress)
+ copy(dAtA[i:], x.GenesisAddress)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.GenesisAddress)))
+ 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().(*QueryTransferStatusRequest)
+ 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: QueryTransferStatusRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryTransferStatusRequest: 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 GenesisAddress", 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.GenesisAddress = 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_QueryTransferStatusResponse protoreflect.MessageDescriptor
+ fd_QueryTransferStatusResponse_is_transferred protoreflect.FieldDescriptor
+ fd_QueryTransferStatusResponse_transfer_record protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_genesistransfer_query_proto_init()
+ md_QueryTransferStatusResponse = File_inference_genesistransfer_query_proto.Messages().ByName("QueryTransferStatusResponse")
+ fd_QueryTransferStatusResponse_is_transferred = md_QueryTransferStatusResponse.Fields().ByName("is_transferred")
+ fd_QueryTransferStatusResponse_transfer_record = md_QueryTransferStatusResponse.Fields().ByName("transfer_record")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryTransferStatusResponse)(nil)
+
+type fastReflection_QueryTransferStatusResponse QueryTransferStatusResponse
+
+func (x *QueryTransferStatusResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryTransferStatusResponse)(x)
+}
+
+func (x *QueryTransferStatusResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_genesistransfer_query_proto_msgTypes[3]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryTransferStatusResponse_messageType fastReflection_QueryTransferStatusResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryTransferStatusResponse_messageType{}
+
+type fastReflection_QueryTransferStatusResponse_messageType struct{}
+
+func (x fastReflection_QueryTransferStatusResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryTransferStatusResponse)(nil)
+}
+func (x fastReflection_QueryTransferStatusResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryTransferStatusResponse)
+}
+func (x fastReflection_QueryTransferStatusResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryTransferStatusResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryTransferStatusResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryTransferStatusResponse
+}
+
+// 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_QueryTransferStatusResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryTransferStatusResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryTransferStatusResponse) New() protoreflect.Message {
+ return new(fastReflection_QueryTransferStatusResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryTransferStatusResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryTransferStatusResponse)(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_QueryTransferStatusResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.IsTransferred != false {
+ value := protoreflect.ValueOfBool(x.IsTransferred)
+ if !f(fd_QueryTransferStatusResponse_is_transferred, value) {
+ return
+ }
+ }
+ if x.TransferRecord != nil {
+ value := protoreflect.ValueOfMessage(x.TransferRecord.ProtoReflect())
+ if !f(fd_QueryTransferStatusResponse_transfer_record, 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_QueryTransferStatusResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryTransferStatusResponse.is_transferred":
+ return x.IsTransferred != false
+ case "inference.genesistransfer.QueryTransferStatusResponse.transfer_record":
+ return x.TransferRecord != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryTransferStatusResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryTransferStatusResponse 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_QueryTransferStatusResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryTransferStatusResponse.is_transferred":
+ x.IsTransferred = false
+ case "inference.genesistransfer.QueryTransferStatusResponse.transfer_record":
+ x.TransferRecord = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryTransferStatusResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryTransferStatusResponse 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_QueryTransferStatusResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.genesistransfer.QueryTransferStatusResponse.is_transferred":
+ value := x.IsTransferred
+ return protoreflect.ValueOfBool(value)
+ case "inference.genesistransfer.QueryTransferStatusResponse.transfer_record":
+ value := x.TransferRecord
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryTransferStatusResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryTransferStatusResponse 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_QueryTransferStatusResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryTransferStatusResponse.is_transferred":
+ x.IsTransferred = value.Bool()
+ case "inference.genesistransfer.QueryTransferStatusResponse.transfer_record":
+ x.TransferRecord = value.Message().Interface().(*TransferRecord)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryTransferStatusResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryTransferStatusResponse 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_QueryTransferStatusResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryTransferStatusResponse.transfer_record":
+ if x.TransferRecord == nil {
+ x.TransferRecord = new(TransferRecord)
+ }
+ return protoreflect.ValueOfMessage(x.TransferRecord.ProtoReflect())
+ case "inference.genesistransfer.QueryTransferStatusResponse.is_transferred":
+ panic(fmt.Errorf("field is_transferred of message inference.genesistransfer.QueryTransferStatusResponse is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryTransferStatusResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryTransferStatusResponse 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_QueryTransferStatusResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryTransferStatusResponse.is_transferred":
+ return protoreflect.ValueOfBool(false)
+ case "inference.genesistransfer.QueryTransferStatusResponse.transfer_record":
+ m := new(TransferRecord)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryTransferStatusResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryTransferStatusResponse 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_QueryTransferStatusResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.genesistransfer.QueryTransferStatusResponse", 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_QueryTransferStatusResponse) 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_QueryTransferStatusResponse) 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_QueryTransferStatusResponse) 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_QueryTransferStatusResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryTransferStatusResponse)
+ 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.IsTransferred {
+ n += 2
+ }
+ if x.TransferRecord != nil {
+ l = options.Size(x.TransferRecord)
+ 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().(*QueryTransferStatusResponse)
+ 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.TransferRecord != nil {
+ encoded, err := options.Marshal(x.TransferRecord)
+ 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.IsTransferred {
+ i--
+ if x.IsTransferred {
+ 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().(*QueryTransferStatusResponse)
+ 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: QueryTransferStatusResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryTransferStatusResponse: 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 IsTransferred", 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.IsTransferred = 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 TransferRecord", 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.TransferRecord == nil {
+ x.TransferRecord = &TransferRecord{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.TransferRecord); 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_QueryTransferHistoryRequest protoreflect.MessageDescriptor
+ fd_QueryTransferHistoryRequest_pagination protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_genesistransfer_query_proto_init()
+ md_QueryTransferHistoryRequest = File_inference_genesistransfer_query_proto.Messages().ByName("QueryTransferHistoryRequest")
+ fd_QueryTransferHistoryRequest_pagination = md_QueryTransferHistoryRequest.Fields().ByName("pagination")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryTransferHistoryRequest)(nil)
+
+type fastReflection_QueryTransferHistoryRequest QueryTransferHistoryRequest
+
+func (x *QueryTransferHistoryRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryTransferHistoryRequest)(x)
+}
+
+func (x *QueryTransferHistoryRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_genesistransfer_query_proto_msgTypes[4]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryTransferHistoryRequest_messageType fastReflection_QueryTransferHistoryRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryTransferHistoryRequest_messageType{}
+
+type fastReflection_QueryTransferHistoryRequest_messageType struct{}
+
+func (x fastReflection_QueryTransferHistoryRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryTransferHistoryRequest)(nil)
+}
+func (x fastReflection_QueryTransferHistoryRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryTransferHistoryRequest)
+}
+func (x fastReflection_QueryTransferHistoryRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryTransferHistoryRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryTransferHistoryRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryTransferHistoryRequest
+}
+
+// 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_QueryTransferHistoryRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryTransferHistoryRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryTransferHistoryRequest) New() protoreflect.Message {
+ return new(fastReflection_QueryTransferHistoryRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryTransferHistoryRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryTransferHistoryRequest)(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_QueryTransferHistoryRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Pagination != nil {
+ value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+ if !f(fd_QueryTransferHistoryRequest_pagination, 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_QueryTransferHistoryRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryTransferHistoryRequest.pagination":
+ return x.Pagination != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryTransferHistoryRequest"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryTransferHistoryRequest 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_QueryTransferHistoryRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryTransferHistoryRequest.pagination":
+ x.Pagination = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryTransferHistoryRequest"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryTransferHistoryRequest 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_QueryTransferHistoryRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.genesistransfer.QueryTransferHistoryRequest.pagination":
+ value := x.Pagination
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryTransferHistoryRequest"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryTransferHistoryRequest 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_QueryTransferHistoryRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryTransferHistoryRequest.pagination":
+ x.Pagination = value.Message().Interface().(*v1beta1.PageRequest)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryTransferHistoryRequest"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryTransferHistoryRequest 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_QueryTransferHistoryRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryTransferHistoryRequest.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.genesistransfer.QueryTransferHistoryRequest"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryTransferHistoryRequest 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_QueryTransferHistoryRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryTransferHistoryRequest.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.genesistransfer.QueryTransferHistoryRequest"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryTransferHistoryRequest 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_QueryTransferHistoryRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.genesistransfer.QueryTransferHistoryRequest", 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_QueryTransferHistoryRequest) 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_QueryTransferHistoryRequest) 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_QueryTransferHistoryRequest) 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_QueryTransferHistoryRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryTransferHistoryRequest)
+ 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.Pagination != nil {
+ l = options.Size(x.Pagination)
+ 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().(*QueryTransferHistoryRequest)
+ 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.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 {
+ 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().(*QueryTransferHistoryRequest)
+ 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: QueryTransferHistoryRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryTransferHistoryRequest: 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:])
+ 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 = (*_QueryTransferHistoryResponse_1_list)(nil)
+
+type _QueryTransferHistoryResponse_1_list struct {
+ list *[]*TransferRecord
+}
+
+func (x *_QueryTransferHistoryResponse_1_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_QueryTransferHistoryResponse_1_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryTransferHistoryResponse_1_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*TransferRecord)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_QueryTransferHistoryResponse_1_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*TransferRecord)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryTransferHistoryResponse_1_list) AppendMutable() protoreflect.Value {
+ v := new(TransferRecord)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryTransferHistoryResponse_1_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_QueryTransferHistoryResponse_1_list) NewElement() protoreflect.Value {
+ v := new(TransferRecord)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryTransferHistoryResponse_1_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_QueryTransferHistoryResponse protoreflect.MessageDescriptor
+ fd_QueryTransferHistoryResponse_transfer_records protoreflect.FieldDescriptor
+ fd_QueryTransferHistoryResponse_pagination protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_genesistransfer_query_proto_init()
+ md_QueryTransferHistoryResponse = File_inference_genesistransfer_query_proto.Messages().ByName("QueryTransferHistoryResponse")
+ fd_QueryTransferHistoryResponse_transfer_records = md_QueryTransferHistoryResponse.Fields().ByName("transfer_records")
+ fd_QueryTransferHistoryResponse_pagination = md_QueryTransferHistoryResponse.Fields().ByName("pagination")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryTransferHistoryResponse)(nil)
+
+type fastReflection_QueryTransferHistoryResponse QueryTransferHistoryResponse
+
+func (x *QueryTransferHistoryResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryTransferHistoryResponse)(x)
+}
+
+func (x *QueryTransferHistoryResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_genesistransfer_query_proto_msgTypes[5]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryTransferHistoryResponse_messageType fastReflection_QueryTransferHistoryResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryTransferHistoryResponse_messageType{}
+
+type fastReflection_QueryTransferHistoryResponse_messageType struct{}
+
+func (x fastReflection_QueryTransferHistoryResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryTransferHistoryResponse)(nil)
+}
+func (x fastReflection_QueryTransferHistoryResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryTransferHistoryResponse)
+}
+func (x fastReflection_QueryTransferHistoryResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryTransferHistoryResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryTransferHistoryResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryTransferHistoryResponse
+}
+
+// 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_QueryTransferHistoryResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryTransferHistoryResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryTransferHistoryResponse) New() protoreflect.Message {
+ return new(fastReflection_QueryTransferHistoryResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryTransferHistoryResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryTransferHistoryResponse)(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_QueryTransferHistoryResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if len(x.TransferRecords) != 0 {
+ value := protoreflect.ValueOfList(&_QueryTransferHistoryResponse_1_list{list: &x.TransferRecords})
+ if !f(fd_QueryTransferHistoryResponse_transfer_records, value) {
+ return
+ }
+ }
+ if x.Pagination != nil {
+ value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+ if !f(fd_QueryTransferHistoryResponse_pagination, 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_QueryTransferHistoryResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryTransferHistoryResponse.transfer_records":
+ return len(x.TransferRecords) != 0
+ case "inference.genesistransfer.QueryTransferHistoryResponse.pagination":
+ return x.Pagination != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryTransferHistoryResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryTransferHistoryResponse 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_QueryTransferHistoryResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryTransferHistoryResponse.transfer_records":
+ x.TransferRecords = nil
+ case "inference.genesistransfer.QueryTransferHistoryResponse.pagination":
+ x.Pagination = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryTransferHistoryResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryTransferHistoryResponse 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_QueryTransferHistoryResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.genesistransfer.QueryTransferHistoryResponse.transfer_records":
+ if len(x.TransferRecords) == 0 {
+ return protoreflect.ValueOfList(&_QueryTransferHistoryResponse_1_list{})
+ }
+ listValue := &_QueryTransferHistoryResponse_1_list{list: &x.TransferRecords}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.genesistransfer.QueryTransferHistoryResponse.pagination":
+ value := x.Pagination
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryTransferHistoryResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryTransferHistoryResponse 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_QueryTransferHistoryResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryTransferHistoryResponse.transfer_records":
+ lv := value.List()
+ clv := lv.(*_QueryTransferHistoryResponse_1_list)
+ x.TransferRecords = *clv.list
+ case "inference.genesistransfer.QueryTransferHistoryResponse.pagination":
+ x.Pagination = value.Message().Interface().(*v1beta1.PageResponse)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryTransferHistoryResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryTransferHistoryResponse 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_QueryTransferHistoryResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryTransferHistoryResponse.transfer_records":
+ if x.TransferRecords == nil {
+ x.TransferRecords = []*TransferRecord{}
+ }
+ value := &_QueryTransferHistoryResponse_1_list{list: &x.TransferRecords}
+ return protoreflect.ValueOfList(value)
+ case "inference.genesistransfer.QueryTransferHistoryResponse.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.genesistransfer.QueryTransferHistoryResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryTransferHistoryResponse 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_QueryTransferHistoryResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryTransferHistoryResponse.transfer_records":
+ list := []*TransferRecord{}
+ return protoreflect.ValueOfList(&_QueryTransferHistoryResponse_1_list{list: &list})
+ case "inference.genesistransfer.QueryTransferHistoryResponse.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.genesistransfer.QueryTransferHistoryResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryTransferHistoryResponse 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_QueryTransferHistoryResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.genesistransfer.QueryTransferHistoryResponse", 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_QueryTransferHistoryResponse) 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_QueryTransferHistoryResponse) 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_QueryTransferHistoryResponse) 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_QueryTransferHistoryResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryTransferHistoryResponse)
+ 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.TransferRecords) > 0 {
+ for _, e := range x.TransferRecords {
+ 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)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*QueryTransferHistoryResponse)
+ 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.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.TransferRecords) > 0 {
+ for iNdEx := len(x.TransferRecords) - 1; iNdEx >= 0; iNdEx-- {
+ encoded, err := options.Marshal(x.TransferRecords[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().(*QueryTransferHistoryResponse)
+ 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: QueryTransferHistoryResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryTransferHistoryResponse: 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 TransferRecords", 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.TransferRecords = append(x.TransferRecords, &TransferRecord{})
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.TransferRecords[len(x.TransferRecords)-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
+ 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_QueryAllowedAccountsRequest protoreflect.MessageDescriptor
+)
+
+func init() {
+ file_inference_genesistransfer_query_proto_init()
+ md_QueryAllowedAccountsRequest = File_inference_genesistransfer_query_proto.Messages().ByName("QueryAllowedAccountsRequest")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryAllowedAccountsRequest)(nil)
+
+type fastReflection_QueryAllowedAccountsRequest QueryAllowedAccountsRequest
+
+func (x *QueryAllowedAccountsRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryAllowedAccountsRequest)(x)
+}
+
+func (x *QueryAllowedAccountsRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_genesistransfer_query_proto_msgTypes[6]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryAllowedAccountsRequest_messageType fastReflection_QueryAllowedAccountsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllowedAccountsRequest_messageType{}
+
+type fastReflection_QueryAllowedAccountsRequest_messageType struct{}
+
+func (x fastReflection_QueryAllowedAccountsRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryAllowedAccountsRequest)(nil)
+}
+func (x fastReflection_QueryAllowedAccountsRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryAllowedAccountsRequest)
+}
+func (x fastReflection_QueryAllowedAccountsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryAllowedAccountsRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryAllowedAccountsRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryAllowedAccountsRequest
+}
+
+// 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_QueryAllowedAccountsRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryAllowedAccountsRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryAllowedAccountsRequest) New() protoreflect.Message {
+ return new(fastReflection_QueryAllowedAccountsRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryAllowedAccountsRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryAllowedAccountsRequest)(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_QueryAllowedAccountsRequest) 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_QueryAllowedAccountsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryAllowedAccountsRequest"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryAllowedAccountsRequest 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_QueryAllowedAccountsRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryAllowedAccountsRequest"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryAllowedAccountsRequest 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_QueryAllowedAccountsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryAllowedAccountsRequest"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryAllowedAccountsRequest 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_QueryAllowedAccountsRequest) 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.genesistransfer.QueryAllowedAccountsRequest"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryAllowedAccountsRequest 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_QueryAllowedAccountsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryAllowedAccountsRequest"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryAllowedAccountsRequest 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_QueryAllowedAccountsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryAllowedAccountsRequest"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryAllowedAccountsRequest 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_QueryAllowedAccountsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.genesistransfer.QueryAllowedAccountsRequest", 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_QueryAllowedAccountsRequest) 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_QueryAllowedAccountsRequest) 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_QueryAllowedAccountsRequest) 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_QueryAllowedAccountsRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryAllowedAccountsRequest)
+ 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().(*QueryAllowedAccountsRequest)
+ 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().(*QueryAllowedAccountsRequest)
+ 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: QueryAllowedAccountsRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllowedAccountsRequest: 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 = (*_QueryAllowedAccountsResponse_1_list)(nil)
+
+type _QueryAllowedAccountsResponse_1_list struct {
+ list *[]string
+}
+
+func (x *_QueryAllowedAccountsResponse_1_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_QueryAllowedAccountsResponse_1_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfString((*x.list)[i])
+}
+
+func (x *_QueryAllowedAccountsResponse_1_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.String()
+ concreteValue := valueUnwrapped
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_QueryAllowedAccountsResponse_1_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.String()
+ concreteValue := valueUnwrapped
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryAllowedAccountsResponse_1_list) AppendMutable() protoreflect.Value {
+ panic(fmt.Errorf("AppendMutable can not be called on message QueryAllowedAccountsResponse at list field AllowedAccounts as it is not of Message kind"))
+}
+
+func (x *_QueryAllowedAccountsResponse_1_list) Truncate(n int) {
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_QueryAllowedAccountsResponse_1_list) NewElement() protoreflect.Value {
+ v := ""
+ return protoreflect.ValueOfString(v)
+}
+
+func (x *_QueryAllowedAccountsResponse_1_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_QueryAllowedAccountsResponse protoreflect.MessageDescriptor
+ fd_QueryAllowedAccountsResponse_allowed_accounts protoreflect.FieldDescriptor
+ fd_QueryAllowedAccountsResponse_restrict_to_list protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_genesistransfer_query_proto_init()
+ md_QueryAllowedAccountsResponse = File_inference_genesistransfer_query_proto.Messages().ByName("QueryAllowedAccountsResponse")
+ fd_QueryAllowedAccountsResponse_allowed_accounts = md_QueryAllowedAccountsResponse.Fields().ByName("allowed_accounts")
+ fd_QueryAllowedAccountsResponse_restrict_to_list = md_QueryAllowedAccountsResponse.Fields().ByName("restrict_to_list")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryAllowedAccountsResponse)(nil)
+
+type fastReflection_QueryAllowedAccountsResponse QueryAllowedAccountsResponse
+
+func (x *QueryAllowedAccountsResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryAllowedAccountsResponse)(x)
+}
+
+func (x *QueryAllowedAccountsResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_genesistransfer_query_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_QueryAllowedAccountsResponse_messageType fastReflection_QueryAllowedAccountsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllowedAccountsResponse_messageType{}
+
+type fastReflection_QueryAllowedAccountsResponse_messageType struct{}
+
+func (x fastReflection_QueryAllowedAccountsResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryAllowedAccountsResponse)(nil)
+}
+func (x fastReflection_QueryAllowedAccountsResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryAllowedAccountsResponse)
+}
+func (x fastReflection_QueryAllowedAccountsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryAllowedAccountsResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryAllowedAccountsResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryAllowedAccountsResponse
+}
+
+// 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_QueryAllowedAccountsResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryAllowedAccountsResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryAllowedAccountsResponse) New() protoreflect.Message {
+ return new(fastReflection_QueryAllowedAccountsResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryAllowedAccountsResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryAllowedAccountsResponse)(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_QueryAllowedAccountsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if len(x.AllowedAccounts) != 0 {
+ value := protoreflect.ValueOfList(&_QueryAllowedAccountsResponse_1_list{list: &x.AllowedAccounts})
+ if !f(fd_QueryAllowedAccountsResponse_allowed_accounts, value) {
+ return
+ }
+ }
+ if x.RestrictToList != false {
+ value := protoreflect.ValueOfBool(x.RestrictToList)
+ if !f(fd_QueryAllowedAccountsResponse_restrict_to_list, 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_QueryAllowedAccountsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryAllowedAccountsResponse.allowed_accounts":
+ return len(x.AllowedAccounts) != 0
+ case "inference.genesistransfer.QueryAllowedAccountsResponse.restrict_to_list":
+ return x.RestrictToList != false
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryAllowedAccountsResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryAllowedAccountsResponse 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_QueryAllowedAccountsResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryAllowedAccountsResponse.allowed_accounts":
+ x.AllowedAccounts = nil
+ case "inference.genesistransfer.QueryAllowedAccountsResponse.restrict_to_list":
+ x.RestrictToList = false
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryAllowedAccountsResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryAllowedAccountsResponse 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_QueryAllowedAccountsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.genesistransfer.QueryAllowedAccountsResponse.allowed_accounts":
+ if len(x.AllowedAccounts) == 0 {
+ return protoreflect.ValueOfList(&_QueryAllowedAccountsResponse_1_list{})
+ }
+ listValue := &_QueryAllowedAccountsResponse_1_list{list: &x.AllowedAccounts}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.genesistransfer.QueryAllowedAccountsResponse.restrict_to_list":
+ value := x.RestrictToList
+ return protoreflect.ValueOfBool(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryAllowedAccountsResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryAllowedAccountsResponse 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_QueryAllowedAccountsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryAllowedAccountsResponse.allowed_accounts":
+ lv := value.List()
+ clv := lv.(*_QueryAllowedAccountsResponse_1_list)
+ x.AllowedAccounts = *clv.list
+ case "inference.genesistransfer.QueryAllowedAccountsResponse.restrict_to_list":
+ x.RestrictToList = value.Bool()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryAllowedAccountsResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryAllowedAccountsResponse 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_QueryAllowedAccountsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryAllowedAccountsResponse.allowed_accounts":
+ if x.AllowedAccounts == nil {
+ x.AllowedAccounts = []string{}
+ }
+ value := &_QueryAllowedAccountsResponse_1_list{list: &x.AllowedAccounts}
+ return protoreflect.ValueOfList(value)
+ case "inference.genesistransfer.QueryAllowedAccountsResponse.restrict_to_list":
+ panic(fmt.Errorf("field restrict_to_list of message inference.genesistransfer.QueryAllowedAccountsResponse is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryAllowedAccountsResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryAllowedAccountsResponse 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_QueryAllowedAccountsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryAllowedAccountsResponse.allowed_accounts":
+ list := []string{}
+ return protoreflect.ValueOfList(&_QueryAllowedAccountsResponse_1_list{list: &list})
+ case "inference.genesistransfer.QueryAllowedAccountsResponse.restrict_to_list":
+ return protoreflect.ValueOfBool(false)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryAllowedAccountsResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryAllowedAccountsResponse 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_QueryAllowedAccountsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.genesistransfer.QueryAllowedAccountsResponse", 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_QueryAllowedAccountsResponse) 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_QueryAllowedAccountsResponse) 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_QueryAllowedAccountsResponse) 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_QueryAllowedAccountsResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryAllowedAccountsResponse)
+ 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.AllowedAccounts) > 0 {
+ for _, s := range x.AllowedAccounts {
+ l = len(s)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ }
+ if x.RestrictToList {
+ 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().(*QueryAllowedAccountsResponse)
+ 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.RestrictToList {
+ i--
+ if x.RestrictToList {
+ dAtA[i] = 1
+ } else {
+ dAtA[i] = 0
+ }
+ i--
+ dAtA[i] = 0x10
+ }
+ if len(x.AllowedAccounts) > 0 {
+ for iNdEx := len(x.AllowedAccounts) - 1; iNdEx >= 0; iNdEx-- {
+ i -= len(x.AllowedAccounts[iNdEx])
+ copy(dAtA[i:], x.AllowedAccounts[iNdEx])
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.AllowedAccounts[iNdEx])))
+ 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().(*QueryAllowedAccountsResponse)
+ 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: QueryAllowedAccountsResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllowedAccountsResponse: 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 AllowedAccounts", 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.AllowedAccounts = append(x.AllowedAccounts, 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 RestrictToList", 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.RestrictToList = 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_QueryTransferEligibilityRequest protoreflect.MessageDescriptor
+ fd_QueryTransferEligibilityRequest_genesis_address protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_genesistransfer_query_proto_init()
+ md_QueryTransferEligibilityRequest = File_inference_genesistransfer_query_proto.Messages().ByName("QueryTransferEligibilityRequest")
+ fd_QueryTransferEligibilityRequest_genesis_address = md_QueryTransferEligibilityRequest.Fields().ByName("genesis_address")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryTransferEligibilityRequest)(nil)
+
+type fastReflection_QueryTransferEligibilityRequest QueryTransferEligibilityRequest
+
+func (x *QueryTransferEligibilityRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryTransferEligibilityRequest)(x)
+}
+
+func (x *QueryTransferEligibilityRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_genesistransfer_query_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_QueryTransferEligibilityRequest_messageType fastReflection_QueryTransferEligibilityRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryTransferEligibilityRequest_messageType{}
+
+type fastReflection_QueryTransferEligibilityRequest_messageType struct{}
+
+func (x fastReflection_QueryTransferEligibilityRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryTransferEligibilityRequest)(nil)
+}
+func (x fastReflection_QueryTransferEligibilityRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryTransferEligibilityRequest)
+}
+func (x fastReflection_QueryTransferEligibilityRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryTransferEligibilityRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryTransferEligibilityRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryTransferEligibilityRequest
+}
+
+// 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_QueryTransferEligibilityRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryTransferEligibilityRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryTransferEligibilityRequest) New() protoreflect.Message {
+ return new(fastReflection_QueryTransferEligibilityRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryTransferEligibilityRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryTransferEligibilityRequest)(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_QueryTransferEligibilityRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.GenesisAddress != "" {
+ value := protoreflect.ValueOfString(x.GenesisAddress)
+ if !f(fd_QueryTransferEligibilityRequest_genesis_address, 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_QueryTransferEligibilityRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryTransferEligibilityRequest.genesis_address":
+ return x.GenesisAddress != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryTransferEligibilityRequest"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryTransferEligibilityRequest 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_QueryTransferEligibilityRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryTransferEligibilityRequest.genesis_address":
+ x.GenesisAddress = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryTransferEligibilityRequest"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryTransferEligibilityRequest 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_QueryTransferEligibilityRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.genesistransfer.QueryTransferEligibilityRequest.genesis_address":
+ value := x.GenesisAddress
+ return protoreflect.ValueOfString(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryTransferEligibilityRequest"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryTransferEligibilityRequest 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_QueryTransferEligibilityRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryTransferEligibilityRequest.genesis_address":
+ x.GenesisAddress = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryTransferEligibilityRequest"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryTransferEligibilityRequest 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_QueryTransferEligibilityRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryTransferEligibilityRequest.genesis_address":
+ panic(fmt.Errorf("field genesis_address of message inference.genesistransfer.QueryTransferEligibilityRequest is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryTransferEligibilityRequest"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryTransferEligibilityRequest 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_QueryTransferEligibilityRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryTransferEligibilityRequest.genesis_address":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryTransferEligibilityRequest"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryTransferEligibilityRequest 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_QueryTransferEligibilityRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.genesistransfer.QueryTransferEligibilityRequest", 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_QueryTransferEligibilityRequest) 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_QueryTransferEligibilityRequest) 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_QueryTransferEligibilityRequest) 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_QueryTransferEligibilityRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryTransferEligibilityRequest)
+ 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.GenesisAddress)
+ 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().(*QueryTransferEligibilityRequest)
+ 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.GenesisAddress) > 0 {
+ i -= len(x.GenesisAddress)
+ copy(dAtA[i:], x.GenesisAddress)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.GenesisAddress)))
+ 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().(*QueryTransferEligibilityRequest)
+ 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: QueryTransferEligibilityRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryTransferEligibilityRequest: 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 GenesisAddress", 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.GenesisAddress = 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_QueryTransferEligibilityResponse protoreflect.MessageDescriptor
+ fd_QueryTransferEligibilityResponse_is_eligible protoreflect.FieldDescriptor
+ fd_QueryTransferEligibilityResponse_reason protoreflect.FieldDescriptor
+ fd_QueryTransferEligibilityResponse_already_transferred protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_genesistransfer_query_proto_init()
+ md_QueryTransferEligibilityResponse = File_inference_genesistransfer_query_proto.Messages().ByName("QueryTransferEligibilityResponse")
+ fd_QueryTransferEligibilityResponse_is_eligible = md_QueryTransferEligibilityResponse.Fields().ByName("is_eligible")
+ fd_QueryTransferEligibilityResponse_reason = md_QueryTransferEligibilityResponse.Fields().ByName("reason")
+ fd_QueryTransferEligibilityResponse_already_transferred = md_QueryTransferEligibilityResponse.Fields().ByName("already_transferred")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryTransferEligibilityResponse)(nil)
+
+type fastReflection_QueryTransferEligibilityResponse QueryTransferEligibilityResponse
+
+func (x *QueryTransferEligibilityResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryTransferEligibilityResponse)(x)
+}
+
+func (x *QueryTransferEligibilityResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_genesistransfer_query_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_QueryTransferEligibilityResponse_messageType fastReflection_QueryTransferEligibilityResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryTransferEligibilityResponse_messageType{}
+
+type fastReflection_QueryTransferEligibilityResponse_messageType struct{}
+
+func (x fastReflection_QueryTransferEligibilityResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryTransferEligibilityResponse)(nil)
+}
+func (x fastReflection_QueryTransferEligibilityResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryTransferEligibilityResponse)
+}
+func (x fastReflection_QueryTransferEligibilityResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryTransferEligibilityResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryTransferEligibilityResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryTransferEligibilityResponse
+}
+
+// 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_QueryTransferEligibilityResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryTransferEligibilityResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryTransferEligibilityResponse) New() protoreflect.Message {
+ return new(fastReflection_QueryTransferEligibilityResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryTransferEligibilityResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryTransferEligibilityResponse)(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_QueryTransferEligibilityResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.IsEligible != false {
+ value := protoreflect.ValueOfBool(x.IsEligible)
+ if !f(fd_QueryTransferEligibilityResponse_is_eligible, value) {
+ return
+ }
+ }
+ if x.Reason != "" {
+ value := protoreflect.ValueOfString(x.Reason)
+ if !f(fd_QueryTransferEligibilityResponse_reason, value) {
+ return
+ }
+ }
+ if x.AlreadyTransferred != false {
+ value := protoreflect.ValueOfBool(x.AlreadyTransferred)
+ if !f(fd_QueryTransferEligibilityResponse_already_transferred, 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_QueryTransferEligibilityResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryTransferEligibilityResponse.is_eligible":
+ return x.IsEligible != false
+ case "inference.genesistransfer.QueryTransferEligibilityResponse.reason":
+ return x.Reason != ""
+ case "inference.genesistransfer.QueryTransferEligibilityResponse.already_transferred":
+ return x.AlreadyTransferred != false
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryTransferEligibilityResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryTransferEligibilityResponse 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_QueryTransferEligibilityResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryTransferEligibilityResponse.is_eligible":
+ x.IsEligible = false
+ case "inference.genesistransfer.QueryTransferEligibilityResponse.reason":
+ x.Reason = ""
+ case "inference.genesistransfer.QueryTransferEligibilityResponse.already_transferred":
+ x.AlreadyTransferred = false
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryTransferEligibilityResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryTransferEligibilityResponse 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_QueryTransferEligibilityResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.genesistransfer.QueryTransferEligibilityResponse.is_eligible":
+ value := x.IsEligible
+ return protoreflect.ValueOfBool(value)
+ case "inference.genesistransfer.QueryTransferEligibilityResponse.reason":
+ value := x.Reason
+ return protoreflect.ValueOfString(value)
+ case "inference.genesistransfer.QueryTransferEligibilityResponse.already_transferred":
+ value := x.AlreadyTransferred
+ return protoreflect.ValueOfBool(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryTransferEligibilityResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryTransferEligibilityResponse 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_QueryTransferEligibilityResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryTransferEligibilityResponse.is_eligible":
+ x.IsEligible = value.Bool()
+ case "inference.genesistransfer.QueryTransferEligibilityResponse.reason":
+ x.Reason = value.Interface().(string)
+ case "inference.genesistransfer.QueryTransferEligibilityResponse.already_transferred":
+ x.AlreadyTransferred = value.Bool()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryTransferEligibilityResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryTransferEligibilityResponse 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_QueryTransferEligibilityResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryTransferEligibilityResponse.is_eligible":
+ panic(fmt.Errorf("field is_eligible of message inference.genesistransfer.QueryTransferEligibilityResponse is not mutable"))
+ case "inference.genesistransfer.QueryTransferEligibilityResponse.reason":
+ panic(fmt.Errorf("field reason of message inference.genesistransfer.QueryTransferEligibilityResponse is not mutable"))
+ case "inference.genesistransfer.QueryTransferEligibilityResponse.already_transferred":
+ panic(fmt.Errorf("field already_transferred of message inference.genesistransfer.QueryTransferEligibilityResponse is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryTransferEligibilityResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryTransferEligibilityResponse 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_QueryTransferEligibilityResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.genesistransfer.QueryTransferEligibilityResponse.is_eligible":
+ return protoreflect.ValueOfBool(false)
+ case "inference.genesistransfer.QueryTransferEligibilityResponse.reason":
+ return protoreflect.ValueOfString("")
+ case "inference.genesistransfer.QueryTransferEligibilityResponse.already_transferred":
+ return protoreflect.ValueOfBool(false)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.QueryTransferEligibilityResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.QueryTransferEligibilityResponse 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_QueryTransferEligibilityResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.genesistransfer.QueryTransferEligibilityResponse", 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_QueryTransferEligibilityResponse) 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_QueryTransferEligibilityResponse) 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_QueryTransferEligibilityResponse) 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_QueryTransferEligibilityResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryTransferEligibilityResponse)
+ 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.IsEligible {
+ n += 2
+ }
+ l = len(x.Reason)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.AlreadyTransferred {
+ 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().(*QueryTransferEligibilityResponse)
+ 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.AlreadyTransferred {
+ i--
+ if x.AlreadyTransferred {
+ dAtA[i] = 1
+ } else {
+ dAtA[i] = 0
+ }
+ i--
+ dAtA[i] = 0x18
+ }
+ 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] = 0x12
+ }
+ if x.IsEligible {
+ i--
+ if x.IsEligible {
+ 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().(*QueryTransferEligibilityResponse)
+ 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: QueryTransferEligibilityResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryTransferEligibilityResponse: 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 IsEligible", 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.IsEligible = 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 Reason", 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.Reason = 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 AlreadyTransferred", 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.AlreadyTransferred = 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,
+ }
+}
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// protoc-gen-go v1.27.0
+// protoc (unknown)
+// source: inference/genesistransfer/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_genesistransfer_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_genesistransfer_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_genesistransfer_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_genesistransfer_query_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *QueryParamsResponse) GetParams() *Params {
+ if x != nil {
+ return x.Params
+ }
+ return nil
+}
+
+// QueryTransferStatusRequest is request type for the Query/TransferStatus RPC method.
+type QueryTransferStatusRequest struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ GenesisAddress string `protobuf:"bytes,1,opt,name=genesis_address,json=genesisAddress,proto3" json:"genesis_address,omitempty"` // Address of the genesis account to query
+}
+
+func (x *QueryTransferStatusRequest) Reset() {
+ *x = QueryTransferStatusRequest{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_genesistransfer_query_proto_msgTypes[2]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *QueryTransferStatusRequest) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryTransferStatusRequest) ProtoMessage() {}
+
+// Deprecated: Use QueryTransferStatusRequest.ProtoReflect.Descriptor instead.
+func (*QueryTransferStatusRequest) Descriptor() ([]byte, []int) {
+ return file_inference_genesistransfer_query_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *QueryTransferStatusRequest) GetGenesisAddress() string {
+ if x != nil {
+ return x.GenesisAddress
+ }
+ return ""
+}
+
+// QueryTransferStatusResponse is response type for the Query/TransferStatus RPC method.
+type QueryTransferStatusResponse struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ IsTransferred bool `protobuf:"varint,1,opt,name=is_transferred,json=isTransferred,proto3" json:"is_transferred,omitempty"` // Whether the account has been transferred
+ TransferRecord *TransferRecord `protobuf:"bytes,2,opt,name=transfer_record,json=transferRecord,proto3" json:"transfer_record,omitempty"` // Transfer record if it exists (optional)
+}
+
+func (x *QueryTransferStatusResponse) Reset() {
+ *x = QueryTransferStatusResponse{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_genesistransfer_query_proto_msgTypes[3]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *QueryTransferStatusResponse) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryTransferStatusResponse) ProtoMessage() {}
+
+// Deprecated: Use QueryTransferStatusResponse.ProtoReflect.Descriptor instead.
+func (*QueryTransferStatusResponse) Descriptor() ([]byte, []int) {
+ return file_inference_genesistransfer_query_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *QueryTransferStatusResponse) GetIsTransferred() bool {
+ if x != nil {
+ return x.IsTransferred
+ }
+ return false
+}
+
+func (x *QueryTransferStatusResponse) GetTransferRecord() *TransferRecord {
+ if x != nil {
+ return x.TransferRecord
+ }
+ return nil
+}
+
+// QueryTransferHistoryRequest is request type for the Query/TransferHistory RPC method.
+type QueryTransferHistoryRequest struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Pagination *v1beta1.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"` // Optional pagination
+}
+
+func (x *QueryTransferHistoryRequest) Reset() {
+ *x = QueryTransferHistoryRequest{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_genesistransfer_query_proto_msgTypes[4]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *QueryTransferHistoryRequest) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryTransferHistoryRequest) ProtoMessage() {}
+
+// Deprecated: Use QueryTransferHistoryRequest.ProtoReflect.Descriptor instead.
+func (*QueryTransferHistoryRequest) Descriptor() ([]byte, []int) {
+ return file_inference_genesistransfer_query_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *QueryTransferHistoryRequest) GetPagination() *v1beta1.PageRequest {
+ if x != nil {
+ return x.Pagination
+ }
+ return nil
+}
+
+// QueryTransferHistoryResponse is response type for the Query/TransferHistory RPC method.
+type QueryTransferHistoryResponse struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ TransferRecords []*TransferRecord `protobuf:"bytes,1,rep,name=transfer_records,json=transferRecords,proto3" json:"transfer_records,omitempty"`
+ Pagination *v1beta1.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"` // Pagination information
+}
+
+func (x *QueryTransferHistoryResponse) Reset() {
+ *x = QueryTransferHistoryResponse{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_genesistransfer_query_proto_msgTypes[5]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *QueryTransferHistoryResponse) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryTransferHistoryResponse) ProtoMessage() {}
+
+// Deprecated: Use QueryTransferHistoryResponse.ProtoReflect.Descriptor instead.
+func (*QueryTransferHistoryResponse) Descriptor() ([]byte, []int) {
+ return file_inference_genesistransfer_query_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *QueryTransferHistoryResponse) GetTransferRecords() []*TransferRecord {
+ if x != nil {
+ return x.TransferRecords
+ }
+ return nil
+}
+
+func (x *QueryTransferHistoryResponse) GetPagination() *v1beta1.PageResponse {
+ if x != nil {
+ return x.Pagination
+ }
+ return nil
+}
+
+// QueryAllowedAccountsRequest is request type for the Query/AllowedAccounts RPC method.
+type QueryAllowedAccountsRequest struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+}
+
+func (x *QueryAllowedAccountsRequest) Reset() {
+ *x = QueryAllowedAccountsRequest{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_genesistransfer_query_proto_msgTypes[6]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *QueryAllowedAccountsRequest) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryAllowedAccountsRequest) ProtoMessage() {}
+
+// Deprecated: Use QueryAllowedAccountsRequest.ProtoReflect.Descriptor instead.
+func (*QueryAllowedAccountsRequest) Descriptor() ([]byte, []int) {
+ return file_inference_genesistransfer_query_proto_rawDescGZIP(), []int{6}
+}
+
+// QueryAllowedAccountsResponse is response type for the Query/AllowedAccounts RPC method.
+type QueryAllowedAccountsResponse struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ AllowedAccounts []string `protobuf:"bytes,1,rep,name=allowed_accounts,json=allowedAccounts,proto3" json:"allowed_accounts,omitempty"` // List of allowed genesis account addresses
+ RestrictToList bool `protobuf:"varint,2,opt,name=restrict_to_list,json=restrictToList,proto3" json:"restrict_to_list,omitempty"` // Whether whitelist enforcement is enabled
+}
+
+func (x *QueryAllowedAccountsResponse) Reset() {
+ *x = QueryAllowedAccountsResponse{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_genesistransfer_query_proto_msgTypes[7]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *QueryAllowedAccountsResponse) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryAllowedAccountsResponse) ProtoMessage() {}
+
+// Deprecated: Use QueryAllowedAccountsResponse.ProtoReflect.Descriptor instead.
+func (*QueryAllowedAccountsResponse) Descriptor() ([]byte, []int) {
+ return file_inference_genesistransfer_query_proto_rawDescGZIP(), []int{7}
+}
+
+func (x *QueryAllowedAccountsResponse) GetAllowedAccounts() []string {
+ if x != nil {
+ return x.AllowedAccounts
+ }
+ return nil
+}
+
+func (x *QueryAllowedAccountsResponse) GetRestrictToList() bool {
+ if x != nil {
+ return x.RestrictToList
+ }
+ return false
+}
+
+// QueryTransferEligibilityRequest is request type for the Query/TransferEligibility RPC method.
+type QueryTransferEligibilityRequest struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ GenesisAddress string `protobuf:"bytes,1,opt,name=genesis_address,json=genesisAddress,proto3" json:"genesis_address,omitempty"` // Address of the genesis account to check eligibility
+}
+
+func (x *QueryTransferEligibilityRequest) Reset() {
+ *x = QueryTransferEligibilityRequest{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_genesistransfer_query_proto_msgTypes[8]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *QueryTransferEligibilityRequest) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryTransferEligibilityRequest) ProtoMessage() {}
+
+// Deprecated: Use QueryTransferEligibilityRequest.ProtoReflect.Descriptor instead.
+func (*QueryTransferEligibilityRequest) Descriptor() ([]byte, []int) {
+ return file_inference_genesistransfer_query_proto_rawDescGZIP(), []int{8}
+}
+
+func (x *QueryTransferEligibilityRequest) GetGenesisAddress() string {
+ if x != nil {
+ return x.GenesisAddress
+ }
+ return ""
+}
+
+// QueryTransferEligibilityResponse is response type for the Query/TransferEligibility RPC method.
+type QueryTransferEligibilityResponse struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ IsEligible bool `protobuf:"varint,1,opt,name=is_eligible,json=isEligible,proto3" json:"is_eligible,omitempty"` // Whether the account is eligible for transfer
+ Reason string `protobuf:"bytes,2,opt,name=reason,proto3" json:"reason,omitempty"` // Reason for ineligibility (if applicable)
+ AlreadyTransferred bool `protobuf:"varint,3,opt,name=already_transferred,json=alreadyTransferred,proto3" json:"already_transferred,omitempty"` // Whether the account has already been transferred
+}
+
+func (x *QueryTransferEligibilityResponse) Reset() {
+ *x = QueryTransferEligibilityResponse{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_genesistransfer_query_proto_msgTypes[9]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *QueryTransferEligibilityResponse) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryTransferEligibilityResponse) ProtoMessage() {}
+
+// Deprecated: Use QueryTransferEligibilityResponse.ProtoReflect.Descriptor instead.
+func (*QueryTransferEligibilityResponse) Descriptor() ([]byte, []int) {
+ return file_inference_genesistransfer_query_proto_rawDescGZIP(), []int{9}
+}
+
+func (x *QueryTransferEligibilityResponse) GetIsEligible() bool {
+ if x != nil {
+ return x.IsEligible
+ }
+ return false
+}
+
+func (x *QueryTransferEligibilityResponse) GetReason() string {
+ if x != nil {
+ return x.Reason
+ }
+ return ""
+}
+
+func (x *QueryTransferEligibilityResponse) GetAlreadyTransferred() bool {
+ if x != nil {
+ return x.AlreadyTransferred
+ }
+ return false
+}
+
+var File_inference_genesistransfer_query_proto protoreflect.FileDescriptor
+
+var file_inference_genesistransfer_query_proto_rawDesc = []byte{
+ 0x0a, 0x25, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x67, 0x65, 0x6e, 0x65,
+ 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2f, 0x71, 0x75, 0x65, 0x72,
+ 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x19, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+ 0x63, 0x65, 0x2e, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66,
+ 0x65, 0x72, 0x1a, 0x11, 0x61, 0x6d, 0x69, 0x6e, 0x6f, 0x2f, 0x61, 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, 0x1c, 0x67, 0x6f, 0x6f,
+ 0x67, 0x6c, 0x65, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69,
+ 0x6f, 0x6e, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x2a, 0x63, 0x6f, 0x73, 0x6d, 0x6f,
+ 0x73, 0x2f, 0x62, 0x61, 0x73, 0x65, 0x2f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2f, 0x76, 0x31, 0x62,
+ 0x65, 0x74, 0x61, 0x31, 0x2f, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e,
+ 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x26, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+ 0x2f, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72,
+ 0x2f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x27, 0x69,
+ 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73,
+ 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2f, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73,
+ 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, 0x5b, 0x0a, 0x13,
+ 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f,
+ 0x6e, 0x73, 0x65, 0x12, 0x44, 0x0a, 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x01, 0x20,
+ 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+ 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 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, 0x45, 0x0a, 0x1a, 0x51, 0x75, 0x65,
+ 0x72, 0x79, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73,
+ 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x27, 0x0a, 0x0f, 0x67, 0x65, 0x6e, 0x65, 0x73,
+ 0x69, 0x73, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
+ 0x52, 0x0e, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73,
+ 0x22, 0x98, 0x01, 0x0a, 0x1b, 0x51, 0x75, 0x65, 0x72, 0x79, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66,
+ 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+ 0x12, 0x25, 0x0a, 0x0e, 0x69, 0x73, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x72,
+ 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0d, 0x69, 0x73, 0x54, 0x72, 0x61, 0x6e,
+ 0x73, 0x66, 0x65, 0x72, 0x72, 0x65, 0x64, 0x12, 0x52, 0x0a, 0x0f, 0x74, 0x72, 0x61, 0x6e, 0x73,
+ 0x66, 0x65, 0x72, 0x5f, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b,
+ 0x32, 0x29, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x67, 0x65, 0x6e,
+ 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x54, 0x72, 0x61,
+ 0x6e, 0x73, 0x66, 0x65, 0x72, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x52, 0x0e, 0x74, 0x72, 0x61,
+ 0x6e, 0x73, 0x66, 0x65, 0x72, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x22, 0x65, 0x0a, 0x1b, 0x51,
+ 0x75, 0x65, 0x72, 0x79, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x48, 0x69, 0x73, 0x74,
+ 0x6f, 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, 0xc8, 0x01, 0x0a, 0x1c, 0x51, 0x75, 0x65, 0x72, 0x79, 0x54, 0x72, 0x61, 0x6e,
+ 0x73, 0x66, 0x65, 0x72, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f,
+ 0x6e, 0x73, 0x65, 0x12, 0x5f, 0x0a, 0x10, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x5f,
+ 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x29, 0x2e,
+ 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69,
+ 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66,
+ 0x65, 0x72, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7,
+ 0xb0, 0x2a, 0x01, 0x52, 0x0f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x52, 0x65, 0x63,
+ 0x6f, 0x72, 0x64, 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, 0x1d, 0x0a,
+ 0x1b, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x41, 0x63, 0x63,
+ 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x73, 0x0a, 0x1c,
+ 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x41, 0x63, 0x63, 0x6f,
+ 0x75, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x29, 0x0a, 0x10,
+ 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x5f, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73,
+ 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0f, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x41,
+ 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x12, 0x28, 0x0a, 0x10, 0x72, 0x65, 0x73, 0x74, 0x72,
+ 0x69, 0x63, 0x74, 0x5f, 0x74, 0x6f, 0x5f, 0x6c, 0x69, 0x73, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28,
+ 0x08, 0x52, 0x0e, 0x72, 0x65, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x54, 0x6f, 0x4c, 0x69, 0x73,
+ 0x74, 0x22, 0x4a, 0x0a, 0x1f, 0x51, 0x75, 0x65, 0x72, 0x79, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66,
+ 0x65, 0x72, 0x45, 0x6c, 0x69, 0x67, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x52, 0x65, 0x71,
+ 0x75, 0x65, 0x73, 0x74, 0x12, 0x27, 0x0a, 0x0f, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x5f,
+ 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x67,
+ 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x8c, 0x01,
+ 0x0a, 0x20, 0x51, 0x75, 0x65, 0x72, 0x79, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x45,
+ 0x6c, 0x69, 0x67, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+ 0x73, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x69, 0x73, 0x5f, 0x65, 0x6c, 0x69, 0x67, 0x69, 0x62, 0x6c,
+ 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x69, 0x73, 0x45, 0x6c, 0x69, 0x67, 0x69,
+ 0x62, 0x6c, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x02, 0x20,
+ 0x01, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x12, 0x2f, 0x0a, 0x13, 0x61,
+ 0x6c, 0x72, 0x65, 0x61, 0x64, 0x79, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x72,
+ 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x12, 0x61, 0x6c, 0x72, 0x65, 0x61, 0x64,
+ 0x79, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x72, 0x65, 0x64, 0x32, 0xff, 0x07, 0x0a,
+ 0x05, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0xa1, 0x01, 0x0a, 0x06, 0x50, 0x61, 0x72, 0x61, 0x6d,
+ 0x73, 0x12, 0x2d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x67, 0x65,
+ 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x51, 0x75,
+ 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+ 0x1a, 0x2e, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x67, 0x65, 0x6e,
+ 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x51, 0x75, 0x65,
+ 0x72, 0x79, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+ 0x22, 0x38, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x32, 0x12, 0x30, 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, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73,
+ 0x66, 0x65, 0x72, 0x2f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0xd4, 0x01, 0x0a, 0x0e, 0x54,
+ 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x35, 0x2e,
+ 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69,
+ 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x54,
+ 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x71,
+ 0x75, 0x65, 0x73, 0x74, 0x1a, 0x36, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+ 0x2e, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72,
+ 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x53, 0x74,
+ 0x61, 0x74, 0x75, 0x73, 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,
+ 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2f,
+ 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2f,
+ 0x7b, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73,
+ 0x7d, 0x12, 0xc6, 0x01, 0x0a, 0x0f, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x48, 0x69,
+ 0x73, 0x74, 0x6f, 0x72, 0x79, 0x12, 0x36, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+ 0x65, 0x2e, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65,
+ 0x72, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x48,
+ 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x37, 0x2e,
+ 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69,
+ 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x54,
+ 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 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, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69,
+ 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66,
+ 0x65, 0x72, 0x5f, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x12, 0xc6, 0x01, 0x0a, 0x0f, 0x41,
+ 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x12, 0x36,
+ 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x67, 0x65, 0x6e, 0x65, 0x73,
+ 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79,
+ 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x52,
+ 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x37, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+ 0x63, 0x65, 0x2e, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66,
+ 0x65, 0x72, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x41,
+ 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 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, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66,
+ 0x65, 0x72, 0x2f, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x5f, 0x61, 0x63, 0x63, 0x6f, 0x75,
+ 0x6e, 0x74, 0x73, 0x12, 0xe8, 0x01, 0x0a, 0x13, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72,
+ 0x45, 0x6c, 0x69, 0x67, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x12, 0x3a, 0x2e, 0x69, 0x6e,
+ 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74,
+ 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x54, 0x72, 0x61,
+ 0x6e, 0x73, 0x66, 0x65, 0x72, 0x45, 0x6c, 0x69, 0x67, 0x69, 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, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73,
+ 0x66, 0x65, 0x72, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65,
+ 0x72, 0x45, 0x6c, 0x69, 0x67, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x52, 0x65, 0x73, 0x70,
+ 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x58, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x52, 0x12, 0x50, 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, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74,
+ 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72,
+ 0x5f, 0x65, 0x6c, 0x69, 0x67, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2f, 0x7b, 0x67, 0x65,
+ 0x6e, 0x65, 0x73, 0x69, 0x73, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x7d, 0x42, 0xdc,
+ 0x01, 0x0a, 0x1d, 0x63, 0x6f, 0x6d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+ 0x2e, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72,
+ 0x42, 0x0a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x2a,
+ 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, 0x67, 0x65, 0x6e, 0x65, 0x73,
+ 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0xa2, 0x02, 0x03, 0x49, 0x47, 0x58,
+ 0xaa, 0x02, 0x19, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x47, 0x65, 0x6e,
+ 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0xca, 0x02, 0x19, 0x49,
+ 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73,
+ 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0xe2, 0x02, 0x25, 0x49, 0x6e, 0x66, 0x65, 0x72,
+ 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e,
+ 0x73, 0x66, 0x65, 0x72, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61,
+ 0xea, 0x02, 0x1a, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x3a, 0x3a, 0x47, 0x65,
+ 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x62, 0x06, 0x70,
+ 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+ file_inference_genesistransfer_query_proto_rawDescOnce sync.Once
+ file_inference_genesistransfer_query_proto_rawDescData = file_inference_genesistransfer_query_proto_rawDesc
+)
+
+func file_inference_genesistransfer_query_proto_rawDescGZIP() []byte {
+ file_inference_genesistransfer_query_proto_rawDescOnce.Do(func() {
+ file_inference_genesistransfer_query_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_genesistransfer_query_proto_rawDescData)
+ })
+ return file_inference_genesistransfer_query_proto_rawDescData
+}
+
+var file_inference_genesistransfer_query_proto_msgTypes = make([]protoimpl.MessageInfo, 10)
+var file_inference_genesistransfer_query_proto_goTypes = []interface{}{
+ (*QueryParamsRequest)(nil), // 0: inference.genesistransfer.QueryParamsRequest
+ (*QueryParamsResponse)(nil), // 1: inference.genesistransfer.QueryParamsResponse
+ (*QueryTransferStatusRequest)(nil), // 2: inference.genesistransfer.QueryTransferStatusRequest
+ (*QueryTransferStatusResponse)(nil), // 3: inference.genesistransfer.QueryTransferStatusResponse
+ (*QueryTransferHistoryRequest)(nil), // 4: inference.genesistransfer.QueryTransferHistoryRequest
+ (*QueryTransferHistoryResponse)(nil), // 5: inference.genesistransfer.QueryTransferHistoryResponse
+ (*QueryAllowedAccountsRequest)(nil), // 6: inference.genesistransfer.QueryAllowedAccountsRequest
+ (*QueryAllowedAccountsResponse)(nil), // 7: inference.genesistransfer.QueryAllowedAccountsResponse
+ (*QueryTransferEligibilityRequest)(nil), // 8: inference.genesistransfer.QueryTransferEligibilityRequest
+ (*QueryTransferEligibilityResponse)(nil), // 9: inference.genesistransfer.QueryTransferEligibilityResponse
+ (*Params)(nil), // 10: inference.genesistransfer.Params
+ (*TransferRecord)(nil), // 11: inference.genesistransfer.TransferRecord
+ (*v1beta1.PageRequest)(nil), // 12: cosmos.base.query.v1beta1.PageRequest
+ (*v1beta1.PageResponse)(nil), // 13: cosmos.base.query.v1beta1.PageResponse
+}
+var file_inference_genesistransfer_query_proto_depIdxs = []int32{
+ 10, // 0: inference.genesistransfer.QueryParamsResponse.params:type_name -> inference.genesistransfer.Params
+ 11, // 1: inference.genesistransfer.QueryTransferStatusResponse.transfer_record:type_name -> inference.genesistransfer.TransferRecord
+ 12, // 2: inference.genesistransfer.QueryTransferHistoryRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest
+ 11, // 3: inference.genesistransfer.QueryTransferHistoryResponse.transfer_records:type_name -> inference.genesistransfer.TransferRecord
+ 13, // 4: inference.genesistransfer.QueryTransferHistoryResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse
+ 0, // 5: inference.genesistransfer.Query.Params:input_type -> inference.genesistransfer.QueryParamsRequest
+ 2, // 6: inference.genesistransfer.Query.TransferStatus:input_type -> inference.genesistransfer.QueryTransferStatusRequest
+ 4, // 7: inference.genesistransfer.Query.TransferHistory:input_type -> inference.genesistransfer.QueryTransferHistoryRequest
+ 6, // 8: inference.genesistransfer.Query.AllowedAccounts:input_type -> inference.genesistransfer.QueryAllowedAccountsRequest
+ 8, // 9: inference.genesistransfer.Query.TransferEligibility:input_type -> inference.genesistransfer.QueryTransferEligibilityRequest
+ 1, // 10: inference.genesistransfer.Query.Params:output_type -> inference.genesistransfer.QueryParamsResponse
+ 3, // 11: inference.genesistransfer.Query.TransferStatus:output_type -> inference.genesistransfer.QueryTransferStatusResponse
+ 5, // 12: inference.genesistransfer.Query.TransferHistory:output_type -> inference.genesistransfer.QueryTransferHistoryResponse
+ 7, // 13: inference.genesistransfer.Query.AllowedAccounts:output_type -> inference.genesistransfer.QueryAllowedAccountsResponse
+ 9, // 14: inference.genesistransfer.Query.TransferEligibility:output_type -> inference.genesistransfer.QueryTransferEligibilityResponse
+ 10, // [10:15] is the sub-list for method output_type
+ 5, // [5:10] is the sub-list for method input_type
+ 5, // [5:5] is the sub-list for extension type_name
+ 5, // [5:5] is the sub-list for extension extendee
+ 0, // [0:5] is the sub-list for field type_name
+}
+
+func init() { file_inference_genesistransfer_query_proto_init() }
+func file_inference_genesistransfer_query_proto_init() {
+ if File_inference_genesistransfer_query_proto != nil {
+ return
+ }
+ file_inference_genesistransfer_params_proto_init()
+ file_inference_genesistransfer_genesis_proto_init()
+ if !protoimpl.UnsafeEnabled {
+ file_inference_genesistransfer_query_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*QueryParamsRequest); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_genesistransfer_query_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*QueryParamsResponse); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_genesistransfer_query_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*QueryTransferStatusRequest); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_genesistransfer_query_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*QueryTransferStatusResponse); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_genesistransfer_query_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*QueryTransferHistoryRequest); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_genesistransfer_query_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*QueryTransferHistoryResponse); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_genesistransfer_query_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*QueryAllowedAccountsRequest); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_genesistransfer_query_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*QueryAllowedAccountsResponse); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_genesistransfer_query_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*QueryTransferEligibilityRequest); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_genesistransfer_query_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*QueryTransferEligibilityResponse); 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_genesistransfer_query_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 10,
+ NumExtensions: 0,
+ NumServices: 1,
+ },
+ GoTypes: file_inference_genesistransfer_query_proto_goTypes,
+ DependencyIndexes: file_inference_genesistransfer_query_proto_depIdxs,
+ MessageInfos: file_inference_genesistransfer_query_proto_msgTypes,
+ }.Build()
+ File_inference_genesistransfer_query_proto = out.File
+ file_inference_genesistransfer_query_proto_rawDesc = nil
+ file_inference_genesistransfer_query_proto_goTypes = nil
+ file_inference_genesistransfer_query_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/genesistransfer/query_grpc.pb.go b/inference-chain/api/inference/genesistransfer/query_grpc.pb.go
new file mode 100644
index 000000000..3af975eb7
--- /dev/null
+++ b/inference-chain/api/inference/genesistransfer/query_grpc.pb.go
@@ -0,0 +1,267 @@
+// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
+// versions:
+// - protoc-gen-go-grpc v1.3.0
+// - protoc (unknown)
+// source: inference/genesistransfer/query.proto
+
+package genesistransfer
+
+import (
+ context "context"
+ grpc "google.golang.org/grpc"
+ codes "google.golang.org/grpc/codes"
+ status "google.golang.org/grpc/status"
+)
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+// Requires gRPC-Go v1.32.0 or later.
+const _ = grpc.SupportPackageIsVersion7
+
+const (
+ Query_Params_FullMethodName = "/inference.genesistransfer.Query/Params"
+ Query_TransferStatus_FullMethodName = "/inference.genesistransfer.Query/TransferStatus"
+ Query_TransferHistory_FullMethodName = "/inference.genesistransfer.Query/TransferHistory"
+ Query_AllowedAccounts_FullMethodName = "/inference.genesistransfer.Query/AllowedAccounts"
+ Query_TransferEligibility_FullMethodName = "/inference.genesistransfer.Query/TransferEligibility"
+)
+
+// QueryClient is the client API for Query service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+type QueryClient interface {
+ // Parameters queries the parameters of the module.
+ Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error)
+ // TransferStatus queries the completion status for a specific genesis account.
+ TransferStatus(ctx context.Context, in *QueryTransferStatusRequest, opts ...grpc.CallOption) (*QueryTransferStatusResponse, error)
+ // TransferHistory retrieves historical transfer records with optional pagination.
+ TransferHistory(ctx context.Context, in *QueryTransferHistoryRequest, opts ...grpc.CallOption) (*QueryTransferHistoryResponse, error)
+ // AllowedAccounts queries the whitelist of accounts eligible for transfer (if enabled).
+ AllowedAccounts(ctx context.Context, in *QueryAllowedAccountsRequest, opts ...grpc.CallOption) (*QueryAllowedAccountsResponse, error)
+ // TransferEligibility validates whether a specific account can be transferred.
+ TransferEligibility(ctx context.Context, in *QueryTransferEligibilityRequest, opts ...grpc.CallOption) (*QueryTransferEligibilityResponse, error)
+}
+
+type queryClient struct {
+ cc grpc.ClientConnInterface
+}
+
+func NewQueryClient(cc grpc.ClientConnInterface) 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, Query_Params_FullMethodName, in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *queryClient) TransferStatus(ctx context.Context, in *QueryTransferStatusRequest, opts ...grpc.CallOption) (*QueryTransferStatusResponse, error) {
+ out := new(QueryTransferStatusResponse)
+ err := c.cc.Invoke(ctx, Query_TransferStatus_FullMethodName, in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *queryClient) TransferHistory(ctx context.Context, in *QueryTransferHistoryRequest, opts ...grpc.CallOption) (*QueryTransferHistoryResponse, error) {
+ out := new(QueryTransferHistoryResponse)
+ err := c.cc.Invoke(ctx, Query_TransferHistory_FullMethodName, in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *queryClient) AllowedAccounts(ctx context.Context, in *QueryAllowedAccountsRequest, opts ...grpc.CallOption) (*QueryAllowedAccountsResponse, error) {
+ out := new(QueryAllowedAccountsResponse)
+ err := c.cc.Invoke(ctx, Query_AllowedAccounts_FullMethodName, in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *queryClient) TransferEligibility(ctx context.Context, in *QueryTransferEligibilityRequest, opts ...grpc.CallOption) (*QueryTransferEligibilityResponse, error) {
+ out := new(QueryTransferEligibilityResponse)
+ err := c.cc.Invoke(ctx, Query_TransferEligibility_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
+type QueryServer interface {
+ // Parameters queries the parameters of the module.
+ Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error)
+ // TransferStatus queries the completion status for a specific genesis account.
+ TransferStatus(context.Context, *QueryTransferStatusRequest) (*QueryTransferStatusResponse, error)
+ // TransferHistory retrieves historical transfer records with optional pagination.
+ TransferHistory(context.Context, *QueryTransferHistoryRequest) (*QueryTransferHistoryResponse, error)
+ // AllowedAccounts queries the whitelist of accounts eligible for transfer (if enabled).
+ AllowedAccounts(context.Context, *QueryAllowedAccountsRequest) (*QueryAllowedAccountsResponse, error)
+ // TransferEligibility validates whether a specific account can be transferred.
+ TransferEligibility(context.Context, *QueryTransferEligibilityRequest) (*QueryTransferEligibilityResponse, error)
+ mustEmbedUnimplementedQueryServer()
+}
+
+// UnimplementedQueryServer must be embedded to have forward compatible implementations.
+type UnimplementedQueryServer struct {
+}
+
+func (UnimplementedQueryServer) Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method Params not implemented")
+}
+func (UnimplementedQueryServer) TransferStatus(context.Context, *QueryTransferStatusRequest) (*QueryTransferStatusResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method TransferStatus not implemented")
+}
+func (UnimplementedQueryServer) TransferHistory(context.Context, *QueryTransferHistoryRequest) (*QueryTransferHistoryResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method TransferHistory not implemented")
+}
+func (UnimplementedQueryServer) AllowedAccounts(context.Context, *QueryAllowedAccountsRequest) (*QueryAllowedAccountsResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method AllowedAccounts not implemented")
+}
+func (UnimplementedQueryServer) TransferEligibility(context.Context, *QueryTransferEligibilityRequest) (*QueryTransferEligibilityResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method TransferEligibility not implemented")
+}
+func (UnimplementedQueryServer) mustEmbedUnimplementedQueryServer() {}
+
+// UnsafeQueryServer may be embedded to opt out of forward compatibility for this service.
+// Use of this interface is not recommended, as added methods to QueryServer will
+// result in compilation errors.
+type UnsafeQueryServer interface {
+ mustEmbedUnimplementedQueryServer()
+}
+
+func RegisterQueryServer(s grpc.ServiceRegistrar, srv QueryServer) {
+ s.RegisterService(&Query_ServiceDesc, srv)
+}
+
+func _Query_Params_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(QueryParamsRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(QueryServer).Params(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: Query_Params_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(QueryServer).Params(ctx, req.(*QueryParamsRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _Query_TransferStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(QueryTransferStatusRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(QueryServer).TransferStatus(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: Query_TransferStatus_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(QueryServer).TransferStatus(ctx, req.(*QueryTransferStatusRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _Query_TransferHistory_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(QueryTransferHistoryRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(QueryServer).TransferHistory(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: Query_TransferHistory_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(QueryServer).TransferHistory(ctx, req.(*QueryTransferHistoryRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _Query_AllowedAccounts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(QueryAllowedAccountsRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(QueryServer).AllowedAccounts(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: Query_AllowedAccounts_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(QueryServer).AllowedAccounts(ctx, req.(*QueryAllowedAccountsRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _Query_TransferEligibility_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(QueryTransferEligibilityRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(QueryServer).TransferEligibility(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: Query_TransferEligibility_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(QueryServer).TransferEligibility(ctx, req.(*QueryTransferEligibilityRequest))
+ }
+ 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)
+var Query_ServiceDesc = grpc.ServiceDesc{
+ ServiceName: "inference.genesistransfer.Query",
+ HandlerType: (*QueryServer)(nil),
+ Methods: []grpc.MethodDesc{
+ {
+ MethodName: "Params",
+ Handler: _Query_Params_Handler,
+ },
+ {
+ MethodName: "TransferStatus",
+ Handler: _Query_TransferStatus_Handler,
+ },
+ {
+ MethodName: "TransferHistory",
+ Handler: _Query_TransferHistory_Handler,
+ },
+ {
+ MethodName: "AllowedAccounts",
+ Handler: _Query_AllowedAccounts_Handler,
+ },
+ {
+ MethodName: "TransferEligibility",
+ Handler: _Query_TransferEligibility_Handler,
+ },
+ },
+ Streams: []grpc.StreamDesc{},
+ Metadata: "inference/genesistransfer/query.proto",
+}
diff --git a/inference-chain/api/inference/genesistransfer/tx.pulsar.go b/inference-chain/api/inference/genesistransfer/tx.pulsar.go
new file mode 100644
index 000000000..33a249a51
--- /dev/null
+++ b/inference-chain/api/inference/genesistransfer/tx.pulsar.go
@@ -0,0 +1,2164 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package genesistransfer
+
+import (
+ _ "cosmossdk.io/api/amino"
+ _ "cosmossdk.io/api/cosmos/msg/v1"
+ fmt "fmt"
+ _ "github.com/cosmos/cosmos-proto"
+ runtime "github.com/cosmos/cosmos-proto/runtime"
+ _ "github.com/cosmos/gogoproto/gogoproto"
+ 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_MsgUpdateParams protoreflect.MessageDescriptor
+ fd_MsgUpdateParams_authority protoreflect.FieldDescriptor
+ fd_MsgUpdateParams_params protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_genesistransfer_tx_proto_init()
+ md_MsgUpdateParams = File_inference_genesistransfer_tx_proto.Messages().ByName("MsgUpdateParams")
+ fd_MsgUpdateParams_authority = md_MsgUpdateParams.Fields().ByName("authority")
+ fd_MsgUpdateParams_params = md_MsgUpdateParams.Fields().ByName("params")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgUpdateParams)(nil)
+
+type fastReflection_MsgUpdateParams MsgUpdateParams
+
+func (x *MsgUpdateParams) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_MsgUpdateParams)(x)
+}
+
+func (x *MsgUpdateParams) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_genesistransfer_tx_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_MsgUpdateParams_messageType fastReflection_MsgUpdateParams_messageType
+var _ protoreflect.MessageType = fastReflection_MsgUpdateParams_messageType{}
+
+type fastReflection_MsgUpdateParams_messageType struct{}
+
+func (x fastReflection_MsgUpdateParams_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_MsgUpdateParams)(nil)
+}
+func (x fastReflection_MsgUpdateParams_messageType) New() protoreflect.Message {
+ return new(fastReflection_MsgUpdateParams)
+}
+func (x fastReflection_MsgUpdateParams_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgUpdateParams
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgUpdateParams) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgUpdateParams
+}
+
+// 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_MsgUpdateParams) Type() protoreflect.MessageType {
+ return _fastReflection_MsgUpdateParams_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgUpdateParams) New() protoreflect.Message {
+ return new(fastReflection_MsgUpdateParams)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgUpdateParams) Interface() protoreflect.ProtoMessage {
+ return (*MsgUpdateParams)(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_MsgUpdateParams) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Authority != "" {
+ value := protoreflect.ValueOfString(x.Authority)
+ if !f(fd_MsgUpdateParams_authority, value) {
+ return
+ }
+ }
+ if x.Params != nil {
+ value := protoreflect.ValueOfMessage(x.Params.ProtoReflect())
+ if !f(fd_MsgUpdateParams_params, 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_MsgUpdateParams) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.genesistransfer.MsgUpdateParams.authority":
+ return x.Authority != ""
+ case "inference.genesistransfer.MsgUpdateParams.params":
+ return x.Params != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.MsgUpdateParams"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.MsgUpdateParams 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_MsgUpdateParams) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.genesistransfer.MsgUpdateParams.authority":
+ x.Authority = ""
+ case "inference.genesistransfer.MsgUpdateParams.params":
+ x.Params = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.MsgUpdateParams"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.MsgUpdateParams 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_MsgUpdateParams) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.genesistransfer.MsgUpdateParams.authority":
+ value := x.Authority
+ return protoreflect.ValueOfString(value)
+ case "inference.genesistransfer.MsgUpdateParams.params":
+ value := x.Params
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.MsgUpdateParams"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.MsgUpdateParams 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_MsgUpdateParams) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.genesistransfer.MsgUpdateParams.authority":
+ x.Authority = value.Interface().(string)
+ case "inference.genesistransfer.MsgUpdateParams.params":
+ x.Params = value.Message().Interface().(*Params)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.MsgUpdateParams"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.MsgUpdateParams 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_MsgUpdateParams) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.genesistransfer.MsgUpdateParams.params":
+ if x.Params == nil {
+ x.Params = new(Params)
+ }
+ return protoreflect.ValueOfMessage(x.Params.ProtoReflect())
+ case "inference.genesistransfer.MsgUpdateParams.authority":
+ panic(fmt.Errorf("field authority of message inference.genesistransfer.MsgUpdateParams is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.MsgUpdateParams"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.MsgUpdateParams 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_MsgUpdateParams) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.genesistransfer.MsgUpdateParams.authority":
+ return protoreflect.ValueOfString("")
+ case "inference.genesistransfer.MsgUpdateParams.params":
+ m := new(Params)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.MsgUpdateParams"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.MsgUpdateParams 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_MsgUpdateParams) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.genesistransfer.MsgUpdateParams", 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_MsgUpdateParams) 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_MsgUpdateParams) 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_MsgUpdateParams) 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_MsgUpdateParams) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*MsgUpdateParams)
+ 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 x.Params != nil {
+ l = options.Size(x.Params)
+ 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().(*MsgUpdateParams)
+ 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.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 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().(*MsgUpdateParams)
+ 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: MsgUpdateParams: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUpdateParams: 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 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
+ 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_MsgUpdateParamsResponse protoreflect.MessageDescriptor
+)
+
+func init() {
+ file_inference_genesistransfer_tx_proto_init()
+ md_MsgUpdateParamsResponse = File_inference_genesistransfer_tx_proto.Messages().ByName("MsgUpdateParamsResponse")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgUpdateParamsResponse)(nil)
+
+type fastReflection_MsgUpdateParamsResponse MsgUpdateParamsResponse
+
+func (x *MsgUpdateParamsResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_MsgUpdateParamsResponse)(x)
+}
+
+func (x *MsgUpdateParamsResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_genesistransfer_tx_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_MsgUpdateParamsResponse_messageType fastReflection_MsgUpdateParamsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgUpdateParamsResponse_messageType{}
+
+type fastReflection_MsgUpdateParamsResponse_messageType struct{}
+
+func (x fastReflection_MsgUpdateParamsResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_MsgUpdateParamsResponse)(nil)
+}
+func (x fastReflection_MsgUpdateParamsResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_MsgUpdateParamsResponse)
+}
+func (x fastReflection_MsgUpdateParamsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgUpdateParamsResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgUpdateParamsResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgUpdateParamsResponse
+}
+
+// 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_MsgUpdateParamsResponse) Type() protoreflect.MessageType {
+ return _fastReflection_MsgUpdateParamsResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgUpdateParamsResponse) New() protoreflect.Message {
+ return new(fastReflection_MsgUpdateParamsResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgUpdateParamsResponse) Interface() protoreflect.ProtoMessage {
+ return (*MsgUpdateParamsResponse)(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_MsgUpdateParamsResponse) 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_MsgUpdateParamsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.MsgUpdateParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.MsgUpdateParamsResponse 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_MsgUpdateParamsResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.MsgUpdateParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.MsgUpdateParamsResponse 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_MsgUpdateParamsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.MsgUpdateParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.MsgUpdateParamsResponse 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_MsgUpdateParamsResponse) 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.genesistransfer.MsgUpdateParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.MsgUpdateParamsResponse 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_MsgUpdateParamsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.MsgUpdateParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.MsgUpdateParamsResponse 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_MsgUpdateParamsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.MsgUpdateParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.MsgUpdateParamsResponse 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_MsgUpdateParamsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.genesistransfer.MsgUpdateParamsResponse", 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_MsgUpdateParamsResponse) 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_MsgUpdateParamsResponse) 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_MsgUpdateParamsResponse) 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_MsgUpdateParamsResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*MsgUpdateParamsResponse)
+ 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().(*MsgUpdateParamsResponse)
+ 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().(*MsgUpdateParamsResponse)
+ 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: MsgUpdateParamsResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUpdateParamsResponse: 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 (
+ md_MsgTransferOwnership protoreflect.MessageDescriptor
+ fd_MsgTransferOwnership_genesis_address protoreflect.FieldDescriptor
+ fd_MsgTransferOwnership_recipient_address protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_genesistransfer_tx_proto_init()
+ md_MsgTransferOwnership = File_inference_genesistransfer_tx_proto.Messages().ByName("MsgTransferOwnership")
+ fd_MsgTransferOwnership_genesis_address = md_MsgTransferOwnership.Fields().ByName("genesis_address")
+ fd_MsgTransferOwnership_recipient_address = md_MsgTransferOwnership.Fields().ByName("recipient_address")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgTransferOwnership)(nil)
+
+type fastReflection_MsgTransferOwnership MsgTransferOwnership
+
+func (x *MsgTransferOwnership) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_MsgTransferOwnership)(x)
+}
+
+func (x *MsgTransferOwnership) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_genesistransfer_tx_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_MsgTransferOwnership_messageType fastReflection_MsgTransferOwnership_messageType
+var _ protoreflect.MessageType = fastReflection_MsgTransferOwnership_messageType{}
+
+type fastReflection_MsgTransferOwnership_messageType struct{}
+
+func (x fastReflection_MsgTransferOwnership_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_MsgTransferOwnership)(nil)
+}
+func (x fastReflection_MsgTransferOwnership_messageType) New() protoreflect.Message {
+ return new(fastReflection_MsgTransferOwnership)
+}
+func (x fastReflection_MsgTransferOwnership_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgTransferOwnership
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgTransferOwnership) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgTransferOwnership
+}
+
+// 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_MsgTransferOwnership) Type() protoreflect.MessageType {
+ return _fastReflection_MsgTransferOwnership_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgTransferOwnership) New() protoreflect.Message {
+ return new(fastReflection_MsgTransferOwnership)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgTransferOwnership) Interface() protoreflect.ProtoMessage {
+ return (*MsgTransferOwnership)(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_MsgTransferOwnership) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.GenesisAddress != "" {
+ value := protoreflect.ValueOfString(x.GenesisAddress)
+ if !f(fd_MsgTransferOwnership_genesis_address, value) {
+ return
+ }
+ }
+ if x.RecipientAddress != "" {
+ value := protoreflect.ValueOfString(x.RecipientAddress)
+ if !f(fd_MsgTransferOwnership_recipient_address, 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_MsgTransferOwnership) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.genesistransfer.MsgTransferOwnership.genesis_address":
+ return x.GenesisAddress != ""
+ case "inference.genesistransfer.MsgTransferOwnership.recipient_address":
+ return x.RecipientAddress != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.MsgTransferOwnership"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.MsgTransferOwnership 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_MsgTransferOwnership) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.genesistransfer.MsgTransferOwnership.genesis_address":
+ x.GenesisAddress = ""
+ case "inference.genesistransfer.MsgTransferOwnership.recipient_address":
+ x.RecipientAddress = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.MsgTransferOwnership"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.MsgTransferOwnership 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_MsgTransferOwnership) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.genesistransfer.MsgTransferOwnership.genesis_address":
+ value := x.GenesisAddress
+ return protoreflect.ValueOfString(value)
+ case "inference.genesistransfer.MsgTransferOwnership.recipient_address":
+ value := x.RecipientAddress
+ return protoreflect.ValueOfString(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.MsgTransferOwnership"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.MsgTransferOwnership 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_MsgTransferOwnership) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.genesistransfer.MsgTransferOwnership.genesis_address":
+ x.GenesisAddress = value.Interface().(string)
+ case "inference.genesistransfer.MsgTransferOwnership.recipient_address":
+ x.RecipientAddress = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.MsgTransferOwnership"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.MsgTransferOwnership 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_MsgTransferOwnership) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.genesistransfer.MsgTransferOwnership.genesis_address":
+ panic(fmt.Errorf("field genesis_address of message inference.genesistransfer.MsgTransferOwnership is not mutable"))
+ case "inference.genesistransfer.MsgTransferOwnership.recipient_address":
+ panic(fmt.Errorf("field recipient_address of message inference.genesistransfer.MsgTransferOwnership is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.MsgTransferOwnership"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.MsgTransferOwnership 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_MsgTransferOwnership) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.genesistransfer.MsgTransferOwnership.genesis_address":
+ return protoreflect.ValueOfString("")
+ case "inference.genesistransfer.MsgTransferOwnership.recipient_address":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.MsgTransferOwnership"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.MsgTransferOwnership 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_MsgTransferOwnership) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.genesistransfer.MsgTransferOwnership", 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_MsgTransferOwnership) 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_MsgTransferOwnership) 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_MsgTransferOwnership) 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_MsgTransferOwnership) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*MsgTransferOwnership)
+ 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.GenesisAddress)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ l = len(x.RecipientAddress)
+ 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().(*MsgTransferOwnership)
+ 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.RecipientAddress) > 0 {
+ i -= len(x.RecipientAddress)
+ copy(dAtA[i:], x.RecipientAddress)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.RecipientAddress)))
+ i--
+ dAtA[i] = 0x12
+ }
+ if len(x.GenesisAddress) > 0 {
+ i -= len(x.GenesisAddress)
+ copy(dAtA[i:], x.GenesisAddress)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.GenesisAddress)))
+ 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().(*MsgTransferOwnership)
+ 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: MsgTransferOwnership: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgTransferOwnership: 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 GenesisAddress", 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.GenesisAddress = 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 RecipientAddress", 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.RecipientAddress = 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_MsgTransferOwnershipResponse protoreflect.MessageDescriptor
+ fd_MsgTransferOwnershipResponse_transfer_record protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_genesistransfer_tx_proto_init()
+ md_MsgTransferOwnershipResponse = File_inference_genesistransfer_tx_proto.Messages().ByName("MsgTransferOwnershipResponse")
+ fd_MsgTransferOwnershipResponse_transfer_record = md_MsgTransferOwnershipResponse.Fields().ByName("transfer_record")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgTransferOwnershipResponse)(nil)
+
+type fastReflection_MsgTransferOwnershipResponse MsgTransferOwnershipResponse
+
+func (x *MsgTransferOwnershipResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_MsgTransferOwnershipResponse)(x)
+}
+
+func (x *MsgTransferOwnershipResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_genesistransfer_tx_proto_msgTypes[3]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_MsgTransferOwnershipResponse_messageType fastReflection_MsgTransferOwnershipResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgTransferOwnershipResponse_messageType{}
+
+type fastReflection_MsgTransferOwnershipResponse_messageType struct{}
+
+func (x fastReflection_MsgTransferOwnershipResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_MsgTransferOwnershipResponse)(nil)
+}
+func (x fastReflection_MsgTransferOwnershipResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_MsgTransferOwnershipResponse)
+}
+func (x fastReflection_MsgTransferOwnershipResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgTransferOwnershipResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgTransferOwnershipResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_MsgTransferOwnershipResponse
+}
+
+// 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_MsgTransferOwnershipResponse) Type() protoreflect.MessageType {
+ return _fastReflection_MsgTransferOwnershipResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgTransferOwnershipResponse) New() protoreflect.Message {
+ return new(fastReflection_MsgTransferOwnershipResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgTransferOwnershipResponse) Interface() protoreflect.ProtoMessage {
+ return (*MsgTransferOwnershipResponse)(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_MsgTransferOwnershipResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.TransferRecord != nil {
+ value := protoreflect.ValueOfMessage(x.TransferRecord.ProtoReflect())
+ if !f(fd_MsgTransferOwnershipResponse_transfer_record, 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_MsgTransferOwnershipResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.genesistransfer.MsgTransferOwnershipResponse.transfer_record":
+ return x.TransferRecord != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.MsgTransferOwnershipResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.MsgTransferOwnershipResponse 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_MsgTransferOwnershipResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.genesistransfer.MsgTransferOwnershipResponse.transfer_record":
+ x.TransferRecord = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.MsgTransferOwnershipResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.MsgTransferOwnershipResponse 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_MsgTransferOwnershipResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.genesistransfer.MsgTransferOwnershipResponse.transfer_record":
+ value := x.TransferRecord
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.MsgTransferOwnershipResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.MsgTransferOwnershipResponse 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_MsgTransferOwnershipResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.genesistransfer.MsgTransferOwnershipResponse.transfer_record":
+ x.TransferRecord = value.Message().Interface().(*TransferRecord)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.MsgTransferOwnershipResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.MsgTransferOwnershipResponse 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_MsgTransferOwnershipResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.genesistransfer.MsgTransferOwnershipResponse.transfer_record":
+ if x.TransferRecord == nil {
+ x.TransferRecord = new(TransferRecord)
+ }
+ return protoreflect.ValueOfMessage(x.TransferRecord.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.MsgTransferOwnershipResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.MsgTransferOwnershipResponse 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_MsgTransferOwnershipResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.genesistransfer.MsgTransferOwnershipResponse.transfer_record":
+ m := new(TransferRecord)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.genesistransfer.MsgTransferOwnershipResponse"))
+ }
+ panic(fmt.Errorf("message inference.genesistransfer.MsgTransferOwnershipResponse 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_MsgTransferOwnershipResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.genesistransfer.MsgTransferOwnershipResponse", 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_MsgTransferOwnershipResponse) 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_MsgTransferOwnershipResponse) 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_MsgTransferOwnershipResponse) 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_MsgTransferOwnershipResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*MsgTransferOwnershipResponse)
+ 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.TransferRecord != nil {
+ l = options.Size(x.TransferRecord)
+ 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().(*MsgTransferOwnershipResponse)
+ 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.TransferRecord != nil {
+ encoded, err := options.Marshal(x.TransferRecord)
+ 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().(*MsgTransferOwnershipResponse)
+ 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: MsgTransferOwnershipResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgTransferOwnershipResponse: 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 TransferRecord", 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.TransferRecord == nil {
+ x.TransferRecord = &TransferRecord{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.TransferRecord); 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/genesistransfer/tx.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)
+)
+
+// MsgUpdateParams is the Msg/UpdateParams request type.
+type MsgUpdateParams struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // authority is the address that controls the module (defaults to x/gov unless overwritten).
+ Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"`
+ // params defines the module parameters to update.
+ //
+ // NOTE: All parameters must be supplied.
+ Params *Params `protobuf:"bytes,2,opt,name=params,proto3" json:"params,omitempty"`
+}
+
+func (x *MsgUpdateParams) Reset() {
+ *x = MsgUpdateParams{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_genesistransfer_tx_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *MsgUpdateParams) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgUpdateParams) ProtoMessage() {}
+
+// Deprecated: Use MsgUpdateParams.ProtoReflect.Descriptor instead.
+func (*MsgUpdateParams) Descriptor() ([]byte, []int) {
+ return file_inference_genesistransfer_tx_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *MsgUpdateParams) GetAuthority() string {
+ if x != nil {
+ return x.Authority
+ }
+ return ""
+}
+
+func (x *MsgUpdateParams) GetParams() *Params {
+ if x != nil {
+ return x.Params
+ }
+ return nil
+}
+
+// MsgUpdateParamsResponse defines the response structure for executing a
+// MsgUpdateParams message.
+type MsgUpdateParamsResponse struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+}
+
+func (x *MsgUpdateParamsResponse) Reset() {
+ *x = MsgUpdateParamsResponse{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_genesistransfer_tx_proto_msgTypes[1]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *MsgUpdateParamsResponse) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgUpdateParamsResponse) ProtoMessage() {}
+
+// Deprecated: Use MsgUpdateParamsResponse.ProtoReflect.Descriptor instead.
+func (*MsgUpdateParamsResponse) Descriptor() ([]byte, []int) {
+ return file_inference_genesistransfer_tx_proto_rawDescGZIP(), []int{1}
+}
+
+// MsgTransferOwnership is the Msg/TransferOwnership request type.
+type MsgTransferOwnership struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // genesis_address is the source genesis account to transfer from (must be the signer)
+ GenesisAddress string `protobuf:"bytes,1,opt,name=genesis_address,json=genesisAddress,proto3" json:"genesis_address,omitempty"`
+ // recipient_address is the destination account to transfer ownership to
+ RecipientAddress string `protobuf:"bytes,2,opt,name=recipient_address,json=recipientAddress,proto3" json:"recipient_address,omitempty"`
+}
+
+func (x *MsgTransferOwnership) Reset() {
+ *x = MsgTransferOwnership{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_genesistransfer_tx_proto_msgTypes[2]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *MsgTransferOwnership) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgTransferOwnership) ProtoMessage() {}
+
+// Deprecated: Use MsgTransferOwnership.ProtoReflect.Descriptor instead.
+func (*MsgTransferOwnership) Descriptor() ([]byte, []int) {
+ return file_inference_genesistransfer_tx_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *MsgTransferOwnership) GetGenesisAddress() string {
+ if x != nil {
+ return x.GenesisAddress
+ }
+ return ""
+}
+
+func (x *MsgTransferOwnership) GetRecipientAddress() string {
+ if x != nil {
+ return x.RecipientAddress
+ }
+ return ""
+}
+
+// MsgTransferOwnershipResponse defines the response structure for executing a
+// MsgTransferOwnership message.
+type MsgTransferOwnershipResponse struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // transfer_record contains the details of the completed transfer
+ TransferRecord *TransferRecord `protobuf:"bytes,1,opt,name=transfer_record,json=transferRecord,proto3" json:"transfer_record,omitempty"`
+}
+
+func (x *MsgTransferOwnershipResponse) Reset() {
+ *x = MsgTransferOwnershipResponse{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_genesistransfer_tx_proto_msgTypes[3]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *MsgTransferOwnershipResponse) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgTransferOwnershipResponse) ProtoMessage() {}
+
+// Deprecated: Use MsgTransferOwnershipResponse.ProtoReflect.Descriptor instead.
+func (*MsgTransferOwnershipResponse) Descriptor() ([]byte, []int) {
+ return file_inference_genesistransfer_tx_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *MsgTransferOwnershipResponse) GetTransferRecord() *TransferRecord {
+ if x != nil {
+ return x.TransferRecord
+ }
+ return nil
+}
+
+var File_inference_genesistransfer_tx_proto protoreflect.FileDescriptor
+
+var file_inference_genesistransfer_tx_proto_rawDesc = []byte{
+ 0x0a, 0x22, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x67, 0x65, 0x6e, 0x65,
+ 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2f, 0x74, 0x78, 0x2e, 0x70,
+ 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x19, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+ 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x1a,
+ 0x11, 0x61, 0x6d, 0x69, 0x6e, 0x6f, 0x2f, 0x61, 0x6d, 0x69, 0x6e, 0x6f, 0x2e, 0x70, 0x72, 0x6f,
+ 0x74, 0x6f, 0x1a, 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, 0x1a, 0x14, 0x67, 0x6f, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74,
+ 0x6f, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x26, 0x69, 0x6e,
+ 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74,
+ 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x70,
+ 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x27, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f,
+ 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2f,
+ 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xcf, 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, 0x44, 0x0a, 0x06, 0x70, 0x61, 0x72,
+ 0x61, 0x6d, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+ 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61,
+ 0x6e, 0x73, 0x66, 0x65, 0x72, 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,
+ 0x3e, 0x82, 0xe7, 0xb0, 0x2a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x8a,
+ 0xe7, 0xb0, 0x2a, 0x2b, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x78, 0x2f,
+ 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 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, 0xeb, 0x01, 0x0a, 0x14, 0x4d,
+ 0x73, 0x67, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x73,
+ 0x68, 0x69, 0x70, 0x12, 0x41, 0x0a, 0x0f, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x5f, 0x61,
+ 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 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, 0x0e, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x41,
+ 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x45, 0x0a, 0x11, 0x72, 0x65, 0x63, 0x69, 0x70, 0x69,
+ 0x65, 0x6e, 0x74, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 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, 0x10, 0x72, 0x65, 0x63,
+ 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x3a, 0x49, 0x82,
+ 0xe7, 0xb0, 0x2a, 0x0f, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x5f, 0x61, 0x64, 0x64, 0x72,
+ 0x65, 0x73, 0x73, 0x8a, 0xe7, 0xb0, 0x2a, 0x30, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+ 0x65, 0x2f, 0x78, 0x2f, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73,
+ 0x66, 0x65, 0x72, 0x2f, 0x4d, 0x73, 0x67, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x4f,
+ 0x77, 0x6e, 0x65, 0x72, 0x73, 0x68, 0x69, 0x70, 0x22, 0x7d, 0x0a, 0x1c, 0x4d, 0x73, 0x67, 0x54,
+ 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x73, 0x68, 0x69, 0x70,
+ 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5d, 0x0a, 0x0f, 0x74, 0x72, 0x61, 0x6e,
+ 0x73, 0x66, 0x65, 0x72, 0x5f, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28,
+ 0x0b, 0x32, 0x29, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x67, 0x65,
+ 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x54, 0x72,
+ 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x42, 0x09, 0xc8, 0xde,
+ 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x0e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65,
+ 0x72, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x32, 0xfb, 0x01, 0x0a, 0x03, 0x4d, 0x73, 0x67, 0x12,
+ 0x6e, 0x0a, 0x0c, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12,
+ 0x2a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x67, 0x65, 0x6e, 0x65,
+ 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x4d, 0x73, 0x67, 0x55,
+ 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x1a, 0x32, 0x2e, 0x69, 0x6e,
+ 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74,
+ 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 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,
+ 0x7d, 0x0a, 0x11, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x4f, 0x77, 0x6e, 0x65, 0x72,
+ 0x73, 0x68, 0x69, 0x70, 0x12, 0x2f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+ 0x2e, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72,
+ 0x2e, 0x4d, 0x73, 0x67, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x4f, 0x77, 0x6e, 0x65,
+ 0x72, 0x73, 0x68, 0x69, 0x70, 0x1a, 0x37, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+ 0x65, 0x2e, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65,
+ 0x72, 0x2e, 0x4d, 0x73, 0x67, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x4f, 0x77, 0x6e,
+ 0x65, 0x72, 0x73, 0x68, 0x69, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x1a, 0x05,
+ 0x80, 0xe7, 0xb0, 0x2a, 0x01, 0x42, 0xd9, 0x01, 0x0a, 0x1d, 0x63, 0x6f, 0x6d, 0x2e, 0x69, 0x6e,
+ 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74,
+ 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x42, 0x07, 0x54, 0x78, 0x50, 0x72, 0x6f, 0x74, 0x6f,
+ 0x50, 0x01, 0x5a, 0x2a, 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, 0x67,
+ 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0xa2, 0x02,
+ 0x03, 0x49, 0x47, 0x58, 0xaa, 0x02, 0x19, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+ 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72,
+ 0xca, 0x02, 0x19, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x47, 0x65, 0x6e,
+ 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0xe2, 0x02, 0x25, 0x49,
+ 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73,
+ 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61,
+ 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x1a, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+ 0x3a, 0x3a, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65,
+ 0x72, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+ file_inference_genesistransfer_tx_proto_rawDescOnce sync.Once
+ file_inference_genesistransfer_tx_proto_rawDescData = file_inference_genesistransfer_tx_proto_rawDesc
+)
+
+func file_inference_genesistransfer_tx_proto_rawDescGZIP() []byte {
+ file_inference_genesistransfer_tx_proto_rawDescOnce.Do(func() {
+ file_inference_genesistransfer_tx_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_genesistransfer_tx_proto_rawDescData)
+ })
+ return file_inference_genesistransfer_tx_proto_rawDescData
+}
+
+var file_inference_genesistransfer_tx_proto_msgTypes = make([]protoimpl.MessageInfo, 4)
+var file_inference_genesistransfer_tx_proto_goTypes = []interface{}{
+ (*MsgUpdateParams)(nil), // 0: inference.genesistransfer.MsgUpdateParams
+ (*MsgUpdateParamsResponse)(nil), // 1: inference.genesistransfer.MsgUpdateParamsResponse
+ (*MsgTransferOwnership)(nil), // 2: inference.genesistransfer.MsgTransferOwnership
+ (*MsgTransferOwnershipResponse)(nil), // 3: inference.genesistransfer.MsgTransferOwnershipResponse
+ (*Params)(nil), // 4: inference.genesistransfer.Params
+ (*TransferRecord)(nil), // 5: inference.genesistransfer.TransferRecord
+}
+var file_inference_genesistransfer_tx_proto_depIdxs = []int32{
+ 4, // 0: inference.genesistransfer.MsgUpdateParams.params:type_name -> inference.genesistransfer.Params
+ 5, // 1: inference.genesistransfer.MsgTransferOwnershipResponse.transfer_record:type_name -> inference.genesistransfer.TransferRecord
+ 0, // 2: inference.genesistransfer.Msg.UpdateParams:input_type -> inference.genesistransfer.MsgUpdateParams
+ 2, // 3: inference.genesistransfer.Msg.TransferOwnership:input_type -> inference.genesistransfer.MsgTransferOwnership
+ 1, // 4: inference.genesistransfer.Msg.UpdateParams:output_type -> inference.genesistransfer.MsgUpdateParamsResponse
+ 3, // 5: inference.genesistransfer.Msg.TransferOwnership:output_type -> inference.genesistransfer.MsgTransferOwnershipResponse
+ 4, // [4:6] is the sub-list for method output_type
+ 2, // [2:4] 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_genesistransfer_tx_proto_init() }
+func file_inference_genesistransfer_tx_proto_init() {
+ if File_inference_genesistransfer_tx_proto != nil {
+ return
+ }
+ file_inference_genesistransfer_params_proto_init()
+ file_inference_genesistransfer_genesis_proto_init()
+ if !protoimpl.UnsafeEnabled {
+ file_inference_genesistransfer_tx_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*MsgUpdateParams); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_genesistransfer_tx_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*MsgUpdateParamsResponse); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_genesistransfer_tx_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*MsgTransferOwnership); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_genesistransfer_tx_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*MsgTransferOwnershipResponse); 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_genesistransfer_tx_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 4,
+ NumExtensions: 0,
+ NumServices: 1,
+ },
+ GoTypes: file_inference_genesistransfer_tx_proto_goTypes,
+ DependencyIndexes: file_inference_genesistransfer_tx_proto_depIdxs,
+ MessageInfos: file_inference_genesistransfer_tx_proto_msgTypes,
+ }.Build()
+ File_inference_genesistransfer_tx_proto = out.File
+ file_inference_genesistransfer_tx_proto_rawDesc = nil
+ file_inference_genesistransfer_tx_proto_goTypes = nil
+ file_inference_genesistransfer_tx_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/genesistransfer/tx_grpc.pb.go b/inference-chain/api/inference/genesistransfer/tx_grpc.pb.go
new file mode 100644
index 000000000..2cd370ff7
--- /dev/null
+++ b/inference-chain/api/inference/genesistransfer/tx_grpc.pb.go
@@ -0,0 +1,154 @@
+// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
+// versions:
+// - protoc-gen-go-grpc v1.3.0
+// - protoc (unknown)
+// source: inference/genesistransfer/tx.proto
+
+package genesistransfer
+
+import (
+ context "context"
+ grpc "google.golang.org/grpc"
+ codes "google.golang.org/grpc/codes"
+ status "google.golang.org/grpc/status"
+)
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+// Requires gRPC-Go v1.32.0 or later.
+const _ = grpc.SupportPackageIsVersion7
+
+const (
+ Msg_UpdateParams_FullMethodName = "/inference.genesistransfer.Msg/UpdateParams"
+ Msg_TransferOwnership_FullMethodName = "/inference.genesistransfer.Msg/TransferOwnership"
+)
+
+// MsgClient is the client API for Msg service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+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)
+ // TransferOwnership transfers complete ownership of a genesis account including
+ // all liquid balances and vesting schedules to the recipient account
+ TransferOwnership(ctx context.Context, in *MsgTransferOwnership, opts ...grpc.CallOption) (*MsgTransferOwnershipResponse, error)
+}
+
+type msgClient struct {
+ cc grpc.ClientConnInterface
+}
+
+func NewMsgClient(cc grpc.ClientConnInterface) MsgClient {
+ return &msgClient{cc}
+}
+
+func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) {
+ out := new(MsgUpdateParamsResponse)
+ err := c.cc.Invoke(ctx, Msg_UpdateParams_FullMethodName, in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *msgClient) TransferOwnership(ctx context.Context, in *MsgTransferOwnership, opts ...grpc.CallOption) (*MsgTransferOwnershipResponse, error) {
+ out := new(MsgTransferOwnershipResponse)
+ err := c.cc.Invoke(ctx, Msg_TransferOwnership_FullMethodName, in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+// MsgServer is the server API for Msg service.
+// All implementations must embed UnimplementedMsgServer
+// for forward compatibility
+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)
+ // TransferOwnership transfers complete ownership of a genesis account including
+ // all liquid balances and vesting schedules to the recipient account
+ TransferOwnership(context.Context, *MsgTransferOwnership) (*MsgTransferOwnershipResponse, error)
+ mustEmbedUnimplementedMsgServer()
+}
+
+// UnimplementedMsgServer must be embedded to have forward compatible implementations.
+type UnimplementedMsgServer struct {
+}
+
+func (UnimplementedMsgServer) UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method UpdateParams not implemented")
+}
+func (UnimplementedMsgServer) TransferOwnership(context.Context, *MsgTransferOwnership) (*MsgTransferOwnershipResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method TransferOwnership not implemented")
+}
+func (UnimplementedMsgServer) mustEmbedUnimplementedMsgServer() {}
+
+// UnsafeMsgServer may be embedded to opt out of forward compatibility for this service.
+// Use of this interface is not recommended, as added methods to MsgServer will
+// result in compilation errors.
+type UnsafeMsgServer interface {
+ mustEmbedUnimplementedMsgServer()
+}
+
+func RegisterMsgServer(s grpc.ServiceRegistrar, srv MsgServer) {
+ s.RegisterService(&Msg_ServiceDesc, srv)
+}
+
+func _Msg_UpdateParams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(MsgUpdateParams)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(MsgServer).UpdateParams(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: Msg_UpdateParams_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(MsgServer).UpdateParams(ctx, req.(*MsgUpdateParams))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _Msg_TransferOwnership_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(MsgTransferOwnership)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(MsgServer).TransferOwnership(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: Msg_TransferOwnership_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(MsgServer).TransferOwnership(ctx, req.(*MsgTransferOwnership))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+// Msg_ServiceDesc is the grpc.ServiceDesc for Msg service.
+// It's only intended for direct use with grpc.RegisterService,
+// and not to be introspected or modified (even as a copy)
+var Msg_ServiceDesc = grpc.ServiceDesc{
+ ServiceName: "inference.genesistransfer.Msg",
+ HandlerType: (*MsgServer)(nil),
+ Methods: []grpc.MethodDesc{
+ {
+ MethodName: "UpdateParams",
+ Handler: _Msg_UpdateParams_Handler,
+ },
+ {
+ MethodName: "TransferOwnership",
+ Handler: _Msg_TransferOwnership_Handler,
+ },
+ },
+ Streams: []grpc.StreamDesc{},
+ Metadata: "inference/genesistransfer/tx.proto",
+}
diff --git a/inference-chain/api/inference/inference/activeparticipants.pulsar.go b/inference-chain/api/inference/inference/activeparticipants.pulsar.go
new file mode 100644
index 000000000..425419a5a
--- /dev/null
+++ b/inference-chain/api/inference/inference/activeparticipants.pulsar.go
@@ -0,0 +1,2554 @@
+// 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 _ protoreflect.List = (*_ModelMLNodes_1_list)(nil)
+
+type _ModelMLNodes_1_list struct {
+ list *[]*MLNodeInfo
+}
+
+func (x *_ModelMLNodes_1_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_ModelMLNodes_1_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_ModelMLNodes_1_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*MLNodeInfo)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_ModelMLNodes_1_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*MLNodeInfo)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_ModelMLNodes_1_list) AppendMutable() protoreflect.Value {
+ v := new(MLNodeInfo)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_ModelMLNodes_1_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_ModelMLNodes_1_list) NewElement() protoreflect.Value {
+ v := new(MLNodeInfo)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_ModelMLNodes_1_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_ModelMLNodes protoreflect.MessageDescriptor
+ fd_ModelMLNodes_ml_nodes protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_activeparticipants_proto_init()
+ md_ModelMLNodes = File_inference_inference_activeparticipants_proto.Messages().ByName("ModelMLNodes")
+ fd_ModelMLNodes_ml_nodes = md_ModelMLNodes.Fields().ByName("ml_nodes")
+}
+
+var _ protoreflect.Message = (*fastReflection_ModelMLNodes)(nil)
+
+type fastReflection_ModelMLNodes ModelMLNodes
+
+func (x *ModelMLNodes) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_ModelMLNodes)(x)
+}
+
+func (x *ModelMLNodes) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_activeparticipants_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_ModelMLNodes_messageType fastReflection_ModelMLNodes_messageType
+var _ protoreflect.MessageType = fastReflection_ModelMLNodes_messageType{}
+
+type fastReflection_ModelMLNodes_messageType struct{}
+
+func (x fastReflection_ModelMLNodes_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_ModelMLNodes)(nil)
+}
+func (x fastReflection_ModelMLNodes_messageType) New() protoreflect.Message {
+ return new(fastReflection_ModelMLNodes)
+}
+func (x fastReflection_ModelMLNodes_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_ModelMLNodes
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_ModelMLNodes) Descriptor() protoreflect.MessageDescriptor {
+ return md_ModelMLNodes
+}
+
+// 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_ModelMLNodes) Type() protoreflect.MessageType {
+ return _fastReflection_ModelMLNodes_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_ModelMLNodes) New() protoreflect.Message {
+ return new(fastReflection_ModelMLNodes)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_ModelMLNodes) Interface() protoreflect.ProtoMessage {
+ return (*ModelMLNodes)(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_ModelMLNodes) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if len(x.MlNodes) != 0 {
+ value := protoreflect.ValueOfList(&_ModelMLNodes_1_list{list: &x.MlNodes})
+ if !f(fd_ModelMLNodes_ml_nodes, 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_ModelMLNodes) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.ModelMLNodes.ml_nodes":
+ return len(x.MlNodes) != 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelMLNodes"))
+ }
+ panic(fmt.Errorf("message inference.inference.ModelMLNodes 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_ModelMLNodes) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.ModelMLNodes.ml_nodes":
+ x.MlNodes = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelMLNodes"))
+ }
+ panic(fmt.Errorf("message inference.inference.ModelMLNodes 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_ModelMLNodes) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.ModelMLNodes.ml_nodes":
+ if len(x.MlNodes) == 0 {
+ return protoreflect.ValueOfList(&_ModelMLNodes_1_list{})
+ }
+ listValue := &_ModelMLNodes_1_list{list: &x.MlNodes}
+ return protoreflect.ValueOfList(listValue)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelMLNodes"))
+ }
+ panic(fmt.Errorf("message inference.inference.ModelMLNodes 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_ModelMLNodes) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.ModelMLNodes.ml_nodes":
+ lv := value.List()
+ clv := lv.(*_ModelMLNodes_1_list)
+ x.MlNodes = *clv.list
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelMLNodes"))
+ }
+ panic(fmt.Errorf("message inference.inference.ModelMLNodes 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_ModelMLNodes) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.ModelMLNodes.ml_nodes":
+ if x.MlNodes == nil {
+ x.MlNodes = []*MLNodeInfo{}
+ }
+ value := &_ModelMLNodes_1_list{list: &x.MlNodes}
+ return protoreflect.ValueOfList(value)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelMLNodes"))
+ }
+ panic(fmt.Errorf("message inference.inference.ModelMLNodes 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_ModelMLNodes) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.ModelMLNodes.ml_nodes":
+ list := []*MLNodeInfo{}
+ return protoreflect.ValueOfList(&_ModelMLNodes_1_list{list: &list})
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelMLNodes"))
+ }
+ panic(fmt.Errorf("message inference.inference.ModelMLNodes 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_ModelMLNodes) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.ModelMLNodes", 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_ModelMLNodes) 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_ModelMLNodes) 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_ModelMLNodes) 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_ModelMLNodes) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*ModelMLNodes)
+ 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.MlNodes) > 0 {
+ for _, e := range x.MlNodes {
+ 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().(*ModelMLNodes)
+ 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.MlNodes) > 0 {
+ for iNdEx := len(x.MlNodes) - 1; iNdEx >= 0; iNdEx-- {
+ encoded, err := options.Marshal(x.MlNodes[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().(*ModelMLNodes)
+ 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: ModelMLNodes: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ModelMLNodes: 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 MlNodes", 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.MlNodes = append(x.MlNodes, &MLNodeInfo{})
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.MlNodes[len(x.MlNodes)-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 _ protoreflect.List = (*_ActiveParticipants_1_list)(nil)
+
+type _ActiveParticipants_1_list struct {
+ list *[]*ActiveParticipant
+}
+
+func (x *_ActiveParticipants_1_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_ActiveParticipants_1_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_ActiveParticipants_1_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*ActiveParticipant)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_ActiveParticipants_1_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*ActiveParticipant)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_ActiveParticipants_1_list) AppendMutable() protoreflect.Value {
+ v := new(ActiveParticipant)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_ActiveParticipants_1_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_ActiveParticipants_1_list) NewElement() protoreflect.Value {
+ v := new(ActiveParticipant)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_ActiveParticipants_1_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_ActiveParticipants protoreflect.MessageDescriptor
+ fd_ActiveParticipants_participants protoreflect.FieldDescriptor
+ fd_ActiveParticipants_epoch_group_id protoreflect.FieldDescriptor
+ fd_ActiveParticipants_poc_start_block_height protoreflect.FieldDescriptor
+ fd_ActiveParticipants_effective_block_height protoreflect.FieldDescriptor
+ fd_ActiveParticipants_created_at_block_height protoreflect.FieldDescriptor
+ fd_ActiveParticipants_epoch_id protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_activeparticipants_proto_init()
+ md_ActiveParticipants = File_inference_inference_activeparticipants_proto.Messages().ByName("ActiveParticipants")
+ fd_ActiveParticipants_participants = md_ActiveParticipants.Fields().ByName("participants")
+ fd_ActiveParticipants_epoch_group_id = md_ActiveParticipants.Fields().ByName("epoch_group_id")
+ fd_ActiveParticipants_poc_start_block_height = md_ActiveParticipants.Fields().ByName("poc_start_block_height")
+ fd_ActiveParticipants_effective_block_height = md_ActiveParticipants.Fields().ByName("effective_block_height")
+ fd_ActiveParticipants_created_at_block_height = md_ActiveParticipants.Fields().ByName("created_at_block_height")
+ fd_ActiveParticipants_epoch_id = md_ActiveParticipants.Fields().ByName("epoch_id")
+}
+
+var _ protoreflect.Message = (*fastReflection_ActiveParticipants)(nil)
+
+type fastReflection_ActiveParticipants ActiveParticipants
+
+func (x *ActiveParticipants) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_ActiveParticipants)(x)
+}
+
+func (x *ActiveParticipants) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_activeparticipants_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_ActiveParticipants_messageType fastReflection_ActiveParticipants_messageType
+var _ protoreflect.MessageType = fastReflection_ActiveParticipants_messageType{}
+
+type fastReflection_ActiveParticipants_messageType struct{}
+
+func (x fastReflection_ActiveParticipants_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_ActiveParticipants)(nil)
+}
+func (x fastReflection_ActiveParticipants_messageType) New() protoreflect.Message {
+ return new(fastReflection_ActiveParticipants)
+}
+func (x fastReflection_ActiveParticipants_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_ActiveParticipants
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_ActiveParticipants) Descriptor() protoreflect.MessageDescriptor {
+ return md_ActiveParticipants
+}
+
+// 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_ActiveParticipants) Type() protoreflect.MessageType {
+ return _fastReflection_ActiveParticipants_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_ActiveParticipants) New() protoreflect.Message {
+ return new(fastReflection_ActiveParticipants)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_ActiveParticipants) Interface() protoreflect.ProtoMessage {
+ return (*ActiveParticipants)(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_ActiveParticipants) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if len(x.Participants) != 0 {
+ value := protoreflect.ValueOfList(&_ActiveParticipants_1_list{list: &x.Participants})
+ if !f(fd_ActiveParticipants_participants, value) {
+ return
+ }
+ }
+ if x.EpochGroupId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.EpochGroupId)
+ if !f(fd_ActiveParticipants_epoch_group_id, value) {
+ return
+ }
+ }
+ if x.PocStartBlockHeight != int64(0) {
+ value := protoreflect.ValueOfInt64(x.PocStartBlockHeight)
+ if !f(fd_ActiveParticipants_poc_start_block_height, value) {
+ return
+ }
+ }
+ if x.EffectiveBlockHeight != int64(0) {
+ value := protoreflect.ValueOfInt64(x.EffectiveBlockHeight)
+ if !f(fd_ActiveParticipants_effective_block_height, value) {
+ return
+ }
+ }
+ if x.CreatedAtBlockHeight != int64(0) {
+ value := protoreflect.ValueOfInt64(x.CreatedAtBlockHeight)
+ if !f(fd_ActiveParticipants_created_at_block_height, value) {
+ return
+ }
+ }
+ if x.EpochId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.EpochId)
+ if !f(fd_ActiveParticipants_epoch_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_ActiveParticipants) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.ActiveParticipants.participants":
+ return len(x.Participants) != 0
+ case "inference.inference.ActiveParticipants.epoch_group_id":
+ return x.EpochGroupId != uint64(0)
+ case "inference.inference.ActiveParticipants.poc_start_block_height":
+ return x.PocStartBlockHeight != int64(0)
+ case "inference.inference.ActiveParticipants.effective_block_height":
+ return x.EffectiveBlockHeight != int64(0)
+ case "inference.inference.ActiveParticipants.created_at_block_height":
+ return x.CreatedAtBlockHeight != int64(0)
+ case "inference.inference.ActiveParticipants.epoch_id":
+ return x.EpochId != uint64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ActiveParticipants"))
+ }
+ panic(fmt.Errorf("message inference.inference.ActiveParticipants 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_ActiveParticipants) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.ActiveParticipants.participants":
+ x.Participants = nil
+ case "inference.inference.ActiveParticipants.epoch_group_id":
+ x.EpochGroupId = uint64(0)
+ case "inference.inference.ActiveParticipants.poc_start_block_height":
+ x.PocStartBlockHeight = int64(0)
+ case "inference.inference.ActiveParticipants.effective_block_height":
+ x.EffectiveBlockHeight = int64(0)
+ case "inference.inference.ActiveParticipants.created_at_block_height":
+ x.CreatedAtBlockHeight = int64(0)
+ case "inference.inference.ActiveParticipants.epoch_id":
+ x.EpochId = uint64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ActiveParticipants"))
+ }
+ panic(fmt.Errorf("message inference.inference.ActiveParticipants 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_ActiveParticipants) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.ActiveParticipants.participants":
+ if len(x.Participants) == 0 {
+ return protoreflect.ValueOfList(&_ActiveParticipants_1_list{})
+ }
+ listValue := &_ActiveParticipants_1_list{list: &x.Participants}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.inference.ActiveParticipants.epoch_group_id":
+ value := x.EpochGroupId
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.ActiveParticipants.poc_start_block_height":
+ value := x.PocStartBlockHeight
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.ActiveParticipants.effective_block_height":
+ value := x.EffectiveBlockHeight
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.ActiveParticipants.created_at_block_height":
+ value := x.CreatedAtBlockHeight
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.ActiveParticipants.epoch_id":
+ value := x.EpochId
+ return protoreflect.ValueOfUint64(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ActiveParticipants"))
+ }
+ panic(fmt.Errorf("message inference.inference.ActiveParticipants 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_ActiveParticipants) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.ActiveParticipants.participants":
+ lv := value.List()
+ clv := lv.(*_ActiveParticipants_1_list)
+ x.Participants = *clv.list
+ case "inference.inference.ActiveParticipants.epoch_group_id":
+ x.EpochGroupId = value.Uint()
+ case "inference.inference.ActiveParticipants.poc_start_block_height":
+ x.PocStartBlockHeight = value.Int()
+ case "inference.inference.ActiveParticipants.effective_block_height":
+ x.EffectiveBlockHeight = value.Int()
+ case "inference.inference.ActiveParticipants.created_at_block_height":
+ x.CreatedAtBlockHeight = value.Int()
+ case "inference.inference.ActiveParticipants.epoch_id":
+ x.EpochId = value.Uint()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ActiveParticipants"))
+ }
+ panic(fmt.Errorf("message inference.inference.ActiveParticipants 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_ActiveParticipants) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.ActiveParticipants.participants":
+ if x.Participants == nil {
+ x.Participants = []*ActiveParticipant{}
+ }
+ value := &_ActiveParticipants_1_list{list: &x.Participants}
+ return protoreflect.ValueOfList(value)
+ case "inference.inference.ActiveParticipants.epoch_group_id":
+ panic(fmt.Errorf("field epoch_group_id of message inference.inference.ActiveParticipants is not mutable"))
+ case "inference.inference.ActiveParticipants.poc_start_block_height":
+ panic(fmt.Errorf("field poc_start_block_height of message inference.inference.ActiveParticipants is not mutable"))
+ case "inference.inference.ActiveParticipants.effective_block_height":
+ panic(fmt.Errorf("field effective_block_height of message inference.inference.ActiveParticipants is not mutable"))
+ case "inference.inference.ActiveParticipants.created_at_block_height":
+ panic(fmt.Errorf("field created_at_block_height of message inference.inference.ActiveParticipants is not mutable"))
+ case "inference.inference.ActiveParticipants.epoch_id":
+ panic(fmt.Errorf("field epoch_id of message inference.inference.ActiveParticipants is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ActiveParticipants"))
+ }
+ panic(fmt.Errorf("message inference.inference.ActiveParticipants 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_ActiveParticipants) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.ActiveParticipants.participants":
+ list := []*ActiveParticipant{}
+ return protoreflect.ValueOfList(&_ActiveParticipants_1_list{list: &list})
+ case "inference.inference.ActiveParticipants.epoch_group_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.ActiveParticipants.poc_start_block_height":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.ActiveParticipants.effective_block_height":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.ActiveParticipants.created_at_block_height":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.ActiveParticipants.epoch_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ActiveParticipants"))
+ }
+ panic(fmt.Errorf("message inference.inference.ActiveParticipants 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_ActiveParticipants) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.ActiveParticipants", 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_ActiveParticipants) 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_ActiveParticipants) 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_ActiveParticipants) 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_ActiveParticipants) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*ActiveParticipants)
+ 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.Participants) > 0 {
+ for _, e := range x.Participants {
+ l = options.Size(e)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ }
+ if x.EpochGroupId != 0 {
+ n += 1 + runtime.Sov(uint64(x.EpochGroupId))
+ }
+ if x.PocStartBlockHeight != 0 {
+ n += 1 + runtime.Sov(uint64(x.PocStartBlockHeight))
+ }
+ if x.EffectiveBlockHeight != 0 {
+ n += 1 + runtime.Sov(uint64(x.EffectiveBlockHeight))
+ }
+ if x.CreatedAtBlockHeight != 0 {
+ n += 1 + runtime.Sov(uint64(x.CreatedAtBlockHeight))
+ }
+ if x.EpochId != 0 {
+ n += 1 + runtime.Sov(uint64(x.EpochId))
+ }
+ 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().(*ActiveParticipants)
+ 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.EpochId != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochId))
+ i--
+ dAtA[i] = 0x30
+ }
+ if x.CreatedAtBlockHeight != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.CreatedAtBlockHeight))
+ i--
+ dAtA[i] = 0x28
+ }
+ if x.EffectiveBlockHeight != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.EffectiveBlockHeight))
+ i--
+ dAtA[i] = 0x20
+ }
+ if x.PocStartBlockHeight != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.PocStartBlockHeight))
+ i--
+ dAtA[i] = 0x18
+ }
+ if x.EpochGroupId != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochGroupId))
+ i--
+ dAtA[i] = 0x10
+ }
+ 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...)
+ } 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().(*ActiveParticipants)
+ 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: ActiveParticipants: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ActiveParticipants: 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, &ActiveParticipant{})
+ 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 != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EpochGroupId", wireType)
+ }
+ x.EpochGroupId = 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.EpochGroupId |= 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 PocStartBlockHeight", wireType)
+ }
+ x.PocStartBlockHeight = 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.PocStartBlockHeight |= 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 EffectiveBlockHeight", wireType)
+ }
+ x.EffectiveBlockHeight = 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.EffectiveBlockHeight |= int64(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 CreatedAtBlockHeight", wireType)
+ }
+ x.CreatedAtBlockHeight = 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.CreatedAtBlockHeight |= int64(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 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
+ }
+ }
+ 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 = (*_ActiveParticipant_5_list)(nil)
+
+type _ActiveParticipant_5_list struct {
+ list *[]string
+}
+
+func (x *_ActiveParticipant_5_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_ActiveParticipant_5_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfString((*x.list)[i])
+}
+
+func (x *_ActiveParticipant_5_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.String()
+ concreteValue := valueUnwrapped
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_ActiveParticipant_5_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.String()
+ concreteValue := valueUnwrapped
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_ActiveParticipant_5_list) AppendMutable() protoreflect.Value {
+ panic(fmt.Errorf("AppendMutable can not be called on message ActiveParticipant at list field Models as it is not of Message kind"))
+}
+
+func (x *_ActiveParticipant_5_list) Truncate(n int) {
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_ActiveParticipant_5_list) NewElement() protoreflect.Value {
+ v := ""
+ return protoreflect.ValueOfString(v)
+}
+
+func (x *_ActiveParticipant_5_list) IsValid() bool {
+ return x.list != nil
+}
+
+var _ protoreflect.List = (*_ActiveParticipant_7_list)(nil)
+
+type _ActiveParticipant_7_list struct {
+ list *[]*ModelMLNodes
+}
+
+func (x *_ActiveParticipant_7_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_ActiveParticipant_7_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_ActiveParticipant_7_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*ModelMLNodes)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_ActiveParticipant_7_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*ModelMLNodes)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_ActiveParticipant_7_list) AppendMutable() protoreflect.Value {
+ v := new(ModelMLNodes)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_ActiveParticipant_7_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_ActiveParticipant_7_list) NewElement() protoreflect.Value {
+ v := new(ModelMLNodes)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_ActiveParticipant_7_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_ActiveParticipant protoreflect.MessageDescriptor
+ fd_ActiveParticipant_index protoreflect.FieldDescriptor
+ fd_ActiveParticipant_validator_key protoreflect.FieldDescriptor
+ fd_ActiveParticipant_weight protoreflect.FieldDescriptor
+ fd_ActiveParticipant_inference_url protoreflect.FieldDescriptor
+ fd_ActiveParticipant_models protoreflect.FieldDescriptor
+ fd_ActiveParticipant_seed protoreflect.FieldDescriptor
+ fd_ActiveParticipant_ml_nodes protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_activeparticipants_proto_init()
+ md_ActiveParticipant = File_inference_inference_activeparticipants_proto.Messages().ByName("ActiveParticipant")
+ fd_ActiveParticipant_index = md_ActiveParticipant.Fields().ByName("index")
+ fd_ActiveParticipant_validator_key = md_ActiveParticipant.Fields().ByName("validator_key")
+ fd_ActiveParticipant_weight = md_ActiveParticipant.Fields().ByName("weight")
+ fd_ActiveParticipant_inference_url = md_ActiveParticipant.Fields().ByName("inference_url")
+ fd_ActiveParticipant_models = md_ActiveParticipant.Fields().ByName("models")
+ fd_ActiveParticipant_seed = md_ActiveParticipant.Fields().ByName("seed")
+ fd_ActiveParticipant_ml_nodes = md_ActiveParticipant.Fields().ByName("ml_nodes")
+}
+
+var _ protoreflect.Message = (*fastReflection_ActiveParticipant)(nil)
+
+type fastReflection_ActiveParticipant ActiveParticipant
+
+func (x *ActiveParticipant) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_ActiveParticipant)(x)
+}
+
+func (x *ActiveParticipant) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_activeparticipants_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_ActiveParticipant_messageType fastReflection_ActiveParticipant_messageType
+var _ protoreflect.MessageType = fastReflection_ActiveParticipant_messageType{}
+
+type fastReflection_ActiveParticipant_messageType struct{}
+
+func (x fastReflection_ActiveParticipant_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_ActiveParticipant)(nil)
+}
+func (x fastReflection_ActiveParticipant_messageType) New() protoreflect.Message {
+ return new(fastReflection_ActiveParticipant)
+}
+func (x fastReflection_ActiveParticipant_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_ActiveParticipant
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_ActiveParticipant) Descriptor() protoreflect.MessageDescriptor {
+ return md_ActiveParticipant
+}
+
+// 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_ActiveParticipant) Type() protoreflect.MessageType {
+ return _fastReflection_ActiveParticipant_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_ActiveParticipant) New() protoreflect.Message {
+ return new(fastReflection_ActiveParticipant)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_ActiveParticipant) Interface() protoreflect.ProtoMessage {
+ return (*ActiveParticipant)(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_ActiveParticipant) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Index != "" {
+ value := protoreflect.ValueOfString(x.Index)
+ if !f(fd_ActiveParticipant_index, value) {
+ return
+ }
+ }
+ if x.ValidatorKey != "" {
+ value := protoreflect.ValueOfString(x.ValidatorKey)
+ if !f(fd_ActiveParticipant_validator_key, value) {
+ return
+ }
+ }
+ if x.Weight != int64(0) {
+ value := protoreflect.ValueOfInt64(x.Weight)
+ if !f(fd_ActiveParticipant_weight, value) {
+ return
+ }
+ }
+ if x.InferenceUrl != "" {
+ value := protoreflect.ValueOfString(x.InferenceUrl)
+ if !f(fd_ActiveParticipant_inference_url, value) {
+ return
+ }
+ }
+ if len(x.Models) != 0 {
+ value := protoreflect.ValueOfList(&_ActiveParticipant_5_list{list: &x.Models})
+ if !f(fd_ActiveParticipant_models, value) {
+ return
+ }
+ }
+ if x.Seed != nil {
+ value := protoreflect.ValueOfMessage(x.Seed.ProtoReflect())
+ if !f(fd_ActiveParticipant_seed, value) {
+ return
+ }
+ }
+ if len(x.MlNodes) != 0 {
+ value := protoreflect.ValueOfList(&_ActiveParticipant_7_list{list: &x.MlNodes})
+ if !f(fd_ActiveParticipant_ml_nodes, 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_ActiveParticipant) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.ActiveParticipant.index":
+ return x.Index != ""
+ case "inference.inference.ActiveParticipant.validator_key":
+ return x.ValidatorKey != ""
+ case "inference.inference.ActiveParticipant.weight":
+ return x.Weight != int64(0)
+ case "inference.inference.ActiveParticipant.inference_url":
+ return x.InferenceUrl != ""
+ case "inference.inference.ActiveParticipant.models":
+ return len(x.Models) != 0
+ case "inference.inference.ActiveParticipant.seed":
+ return x.Seed != nil
+ case "inference.inference.ActiveParticipant.ml_nodes":
+ return len(x.MlNodes) != 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ActiveParticipant"))
+ }
+ panic(fmt.Errorf("message inference.inference.ActiveParticipant 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_ActiveParticipant) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.ActiveParticipant.index":
+ x.Index = ""
+ case "inference.inference.ActiveParticipant.validator_key":
+ x.ValidatorKey = ""
+ case "inference.inference.ActiveParticipant.weight":
+ x.Weight = int64(0)
+ case "inference.inference.ActiveParticipant.inference_url":
+ x.InferenceUrl = ""
+ case "inference.inference.ActiveParticipant.models":
+ x.Models = nil
+ case "inference.inference.ActiveParticipant.seed":
+ x.Seed = nil
+ case "inference.inference.ActiveParticipant.ml_nodes":
+ x.MlNodes = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ActiveParticipant"))
+ }
+ panic(fmt.Errorf("message inference.inference.ActiveParticipant 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_ActiveParticipant) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.ActiveParticipant.index":
+ value := x.Index
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.ActiveParticipant.validator_key":
+ value := x.ValidatorKey
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.ActiveParticipant.weight":
+ value := x.Weight
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.ActiveParticipant.inference_url":
+ value := x.InferenceUrl
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.ActiveParticipant.models":
+ if len(x.Models) == 0 {
+ return protoreflect.ValueOfList(&_ActiveParticipant_5_list{})
+ }
+ listValue := &_ActiveParticipant_5_list{list: &x.Models}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.inference.ActiveParticipant.seed":
+ value := x.Seed
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.ActiveParticipant.ml_nodes":
+ if len(x.MlNodes) == 0 {
+ return protoreflect.ValueOfList(&_ActiveParticipant_7_list{})
+ }
+ listValue := &_ActiveParticipant_7_list{list: &x.MlNodes}
+ return protoreflect.ValueOfList(listValue)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ActiveParticipant"))
+ }
+ panic(fmt.Errorf("message inference.inference.ActiveParticipant 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_ActiveParticipant) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.ActiveParticipant.index":
+ x.Index = value.Interface().(string)
+ case "inference.inference.ActiveParticipant.validator_key":
+ x.ValidatorKey = value.Interface().(string)
+ case "inference.inference.ActiveParticipant.weight":
+ x.Weight = value.Int()
+ case "inference.inference.ActiveParticipant.inference_url":
+ x.InferenceUrl = value.Interface().(string)
+ case "inference.inference.ActiveParticipant.models":
+ lv := value.List()
+ clv := lv.(*_ActiveParticipant_5_list)
+ x.Models = *clv.list
+ case "inference.inference.ActiveParticipant.seed":
+ x.Seed = value.Message().Interface().(*RandomSeed)
+ case "inference.inference.ActiveParticipant.ml_nodes":
+ lv := value.List()
+ clv := lv.(*_ActiveParticipant_7_list)
+ x.MlNodes = *clv.list
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ActiveParticipant"))
+ }
+ panic(fmt.Errorf("message inference.inference.ActiveParticipant 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_ActiveParticipant) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.ActiveParticipant.models":
+ if x.Models == nil {
+ x.Models = []string{}
+ }
+ value := &_ActiveParticipant_5_list{list: &x.Models}
+ return protoreflect.ValueOfList(value)
+ case "inference.inference.ActiveParticipant.seed":
+ if x.Seed == nil {
+ x.Seed = new(RandomSeed)
+ }
+ return protoreflect.ValueOfMessage(x.Seed.ProtoReflect())
+ case "inference.inference.ActiveParticipant.ml_nodes":
+ if x.MlNodes == nil {
+ x.MlNodes = []*ModelMLNodes{}
+ }
+ value := &_ActiveParticipant_7_list{list: &x.MlNodes}
+ return protoreflect.ValueOfList(value)
+ case "inference.inference.ActiveParticipant.index":
+ panic(fmt.Errorf("field index of message inference.inference.ActiveParticipant is not mutable"))
+ case "inference.inference.ActiveParticipant.validator_key":
+ panic(fmt.Errorf("field validator_key of message inference.inference.ActiveParticipant is not mutable"))
+ case "inference.inference.ActiveParticipant.weight":
+ panic(fmt.Errorf("field weight of message inference.inference.ActiveParticipant is not mutable"))
+ case "inference.inference.ActiveParticipant.inference_url":
+ panic(fmt.Errorf("field inference_url of message inference.inference.ActiveParticipant is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ActiveParticipant"))
+ }
+ panic(fmt.Errorf("message inference.inference.ActiveParticipant 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_ActiveParticipant) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.ActiveParticipant.index":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.ActiveParticipant.validator_key":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.ActiveParticipant.weight":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.ActiveParticipant.inference_url":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.ActiveParticipant.models":
+ list := []string{}
+ return protoreflect.ValueOfList(&_ActiveParticipant_5_list{list: &list})
+ case "inference.inference.ActiveParticipant.seed":
+ m := new(RandomSeed)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.ActiveParticipant.ml_nodes":
+ list := []*ModelMLNodes{}
+ return protoreflect.ValueOfList(&_ActiveParticipant_7_list{list: &list})
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ActiveParticipant"))
+ }
+ panic(fmt.Errorf("message inference.inference.ActiveParticipant 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_ActiveParticipant) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.ActiveParticipant", 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_ActiveParticipant) 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_ActiveParticipant) 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_ActiveParticipant) 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_ActiveParticipant) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*ActiveParticipant)
+ 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.Index)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ l = len(x.ValidatorKey)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.Weight != 0 {
+ n += 1 + runtime.Sov(uint64(x.Weight))
+ }
+ l = len(x.InferenceUrl)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if len(x.Models) > 0 {
+ for _, s := range x.Models {
+ l = len(s)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ }
+ if x.Seed != nil {
+ l = options.Size(x.Seed)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if len(x.MlNodes) > 0 {
+ for _, e := range x.MlNodes {
+ 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().(*ActiveParticipant)
+ 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.MlNodes) > 0 {
+ for iNdEx := len(x.MlNodes) - 1; iNdEx >= 0; iNdEx-- {
+ encoded, err := options.Marshal(x.MlNodes[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 x.Seed != nil {
+ encoded, err := options.Marshal(x.Seed)
+ 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.Models) > 0 {
+ for iNdEx := len(x.Models) - 1; iNdEx >= 0; iNdEx-- {
+ i -= len(x.Models[iNdEx])
+ copy(dAtA[i:], x.Models[iNdEx])
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Models[iNdEx])))
+ i--
+ dAtA[i] = 0x2a
+ }
+ }
+ if len(x.InferenceUrl) > 0 {
+ i -= len(x.InferenceUrl)
+ copy(dAtA[i:], x.InferenceUrl)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.InferenceUrl)))
+ i--
+ dAtA[i] = 0x22
+ }
+ if x.Weight != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.Weight))
+ i--
+ dAtA[i] = 0x18
+ }
+ if len(x.ValidatorKey) > 0 {
+ i -= len(x.ValidatorKey)
+ copy(dAtA[i:], x.ValidatorKey)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ValidatorKey)))
+ i--
+ dAtA[i] = 0x12
+ }
+ if len(x.Index) > 0 {
+ i -= len(x.Index)
+ copy(dAtA[i:], x.Index)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Index)))
+ 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().(*ActiveParticipant)
+ 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: ActiveParticipant: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ActiveParticipant: 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 Index", 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.Index = 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 ValidatorKey", 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.ValidatorKey = 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 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 |= int64(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 InferenceUrl", 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.InferenceUrl = 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 Models", 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.Models = append(x.Models, 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 Seed", 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.Seed == nil {
+ x.Seed = &RandomSeed{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Seed); 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 MlNodes", 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.MlNodes = append(x.MlNodes, &ModelMLNodes{})
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.MlNodes[len(x.MlNodes)-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/activeparticipants.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)
+)
+
+// Wrapper message to enable double repeated structure for model-based MLNode organization
+type ModelMLNodes struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ MlNodes []*MLNodeInfo `protobuf:"bytes,1,rep,name=ml_nodes,json=mlNodes,proto3" json:"ml_nodes,omitempty"`
+}
+
+func (x *ModelMLNodes) Reset() {
+ *x = ModelMLNodes{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_activeparticipants_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *ModelMLNodes) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ModelMLNodes) ProtoMessage() {}
+
+// Deprecated: Use ModelMLNodes.ProtoReflect.Descriptor instead.
+func (*ModelMLNodes) Descriptor() ([]byte, []int) {
+ return file_inference_inference_activeparticipants_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *ModelMLNodes) GetMlNodes() []*MLNodeInfo {
+ if x != nil {
+ return x.MlNodes
+ }
+ return nil
+}
+
+// Not added to the Genesis, because at genesis it's constructed based on Participants
+type ActiveParticipants struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Participants []*ActiveParticipant `protobuf:"bytes,1,rep,name=participants,proto3" json:"participants,omitempty"`
+ EpochGroupId uint64 `protobuf:"varint,2,opt,name=epoch_group_id,json=epochGroupId,proto3" json:"epoch_group_id,omitempty"` // DEPRECATED: the id of the group entity. Previously the key of the ActiveParticipants entity
+ PocStartBlockHeight int64 `protobuf:"varint,3,opt,name=poc_start_block_height,json=pocStartBlockHeight,proto3" json:"poc_start_block_height,omitempty"`
+ EffectiveBlockHeight int64 `protobuf:"varint,4,opt,name=effective_block_height,json=effectiveBlockHeight,proto3" json:"effective_block_height,omitempty"`
+ CreatedAtBlockHeight int64 `protobuf:"varint,5,opt,name=created_at_block_height,json=createdAtBlockHeight,proto3" json:"created_at_block_height,omitempty"` // Same as effective_block_height???
+ EpochId uint64 `protobuf:"varint,6,opt,name=epoch_id,json=epochId,proto3" json:"epoch_id,omitempty"` // The current key of the ActiveParticipants entity
+}
+
+func (x *ActiveParticipants) Reset() {
+ *x = ActiveParticipants{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_activeparticipants_proto_msgTypes[1]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *ActiveParticipants) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ActiveParticipants) ProtoMessage() {}
+
+// Deprecated: Use ActiveParticipants.ProtoReflect.Descriptor instead.
+func (*ActiveParticipants) Descriptor() ([]byte, []int) {
+ return file_inference_inference_activeparticipants_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *ActiveParticipants) GetParticipants() []*ActiveParticipant {
+ if x != nil {
+ return x.Participants
+ }
+ return nil
+}
+
+func (x *ActiveParticipants) GetEpochGroupId() uint64 {
+ if x != nil {
+ return x.EpochGroupId
+ }
+ return 0
+}
+
+func (x *ActiveParticipants) GetPocStartBlockHeight() int64 {
+ if x != nil {
+ return x.PocStartBlockHeight
+ }
+ return 0
+}
+
+func (x *ActiveParticipants) GetEffectiveBlockHeight() int64 {
+ if x != nil {
+ return x.EffectiveBlockHeight
+ }
+ return 0
+}
+
+func (x *ActiveParticipants) GetCreatedAtBlockHeight() int64 {
+ if x != nil {
+ return x.CreatedAtBlockHeight
+ }
+ return 0
+}
+
+func (x *ActiveParticipants) GetEpochId() uint64 {
+ if x != nil {
+ return x.EpochId
+ }
+ return 0
+}
+
+type ActiveParticipant struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Index string `protobuf:"bytes,1,opt,name=index,proto3" json:"index,omitempty"`
+ ValidatorKey string `protobuf:"bytes,2,opt,name=validator_key,json=validatorKey,proto3" json:"validator_key,omitempty"`
+ Weight int64 `protobuf:"varint,3,opt,name=weight,proto3" json:"weight,omitempty"`
+ InferenceUrl string `protobuf:"bytes,4,opt,name=inference_url,json=inferenceUrl,proto3" json:"inference_url,omitempty"`
+ Models []string `protobuf:"bytes,5,rep,name=models,proto3" json:"models,omitempty"`
+ Seed *RandomSeed `protobuf:"bytes,6,opt,name=seed,proto3" json:"seed,omitempty"`
+ MlNodes []*ModelMLNodes `protobuf:"bytes,7,rep,name=ml_nodes,json=mlNodes,proto3" json:"ml_nodes,omitempty"`
+}
+
+func (x *ActiveParticipant) Reset() {
+ *x = ActiveParticipant{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_activeparticipants_proto_msgTypes[2]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *ActiveParticipant) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ActiveParticipant) ProtoMessage() {}
+
+// Deprecated: Use ActiveParticipant.ProtoReflect.Descriptor instead.
+func (*ActiveParticipant) Descriptor() ([]byte, []int) {
+ return file_inference_inference_activeparticipants_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *ActiveParticipant) GetIndex() string {
+ if x != nil {
+ return x.Index
+ }
+ return ""
+}
+
+func (x *ActiveParticipant) GetValidatorKey() string {
+ if x != nil {
+ return x.ValidatorKey
+ }
+ return ""
+}
+
+func (x *ActiveParticipant) GetWeight() int64 {
+ if x != nil {
+ return x.Weight
+ }
+ return 0
+}
+
+func (x *ActiveParticipant) GetInferenceUrl() string {
+ if x != nil {
+ return x.InferenceUrl
+ }
+ return ""
+}
+
+func (x *ActiveParticipant) GetModels() []string {
+ if x != nil {
+ return x.Models
+ }
+ return nil
+}
+
+func (x *ActiveParticipant) GetSeed() *RandomSeed {
+ if x != nil {
+ return x.Seed
+ }
+ return nil
+}
+
+func (x *ActiveParticipant) GetMlNodes() []*ModelMLNodes {
+ if x != nil {
+ return x.MlNodes
+ }
+ return nil
+}
+
+var File_inference_inference_activeparticipants_proto protoreflect.FileDescriptor
+
+var file_inference_inference_activeparticipants_proto_rawDesc = []byte{
+ 0x0a, 0x2c, 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, 0x70, 0x61, 0x72, 0x74,
+ 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 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, 0x1a, 0x25, 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, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x2a, 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,
+ 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x4a, 0x0a, 0x0c, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x4d,
+ 0x4c, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x12, 0x3a, 0x0a, 0x08, 0x6d, 0x6c, 0x5f, 0x6e, 0x6f, 0x64,
+ 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,
+ 0x4c, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x07, 0x6d, 0x6c, 0x4e, 0x6f, 0x64,
+ 0x65, 0x73, 0x22, 0xc3, 0x02, 0x0a, 0x12, 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x50, 0x61, 0x72,
+ 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x12, 0x4a, 0x0a, 0x0c, 0x70, 0x61, 0x72,
+ 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 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, 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x50, 0x61, 0x72, 0x74,
+ 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x52, 0x0c, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69,
+ 0x70, 0x61, 0x6e, 0x74, 0x73, 0x12, 0x24, 0x0a, 0x0e, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x67,
+ 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0c, 0x65,
+ 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x64, 0x12, 0x33, 0x0a, 0x16, 0x70,
+ 0x6f, 0x63, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68,
+ 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x13, 0x70, 0x6f, 0x63,
+ 0x53, 0x74, 0x61, 0x72, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74,
+ 0x12, 0x34, 0x0a, 0x16, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x62, 0x6c,
+ 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03,
+ 0x52, 0x14, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x42, 0x6c, 0x6f, 0x63, 0x6b,
+ 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x35, 0x0a, 0x17, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65,
+ 0x64, 0x5f, 0x61, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68,
+ 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x14, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64,
+ 0x41, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x19, 0x0a,
+ 0x08, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x04, 0x52,
+ 0x07, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x64, 0x22, 0x96, 0x02, 0x0a, 0x11, 0x41, 0x63, 0x74,
+ 0x69, 0x76, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x12, 0x14,
+ 0x0a, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x69,
+ 0x6e, 0x64, 0x65, 0x78, 0x12, 0x23, 0x0a, 0x0d, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f,
+ 0x72, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x76, 0x61, 0x6c,
+ 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x4b, 0x65, 0x79, 0x12, 0x16, 0x0a, 0x06, 0x77, 0x65, 0x69,
+ 0x67, 0x68, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x77, 0x65, 0x69, 0x67, 0x68,
+ 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5f, 0x75,
+ 0x72, 0x6c, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+ 0x6e, 0x63, 0x65, 0x55, 0x72, 0x6c, 0x12, 0x16, 0x0a, 0x06, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73,
+ 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x12, 0x33,
+ 0x0a, 0x04, 0x73, 0x65, 0x65, 0x64, 0x18, 0x06, 0x20, 0x01, 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, 0x04, 0x73,
+ 0x65, 0x65, 0x64, 0x12, 0x3c, 0x0a, 0x08, 0x6d, 0x6c, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x18,
+ 0x07, 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, 0x6f, 0x64, 0x65,
+ 0x6c, 0x4d, 0x4c, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x52, 0x07, 0x6d, 0x6c, 0x4e, 0x6f, 0x64, 0x65,
+ 0x73, 0x42, 0xc5, 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, 0x17, 0x41,
+ 0x63, 0x74, 0x69, 0x76, 0x65, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74,
+ 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 (
+ file_inference_inference_activeparticipants_proto_rawDescOnce sync.Once
+ file_inference_inference_activeparticipants_proto_rawDescData = file_inference_inference_activeparticipants_proto_rawDesc
+)
+
+func file_inference_inference_activeparticipants_proto_rawDescGZIP() []byte {
+ file_inference_inference_activeparticipants_proto_rawDescOnce.Do(func() {
+ file_inference_inference_activeparticipants_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_inference_activeparticipants_proto_rawDescData)
+ })
+ return file_inference_inference_activeparticipants_proto_rawDescData
+}
+
+var file_inference_inference_activeparticipants_proto_msgTypes = make([]protoimpl.MessageInfo, 3)
+var file_inference_inference_activeparticipants_proto_goTypes = []interface{}{
+ (*ModelMLNodes)(nil), // 0: inference.inference.ModelMLNodes
+ (*ActiveParticipants)(nil), // 1: inference.inference.ActiveParticipants
+ (*ActiveParticipant)(nil), // 2: inference.inference.ActiveParticipant
+ (*MLNodeInfo)(nil), // 3: inference.inference.MLNodeInfo
+ (*RandomSeed)(nil), // 4: inference.inference.RandomSeed
+}
+var file_inference_inference_activeparticipants_proto_depIdxs = []int32{
+ 3, // 0: inference.inference.ModelMLNodes.ml_nodes:type_name -> inference.inference.MLNodeInfo
+ 2, // 1: inference.inference.ActiveParticipants.participants:type_name -> inference.inference.ActiveParticipant
+ 4, // 2: inference.inference.ActiveParticipant.seed:type_name -> inference.inference.RandomSeed
+ 0, // 3: inference.inference.ActiveParticipant.ml_nodes:type_name -> inference.inference.ModelMLNodes
+ 4, // [4:4] is the sub-list for method output_type
+ 4, // [4:4] is the sub-list for method input_type
+ 4, // [4:4] is the sub-list for extension type_name
+ 4, // [4:4] is the sub-list for extension extendee
+ 0, // [0:4] is the sub-list for field type_name
+}
+
+func init() { file_inference_inference_activeparticipants_proto_init() }
+func file_inference_inference_activeparticipants_proto_init() {
+ if File_inference_inference_activeparticipants_proto != nil {
+ return
+ }
+ file_inference_inference_random_seed_proto_init()
+ file_inference_inference_epoch_group_data_proto_init()
+ if !protoimpl.UnsafeEnabled {
+ file_inference_inference_activeparticipants_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*ModelMLNodes); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_inference_activeparticipants_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*ActiveParticipants); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_inference_activeparticipants_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*ActiveParticipant); 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_activeparticipants_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 3,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_inference_activeparticipants_proto_goTypes,
+ DependencyIndexes: file_inference_inference_activeparticipants_proto_depIdxs,
+ MessageInfos: file_inference_inference_activeparticipants_proto_msgTypes,
+ }.Build()
+ File_inference_inference_activeparticipants_proto = out.File
+ file_inference_inference_activeparticipants_proto_rawDesc = nil
+ file_inference_inference_activeparticipants_proto_goTypes = nil
+ file_inference_inference_activeparticipants_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/inference/bridge.pulsar.go b/inference-chain/api/inference/inference/bridge.pulsar.go
new file mode 100644
index 000000000..515c7f4bb
--- /dev/null
+++ b/inference-chain/api/inference/inference/bridge.pulsar.go
@@ -0,0 +1,4847 @@
+// 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_BridgeContractAddress protoreflect.MessageDescriptor
+ fd_BridgeContractAddress_id protoreflect.FieldDescriptor
+ fd_BridgeContractAddress_chainId protoreflect.FieldDescriptor
+ fd_BridgeContractAddress_address protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_bridge_proto_init()
+ md_BridgeContractAddress = File_inference_inference_bridge_proto.Messages().ByName("BridgeContractAddress")
+ fd_BridgeContractAddress_id = md_BridgeContractAddress.Fields().ByName("id")
+ fd_BridgeContractAddress_chainId = md_BridgeContractAddress.Fields().ByName("chainId")
+ fd_BridgeContractAddress_address = md_BridgeContractAddress.Fields().ByName("address")
+}
+
+var _ protoreflect.Message = (*fastReflection_BridgeContractAddress)(nil)
+
+type fastReflection_BridgeContractAddress BridgeContractAddress
+
+func (x *BridgeContractAddress) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_BridgeContractAddress)(x)
+}
+
+func (x *BridgeContractAddress) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_bridge_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_BridgeContractAddress_messageType fastReflection_BridgeContractAddress_messageType
+var _ protoreflect.MessageType = fastReflection_BridgeContractAddress_messageType{}
+
+type fastReflection_BridgeContractAddress_messageType struct{}
+
+func (x fastReflection_BridgeContractAddress_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_BridgeContractAddress)(nil)
+}
+func (x fastReflection_BridgeContractAddress_messageType) New() protoreflect.Message {
+ return new(fastReflection_BridgeContractAddress)
+}
+func (x fastReflection_BridgeContractAddress_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_BridgeContractAddress
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_BridgeContractAddress) Descriptor() protoreflect.MessageDescriptor {
+ return md_BridgeContractAddress
+}
+
+// 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_BridgeContractAddress) Type() protoreflect.MessageType {
+ return _fastReflection_BridgeContractAddress_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_BridgeContractAddress) New() protoreflect.Message {
+ return new(fastReflection_BridgeContractAddress)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_BridgeContractAddress) Interface() protoreflect.ProtoMessage {
+ return (*BridgeContractAddress)(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_BridgeContractAddress) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Id != "" {
+ value := protoreflect.ValueOfString(x.Id)
+ if !f(fd_BridgeContractAddress_id, value) {
+ return
+ }
+ }
+ if x.ChainId != "" {
+ value := protoreflect.ValueOfString(x.ChainId)
+ if !f(fd_BridgeContractAddress_chainId, value) {
+ return
+ }
+ }
+ if x.Address != "" {
+ value := protoreflect.ValueOfString(x.Address)
+ if !f(fd_BridgeContractAddress_address, 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_BridgeContractAddress) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.BridgeContractAddress.id":
+ return x.Id != ""
+ case "inference.inference.BridgeContractAddress.chainId":
+ return x.ChainId != ""
+ case "inference.inference.BridgeContractAddress.address":
+ return x.Address != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BridgeContractAddress"))
+ }
+ panic(fmt.Errorf("message inference.inference.BridgeContractAddress 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_BridgeContractAddress) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.BridgeContractAddress.id":
+ x.Id = ""
+ case "inference.inference.BridgeContractAddress.chainId":
+ x.ChainId = ""
+ case "inference.inference.BridgeContractAddress.address":
+ x.Address = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BridgeContractAddress"))
+ }
+ panic(fmt.Errorf("message inference.inference.BridgeContractAddress 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_BridgeContractAddress) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.BridgeContractAddress.id":
+ value := x.Id
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.BridgeContractAddress.chainId":
+ value := x.ChainId
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.BridgeContractAddress.address":
+ value := x.Address
+ return protoreflect.ValueOfString(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BridgeContractAddress"))
+ }
+ panic(fmt.Errorf("message inference.inference.BridgeContractAddress 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_BridgeContractAddress) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.BridgeContractAddress.id":
+ x.Id = value.Interface().(string)
+ case "inference.inference.BridgeContractAddress.chainId":
+ x.ChainId = value.Interface().(string)
+ case "inference.inference.BridgeContractAddress.address":
+ x.Address = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BridgeContractAddress"))
+ }
+ panic(fmt.Errorf("message inference.inference.BridgeContractAddress 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_BridgeContractAddress) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.BridgeContractAddress.id":
+ panic(fmt.Errorf("field id of message inference.inference.BridgeContractAddress is not mutable"))
+ case "inference.inference.BridgeContractAddress.chainId":
+ panic(fmt.Errorf("field chainId of message inference.inference.BridgeContractAddress is not mutable"))
+ case "inference.inference.BridgeContractAddress.address":
+ panic(fmt.Errorf("field address of message inference.inference.BridgeContractAddress is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BridgeContractAddress"))
+ }
+ panic(fmt.Errorf("message inference.inference.BridgeContractAddress 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_BridgeContractAddress) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.BridgeContractAddress.id":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.BridgeContractAddress.chainId":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.BridgeContractAddress.address":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BridgeContractAddress"))
+ }
+ panic(fmt.Errorf("message inference.inference.BridgeContractAddress 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_BridgeContractAddress) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.BridgeContractAddress", 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_BridgeContractAddress) 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_BridgeContractAddress) 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_BridgeContractAddress) 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_BridgeContractAddress) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*BridgeContractAddress)
+ 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))
+ }
+ l = len(x.ChainId)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ l = len(x.Address)
+ 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().(*BridgeContractAddress)
+ 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.Address) > 0 {
+ i -= len(x.Address)
+ copy(dAtA[i:], x.Address)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Address)))
+ 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.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().(*BridgeContractAddress)
+ 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: BridgeContractAddress: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: BridgeContractAddress: 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
+ 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 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
+ 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_BridgeTokenMetadata protoreflect.MessageDescriptor
+ fd_BridgeTokenMetadata_chainId protoreflect.FieldDescriptor
+ fd_BridgeTokenMetadata_contractAddress protoreflect.FieldDescriptor
+ fd_BridgeTokenMetadata_name protoreflect.FieldDescriptor
+ fd_BridgeTokenMetadata_symbol protoreflect.FieldDescriptor
+ fd_BridgeTokenMetadata_decimals protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_bridge_proto_init()
+ md_BridgeTokenMetadata = File_inference_inference_bridge_proto.Messages().ByName("BridgeTokenMetadata")
+ fd_BridgeTokenMetadata_chainId = md_BridgeTokenMetadata.Fields().ByName("chainId")
+ fd_BridgeTokenMetadata_contractAddress = md_BridgeTokenMetadata.Fields().ByName("contractAddress")
+ fd_BridgeTokenMetadata_name = md_BridgeTokenMetadata.Fields().ByName("name")
+ fd_BridgeTokenMetadata_symbol = md_BridgeTokenMetadata.Fields().ByName("symbol")
+ fd_BridgeTokenMetadata_decimals = md_BridgeTokenMetadata.Fields().ByName("decimals")
+}
+
+var _ protoreflect.Message = (*fastReflection_BridgeTokenMetadata)(nil)
+
+type fastReflection_BridgeTokenMetadata BridgeTokenMetadata
+
+func (x *BridgeTokenMetadata) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_BridgeTokenMetadata)(x)
+}
+
+func (x *BridgeTokenMetadata) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_bridge_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_BridgeTokenMetadata_messageType fastReflection_BridgeTokenMetadata_messageType
+var _ protoreflect.MessageType = fastReflection_BridgeTokenMetadata_messageType{}
+
+type fastReflection_BridgeTokenMetadata_messageType struct{}
+
+func (x fastReflection_BridgeTokenMetadata_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_BridgeTokenMetadata)(nil)
+}
+func (x fastReflection_BridgeTokenMetadata_messageType) New() protoreflect.Message {
+ return new(fastReflection_BridgeTokenMetadata)
+}
+func (x fastReflection_BridgeTokenMetadata_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_BridgeTokenMetadata
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_BridgeTokenMetadata) Descriptor() protoreflect.MessageDescriptor {
+ return md_BridgeTokenMetadata
+}
+
+// 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_BridgeTokenMetadata) Type() protoreflect.MessageType {
+ return _fastReflection_BridgeTokenMetadata_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_BridgeTokenMetadata) New() protoreflect.Message {
+ return new(fastReflection_BridgeTokenMetadata)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_BridgeTokenMetadata) Interface() protoreflect.ProtoMessage {
+ return (*BridgeTokenMetadata)(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_BridgeTokenMetadata) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.ChainId != "" {
+ value := protoreflect.ValueOfString(x.ChainId)
+ if !f(fd_BridgeTokenMetadata_chainId, value) {
+ return
+ }
+ }
+ if x.ContractAddress != "" {
+ value := protoreflect.ValueOfString(x.ContractAddress)
+ if !f(fd_BridgeTokenMetadata_contractAddress, value) {
+ return
+ }
+ }
+ if x.Name != "" {
+ value := protoreflect.ValueOfString(x.Name)
+ if !f(fd_BridgeTokenMetadata_name, value) {
+ return
+ }
+ }
+ if x.Symbol != "" {
+ value := protoreflect.ValueOfString(x.Symbol)
+ if !f(fd_BridgeTokenMetadata_symbol, value) {
+ return
+ }
+ }
+ if x.Decimals != uint32(0) {
+ value := protoreflect.ValueOfUint32(x.Decimals)
+ if !f(fd_BridgeTokenMetadata_decimals, 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_BridgeTokenMetadata) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.BridgeTokenMetadata.chainId":
+ return x.ChainId != ""
+ case "inference.inference.BridgeTokenMetadata.contractAddress":
+ return x.ContractAddress != ""
+ case "inference.inference.BridgeTokenMetadata.name":
+ return x.Name != ""
+ case "inference.inference.BridgeTokenMetadata.symbol":
+ return x.Symbol != ""
+ case "inference.inference.BridgeTokenMetadata.decimals":
+ return x.Decimals != uint32(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BridgeTokenMetadata"))
+ }
+ panic(fmt.Errorf("message inference.inference.BridgeTokenMetadata 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_BridgeTokenMetadata) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.BridgeTokenMetadata.chainId":
+ x.ChainId = ""
+ case "inference.inference.BridgeTokenMetadata.contractAddress":
+ x.ContractAddress = ""
+ case "inference.inference.BridgeTokenMetadata.name":
+ x.Name = ""
+ case "inference.inference.BridgeTokenMetadata.symbol":
+ x.Symbol = ""
+ case "inference.inference.BridgeTokenMetadata.decimals":
+ x.Decimals = uint32(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BridgeTokenMetadata"))
+ }
+ panic(fmt.Errorf("message inference.inference.BridgeTokenMetadata 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_BridgeTokenMetadata) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.BridgeTokenMetadata.chainId":
+ value := x.ChainId
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.BridgeTokenMetadata.contractAddress":
+ value := x.ContractAddress
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.BridgeTokenMetadata.name":
+ value := x.Name
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.BridgeTokenMetadata.symbol":
+ value := x.Symbol
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.BridgeTokenMetadata.decimals":
+ value := x.Decimals
+ return protoreflect.ValueOfUint32(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BridgeTokenMetadata"))
+ }
+ panic(fmt.Errorf("message inference.inference.BridgeTokenMetadata 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_BridgeTokenMetadata) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.BridgeTokenMetadata.chainId":
+ x.ChainId = value.Interface().(string)
+ case "inference.inference.BridgeTokenMetadata.contractAddress":
+ x.ContractAddress = value.Interface().(string)
+ case "inference.inference.BridgeTokenMetadata.name":
+ x.Name = value.Interface().(string)
+ case "inference.inference.BridgeTokenMetadata.symbol":
+ x.Symbol = value.Interface().(string)
+ case "inference.inference.BridgeTokenMetadata.decimals":
+ x.Decimals = uint32(value.Uint())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BridgeTokenMetadata"))
+ }
+ panic(fmt.Errorf("message inference.inference.BridgeTokenMetadata 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_BridgeTokenMetadata) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.BridgeTokenMetadata.chainId":
+ panic(fmt.Errorf("field chainId of message inference.inference.BridgeTokenMetadata is not mutable"))
+ case "inference.inference.BridgeTokenMetadata.contractAddress":
+ panic(fmt.Errorf("field contractAddress of message inference.inference.BridgeTokenMetadata is not mutable"))
+ case "inference.inference.BridgeTokenMetadata.name":
+ panic(fmt.Errorf("field name of message inference.inference.BridgeTokenMetadata is not mutable"))
+ case "inference.inference.BridgeTokenMetadata.symbol":
+ panic(fmt.Errorf("field symbol of message inference.inference.BridgeTokenMetadata is not mutable"))
+ case "inference.inference.BridgeTokenMetadata.decimals":
+ panic(fmt.Errorf("field decimals of message inference.inference.BridgeTokenMetadata is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BridgeTokenMetadata"))
+ }
+ panic(fmt.Errorf("message inference.inference.BridgeTokenMetadata 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_BridgeTokenMetadata) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.BridgeTokenMetadata.chainId":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.BridgeTokenMetadata.contractAddress":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.BridgeTokenMetadata.name":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.BridgeTokenMetadata.symbol":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.BridgeTokenMetadata.decimals":
+ return protoreflect.ValueOfUint32(uint32(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BridgeTokenMetadata"))
+ }
+ panic(fmt.Errorf("message inference.inference.BridgeTokenMetadata 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_BridgeTokenMetadata) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.BridgeTokenMetadata", 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_BridgeTokenMetadata) 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_BridgeTokenMetadata) 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_BridgeTokenMetadata) 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_BridgeTokenMetadata) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*BridgeTokenMetadata)
+ 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.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.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().(*BridgeTokenMetadata)
+ 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.Decimals != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.Decimals))
+ i--
+ dAtA[i] = 0x28
+ }
+ 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] = 0x22
+ }
+ 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] = 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] = 0x12
+ }
+ 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
+ }
+ 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().(*BridgeTokenMetadata)
+ 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: BridgeTokenMetadata: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: BridgeTokenMetadata: 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)
+ }
+ 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 2:
+ 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 3:
+ 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 4:
+ 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 5:
+ 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:])
+ 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_BridgeTokenReference protoreflect.MessageDescriptor
+ fd_BridgeTokenReference_chainId protoreflect.FieldDescriptor
+ fd_BridgeTokenReference_contractAddress protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_bridge_proto_init()
+ md_BridgeTokenReference = File_inference_inference_bridge_proto.Messages().ByName("BridgeTokenReference")
+ fd_BridgeTokenReference_chainId = md_BridgeTokenReference.Fields().ByName("chainId")
+ fd_BridgeTokenReference_contractAddress = md_BridgeTokenReference.Fields().ByName("contractAddress")
+}
+
+var _ protoreflect.Message = (*fastReflection_BridgeTokenReference)(nil)
+
+type fastReflection_BridgeTokenReference BridgeTokenReference
+
+func (x *BridgeTokenReference) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_BridgeTokenReference)(x)
+}
+
+func (x *BridgeTokenReference) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_bridge_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_BridgeTokenReference_messageType fastReflection_BridgeTokenReference_messageType
+var _ protoreflect.MessageType = fastReflection_BridgeTokenReference_messageType{}
+
+type fastReflection_BridgeTokenReference_messageType struct{}
+
+func (x fastReflection_BridgeTokenReference_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_BridgeTokenReference)(nil)
+}
+func (x fastReflection_BridgeTokenReference_messageType) New() protoreflect.Message {
+ return new(fastReflection_BridgeTokenReference)
+}
+func (x fastReflection_BridgeTokenReference_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_BridgeTokenReference
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_BridgeTokenReference) Descriptor() protoreflect.MessageDescriptor {
+ return md_BridgeTokenReference
+}
+
+// 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_BridgeTokenReference) Type() protoreflect.MessageType {
+ return _fastReflection_BridgeTokenReference_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_BridgeTokenReference) New() protoreflect.Message {
+ return new(fastReflection_BridgeTokenReference)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_BridgeTokenReference) Interface() protoreflect.ProtoMessage {
+ return (*BridgeTokenReference)(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_BridgeTokenReference) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.ChainId != "" {
+ value := protoreflect.ValueOfString(x.ChainId)
+ if !f(fd_BridgeTokenReference_chainId, value) {
+ return
+ }
+ }
+ if x.ContractAddress != "" {
+ value := protoreflect.ValueOfString(x.ContractAddress)
+ if !f(fd_BridgeTokenReference_contractAddress, 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_BridgeTokenReference) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.BridgeTokenReference.chainId":
+ return x.ChainId != ""
+ case "inference.inference.BridgeTokenReference.contractAddress":
+ return x.ContractAddress != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BridgeTokenReference"))
+ }
+ panic(fmt.Errorf("message inference.inference.BridgeTokenReference 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_BridgeTokenReference) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.BridgeTokenReference.chainId":
+ x.ChainId = ""
+ case "inference.inference.BridgeTokenReference.contractAddress":
+ x.ContractAddress = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BridgeTokenReference"))
+ }
+ panic(fmt.Errorf("message inference.inference.BridgeTokenReference 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_BridgeTokenReference) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.BridgeTokenReference.chainId":
+ value := x.ChainId
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.BridgeTokenReference.contractAddress":
+ value := x.ContractAddress
+ return protoreflect.ValueOfString(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BridgeTokenReference"))
+ }
+ panic(fmt.Errorf("message inference.inference.BridgeTokenReference 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_BridgeTokenReference) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.BridgeTokenReference.chainId":
+ x.ChainId = value.Interface().(string)
+ case "inference.inference.BridgeTokenReference.contractAddress":
+ x.ContractAddress = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BridgeTokenReference"))
+ }
+ panic(fmt.Errorf("message inference.inference.BridgeTokenReference 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_BridgeTokenReference) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.BridgeTokenReference.chainId":
+ panic(fmt.Errorf("field chainId of message inference.inference.BridgeTokenReference is not mutable"))
+ case "inference.inference.BridgeTokenReference.contractAddress":
+ panic(fmt.Errorf("field contractAddress of message inference.inference.BridgeTokenReference is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BridgeTokenReference"))
+ }
+ panic(fmt.Errorf("message inference.inference.BridgeTokenReference 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_BridgeTokenReference) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.BridgeTokenReference.chainId":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.BridgeTokenReference.contractAddress":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BridgeTokenReference"))
+ }
+ panic(fmt.Errorf("message inference.inference.BridgeTokenReference 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_BridgeTokenReference) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.BridgeTokenReference", 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_BridgeTokenReference) 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_BridgeTokenReference) 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_BridgeTokenReference) 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_BridgeTokenReference) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*BridgeTokenReference)
+ 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.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))
+ }
+ 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().(*BridgeTokenReference)
+ 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.ContractAddress) > 0 {
+ i -= len(x.ContractAddress)
+ copy(dAtA[i:], x.ContractAddress)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ContractAddress)))
+ i--
+ dAtA[i] = 0x12
+ }
+ 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
+ }
+ 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().(*BridgeTokenReference)
+ 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: BridgeTokenReference: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: BridgeTokenReference: 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)
+ }
+ 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 2:
+ 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
+ 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 = (*_BridgeTransaction_11_list)(nil)
+
+type _BridgeTransaction_11_list struct {
+ list *[]string
+}
+
+func (x *_BridgeTransaction_11_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_BridgeTransaction_11_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfString((*x.list)[i])
+}
+
+func (x *_BridgeTransaction_11_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.String()
+ concreteValue := valueUnwrapped
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_BridgeTransaction_11_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.String()
+ concreteValue := valueUnwrapped
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_BridgeTransaction_11_list) AppendMutable() protoreflect.Value {
+ panic(fmt.Errorf("AppendMutable can not be called on message BridgeTransaction at list field Validators as it is not of Message kind"))
+}
+
+func (x *_BridgeTransaction_11_list) Truncate(n int) {
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_BridgeTransaction_11_list) NewElement() protoreflect.Value {
+ v := ""
+ return protoreflect.ValueOfString(v)
+}
+
+func (x *_BridgeTransaction_11_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_BridgeTransaction protoreflect.MessageDescriptor
+ fd_BridgeTransaction_id protoreflect.FieldDescriptor
+ fd_BridgeTransaction_chainId protoreflect.FieldDescriptor
+ fd_BridgeTransaction_contractAddress protoreflect.FieldDescriptor
+ fd_BridgeTransaction_ownerAddress protoreflect.FieldDescriptor
+ fd_BridgeTransaction_amount protoreflect.FieldDescriptor
+ fd_BridgeTransaction_status protoreflect.FieldDescriptor
+ fd_BridgeTransaction_blockNumber protoreflect.FieldDescriptor
+ fd_BridgeTransaction_receiptIndex protoreflect.FieldDescriptor
+ fd_BridgeTransaction_receiptsRoot protoreflect.FieldDescriptor
+ fd_BridgeTransaction_epochIndex protoreflect.FieldDescriptor
+ fd_BridgeTransaction_validators protoreflect.FieldDescriptor
+ fd_BridgeTransaction_totalValidationPower protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_bridge_proto_init()
+ md_BridgeTransaction = File_inference_inference_bridge_proto.Messages().ByName("BridgeTransaction")
+ fd_BridgeTransaction_id = md_BridgeTransaction.Fields().ByName("id")
+ fd_BridgeTransaction_chainId = md_BridgeTransaction.Fields().ByName("chainId")
+ fd_BridgeTransaction_contractAddress = md_BridgeTransaction.Fields().ByName("contractAddress")
+ fd_BridgeTransaction_ownerAddress = md_BridgeTransaction.Fields().ByName("ownerAddress")
+ fd_BridgeTransaction_amount = md_BridgeTransaction.Fields().ByName("amount")
+ fd_BridgeTransaction_status = md_BridgeTransaction.Fields().ByName("status")
+ fd_BridgeTransaction_blockNumber = md_BridgeTransaction.Fields().ByName("blockNumber")
+ fd_BridgeTransaction_receiptIndex = md_BridgeTransaction.Fields().ByName("receiptIndex")
+ fd_BridgeTransaction_receiptsRoot = md_BridgeTransaction.Fields().ByName("receiptsRoot")
+ fd_BridgeTransaction_epochIndex = md_BridgeTransaction.Fields().ByName("epochIndex")
+ fd_BridgeTransaction_validators = md_BridgeTransaction.Fields().ByName("validators")
+ fd_BridgeTransaction_totalValidationPower = md_BridgeTransaction.Fields().ByName("totalValidationPower")
+}
+
+var _ protoreflect.Message = (*fastReflection_BridgeTransaction)(nil)
+
+type fastReflection_BridgeTransaction BridgeTransaction
+
+func (x *BridgeTransaction) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_BridgeTransaction)(x)
+}
+
+func (x *BridgeTransaction) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_bridge_proto_msgTypes[3]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_BridgeTransaction_messageType fastReflection_BridgeTransaction_messageType
+var _ protoreflect.MessageType = fastReflection_BridgeTransaction_messageType{}
+
+type fastReflection_BridgeTransaction_messageType struct{}
+
+func (x fastReflection_BridgeTransaction_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_BridgeTransaction)(nil)
+}
+func (x fastReflection_BridgeTransaction_messageType) New() protoreflect.Message {
+ return new(fastReflection_BridgeTransaction)
+}
+func (x fastReflection_BridgeTransaction_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_BridgeTransaction
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_BridgeTransaction) Descriptor() protoreflect.MessageDescriptor {
+ return md_BridgeTransaction
+}
+
+// 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_BridgeTransaction) Type() protoreflect.MessageType {
+ return _fastReflection_BridgeTransaction_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_BridgeTransaction) New() protoreflect.Message {
+ return new(fastReflection_BridgeTransaction)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_BridgeTransaction) Interface() protoreflect.ProtoMessage {
+ return (*BridgeTransaction)(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_BridgeTransaction) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Id != "" {
+ value := protoreflect.ValueOfString(x.Id)
+ if !f(fd_BridgeTransaction_id, value) {
+ return
+ }
+ }
+ if x.ChainId != "" {
+ value := protoreflect.ValueOfString(x.ChainId)
+ if !f(fd_BridgeTransaction_chainId, value) {
+ return
+ }
+ }
+ if x.ContractAddress != "" {
+ value := protoreflect.ValueOfString(x.ContractAddress)
+ if !f(fd_BridgeTransaction_contractAddress, value) {
+ return
+ }
+ }
+ if x.OwnerAddress != "" {
+ value := protoreflect.ValueOfString(x.OwnerAddress)
+ if !f(fd_BridgeTransaction_ownerAddress, value) {
+ return
+ }
+ }
+ if x.Amount != "" {
+ value := protoreflect.ValueOfString(x.Amount)
+ if !f(fd_BridgeTransaction_amount, value) {
+ return
+ }
+ }
+ if x.Status != 0 {
+ value := protoreflect.ValueOfEnum((protoreflect.EnumNumber)(x.Status))
+ if !f(fd_BridgeTransaction_status, value) {
+ return
+ }
+ }
+ if x.BlockNumber != "" {
+ value := protoreflect.ValueOfString(x.BlockNumber)
+ if !f(fd_BridgeTransaction_blockNumber, value) {
+ return
+ }
+ }
+ if x.ReceiptIndex != "" {
+ value := protoreflect.ValueOfString(x.ReceiptIndex)
+ if !f(fd_BridgeTransaction_receiptIndex, value) {
+ return
+ }
+ }
+ if x.ReceiptsRoot != "" {
+ value := protoreflect.ValueOfString(x.ReceiptsRoot)
+ if !f(fd_BridgeTransaction_receiptsRoot, value) {
+ return
+ }
+ }
+ if x.EpochIndex != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.EpochIndex)
+ if !f(fd_BridgeTransaction_epochIndex, value) {
+ return
+ }
+ }
+ if len(x.Validators) != 0 {
+ value := protoreflect.ValueOfList(&_BridgeTransaction_11_list{list: &x.Validators})
+ if !f(fd_BridgeTransaction_validators, value) {
+ return
+ }
+ }
+ if x.TotalValidationPower != int64(0) {
+ value := protoreflect.ValueOfInt64(x.TotalValidationPower)
+ if !f(fd_BridgeTransaction_totalValidationPower, 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_BridgeTransaction) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.BridgeTransaction.id":
+ return x.Id != ""
+ case "inference.inference.BridgeTransaction.chainId":
+ return x.ChainId != ""
+ case "inference.inference.BridgeTransaction.contractAddress":
+ return x.ContractAddress != ""
+ case "inference.inference.BridgeTransaction.ownerAddress":
+ return x.OwnerAddress != ""
+ case "inference.inference.BridgeTransaction.amount":
+ return x.Amount != ""
+ case "inference.inference.BridgeTransaction.status":
+ return x.Status != 0
+ case "inference.inference.BridgeTransaction.blockNumber":
+ return x.BlockNumber != ""
+ case "inference.inference.BridgeTransaction.receiptIndex":
+ return x.ReceiptIndex != ""
+ case "inference.inference.BridgeTransaction.receiptsRoot":
+ return x.ReceiptsRoot != ""
+ case "inference.inference.BridgeTransaction.epochIndex":
+ return x.EpochIndex != uint64(0)
+ case "inference.inference.BridgeTransaction.validators":
+ return len(x.Validators) != 0
+ case "inference.inference.BridgeTransaction.totalValidationPower":
+ return x.TotalValidationPower != int64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BridgeTransaction"))
+ }
+ panic(fmt.Errorf("message inference.inference.BridgeTransaction 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_BridgeTransaction) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.BridgeTransaction.id":
+ x.Id = ""
+ case "inference.inference.BridgeTransaction.chainId":
+ x.ChainId = ""
+ case "inference.inference.BridgeTransaction.contractAddress":
+ x.ContractAddress = ""
+ case "inference.inference.BridgeTransaction.ownerAddress":
+ x.OwnerAddress = ""
+ case "inference.inference.BridgeTransaction.amount":
+ x.Amount = ""
+ case "inference.inference.BridgeTransaction.status":
+ x.Status = 0
+ case "inference.inference.BridgeTransaction.blockNumber":
+ x.BlockNumber = ""
+ case "inference.inference.BridgeTransaction.receiptIndex":
+ x.ReceiptIndex = ""
+ case "inference.inference.BridgeTransaction.receiptsRoot":
+ x.ReceiptsRoot = ""
+ case "inference.inference.BridgeTransaction.epochIndex":
+ x.EpochIndex = uint64(0)
+ case "inference.inference.BridgeTransaction.validators":
+ x.Validators = nil
+ case "inference.inference.BridgeTransaction.totalValidationPower":
+ x.TotalValidationPower = int64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BridgeTransaction"))
+ }
+ panic(fmt.Errorf("message inference.inference.BridgeTransaction 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_BridgeTransaction) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.BridgeTransaction.id":
+ value := x.Id
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.BridgeTransaction.chainId":
+ value := x.ChainId
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.BridgeTransaction.contractAddress":
+ value := x.ContractAddress
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.BridgeTransaction.ownerAddress":
+ value := x.OwnerAddress
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.BridgeTransaction.amount":
+ value := x.Amount
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.BridgeTransaction.status":
+ value := x.Status
+ return protoreflect.ValueOfEnum((protoreflect.EnumNumber)(value))
+ case "inference.inference.BridgeTransaction.blockNumber":
+ value := x.BlockNumber
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.BridgeTransaction.receiptIndex":
+ value := x.ReceiptIndex
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.BridgeTransaction.receiptsRoot":
+ value := x.ReceiptsRoot
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.BridgeTransaction.epochIndex":
+ value := x.EpochIndex
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.BridgeTransaction.validators":
+ if len(x.Validators) == 0 {
+ return protoreflect.ValueOfList(&_BridgeTransaction_11_list{})
+ }
+ listValue := &_BridgeTransaction_11_list{list: &x.Validators}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.inference.BridgeTransaction.totalValidationPower":
+ value := x.TotalValidationPower
+ return protoreflect.ValueOfInt64(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BridgeTransaction"))
+ }
+ panic(fmt.Errorf("message inference.inference.BridgeTransaction 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_BridgeTransaction) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.BridgeTransaction.id":
+ x.Id = value.Interface().(string)
+ case "inference.inference.BridgeTransaction.chainId":
+ x.ChainId = value.Interface().(string)
+ case "inference.inference.BridgeTransaction.contractAddress":
+ x.ContractAddress = value.Interface().(string)
+ case "inference.inference.BridgeTransaction.ownerAddress":
+ x.OwnerAddress = value.Interface().(string)
+ case "inference.inference.BridgeTransaction.amount":
+ x.Amount = value.Interface().(string)
+ case "inference.inference.BridgeTransaction.status":
+ x.Status = (BridgeTransactionStatus)(value.Enum())
+ case "inference.inference.BridgeTransaction.blockNumber":
+ x.BlockNumber = value.Interface().(string)
+ case "inference.inference.BridgeTransaction.receiptIndex":
+ x.ReceiptIndex = value.Interface().(string)
+ case "inference.inference.BridgeTransaction.receiptsRoot":
+ x.ReceiptsRoot = value.Interface().(string)
+ case "inference.inference.BridgeTransaction.epochIndex":
+ x.EpochIndex = value.Uint()
+ case "inference.inference.BridgeTransaction.validators":
+ lv := value.List()
+ clv := lv.(*_BridgeTransaction_11_list)
+ x.Validators = *clv.list
+ case "inference.inference.BridgeTransaction.totalValidationPower":
+ x.TotalValidationPower = value.Int()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BridgeTransaction"))
+ }
+ panic(fmt.Errorf("message inference.inference.BridgeTransaction 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_BridgeTransaction) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.BridgeTransaction.validators":
+ if x.Validators == nil {
+ x.Validators = []string{}
+ }
+ value := &_BridgeTransaction_11_list{list: &x.Validators}
+ return protoreflect.ValueOfList(value)
+ case "inference.inference.BridgeTransaction.id":
+ panic(fmt.Errorf("field id of message inference.inference.BridgeTransaction is not mutable"))
+ case "inference.inference.BridgeTransaction.chainId":
+ panic(fmt.Errorf("field chainId of message inference.inference.BridgeTransaction is not mutable"))
+ case "inference.inference.BridgeTransaction.contractAddress":
+ panic(fmt.Errorf("field contractAddress of message inference.inference.BridgeTransaction is not mutable"))
+ case "inference.inference.BridgeTransaction.ownerAddress":
+ panic(fmt.Errorf("field ownerAddress of message inference.inference.BridgeTransaction is not mutable"))
+ case "inference.inference.BridgeTransaction.amount":
+ panic(fmt.Errorf("field amount of message inference.inference.BridgeTransaction is not mutable"))
+ case "inference.inference.BridgeTransaction.status":
+ panic(fmt.Errorf("field status of message inference.inference.BridgeTransaction is not mutable"))
+ case "inference.inference.BridgeTransaction.blockNumber":
+ panic(fmt.Errorf("field blockNumber of message inference.inference.BridgeTransaction is not mutable"))
+ case "inference.inference.BridgeTransaction.receiptIndex":
+ panic(fmt.Errorf("field receiptIndex of message inference.inference.BridgeTransaction is not mutable"))
+ case "inference.inference.BridgeTransaction.receiptsRoot":
+ panic(fmt.Errorf("field receiptsRoot of message inference.inference.BridgeTransaction is not mutable"))
+ case "inference.inference.BridgeTransaction.epochIndex":
+ panic(fmt.Errorf("field epochIndex of message inference.inference.BridgeTransaction is not mutable"))
+ case "inference.inference.BridgeTransaction.totalValidationPower":
+ panic(fmt.Errorf("field totalValidationPower of message inference.inference.BridgeTransaction is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BridgeTransaction"))
+ }
+ panic(fmt.Errorf("message inference.inference.BridgeTransaction 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_BridgeTransaction) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.BridgeTransaction.id":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.BridgeTransaction.chainId":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.BridgeTransaction.contractAddress":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.BridgeTransaction.ownerAddress":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.BridgeTransaction.amount":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.BridgeTransaction.status":
+ return protoreflect.ValueOfEnum(0)
+ case "inference.inference.BridgeTransaction.blockNumber":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.BridgeTransaction.receiptIndex":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.BridgeTransaction.receiptsRoot":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.BridgeTransaction.epochIndex":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.BridgeTransaction.validators":
+ list := []string{}
+ return protoreflect.ValueOfList(&_BridgeTransaction_11_list{list: &list})
+ case "inference.inference.BridgeTransaction.totalValidationPower":
+ return protoreflect.ValueOfInt64(int64(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BridgeTransaction"))
+ }
+ panic(fmt.Errorf("message inference.inference.BridgeTransaction 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_BridgeTransaction) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.BridgeTransaction", 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_BridgeTransaction) 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_BridgeTransaction) 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_BridgeTransaction) 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_BridgeTransaction) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*BridgeTransaction)
+ 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))
+ }
+ 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.OwnerAddress)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ l = len(x.Amount)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.Status != 0 {
+ n += 1 + runtime.Sov(uint64(x.Status))
+ }
+ 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.EpochIndex != 0 {
+ n += 1 + runtime.Sov(uint64(x.EpochIndex))
+ }
+ if len(x.Validators) > 0 {
+ for _, s := range x.Validators {
+ l = len(s)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ }
+ if x.TotalValidationPower != 0 {
+ n += 1 + runtime.Sov(uint64(x.TotalValidationPower))
+ }
+ 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().(*BridgeTransaction)
+ 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.TotalValidationPower != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.TotalValidationPower))
+ i--
+ dAtA[i] = 0x60
+ }
+ if len(x.Validators) > 0 {
+ for iNdEx := len(x.Validators) - 1; iNdEx >= 0; iNdEx-- {
+ i -= len(x.Validators[iNdEx])
+ copy(dAtA[i:], x.Validators[iNdEx])
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Validators[iNdEx])))
+ i--
+ dAtA[i] = 0x5a
+ }
+ }
+ if x.EpochIndex != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochIndex))
+ i--
+ dAtA[i] = 0x50
+ }
+ 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 x.Status != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.Status))
+ i--
+ dAtA[i] = 0x30
+ }
+ 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] = 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.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.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().(*BridgeTransaction)
+ 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: BridgeTransaction: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: BridgeTransaction: 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
+ 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])
+ 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 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 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 |= BridgeTransactionStatus(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 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
+ case 10:
+ 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 11:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Validators", 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.Validators = append(x.Validators, string(dAtA[iNdEx:postIndex]))
+ iNdEx = postIndex
+ case 12:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TotalValidationPower", wireType)
+ }
+ x.TotalValidationPower = 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.TotalValidationPower |= 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_BridgeWrappedTokenContract protoreflect.MessageDescriptor
+ fd_BridgeWrappedTokenContract_chainId protoreflect.FieldDescriptor
+ fd_BridgeWrappedTokenContract_contractAddress protoreflect.FieldDescriptor
+ fd_BridgeWrappedTokenContract_wrappedContractAddress protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_bridge_proto_init()
+ md_BridgeWrappedTokenContract = File_inference_inference_bridge_proto.Messages().ByName("BridgeWrappedTokenContract")
+ fd_BridgeWrappedTokenContract_chainId = md_BridgeWrappedTokenContract.Fields().ByName("chainId")
+ fd_BridgeWrappedTokenContract_contractAddress = md_BridgeWrappedTokenContract.Fields().ByName("contractAddress")
+ fd_BridgeWrappedTokenContract_wrappedContractAddress = md_BridgeWrappedTokenContract.Fields().ByName("wrappedContractAddress")
+}
+
+var _ protoreflect.Message = (*fastReflection_BridgeWrappedTokenContract)(nil)
+
+type fastReflection_BridgeWrappedTokenContract BridgeWrappedTokenContract
+
+func (x *BridgeWrappedTokenContract) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_BridgeWrappedTokenContract)(x)
+}
+
+func (x *BridgeWrappedTokenContract) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_bridge_proto_msgTypes[4]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_BridgeWrappedTokenContract_messageType fastReflection_BridgeWrappedTokenContract_messageType
+var _ protoreflect.MessageType = fastReflection_BridgeWrappedTokenContract_messageType{}
+
+type fastReflection_BridgeWrappedTokenContract_messageType struct{}
+
+func (x fastReflection_BridgeWrappedTokenContract_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_BridgeWrappedTokenContract)(nil)
+}
+func (x fastReflection_BridgeWrappedTokenContract_messageType) New() protoreflect.Message {
+ return new(fastReflection_BridgeWrappedTokenContract)
+}
+func (x fastReflection_BridgeWrappedTokenContract_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_BridgeWrappedTokenContract
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_BridgeWrappedTokenContract) Descriptor() protoreflect.MessageDescriptor {
+ return md_BridgeWrappedTokenContract
+}
+
+// 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_BridgeWrappedTokenContract) Type() protoreflect.MessageType {
+ return _fastReflection_BridgeWrappedTokenContract_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_BridgeWrappedTokenContract) New() protoreflect.Message {
+ return new(fastReflection_BridgeWrappedTokenContract)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_BridgeWrappedTokenContract) Interface() protoreflect.ProtoMessage {
+ return (*BridgeWrappedTokenContract)(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_BridgeWrappedTokenContract) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.ChainId != "" {
+ value := protoreflect.ValueOfString(x.ChainId)
+ if !f(fd_BridgeWrappedTokenContract_chainId, value) {
+ return
+ }
+ }
+ if x.ContractAddress != "" {
+ value := protoreflect.ValueOfString(x.ContractAddress)
+ if !f(fd_BridgeWrappedTokenContract_contractAddress, value) {
+ return
+ }
+ }
+ if x.WrappedContractAddress != "" {
+ value := protoreflect.ValueOfString(x.WrappedContractAddress)
+ if !f(fd_BridgeWrappedTokenContract_wrappedContractAddress, 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_BridgeWrappedTokenContract) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.BridgeWrappedTokenContract.chainId":
+ return x.ChainId != ""
+ case "inference.inference.BridgeWrappedTokenContract.contractAddress":
+ return x.ContractAddress != ""
+ case "inference.inference.BridgeWrappedTokenContract.wrappedContractAddress":
+ return x.WrappedContractAddress != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BridgeWrappedTokenContract"))
+ }
+ panic(fmt.Errorf("message inference.inference.BridgeWrappedTokenContract 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_BridgeWrappedTokenContract) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.BridgeWrappedTokenContract.chainId":
+ x.ChainId = ""
+ case "inference.inference.BridgeWrappedTokenContract.contractAddress":
+ x.ContractAddress = ""
+ case "inference.inference.BridgeWrappedTokenContract.wrappedContractAddress":
+ x.WrappedContractAddress = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BridgeWrappedTokenContract"))
+ }
+ panic(fmt.Errorf("message inference.inference.BridgeWrappedTokenContract 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_BridgeWrappedTokenContract) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.BridgeWrappedTokenContract.chainId":
+ value := x.ChainId
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.BridgeWrappedTokenContract.contractAddress":
+ value := x.ContractAddress
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.BridgeWrappedTokenContract.wrappedContractAddress":
+ value := x.WrappedContractAddress
+ return protoreflect.ValueOfString(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BridgeWrappedTokenContract"))
+ }
+ panic(fmt.Errorf("message inference.inference.BridgeWrappedTokenContract 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_BridgeWrappedTokenContract) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.BridgeWrappedTokenContract.chainId":
+ x.ChainId = value.Interface().(string)
+ case "inference.inference.BridgeWrappedTokenContract.contractAddress":
+ x.ContractAddress = value.Interface().(string)
+ case "inference.inference.BridgeWrappedTokenContract.wrappedContractAddress":
+ x.WrappedContractAddress = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BridgeWrappedTokenContract"))
+ }
+ panic(fmt.Errorf("message inference.inference.BridgeWrappedTokenContract 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_BridgeWrappedTokenContract) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.BridgeWrappedTokenContract.chainId":
+ panic(fmt.Errorf("field chainId of message inference.inference.BridgeWrappedTokenContract is not mutable"))
+ case "inference.inference.BridgeWrappedTokenContract.contractAddress":
+ panic(fmt.Errorf("field contractAddress of message inference.inference.BridgeWrappedTokenContract is not mutable"))
+ case "inference.inference.BridgeWrappedTokenContract.wrappedContractAddress":
+ panic(fmt.Errorf("field wrappedContractAddress of message inference.inference.BridgeWrappedTokenContract is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BridgeWrappedTokenContract"))
+ }
+ panic(fmt.Errorf("message inference.inference.BridgeWrappedTokenContract 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_BridgeWrappedTokenContract) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.BridgeWrappedTokenContract.chainId":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.BridgeWrappedTokenContract.contractAddress":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.BridgeWrappedTokenContract.wrappedContractAddress":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BridgeWrappedTokenContract"))
+ }
+ panic(fmt.Errorf("message inference.inference.BridgeWrappedTokenContract 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_BridgeWrappedTokenContract) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.BridgeWrappedTokenContract", 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_BridgeWrappedTokenContract) 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_BridgeWrappedTokenContract) 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_BridgeWrappedTokenContract) 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_BridgeWrappedTokenContract) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*BridgeWrappedTokenContract)
+ 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.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.WrappedContractAddress)
+ 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().(*BridgeWrappedTokenContract)
+ 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.WrappedContractAddress) > 0 {
+ i -= len(x.WrappedContractAddress)
+ copy(dAtA[i:], x.WrappedContractAddress)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.WrappedContractAddress)))
+ 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] = 0x12
+ }
+ 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
+ }
+ 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().(*BridgeWrappedTokenContract)
+ 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: BridgeWrappedTokenContract: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: BridgeWrappedTokenContract: 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)
+ }
+ 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 2:
+ 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 3:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field WrappedContractAddress", 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.WrappedContractAddress = 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 = (*_Bridge_1_list)(nil)
+
+type _Bridge_1_list struct {
+ list *[]*BridgeContractAddress
+}
+
+func (x *_Bridge_1_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_Bridge_1_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_Bridge_1_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*BridgeContractAddress)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_Bridge_1_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*BridgeContractAddress)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_Bridge_1_list) AppendMutable() protoreflect.Value {
+ v := new(BridgeContractAddress)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_Bridge_1_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_Bridge_1_list) NewElement() protoreflect.Value {
+ v := new(BridgeContractAddress)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_Bridge_1_list) IsValid() bool {
+ return x.list != nil
+}
+
+var _ protoreflect.List = (*_Bridge_2_list)(nil)
+
+type _Bridge_2_list struct {
+ list *[]*BridgeTokenMetadata
+}
+
+func (x *_Bridge_2_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_Bridge_2_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_Bridge_2_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*BridgeTokenMetadata)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_Bridge_2_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*BridgeTokenMetadata)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_Bridge_2_list) AppendMutable() protoreflect.Value {
+ v := new(BridgeTokenMetadata)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_Bridge_2_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_Bridge_2_list) NewElement() protoreflect.Value {
+ v := new(BridgeTokenMetadata)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_Bridge_2_list) IsValid() bool {
+ return x.list != nil
+}
+
+var _ protoreflect.List = (*_Bridge_3_list)(nil)
+
+type _Bridge_3_list struct {
+ list *[]*BridgeTokenReference
+}
+
+func (x *_Bridge_3_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_Bridge_3_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_Bridge_3_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*BridgeTokenReference)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_Bridge_3_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*BridgeTokenReference)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_Bridge_3_list) AppendMutable() protoreflect.Value {
+ v := new(BridgeTokenReference)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_Bridge_3_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_Bridge_3_list) NewElement() protoreflect.Value {
+ v := new(BridgeTokenReference)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_Bridge_3_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_Bridge protoreflect.MessageDescriptor
+ fd_Bridge_contract_addresses protoreflect.FieldDescriptor
+ fd_Bridge_token_metadata protoreflect.FieldDescriptor
+ fd_Bridge_trade_approved_tokens protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_bridge_proto_init()
+ md_Bridge = File_inference_inference_bridge_proto.Messages().ByName("Bridge")
+ fd_Bridge_contract_addresses = md_Bridge.Fields().ByName("contract_addresses")
+ fd_Bridge_token_metadata = md_Bridge.Fields().ByName("token_metadata")
+ fd_Bridge_trade_approved_tokens = md_Bridge.Fields().ByName("trade_approved_tokens")
+}
+
+var _ protoreflect.Message = (*fastReflection_Bridge)(nil)
+
+type fastReflection_Bridge Bridge
+
+func (x *Bridge) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_Bridge)(x)
+}
+
+func (x *Bridge) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_bridge_proto_msgTypes[5]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_Bridge_messageType fastReflection_Bridge_messageType
+var _ protoreflect.MessageType = fastReflection_Bridge_messageType{}
+
+type fastReflection_Bridge_messageType struct{}
+
+func (x fastReflection_Bridge_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_Bridge)(nil)
+}
+func (x fastReflection_Bridge_messageType) New() protoreflect.Message {
+ return new(fastReflection_Bridge)
+}
+func (x fastReflection_Bridge_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_Bridge
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_Bridge) Descriptor() protoreflect.MessageDescriptor {
+ return md_Bridge
+}
+
+// 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_Bridge) Type() protoreflect.MessageType {
+ return _fastReflection_Bridge_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_Bridge) New() protoreflect.Message {
+ return new(fastReflection_Bridge)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_Bridge) Interface() protoreflect.ProtoMessage {
+ return (*Bridge)(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_Bridge) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if len(x.ContractAddresses) != 0 {
+ value := protoreflect.ValueOfList(&_Bridge_1_list{list: &x.ContractAddresses})
+ if !f(fd_Bridge_contract_addresses, value) {
+ return
+ }
+ }
+ if len(x.TokenMetadata) != 0 {
+ value := protoreflect.ValueOfList(&_Bridge_2_list{list: &x.TokenMetadata})
+ if !f(fd_Bridge_token_metadata, value) {
+ return
+ }
+ }
+ if len(x.TradeApprovedTokens) != 0 {
+ value := protoreflect.ValueOfList(&_Bridge_3_list{list: &x.TradeApprovedTokens})
+ if !f(fd_Bridge_trade_approved_tokens, 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_Bridge) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.Bridge.contract_addresses":
+ return len(x.ContractAddresses) != 0
+ case "inference.inference.Bridge.token_metadata":
+ return len(x.TokenMetadata) != 0
+ case "inference.inference.Bridge.trade_approved_tokens":
+ return len(x.TradeApprovedTokens) != 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Bridge"))
+ }
+ panic(fmt.Errorf("message inference.inference.Bridge 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_Bridge) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.Bridge.contract_addresses":
+ x.ContractAddresses = nil
+ case "inference.inference.Bridge.token_metadata":
+ x.TokenMetadata = nil
+ case "inference.inference.Bridge.trade_approved_tokens":
+ x.TradeApprovedTokens = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Bridge"))
+ }
+ panic(fmt.Errorf("message inference.inference.Bridge 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_Bridge) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.Bridge.contract_addresses":
+ if len(x.ContractAddresses) == 0 {
+ return protoreflect.ValueOfList(&_Bridge_1_list{})
+ }
+ listValue := &_Bridge_1_list{list: &x.ContractAddresses}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.inference.Bridge.token_metadata":
+ if len(x.TokenMetadata) == 0 {
+ return protoreflect.ValueOfList(&_Bridge_2_list{})
+ }
+ listValue := &_Bridge_2_list{list: &x.TokenMetadata}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.inference.Bridge.trade_approved_tokens":
+ if len(x.TradeApprovedTokens) == 0 {
+ return protoreflect.ValueOfList(&_Bridge_3_list{})
+ }
+ listValue := &_Bridge_3_list{list: &x.TradeApprovedTokens}
+ return protoreflect.ValueOfList(listValue)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Bridge"))
+ }
+ panic(fmt.Errorf("message inference.inference.Bridge 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_Bridge) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.Bridge.contract_addresses":
+ lv := value.List()
+ clv := lv.(*_Bridge_1_list)
+ x.ContractAddresses = *clv.list
+ case "inference.inference.Bridge.token_metadata":
+ lv := value.List()
+ clv := lv.(*_Bridge_2_list)
+ x.TokenMetadata = *clv.list
+ case "inference.inference.Bridge.trade_approved_tokens":
+ lv := value.List()
+ clv := lv.(*_Bridge_3_list)
+ x.TradeApprovedTokens = *clv.list
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Bridge"))
+ }
+ panic(fmt.Errorf("message inference.inference.Bridge 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_Bridge) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.Bridge.contract_addresses":
+ if x.ContractAddresses == nil {
+ x.ContractAddresses = []*BridgeContractAddress{}
+ }
+ value := &_Bridge_1_list{list: &x.ContractAddresses}
+ return protoreflect.ValueOfList(value)
+ case "inference.inference.Bridge.token_metadata":
+ if x.TokenMetadata == nil {
+ x.TokenMetadata = []*BridgeTokenMetadata{}
+ }
+ value := &_Bridge_2_list{list: &x.TokenMetadata}
+ return protoreflect.ValueOfList(value)
+ case "inference.inference.Bridge.trade_approved_tokens":
+ if x.TradeApprovedTokens == nil {
+ x.TradeApprovedTokens = []*BridgeTokenReference{}
+ }
+ value := &_Bridge_3_list{list: &x.TradeApprovedTokens}
+ return protoreflect.ValueOfList(value)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Bridge"))
+ }
+ panic(fmt.Errorf("message inference.inference.Bridge 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_Bridge) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.Bridge.contract_addresses":
+ list := []*BridgeContractAddress{}
+ return protoreflect.ValueOfList(&_Bridge_1_list{list: &list})
+ case "inference.inference.Bridge.token_metadata":
+ list := []*BridgeTokenMetadata{}
+ return protoreflect.ValueOfList(&_Bridge_2_list{list: &list})
+ case "inference.inference.Bridge.trade_approved_tokens":
+ list := []*BridgeTokenReference{}
+ return protoreflect.ValueOfList(&_Bridge_3_list{list: &list})
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Bridge"))
+ }
+ panic(fmt.Errorf("message inference.inference.Bridge 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_Bridge) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.Bridge", 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_Bridge) 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_Bridge) 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_Bridge) 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_Bridge) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*Bridge)
+ 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.ContractAddresses) > 0 {
+ for _, e := range x.ContractAddresses {
+ l = options.Size(e)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ }
+ if len(x.TokenMetadata) > 0 {
+ for _, e := range x.TokenMetadata {
+ l = options.Size(e)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ }
+ if len(x.TradeApprovedTokens) > 0 {
+ for _, e := range x.TradeApprovedTokens {
+ 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().(*Bridge)
+ 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.TradeApprovedTokens) > 0 {
+ for iNdEx := len(x.TradeApprovedTokens) - 1; iNdEx >= 0; iNdEx-- {
+ encoded, err := options.Marshal(x.TradeApprovedTokens[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.TokenMetadata) > 0 {
+ for iNdEx := len(x.TokenMetadata) - 1; iNdEx >= 0; iNdEx-- {
+ encoded, err := options.Marshal(x.TokenMetadata[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.ContractAddresses) > 0 {
+ for iNdEx := len(x.ContractAddresses) - 1; iNdEx >= 0; iNdEx-- {
+ encoded, err := options.Marshal(x.ContractAddresses[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().(*Bridge)
+ 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: Bridge: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Bridge: 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 ContractAddresses", 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.ContractAddresses = append(x.ContractAddresses, &BridgeContractAddress{})
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ContractAddresses[len(x.ContractAddresses)-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 TokenMetadata", 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.TokenMetadata = append(x.TokenMetadata, &BridgeTokenMetadata{})
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.TokenMetadata[len(x.TokenMetadata)-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 TradeApprovedTokens", 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.TradeApprovedTokens = append(x.TradeApprovedTokens, &BridgeTokenReference{})
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.TradeApprovedTokens[len(x.TradeApprovedTokens)-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/bridge.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)
+)
+
+type BridgeTransactionStatus int32
+
+const (
+ BridgeTransactionStatus_BRIDGE_PENDING BridgeTransactionStatus = 0
+ BridgeTransactionStatus_BRIDGE_COMPLETED BridgeTransactionStatus = 1
+)
+
+// Enum value maps for BridgeTransactionStatus.
+var (
+ BridgeTransactionStatus_name = map[int32]string{
+ 0: "BRIDGE_PENDING",
+ 1: "BRIDGE_COMPLETED",
+ }
+ BridgeTransactionStatus_value = map[string]int32{
+ "BRIDGE_PENDING": 0,
+ "BRIDGE_COMPLETED": 1,
+ }
+)
+
+func (x BridgeTransactionStatus) Enum() *BridgeTransactionStatus {
+ p := new(BridgeTransactionStatus)
+ *p = x
+ return p
+}
+
+func (x BridgeTransactionStatus) String() string {
+ return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (BridgeTransactionStatus) Descriptor() protoreflect.EnumDescriptor {
+ return file_inference_inference_bridge_proto_enumTypes[0].Descriptor()
+}
+
+func (BridgeTransactionStatus) Type() protoreflect.EnumType {
+ return &file_inference_inference_bridge_proto_enumTypes[0]
+}
+
+func (x BridgeTransactionStatus) Number() protoreflect.EnumNumber {
+ return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use BridgeTransactionStatus.Descriptor instead.
+func (BridgeTransactionStatus) EnumDescriptor() ([]byte, []int) {
+ return file_inference_inference_bridge_proto_rawDescGZIP(), []int{0}
+}
+
+type BridgeContractAddress struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
+ ChainId string `protobuf:"bytes,2,opt,name=chainId,proto3" json:"chainId,omitempty"`
+ Address string `protobuf:"bytes,3,opt,name=address,proto3" json:"address,omitempty"`
+}
+
+func (x *BridgeContractAddress) Reset() {
+ *x = BridgeContractAddress{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_bridge_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *BridgeContractAddress) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BridgeContractAddress) ProtoMessage() {}
+
+// Deprecated: Use BridgeContractAddress.ProtoReflect.Descriptor instead.
+func (*BridgeContractAddress) Descriptor() ([]byte, []int) {
+ return file_inference_inference_bridge_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *BridgeContractAddress) GetId() string {
+ if x != nil {
+ return x.Id
+ }
+ return ""
+}
+
+func (x *BridgeContractAddress) GetChainId() string {
+ if x != nil {
+ return x.ChainId
+ }
+ return ""
+}
+
+func (x *BridgeContractAddress) GetAddress() string {
+ if x != nil {
+ return x.Address
+ }
+ return ""
+}
+
+// TokenMetadata is used for pre-configuring known tokens before they are bridged
+type BridgeTokenMetadata struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ ChainId string `protobuf:"bytes,1,opt,name=chainId,proto3" json:"chainId,omitempty"` // e.g. "ethereum"
+ ContractAddress string `protobuf:"bytes,2,opt,name=contractAddress,proto3" json:"contractAddress,omitempty"` // original chain contract address
+ Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"` // token name
+ Symbol string `protobuf:"bytes,4,opt,name=symbol,proto3" json:"symbol,omitempty"` // token symbol
+ Decimals uint32 `protobuf:"varint,5,opt,name=decimals,proto3" json:"decimals,omitempty"` // token decimals
+}
+
+func (x *BridgeTokenMetadata) Reset() {
+ *x = BridgeTokenMetadata{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_bridge_proto_msgTypes[1]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *BridgeTokenMetadata) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BridgeTokenMetadata) ProtoMessage() {}
+
+// Deprecated: Use BridgeTokenMetadata.ProtoReflect.Descriptor instead.
+func (*BridgeTokenMetadata) Descriptor() ([]byte, []int) {
+ return file_inference_inference_bridge_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *BridgeTokenMetadata) GetChainId() string {
+ if x != nil {
+ return x.ChainId
+ }
+ return ""
+}
+
+func (x *BridgeTokenMetadata) GetContractAddress() string {
+ if x != nil {
+ return x.ContractAddress
+ }
+ return ""
+}
+
+func (x *BridgeTokenMetadata) GetName() string {
+ if x != nil {
+ return x.Name
+ }
+ return ""
+}
+
+func (x *BridgeTokenMetadata) GetSymbol() string {
+ if x != nil {
+ return x.Symbol
+ }
+ return ""
+}
+
+func (x *BridgeTokenMetadata) GetDecimals() uint32 {
+ if x != nil {
+ return x.Decimals
+ }
+ return 0
+}
+
+// BridgeTokenReference defines a reference to a token on an external chain
+// Used for various purposes: trade approval, reverse index lookups, etc.
+type BridgeTokenReference struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ ChainId string `protobuf:"bytes,1,opt,name=chainId,proto3" json:"chainId,omitempty"` // e.g. "ethereum" - external chain identifier
+ ContractAddress string `protobuf:"bytes,2,opt,name=contractAddress,proto3" json:"contractAddress,omitempty"` // external chain contract address
+}
+
+func (x *BridgeTokenReference) Reset() {
+ *x = BridgeTokenReference{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_bridge_proto_msgTypes[2]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *BridgeTokenReference) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BridgeTokenReference) ProtoMessage() {}
+
+// Deprecated: Use BridgeTokenReference.ProtoReflect.Descriptor instead.
+func (*BridgeTokenReference) Descriptor() ([]byte, []int) {
+ return file_inference_inference_bridge_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *BridgeTokenReference) GetChainId() string {
+ if x != nil {
+ return x.ChainId
+ }
+ return ""
+}
+
+func (x *BridgeTokenReference) GetContractAddress() string {
+ if x != nil {
+ return x.ContractAddress
+ }
+ return ""
+}
+
+type BridgeTransaction struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
+ ChainId string `protobuf:"bytes,2,opt,name=chainId,proto3" json:"chainId,omitempty"`
+ ContractAddress string `protobuf:"bytes,3,opt,name=contractAddress,proto3" json:"contractAddress,omitempty"`
+ OwnerAddress string `protobuf:"bytes,4,opt,name=ownerAddress,proto3" json:"ownerAddress,omitempty"`
+ Amount string `protobuf:"bytes,5,opt,name=amount,proto3" json:"amount,omitempty"`
+ Status BridgeTransactionStatus `protobuf:"varint,6,opt,name=status,proto3,enum=inference.inference.BridgeTransactionStatus" json:"status,omitempty"`
+ BlockNumber string `protobuf:"bytes,7,opt,name=blockNumber,proto3" json:"blockNumber,omitempty"` // block number where the transaction occurred on the origin chain
+ ReceiptIndex string `protobuf:"bytes,8,opt,name=receiptIndex,proto3" json:"receiptIndex,omitempty"` // index of the transaction receipt in the block
+ ReceiptsRoot string `protobuf:"bytes,9,opt,name=receiptsRoot,proto3" json:"receiptsRoot,omitempty"` // merkle root of receipts trie for transaction verification
+ EpochIndex uint64 `protobuf:"varint,10,opt,name=epochIndex,proto3" json:"epochIndex,omitempty"`
+ Validators []string `protobuf:"bytes,11,rep,name=validators,proto3" json:"validators,omitempty"` // list of validator addresses that validated
+ TotalValidationPower int64 `protobuf:"varint,12,opt,name=totalValidationPower,proto3" json:"totalValidationPower,omitempty"` // sum of all validator powers that validated
+}
+
+func (x *BridgeTransaction) Reset() {
+ *x = BridgeTransaction{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_bridge_proto_msgTypes[3]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *BridgeTransaction) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BridgeTransaction) ProtoMessage() {}
+
+// Deprecated: Use BridgeTransaction.ProtoReflect.Descriptor instead.
+func (*BridgeTransaction) Descriptor() ([]byte, []int) {
+ return file_inference_inference_bridge_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *BridgeTransaction) GetId() string {
+ if x != nil {
+ return x.Id
+ }
+ return ""
+}
+
+func (x *BridgeTransaction) GetChainId() string {
+ if x != nil {
+ return x.ChainId
+ }
+ return ""
+}
+
+func (x *BridgeTransaction) GetContractAddress() string {
+ if x != nil {
+ return x.ContractAddress
+ }
+ return ""
+}
+
+func (x *BridgeTransaction) GetOwnerAddress() string {
+ if x != nil {
+ return x.OwnerAddress
+ }
+ return ""
+}
+
+func (x *BridgeTransaction) GetAmount() string {
+ if x != nil {
+ return x.Amount
+ }
+ return ""
+}
+
+func (x *BridgeTransaction) GetStatus() BridgeTransactionStatus {
+ if x != nil {
+ return x.Status
+ }
+ return BridgeTransactionStatus_BRIDGE_PENDING
+}
+
+func (x *BridgeTransaction) GetBlockNumber() string {
+ if x != nil {
+ return x.BlockNumber
+ }
+ return ""
+}
+
+func (x *BridgeTransaction) GetReceiptIndex() string {
+ if x != nil {
+ return x.ReceiptIndex
+ }
+ return ""
+}
+
+func (x *BridgeTransaction) GetReceiptsRoot() string {
+ if x != nil {
+ return x.ReceiptsRoot
+ }
+ return ""
+}
+
+func (x *BridgeTransaction) GetEpochIndex() uint64 {
+ if x != nil {
+ return x.EpochIndex
+ }
+ return 0
+}
+
+func (x *BridgeTransaction) GetValidators() []string {
+ if x != nil {
+ return x.Validators
+ }
+ return nil
+}
+
+func (x *BridgeTransaction) GetTotalValidationPower() int64 {
+ if x != nil {
+ return x.TotalValidationPower
+ }
+ return 0
+}
+
+// Stores mapping between external chain tokens and their CW20 counterparts
+type BridgeWrappedTokenContract struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ ChainId string `protobuf:"bytes,1,opt,name=chainId,proto3" json:"chainId,omitempty"`
+ ContractAddress string `protobuf:"bytes,2,opt,name=contractAddress,proto3" json:"contractAddress,omitempty"`
+ WrappedContractAddress string `protobuf:"bytes,3,opt,name=wrappedContractAddress,proto3" json:"wrappedContractAddress,omitempty"`
+}
+
+func (x *BridgeWrappedTokenContract) Reset() {
+ *x = BridgeWrappedTokenContract{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_bridge_proto_msgTypes[4]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *BridgeWrappedTokenContract) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BridgeWrappedTokenContract) ProtoMessage() {}
+
+// Deprecated: Use BridgeWrappedTokenContract.ProtoReflect.Descriptor instead.
+func (*BridgeWrappedTokenContract) Descriptor() ([]byte, []int) {
+ return file_inference_inference_bridge_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *BridgeWrappedTokenContract) GetChainId() string {
+ if x != nil {
+ return x.ChainId
+ }
+ return ""
+}
+
+func (x *BridgeWrappedTokenContract) GetContractAddress() string {
+ if x != nil {
+ return x.ContractAddress
+ }
+ return ""
+}
+
+func (x *BridgeWrappedTokenContract) GetWrappedContractAddress() string {
+ if x != nil {
+ return x.WrappedContractAddress
+ }
+ return ""
+}
+
+// Bridge groups all bridge-related entities under a single parent structure
+type Bridge struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ ContractAddresses []*BridgeContractAddress `protobuf:"bytes,1,rep,name=contract_addresses,json=contractAddresses,proto3" json:"contract_addresses,omitempty"`
+ TokenMetadata []*BridgeTokenMetadata `protobuf:"bytes,2,rep,name=token_metadata,json=tokenMetadata,proto3" json:"token_metadata,omitempty"`
+ TradeApprovedTokens []*BridgeTokenReference `protobuf:"bytes,3,rep,name=trade_approved_tokens,json=tradeApprovedTokens,proto3" json:"trade_approved_tokens,omitempty"`
+}
+
+func (x *Bridge) Reset() {
+ *x = Bridge{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_bridge_proto_msgTypes[5]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *Bridge) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Bridge) ProtoMessage() {}
+
+// Deprecated: Use Bridge.ProtoReflect.Descriptor instead.
+func (*Bridge) Descriptor() ([]byte, []int) {
+ return file_inference_inference_bridge_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *Bridge) GetContractAddresses() []*BridgeContractAddress {
+ if x != nil {
+ return x.ContractAddresses
+ }
+ return nil
+}
+
+func (x *Bridge) GetTokenMetadata() []*BridgeTokenMetadata {
+ if x != nil {
+ return x.TokenMetadata
+ }
+ return nil
+}
+
+func (x *Bridge) GetTradeApprovedTokens() []*BridgeTokenReference {
+ if x != nil {
+ return x.TradeApprovedTokens
+ }
+ return nil
+}
+
+var File_inference_inference_bridge_proto protoreflect.FileDescriptor
+
+var file_inference_inference_bridge_proto_rawDesc = []byte{
+ 0x0a, 0x20, 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, 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, 0x5b, 0x0a, 0x15, 0x42, 0x72, 0x69, 0x64, 0x67,
+ 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73,
+ 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64,
+ 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, 0x18, 0x0a, 0x07, 0x61, 0x64,
+ 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x64,
+ 0x72, 0x65, 0x73, 0x73, 0x22, 0xa1, 0x01, 0x0a, 0x13, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x54,
+ 0x6f, 0x6b, 0x65, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x18, 0x0a, 0x07,
+ 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x18, 0x01, 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, 0x02, 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, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04,
+ 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x18, 0x04,
+ 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, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x08,
+ 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x73, 0x22, 0x5a, 0x0a, 0x14, 0x42, 0x72, 0x69, 0x64,
+ 0x67, 0x65, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+ 0x12, 0x18, 0x0a, 0x07, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x18, 0x01, 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, 0x02, 0x20,
+ 0x01, 0x28, 0x09, 0x52, 0x0f, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x41, 0x64, 0x64,
+ 0x72, 0x65, 0x73, 0x73, 0x22, 0xc7, 0x03, 0x0a, 0x11, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x54,
+ 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64,
+ 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 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, 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, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x05, 0x20, 0x01,
+ 0x28, 0x09, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x44, 0x0a, 0x06, 0x73, 0x74,
+ 0x61, 0x74, 0x75, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2c, 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, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73,
+ 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, 0x12, 0x1e, 0x0a, 0x0a, 0x65, 0x70,
+ 0x6f, 0x63, 0x68, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a,
+ 0x65, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x1e, 0x0a, 0x0a, 0x76, 0x61,
+ 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a,
+ 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x12, 0x32, 0x0a, 0x14, 0x74, 0x6f,
+ 0x74, 0x61, 0x6c, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x77,
+ 0x65, 0x72, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x03, 0x52, 0x14, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x56,
+ 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x22, 0x98,
+ 0x01, 0x0a, 0x1a, 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, 0x12, 0x18, 0x0a,
+ 0x07, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x18, 0x01, 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, 0x02, 0x20, 0x01, 0x28, 0x09,
+ 0x52, 0x0f, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73,
+ 0x73, 0x12, 0x36, 0x0a, 0x16, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x43, 0x6f, 0x6e, 0x74,
+ 0x72, 0x61, 0x63, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28,
+ 0x09, 0x52, 0x16, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61,
+ 0x63, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x93, 0x02, 0x0a, 0x06, 0x42, 0x72,
+ 0x69, 0x64, 0x67, 0x65, 0x12, 0x59, 0x0a, 0x12, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74,
+ 0x5f, 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, 0x52, 0x11, 0x63, 0x6f,
+ 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x12,
+ 0x4f, 0x0a, 0x0e, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74,
+ 0x61, 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, 0x42, 0x72,
+ 0x69, 0x64, 0x67, 0x65, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74,
+ 0x61, 0x52, 0x0d, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61,
+ 0x12, 0x5d, 0x0a, 0x15, 0x74, 0x72, 0x61, 0x64, 0x65, 0x5f, 0x61, 0x70, 0x70, 0x72, 0x6f, 0x76,
+ 0x65, 0x64, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 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, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x54, 0x6f, 0x6b, 0x65,
+ 0x6e, 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x52, 0x13, 0x74, 0x72, 0x61, 0x64,
+ 0x65, 0x41, 0x70, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x2a,
+ 0x43, 0x0a, 0x17, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63,
+ 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x12, 0x0a, 0x0e, 0x42, 0x52,
+ 0x49, 0x44, 0x47, 0x45, 0x5f, 0x50, 0x45, 0x4e, 0x44, 0x49, 0x4e, 0x47, 0x10, 0x00, 0x12, 0x14,
+ 0x0a, 0x10, 0x42, 0x52, 0x49, 0x44, 0x47, 0x45, 0x5f, 0x43, 0x4f, 0x4d, 0x50, 0x4c, 0x45, 0x54,
+ 0x45, 0x44, 0x10, 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, 0x42, 0x72, 0x69, 0x64, 0x67, 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_bridge_proto_rawDescOnce sync.Once
+ file_inference_inference_bridge_proto_rawDescData = file_inference_inference_bridge_proto_rawDesc
+)
+
+func file_inference_inference_bridge_proto_rawDescGZIP() []byte {
+ file_inference_inference_bridge_proto_rawDescOnce.Do(func() {
+ file_inference_inference_bridge_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_inference_bridge_proto_rawDescData)
+ })
+ return file_inference_inference_bridge_proto_rawDescData
+}
+
+var file_inference_inference_bridge_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
+var file_inference_inference_bridge_proto_msgTypes = make([]protoimpl.MessageInfo, 6)
+var file_inference_inference_bridge_proto_goTypes = []interface{}{
+ (BridgeTransactionStatus)(0), // 0: inference.inference.BridgeTransactionStatus
+ (*BridgeContractAddress)(nil), // 1: inference.inference.BridgeContractAddress
+ (*BridgeTokenMetadata)(nil), // 2: inference.inference.BridgeTokenMetadata
+ (*BridgeTokenReference)(nil), // 3: inference.inference.BridgeTokenReference
+ (*BridgeTransaction)(nil), // 4: inference.inference.BridgeTransaction
+ (*BridgeWrappedTokenContract)(nil), // 5: inference.inference.BridgeWrappedTokenContract
+ (*Bridge)(nil), // 6: inference.inference.Bridge
+}
+var file_inference_inference_bridge_proto_depIdxs = []int32{
+ 0, // 0: inference.inference.BridgeTransaction.status:type_name -> inference.inference.BridgeTransactionStatus
+ 1, // 1: inference.inference.Bridge.contract_addresses:type_name -> inference.inference.BridgeContractAddress
+ 2, // 2: inference.inference.Bridge.token_metadata:type_name -> inference.inference.BridgeTokenMetadata
+ 3, // 3: inference.inference.Bridge.trade_approved_tokens:type_name -> inference.inference.BridgeTokenReference
+ 4, // [4:4] is the sub-list for method output_type
+ 4, // [4:4] is the sub-list for method input_type
+ 4, // [4:4] is the sub-list for extension type_name
+ 4, // [4:4] is the sub-list for extension extendee
+ 0, // [0:4] is the sub-list for field type_name
+}
+
+func init() { file_inference_inference_bridge_proto_init() }
+func file_inference_inference_bridge_proto_init() {
+ if File_inference_inference_bridge_proto != nil {
+ return
+ }
+ if !protoimpl.UnsafeEnabled {
+ file_inference_inference_bridge_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*BridgeContractAddress); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_inference_bridge_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*BridgeTokenMetadata); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_inference_bridge_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*BridgeTokenReference); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_inference_bridge_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*BridgeTransaction); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_inference_bridge_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*BridgeWrappedTokenContract); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_inference_bridge_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*Bridge); 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_bridge_proto_rawDesc,
+ NumEnums: 1,
+ NumMessages: 6,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_inference_bridge_proto_goTypes,
+ DependencyIndexes: file_inference_inference_bridge_proto_depIdxs,
+ EnumInfos: file_inference_inference_bridge_proto_enumTypes,
+ MessageInfos: file_inference_inference_bridge_proto_msgTypes,
+ }.Build()
+ File_inference_inference_bridge_proto = out.File
+ file_inference_inference_bridge_proto_rawDesc = nil
+ file_inference_inference_bridge_proto_goTypes = nil
+ file_inference_inference_bridge_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/inference/confirmation_poc_event.pulsar.go b/inference-chain/api/inference/inference/confirmation_poc_event.pulsar.go
new file mode 100644
index 000000000..32d789266
--- /dev/null
+++ b/inference-chain/api/inference/inference/confirmation_poc_event.pulsar.go
@@ -0,0 +1,944 @@
+// 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_ConfirmationPoCEvent protoreflect.MessageDescriptor
+ fd_ConfirmationPoCEvent_epoch_index protoreflect.FieldDescriptor
+ fd_ConfirmationPoCEvent_event_sequence protoreflect.FieldDescriptor
+ fd_ConfirmationPoCEvent_trigger_height protoreflect.FieldDescriptor
+ fd_ConfirmationPoCEvent_generation_start_height protoreflect.FieldDescriptor
+ fd_ConfirmationPoCEvent_phase protoreflect.FieldDescriptor
+ fd_ConfirmationPoCEvent_poc_seed_block_hash protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_confirmation_poc_event_proto_init()
+ md_ConfirmationPoCEvent = File_inference_inference_confirmation_poc_event_proto.Messages().ByName("ConfirmationPoCEvent")
+ fd_ConfirmationPoCEvent_epoch_index = md_ConfirmationPoCEvent.Fields().ByName("epoch_index")
+ fd_ConfirmationPoCEvent_event_sequence = md_ConfirmationPoCEvent.Fields().ByName("event_sequence")
+ fd_ConfirmationPoCEvent_trigger_height = md_ConfirmationPoCEvent.Fields().ByName("trigger_height")
+ fd_ConfirmationPoCEvent_generation_start_height = md_ConfirmationPoCEvent.Fields().ByName("generation_start_height")
+ fd_ConfirmationPoCEvent_phase = md_ConfirmationPoCEvent.Fields().ByName("phase")
+ fd_ConfirmationPoCEvent_poc_seed_block_hash = md_ConfirmationPoCEvent.Fields().ByName("poc_seed_block_hash")
+}
+
+var _ protoreflect.Message = (*fastReflection_ConfirmationPoCEvent)(nil)
+
+type fastReflection_ConfirmationPoCEvent ConfirmationPoCEvent
+
+func (x *ConfirmationPoCEvent) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_ConfirmationPoCEvent)(x)
+}
+
+func (x *ConfirmationPoCEvent) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_confirmation_poc_event_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_ConfirmationPoCEvent_messageType fastReflection_ConfirmationPoCEvent_messageType
+var _ protoreflect.MessageType = fastReflection_ConfirmationPoCEvent_messageType{}
+
+type fastReflection_ConfirmationPoCEvent_messageType struct{}
+
+func (x fastReflection_ConfirmationPoCEvent_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_ConfirmationPoCEvent)(nil)
+}
+func (x fastReflection_ConfirmationPoCEvent_messageType) New() protoreflect.Message {
+ return new(fastReflection_ConfirmationPoCEvent)
+}
+func (x fastReflection_ConfirmationPoCEvent_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_ConfirmationPoCEvent
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_ConfirmationPoCEvent) Descriptor() protoreflect.MessageDescriptor {
+ return md_ConfirmationPoCEvent
+}
+
+// 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_ConfirmationPoCEvent) Type() protoreflect.MessageType {
+ return _fastReflection_ConfirmationPoCEvent_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_ConfirmationPoCEvent) New() protoreflect.Message {
+ return new(fastReflection_ConfirmationPoCEvent)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_ConfirmationPoCEvent) Interface() protoreflect.ProtoMessage {
+ return (*ConfirmationPoCEvent)(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_ConfirmationPoCEvent) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.EpochIndex != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.EpochIndex)
+ if !f(fd_ConfirmationPoCEvent_epoch_index, value) {
+ return
+ }
+ }
+ if x.EventSequence != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.EventSequence)
+ if !f(fd_ConfirmationPoCEvent_event_sequence, value) {
+ return
+ }
+ }
+ if x.TriggerHeight != int64(0) {
+ value := protoreflect.ValueOfInt64(x.TriggerHeight)
+ if !f(fd_ConfirmationPoCEvent_trigger_height, value) {
+ return
+ }
+ }
+ if x.GenerationStartHeight != int64(0) {
+ value := protoreflect.ValueOfInt64(x.GenerationStartHeight)
+ if !f(fd_ConfirmationPoCEvent_generation_start_height, value) {
+ return
+ }
+ }
+ if x.Phase != 0 {
+ value := protoreflect.ValueOfEnum((protoreflect.EnumNumber)(x.Phase))
+ if !f(fd_ConfirmationPoCEvent_phase, value) {
+ return
+ }
+ }
+ if x.PocSeedBlockHash != "" {
+ value := protoreflect.ValueOfString(x.PocSeedBlockHash)
+ if !f(fd_ConfirmationPoCEvent_poc_seed_block_hash, 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_ConfirmationPoCEvent) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.ConfirmationPoCEvent.epoch_index":
+ return x.EpochIndex != uint64(0)
+ case "inference.inference.ConfirmationPoCEvent.event_sequence":
+ return x.EventSequence != uint64(0)
+ case "inference.inference.ConfirmationPoCEvent.trigger_height":
+ return x.TriggerHeight != int64(0)
+ case "inference.inference.ConfirmationPoCEvent.generation_start_height":
+ return x.GenerationStartHeight != int64(0)
+ case "inference.inference.ConfirmationPoCEvent.phase":
+ return x.Phase != 0
+ case "inference.inference.ConfirmationPoCEvent.poc_seed_block_hash":
+ return x.PocSeedBlockHash != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ConfirmationPoCEvent"))
+ }
+ panic(fmt.Errorf("message inference.inference.ConfirmationPoCEvent 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_ConfirmationPoCEvent) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.ConfirmationPoCEvent.epoch_index":
+ x.EpochIndex = uint64(0)
+ case "inference.inference.ConfirmationPoCEvent.event_sequence":
+ x.EventSequence = uint64(0)
+ case "inference.inference.ConfirmationPoCEvent.trigger_height":
+ x.TriggerHeight = int64(0)
+ case "inference.inference.ConfirmationPoCEvent.generation_start_height":
+ x.GenerationStartHeight = int64(0)
+ case "inference.inference.ConfirmationPoCEvent.phase":
+ x.Phase = 0
+ case "inference.inference.ConfirmationPoCEvent.poc_seed_block_hash":
+ x.PocSeedBlockHash = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ConfirmationPoCEvent"))
+ }
+ panic(fmt.Errorf("message inference.inference.ConfirmationPoCEvent 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_ConfirmationPoCEvent) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.ConfirmationPoCEvent.epoch_index":
+ value := x.EpochIndex
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.ConfirmationPoCEvent.event_sequence":
+ value := x.EventSequence
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.ConfirmationPoCEvent.trigger_height":
+ value := x.TriggerHeight
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.ConfirmationPoCEvent.generation_start_height":
+ value := x.GenerationStartHeight
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.ConfirmationPoCEvent.phase":
+ value := x.Phase
+ return protoreflect.ValueOfEnum((protoreflect.EnumNumber)(value))
+ case "inference.inference.ConfirmationPoCEvent.poc_seed_block_hash":
+ value := x.PocSeedBlockHash
+ return protoreflect.ValueOfString(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ConfirmationPoCEvent"))
+ }
+ panic(fmt.Errorf("message inference.inference.ConfirmationPoCEvent 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_ConfirmationPoCEvent) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.ConfirmationPoCEvent.epoch_index":
+ x.EpochIndex = value.Uint()
+ case "inference.inference.ConfirmationPoCEvent.event_sequence":
+ x.EventSequence = value.Uint()
+ case "inference.inference.ConfirmationPoCEvent.trigger_height":
+ x.TriggerHeight = value.Int()
+ case "inference.inference.ConfirmationPoCEvent.generation_start_height":
+ x.GenerationStartHeight = value.Int()
+ case "inference.inference.ConfirmationPoCEvent.phase":
+ x.Phase = (ConfirmationPoCPhase)(value.Enum())
+ case "inference.inference.ConfirmationPoCEvent.poc_seed_block_hash":
+ x.PocSeedBlockHash = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ConfirmationPoCEvent"))
+ }
+ panic(fmt.Errorf("message inference.inference.ConfirmationPoCEvent 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_ConfirmationPoCEvent) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.ConfirmationPoCEvent.epoch_index":
+ panic(fmt.Errorf("field epoch_index of message inference.inference.ConfirmationPoCEvent is not mutable"))
+ case "inference.inference.ConfirmationPoCEvent.event_sequence":
+ panic(fmt.Errorf("field event_sequence of message inference.inference.ConfirmationPoCEvent is not mutable"))
+ case "inference.inference.ConfirmationPoCEvent.trigger_height":
+ panic(fmt.Errorf("field trigger_height of message inference.inference.ConfirmationPoCEvent is not mutable"))
+ case "inference.inference.ConfirmationPoCEvent.generation_start_height":
+ panic(fmt.Errorf("field generation_start_height of message inference.inference.ConfirmationPoCEvent is not mutable"))
+ case "inference.inference.ConfirmationPoCEvent.phase":
+ panic(fmt.Errorf("field phase of message inference.inference.ConfirmationPoCEvent is not mutable"))
+ case "inference.inference.ConfirmationPoCEvent.poc_seed_block_hash":
+ panic(fmt.Errorf("field poc_seed_block_hash of message inference.inference.ConfirmationPoCEvent is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ConfirmationPoCEvent"))
+ }
+ panic(fmt.Errorf("message inference.inference.ConfirmationPoCEvent 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_ConfirmationPoCEvent) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.ConfirmationPoCEvent.epoch_index":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.ConfirmationPoCEvent.event_sequence":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.ConfirmationPoCEvent.trigger_height":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.ConfirmationPoCEvent.generation_start_height":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.ConfirmationPoCEvent.phase":
+ return protoreflect.ValueOfEnum(0)
+ case "inference.inference.ConfirmationPoCEvent.poc_seed_block_hash":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ConfirmationPoCEvent"))
+ }
+ panic(fmt.Errorf("message inference.inference.ConfirmationPoCEvent 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_ConfirmationPoCEvent) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.ConfirmationPoCEvent", 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_ConfirmationPoCEvent) 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_ConfirmationPoCEvent) 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_ConfirmationPoCEvent) 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_ConfirmationPoCEvent) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*ConfirmationPoCEvent)
+ 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 x.EventSequence != 0 {
+ n += 1 + runtime.Sov(uint64(x.EventSequence))
+ }
+ if x.TriggerHeight != 0 {
+ n += 1 + runtime.Sov(uint64(x.TriggerHeight))
+ }
+ if x.GenerationStartHeight != 0 {
+ n += 1 + runtime.Sov(uint64(x.GenerationStartHeight))
+ }
+ if x.Phase != 0 {
+ n += 1 + runtime.Sov(uint64(x.Phase))
+ }
+ l = len(x.PocSeedBlockHash)
+ 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().(*ConfirmationPoCEvent)
+ 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.PocSeedBlockHash) > 0 {
+ i -= len(x.PocSeedBlockHash)
+ copy(dAtA[i:], x.PocSeedBlockHash)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.PocSeedBlockHash)))
+ i--
+ dAtA[i] = 0x4a
+ }
+ if x.Phase != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.Phase))
+ i--
+ dAtA[i] = 0x40
+ }
+ if x.GenerationStartHeight != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.GenerationStartHeight))
+ i--
+ dAtA[i] = 0x20
+ }
+ if x.TriggerHeight != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.TriggerHeight))
+ i--
+ dAtA[i] = 0x18
+ }
+ if x.EventSequence != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.EventSequence))
+ i--
+ dAtA[i] = 0x10
+ }
+ 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().(*ConfirmationPoCEvent)
+ 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: ConfirmationPoCEvent: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ConfirmationPoCEvent: 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 != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EventSequence", wireType)
+ }
+ x.EventSequence = 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.EventSequence |= 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 TriggerHeight", wireType)
+ }
+ x.TriggerHeight = 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.TriggerHeight |= 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 GenerationStartHeight", wireType)
+ }
+ x.GenerationStartHeight = 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.GenerationStartHeight |= int64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 8:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Phase", wireType)
+ }
+ x.Phase = 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.Phase |= ConfirmationPoCPhase(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 PocSeedBlockHash", 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.PocSeedBlockHash = 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/confirmation_poc_event.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)
+)
+
+// ConfirmationPoCPhase defines the phases of a confirmation PoC event.
+type ConfirmationPoCPhase int32
+
+const (
+ ConfirmationPoCPhase_CONFIRMATION_POC_INACTIVE ConfirmationPoCPhase = 0 // No active event
+ ConfirmationPoCPhase_CONFIRMATION_POC_GRACE_PERIOD ConfirmationPoCPhase = 1 // Grace period: nodes finish in-flight inference
+ ConfirmationPoCPhase_CONFIRMATION_POC_GENERATION ConfirmationPoCPhase = 2 // Generation phase: nodes generate PoC nonces
+ ConfirmationPoCPhase_CONFIRMATION_POC_VALIDATION ConfirmationPoCPhase = 3 // Validation phase: validators verify nonces
+ ConfirmationPoCPhase_CONFIRMATION_POC_COMPLETED ConfirmationPoCPhase = 4 // Event completed, weights recorded
+)
+
+// Enum value maps for ConfirmationPoCPhase.
+var (
+ ConfirmationPoCPhase_name = map[int32]string{
+ 0: "CONFIRMATION_POC_INACTIVE",
+ 1: "CONFIRMATION_POC_GRACE_PERIOD",
+ 2: "CONFIRMATION_POC_GENERATION",
+ 3: "CONFIRMATION_POC_VALIDATION",
+ 4: "CONFIRMATION_POC_COMPLETED",
+ }
+ ConfirmationPoCPhase_value = map[string]int32{
+ "CONFIRMATION_POC_INACTIVE": 0,
+ "CONFIRMATION_POC_GRACE_PERIOD": 1,
+ "CONFIRMATION_POC_GENERATION": 2,
+ "CONFIRMATION_POC_VALIDATION": 3,
+ "CONFIRMATION_POC_COMPLETED": 4,
+ }
+)
+
+func (x ConfirmationPoCPhase) Enum() *ConfirmationPoCPhase {
+ p := new(ConfirmationPoCPhase)
+ *p = x
+ return p
+}
+
+func (x ConfirmationPoCPhase) String() string {
+ return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (ConfirmationPoCPhase) Descriptor() protoreflect.EnumDescriptor {
+ return file_inference_inference_confirmation_poc_event_proto_enumTypes[0].Descriptor()
+}
+
+func (ConfirmationPoCPhase) Type() protoreflect.EnumType {
+ return &file_inference_inference_confirmation_poc_event_proto_enumTypes[0]
+}
+
+func (x ConfirmationPoCPhase) Number() protoreflect.EnumNumber {
+ return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use ConfirmationPoCPhase.Descriptor instead.
+func (ConfirmationPoCPhase) EnumDescriptor() ([]byte, []int) {
+ return file_inference_inference_confirmation_poc_event_proto_rawDescGZIP(), []int{0}
+}
+
+// ConfirmationPoCEvent tracks a single confirmation PoC event during the inference phase.
+// These events randomly trigger to verify that inference-serving nodes (POC_SLOT=false)
+// maintain their computational capacity.
+type ConfirmationPoCEvent 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"` // Which epoch this event belongs to
+ EventSequence uint64 `protobuf:"varint,2,opt,name=event_sequence,json=eventSequence,proto3" json:"event_sequence,omitempty"` // Sequence number for multiple events per epoch (0, 1, 2...)
+ TriggerHeight int64 `protobuf:"varint,3,opt,name=trigger_height,json=triggerHeight,proto3" json:"trigger_height,omitempty"` // Block height where trigger decision was made
+ GenerationStartHeight int64 `protobuf:"varint,4,opt,name=generation_start_height,json=generationStartHeight,proto3" json:"generation_start_height,omitempty"` // Anchor: all other heights calculated from this + EpochParams
+ Phase ConfirmationPoCPhase `protobuf:"varint,8,opt,name=phase,proto3,enum=inference.inference.ConfirmationPoCPhase" json:"phase,omitempty"` // Current phase of the event
+ // Block hash from (generation_start_height - 1) for PoC nonce generation.
+ // This hash is only set when transitioning to GENERATION phase to prevent
+ // precomputation during the grace period.
+ PocSeedBlockHash string `protobuf:"bytes,9,opt,name=poc_seed_block_hash,json=pocSeedBlockHash,proto3" json:"poc_seed_block_hash,omitempty"`
+}
+
+func (x *ConfirmationPoCEvent) Reset() {
+ *x = ConfirmationPoCEvent{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_confirmation_poc_event_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *ConfirmationPoCEvent) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ConfirmationPoCEvent) ProtoMessage() {}
+
+// Deprecated: Use ConfirmationPoCEvent.ProtoReflect.Descriptor instead.
+func (*ConfirmationPoCEvent) Descriptor() ([]byte, []int) {
+ return file_inference_inference_confirmation_poc_event_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *ConfirmationPoCEvent) GetEpochIndex() uint64 {
+ if x != nil {
+ return x.EpochIndex
+ }
+ return 0
+}
+
+func (x *ConfirmationPoCEvent) GetEventSequence() uint64 {
+ if x != nil {
+ return x.EventSequence
+ }
+ return 0
+}
+
+func (x *ConfirmationPoCEvent) GetTriggerHeight() int64 {
+ if x != nil {
+ return x.TriggerHeight
+ }
+ return 0
+}
+
+func (x *ConfirmationPoCEvent) GetGenerationStartHeight() int64 {
+ if x != nil {
+ return x.GenerationStartHeight
+ }
+ return 0
+}
+
+func (x *ConfirmationPoCEvent) GetPhase() ConfirmationPoCPhase {
+ if x != nil {
+ return x.Phase
+ }
+ return ConfirmationPoCPhase_CONFIRMATION_POC_INACTIVE
+}
+
+func (x *ConfirmationPoCEvent) GetPocSeedBlockHash() string {
+ if x != nil {
+ return x.PocSeedBlockHash
+ }
+ return ""
+}
+
+var File_inference_inference_confirmation_poc_event_proto protoreflect.FileDescriptor
+
+var file_inference_inference_confirmation_poc_event_proto_rawDesc = []byte{
+ 0x0a, 0x30, 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, 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, 0xad, 0x02, 0x0a, 0x14, 0x43, 0x6f, 0x6e, 0x66,
+ 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x43, 0x45, 0x76, 0x65, 0x6e, 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, 0x25, 0x0a, 0x0e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x65, 0x71, 0x75, 0x65,
+ 0x6e, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0d, 0x65, 0x76, 0x65, 0x6e, 0x74,
+ 0x53, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x74, 0x72, 0x69, 0x67,
+ 0x67, 0x65, 0x72, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03,
+ 0x52, 0x0d, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12,
+ 0x36, 0x0a, 0x17, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x74,
+ 0x61, 0x72, 0x74, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03,
+ 0x52, 0x15, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x72,
+ 0x74, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x3f, 0x0a, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65,
+ 0x18, 0x08, 0x20, 0x01, 0x28, 0x0e, 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, 0x50, 0x68, 0x61, 0x73,
+ 0x65, 0x52, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x12, 0x2d, 0x0a, 0x13, 0x70, 0x6f, 0x63, 0x5f,
+ 0x73, 0x65, 0x65, 0x64, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18,
+ 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x70, 0x6f, 0x63, 0x53, 0x65, 0x65, 0x64, 0x42, 0x6c,
+ 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x2a, 0xba, 0x01, 0x0a, 0x14, 0x43, 0x6f, 0x6e, 0x66,
+ 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x43, 0x50, 0x68, 0x61, 0x73, 0x65,
+ 0x12, 0x1d, 0x0a, 0x19, 0x43, 0x4f, 0x4e, 0x46, 0x49, 0x52, 0x4d, 0x41, 0x54, 0x49, 0x4f, 0x4e,
+ 0x5f, 0x50, 0x4f, 0x43, 0x5f, 0x49, 0x4e, 0x41, 0x43, 0x54, 0x49, 0x56, 0x45, 0x10, 0x00, 0x12,
+ 0x21, 0x0a, 0x1d, 0x43, 0x4f, 0x4e, 0x46, 0x49, 0x52, 0x4d, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f,
+ 0x50, 0x4f, 0x43, 0x5f, 0x47, 0x52, 0x41, 0x43, 0x45, 0x5f, 0x50, 0x45, 0x52, 0x49, 0x4f, 0x44,
+ 0x10, 0x01, 0x12, 0x1f, 0x0a, 0x1b, 0x43, 0x4f, 0x4e, 0x46, 0x49, 0x52, 0x4d, 0x41, 0x54, 0x49,
+ 0x4f, 0x4e, 0x5f, 0x50, 0x4f, 0x43, 0x5f, 0x47, 0x45, 0x4e, 0x45, 0x52, 0x41, 0x54, 0x49, 0x4f,
+ 0x4e, 0x10, 0x02, 0x12, 0x1f, 0x0a, 0x1b, 0x43, 0x4f, 0x4e, 0x46, 0x49, 0x52, 0x4d, 0x41, 0x54,
+ 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x4f, 0x43, 0x5f, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x41, 0x54, 0x49,
+ 0x4f, 0x4e, 0x10, 0x03, 0x12, 0x1e, 0x0a, 0x1a, 0x43, 0x4f, 0x4e, 0x46, 0x49, 0x52, 0x4d, 0x41,
+ 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x4f, 0x43, 0x5f, 0x43, 0x4f, 0x4d, 0x50, 0x4c, 0x45, 0x54,
+ 0x45, 0x44, 0x10, 0x04, 0x42, 0xc7, 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, 0x19, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f,
+ 0x63, 0x45, 0x76, 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_confirmation_poc_event_proto_rawDescOnce sync.Once
+ file_inference_inference_confirmation_poc_event_proto_rawDescData = file_inference_inference_confirmation_poc_event_proto_rawDesc
+)
+
+func file_inference_inference_confirmation_poc_event_proto_rawDescGZIP() []byte {
+ file_inference_inference_confirmation_poc_event_proto_rawDescOnce.Do(func() {
+ file_inference_inference_confirmation_poc_event_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_inference_confirmation_poc_event_proto_rawDescData)
+ })
+ return file_inference_inference_confirmation_poc_event_proto_rawDescData
+}
+
+var file_inference_inference_confirmation_poc_event_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
+var file_inference_inference_confirmation_poc_event_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_inference_inference_confirmation_poc_event_proto_goTypes = []interface{}{
+ (ConfirmationPoCPhase)(0), // 0: inference.inference.ConfirmationPoCPhase
+ (*ConfirmationPoCEvent)(nil), // 1: inference.inference.ConfirmationPoCEvent
+}
+var file_inference_inference_confirmation_poc_event_proto_depIdxs = []int32{
+ 0, // 0: inference.inference.ConfirmationPoCEvent.phase:type_name -> inference.inference.ConfirmationPoCPhase
+ 1, // [1:1] is the sub-list for method output_type
+ 1, // [1:1] is the sub-list for method input_type
+ 1, // [1:1] is the sub-list for extension type_name
+ 1, // [1:1] is the sub-list for extension extendee
+ 0, // [0:1] is the sub-list for field type_name
+}
+
+func init() { file_inference_inference_confirmation_poc_event_proto_init() }
+func file_inference_inference_confirmation_poc_event_proto_init() {
+ if File_inference_inference_confirmation_poc_event_proto != nil {
+ return
+ }
+ if !protoimpl.UnsafeEnabled {
+ file_inference_inference_confirmation_poc_event_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*ConfirmationPoCEvent); 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_confirmation_poc_event_proto_rawDesc,
+ NumEnums: 1,
+ NumMessages: 1,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_inference_confirmation_poc_event_proto_goTypes,
+ DependencyIndexes: file_inference_inference_confirmation_poc_event_proto_depIdxs,
+ EnumInfos: file_inference_inference_confirmation_poc_event_proto_enumTypes,
+ MessageInfos: file_inference_inference_confirmation_poc_event_proto_msgTypes,
+ }.Build()
+ File_inference_inference_confirmation_poc_event_proto = out.File
+ file_inference_inference_confirmation_poc_event_proto_rawDesc = nil
+ file_inference_inference_confirmation_poc_event_proto_goTypes = nil
+ file_inference_inference_confirmation_poc_event_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/inference/epoch.pulsar.go b/inference-chain/api/inference/inference/epoch.pulsar.go
new file mode 100644
index 000000000..9ed523e81
--- /dev/null
+++ b/inference-chain/api/inference/inference/epoch.pulsar.go
@@ -0,0 +1,610 @@
+// 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_Epoch protoreflect.MessageDescriptor
+ fd_Epoch_index protoreflect.FieldDescriptor
+ fd_Epoch_poc_start_block_height protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_epoch_proto_init()
+ md_Epoch = File_inference_inference_epoch_proto.Messages().ByName("Epoch")
+ fd_Epoch_index = md_Epoch.Fields().ByName("index")
+ fd_Epoch_poc_start_block_height = md_Epoch.Fields().ByName("poc_start_block_height")
+}
+
+var _ protoreflect.Message = (*fastReflection_Epoch)(nil)
+
+type fastReflection_Epoch Epoch
+
+func (x *Epoch) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_Epoch)(x)
+}
+
+func (x *Epoch) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_epoch_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_Epoch_messageType fastReflection_Epoch_messageType
+var _ protoreflect.MessageType = fastReflection_Epoch_messageType{}
+
+type fastReflection_Epoch_messageType struct{}
+
+func (x fastReflection_Epoch_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_Epoch)(nil)
+}
+func (x fastReflection_Epoch_messageType) New() protoreflect.Message {
+ return new(fastReflection_Epoch)
+}
+func (x fastReflection_Epoch_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_Epoch
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_Epoch) Descriptor() protoreflect.MessageDescriptor {
+ return md_Epoch
+}
+
+// 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_Epoch) Type() protoreflect.MessageType {
+ return _fastReflection_Epoch_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_Epoch) New() protoreflect.Message {
+ return new(fastReflection_Epoch)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_Epoch) Interface() protoreflect.ProtoMessage {
+ return (*Epoch)(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_Epoch) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Index != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.Index)
+ if !f(fd_Epoch_index, value) {
+ return
+ }
+ }
+ if x.PocStartBlockHeight != int64(0) {
+ value := protoreflect.ValueOfInt64(x.PocStartBlockHeight)
+ if !f(fd_Epoch_poc_start_block_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_Epoch) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.Epoch.index":
+ return x.Index != uint64(0)
+ case "inference.inference.Epoch.poc_start_block_height":
+ return x.PocStartBlockHeight != int64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Epoch"))
+ }
+ panic(fmt.Errorf("message inference.inference.Epoch 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_Epoch) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.Epoch.index":
+ x.Index = uint64(0)
+ case "inference.inference.Epoch.poc_start_block_height":
+ x.PocStartBlockHeight = int64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Epoch"))
+ }
+ panic(fmt.Errorf("message inference.inference.Epoch 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_Epoch) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.Epoch.index":
+ value := x.Index
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.Epoch.poc_start_block_height":
+ value := x.PocStartBlockHeight
+ return protoreflect.ValueOfInt64(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Epoch"))
+ }
+ panic(fmt.Errorf("message inference.inference.Epoch 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_Epoch) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.Epoch.index":
+ x.Index = value.Uint()
+ case "inference.inference.Epoch.poc_start_block_height":
+ x.PocStartBlockHeight = value.Int()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Epoch"))
+ }
+ panic(fmt.Errorf("message inference.inference.Epoch 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_Epoch) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.Epoch.index":
+ panic(fmt.Errorf("field index of message inference.inference.Epoch is not mutable"))
+ case "inference.inference.Epoch.poc_start_block_height":
+ panic(fmt.Errorf("field poc_start_block_height of message inference.inference.Epoch is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Epoch"))
+ }
+ panic(fmt.Errorf("message inference.inference.Epoch 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_Epoch) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.Epoch.index":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.Epoch.poc_start_block_height":
+ return protoreflect.ValueOfInt64(int64(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Epoch"))
+ }
+ panic(fmt.Errorf("message inference.inference.Epoch 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_Epoch) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.Epoch", 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_Epoch) 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_Epoch) 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_Epoch) 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_Epoch) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*Epoch)
+ 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.Index != 0 {
+ n += 1 + runtime.Sov(uint64(x.Index))
+ }
+ if x.PocStartBlockHeight != 0 {
+ n += 1 + runtime.Sov(uint64(x.PocStartBlockHeight))
+ }
+ 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().(*Epoch)
+ 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.PocStartBlockHeight != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.PocStartBlockHeight))
+ i--
+ dAtA[i] = 0x10
+ }
+ if x.Index != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.Index))
+ 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().(*Epoch)
+ 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: Epoch: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Epoch: 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 Index", wireType)
+ }
+ x.Index = 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.Index |= 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 PocStartBlockHeight", wireType)
+ }
+ x.PocStartBlockHeight = 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.PocStartBlockHeight |= 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,
+ }
+}
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// protoc-gen-go v1.27.0
+// protoc (unknown)
+// source: inference/inference/epoch.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)
+)
+
+type Epoch struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Index uint64 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
+ PocStartBlockHeight int64 `protobuf:"varint,2,opt,name=poc_start_block_height,json=pocStartBlockHeight,proto3" json:"poc_start_block_height,omitempty"`
+}
+
+func (x *Epoch) Reset() {
+ *x = Epoch{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_epoch_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *Epoch) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Epoch) ProtoMessage() {}
+
+// Deprecated: Use Epoch.ProtoReflect.Descriptor instead.
+func (*Epoch) Descriptor() ([]byte, []int) {
+ return file_inference_inference_epoch_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Epoch) GetIndex() uint64 {
+ if x != nil {
+ return x.Index
+ }
+ return 0
+}
+
+func (x *Epoch) GetPocStartBlockHeight() int64 {
+ if x != nil {
+ return x.PocStartBlockHeight
+ }
+ return 0
+}
+
+var File_inference_inference_epoch_proto protoreflect.FileDescriptor
+
+var file_inference_inference_epoch_proto_rawDesc = []byte{
+ 0x0a, 0x1f, 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, 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, 0x52, 0x0a, 0x05, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x12,
+ 0x14, 0x0a, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05,
+ 0x69, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x33, 0x0a, 0x16, 0x70, 0x6f, 0x63, 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, 0x13, 0x70, 0x6f, 0x63, 0x53, 0x74, 0x61, 0x72, 0x74, 0x42,
+ 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 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, 0x45, 0x70, 0x6f, 0x63, 0x68, 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_epoch_proto_rawDescOnce sync.Once
+ file_inference_inference_epoch_proto_rawDescData = file_inference_inference_epoch_proto_rawDesc
+)
+
+func file_inference_inference_epoch_proto_rawDescGZIP() []byte {
+ file_inference_inference_epoch_proto_rawDescOnce.Do(func() {
+ file_inference_inference_epoch_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_inference_epoch_proto_rawDescData)
+ })
+ return file_inference_inference_epoch_proto_rawDescData
+}
+
+var file_inference_inference_epoch_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_inference_inference_epoch_proto_goTypes = []interface{}{
+ (*Epoch)(nil), // 0: inference.inference.Epoch
+}
+var file_inference_inference_epoch_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_epoch_proto_init() }
+func file_inference_inference_epoch_proto_init() {
+ if File_inference_inference_epoch_proto != nil {
+ return
+ }
+ if !protoimpl.UnsafeEnabled {
+ file_inference_inference_epoch_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*Epoch); 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_epoch_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 1,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_inference_epoch_proto_goTypes,
+ DependencyIndexes: file_inference_inference_epoch_proto_depIdxs,
+ MessageInfos: file_inference_inference_epoch_proto_msgTypes,
+ }.Build()
+ File_inference_inference_epoch_proto = out.File
+ file_inference_inference_epoch_proto_rawDesc = nil
+ file_inference_inference_epoch_proto_goTypes = nil
+ file_inference_inference_epoch_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/inference/epoch_group_data.pulsar.go b/inference-chain/api/inference/inference/epoch_group_data.pulsar.go
new file mode 100644
index 000000000..92341e9e9
--- /dev/null
+++ b/inference-chain/api/inference/inference/epoch_group_data.pulsar.go
@@ -0,0 +1,4037 @@
+// 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 _ protoreflect.List = (*_EpochGroupData_6_list)(nil)
+
+type _EpochGroupData_6_list struct {
+ list *[]*SeedSignature
+}
+
+func (x *_EpochGroupData_6_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_EpochGroupData_6_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_EpochGroupData_6_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*SeedSignature)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_EpochGroupData_6_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*SeedSignature)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_EpochGroupData_6_list) AppendMutable() protoreflect.Value {
+ v := new(SeedSignature)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_EpochGroupData_6_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_EpochGroupData_6_list) NewElement() protoreflect.Value {
+ v := new(SeedSignature)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_EpochGroupData_6_list) IsValid() bool {
+ return x.list != nil
+}
+
+var _ protoreflect.List = (*_EpochGroupData_8_list)(nil)
+
+type _EpochGroupData_8_list struct {
+ list *[]*ValidationWeight
+}
+
+func (x *_EpochGroupData_8_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_EpochGroupData_8_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_EpochGroupData_8_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*ValidationWeight)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_EpochGroupData_8_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*ValidationWeight)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_EpochGroupData_8_list) AppendMutable() protoreflect.Value {
+ v := new(ValidationWeight)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_EpochGroupData_8_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_EpochGroupData_8_list) NewElement() protoreflect.Value {
+ v := new(ValidationWeight)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_EpochGroupData_8_list) IsValid() bool {
+ return x.list != nil
+}
+
+var _ protoreflect.List = (*_EpochGroupData_15_list)(nil)
+
+type _EpochGroupData_15_list struct {
+ list *[]string
+}
+
+func (x *_EpochGroupData_15_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_EpochGroupData_15_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfString((*x.list)[i])
+}
+
+func (x *_EpochGroupData_15_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.String()
+ concreteValue := valueUnwrapped
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_EpochGroupData_15_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.String()
+ concreteValue := valueUnwrapped
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_EpochGroupData_15_list) AppendMutable() protoreflect.Value {
+ panic(fmt.Errorf("AppendMutable can not be called on message EpochGroupData at list field SubGroupModels as it is not of Message kind"))
+}
+
+func (x *_EpochGroupData_15_list) Truncate(n int) {
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_EpochGroupData_15_list) NewElement() protoreflect.Value {
+ v := ""
+ return protoreflect.ValueOfString(v)
+}
+
+func (x *_EpochGroupData_15_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_EpochGroupData protoreflect.MessageDescriptor
+ fd_EpochGroupData_poc_start_block_height protoreflect.FieldDescriptor
+ fd_EpochGroupData_epoch_group_id protoreflect.FieldDescriptor
+ fd_EpochGroupData_epoch_policy protoreflect.FieldDescriptor
+ fd_EpochGroupData_effective_block_height protoreflect.FieldDescriptor
+ fd_EpochGroupData_last_block_height protoreflect.FieldDescriptor
+ fd_EpochGroupData_member_seed_signatures protoreflect.FieldDescriptor
+ fd_EpochGroupData_validation_weights protoreflect.FieldDescriptor
+ fd_EpochGroupData_unit_of_compute_price protoreflect.FieldDescriptor
+ fd_EpochGroupData_number_of_requests protoreflect.FieldDescriptor
+ fd_EpochGroupData_previous_epoch_requests protoreflect.FieldDescriptor
+ fd_EpochGroupData_validation_params protoreflect.FieldDescriptor
+ fd_EpochGroupData_total_weight protoreflect.FieldDescriptor
+ fd_EpochGroupData_model_id protoreflect.FieldDescriptor
+ fd_EpochGroupData_sub_group_models protoreflect.FieldDescriptor
+ fd_EpochGroupData_epoch_index protoreflect.FieldDescriptor
+ fd_EpochGroupData_model_snapshot protoreflect.FieldDescriptor
+ fd_EpochGroupData_total_throughput protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_epoch_group_data_proto_init()
+ md_EpochGroupData = File_inference_inference_epoch_group_data_proto.Messages().ByName("EpochGroupData")
+ fd_EpochGroupData_poc_start_block_height = md_EpochGroupData.Fields().ByName("poc_start_block_height")
+ fd_EpochGroupData_epoch_group_id = md_EpochGroupData.Fields().ByName("epoch_group_id")
+ fd_EpochGroupData_epoch_policy = md_EpochGroupData.Fields().ByName("epoch_policy")
+ fd_EpochGroupData_effective_block_height = md_EpochGroupData.Fields().ByName("effective_block_height")
+ fd_EpochGroupData_last_block_height = md_EpochGroupData.Fields().ByName("last_block_height")
+ fd_EpochGroupData_member_seed_signatures = md_EpochGroupData.Fields().ByName("member_seed_signatures")
+ fd_EpochGroupData_validation_weights = md_EpochGroupData.Fields().ByName("validation_weights")
+ fd_EpochGroupData_unit_of_compute_price = md_EpochGroupData.Fields().ByName("unit_of_compute_price")
+ fd_EpochGroupData_number_of_requests = md_EpochGroupData.Fields().ByName("number_of_requests")
+ fd_EpochGroupData_previous_epoch_requests = md_EpochGroupData.Fields().ByName("previous_epoch_requests")
+ fd_EpochGroupData_validation_params = md_EpochGroupData.Fields().ByName("validation_params")
+ fd_EpochGroupData_total_weight = md_EpochGroupData.Fields().ByName("total_weight")
+ fd_EpochGroupData_model_id = md_EpochGroupData.Fields().ByName("model_id")
+ fd_EpochGroupData_sub_group_models = md_EpochGroupData.Fields().ByName("sub_group_models")
+ fd_EpochGroupData_epoch_index = md_EpochGroupData.Fields().ByName("epoch_index")
+ fd_EpochGroupData_model_snapshot = md_EpochGroupData.Fields().ByName("model_snapshot")
+ fd_EpochGroupData_total_throughput = md_EpochGroupData.Fields().ByName("total_throughput")
+}
+
+var _ protoreflect.Message = (*fastReflection_EpochGroupData)(nil)
+
+type fastReflection_EpochGroupData EpochGroupData
+
+func (x *EpochGroupData) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_EpochGroupData)(x)
+}
+
+func (x *EpochGroupData) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_epoch_group_data_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_EpochGroupData_messageType fastReflection_EpochGroupData_messageType
+var _ protoreflect.MessageType = fastReflection_EpochGroupData_messageType{}
+
+type fastReflection_EpochGroupData_messageType struct{}
+
+func (x fastReflection_EpochGroupData_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_EpochGroupData)(nil)
+}
+func (x fastReflection_EpochGroupData_messageType) New() protoreflect.Message {
+ return new(fastReflection_EpochGroupData)
+}
+func (x fastReflection_EpochGroupData_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_EpochGroupData
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_EpochGroupData) Descriptor() protoreflect.MessageDescriptor {
+ return md_EpochGroupData
+}
+
+// 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_EpochGroupData) Type() protoreflect.MessageType {
+ return _fastReflection_EpochGroupData_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_EpochGroupData) New() protoreflect.Message {
+ return new(fastReflection_EpochGroupData)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_EpochGroupData) Interface() protoreflect.ProtoMessage {
+ return (*EpochGroupData)(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_EpochGroupData) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.PocStartBlockHeight != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.PocStartBlockHeight)
+ if !f(fd_EpochGroupData_poc_start_block_height, value) {
+ return
+ }
+ }
+ if x.EpochGroupId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.EpochGroupId)
+ if !f(fd_EpochGroupData_epoch_group_id, value) {
+ return
+ }
+ }
+ if x.EpochPolicy != "" {
+ value := protoreflect.ValueOfString(x.EpochPolicy)
+ if !f(fd_EpochGroupData_epoch_policy, value) {
+ return
+ }
+ }
+ if x.EffectiveBlockHeight != int64(0) {
+ value := protoreflect.ValueOfInt64(x.EffectiveBlockHeight)
+ if !f(fd_EpochGroupData_effective_block_height, value) {
+ return
+ }
+ }
+ if x.LastBlockHeight != int64(0) {
+ value := protoreflect.ValueOfInt64(x.LastBlockHeight)
+ if !f(fd_EpochGroupData_last_block_height, value) {
+ return
+ }
+ }
+ if len(x.MemberSeedSignatures) != 0 {
+ value := protoreflect.ValueOfList(&_EpochGroupData_6_list{list: &x.MemberSeedSignatures})
+ if !f(fd_EpochGroupData_member_seed_signatures, value) {
+ return
+ }
+ }
+ if len(x.ValidationWeights) != 0 {
+ value := protoreflect.ValueOfList(&_EpochGroupData_8_list{list: &x.ValidationWeights})
+ if !f(fd_EpochGroupData_validation_weights, value) {
+ return
+ }
+ }
+ if x.UnitOfComputePrice != int64(0) {
+ value := protoreflect.ValueOfInt64(x.UnitOfComputePrice)
+ if !f(fd_EpochGroupData_unit_of_compute_price, value) {
+ return
+ }
+ }
+ if x.NumberOfRequests != int64(0) {
+ value := protoreflect.ValueOfInt64(x.NumberOfRequests)
+ if !f(fd_EpochGroupData_number_of_requests, value) {
+ return
+ }
+ }
+ if x.PreviousEpochRequests != int64(0) {
+ value := protoreflect.ValueOfInt64(x.PreviousEpochRequests)
+ if !f(fd_EpochGroupData_previous_epoch_requests, value) {
+ return
+ }
+ }
+ if x.ValidationParams != nil {
+ value := protoreflect.ValueOfMessage(x.ValidationParams.ProtoReflect())
+ if !f(fd_EpochGroupData_validation_params, value) {
+ return
+ }
+ }
+ if x.TotalWeight != int64(0) {
+ value := protoreflect.ValueOfInt64(x.TotalWeight)
+ if !f(fd_EpochGroupData_total_weight, value) {
+ return
+ }
+ }
+ if x.ModelId != "" {
+ value := protoreflect.ValueOfString(x.ModelId)
+ if !f(fd_EpochGroupData_model_id, value) {
+ return
+ }
+ }
+ if len(x.SubGroupModels) != 0 {
+ value := protoreflect.ValueOfList(&_EpochGroupData_15_list{list: &x.SubGroupModels})
+ if !f(fd_EpochGroupData_sub_group_models, value) {
+ return
+ }
+ }
+ if x.EpochIndex != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.EpochIndex)
+ if !f(fd_EpochGroupData_epoch_index, value) {
+ return
+ }
+ }
+ if x.ModelSnapshot != nil {
+ value := protoreflect.ValueOfMessage(x.ModelSnapshot.ProtoReflect())
+ if !f(fd_EpochGroupData_model_snapshot, value) {
+ return
+ }
+ }
+ if x.TotalThroughput != int64(0) {
+ value := protoreflect.ValueOfInt64(x.TotalThroughput)
+ if !f(fd_EpochGroupData_total_throughput, 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_EpochGroupData) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.EpochGroupData.poc_start_block_height":
+ return x.PocStartBlockHeight != uint64(0)
+ case "inference.inference.EpochGroupData.epoch_group_id":
+ return x.EpochGroupId != uint64(0)
+ case "inference.inference.EpochGroupData.epoch_policy":
+ return x.EpochPolicy != ""
+ case "inference.inference.EpochGroupData.effective_block_height":
+ return x.EffectiveBlockHeight != int64(0)
+ case "inference.inference.EpochGroupData.last_block_height":
+ return x.LastBlockHeight != int64(0)
+ case "inference.inference.EpochGroupData.member_seed_signatures":
+ return len(x.MemberSeedSignatures) != 0
+ case "inference.inference.EpochGroupData.validation_weights":
+ return len(x.ValidationWeights) != 0
+ case "inference.inference.EpochGroupData.unit_of_compute_price":
+ return x.UnitOfComputePrice != int64(0)
+ case "inference.inference.EpochGroupData.number_of_requests":
+ return x.NumberOfRequests != int64(0)
+ case "inference.inference.EpochGroupData.previous_epoch_requests":
+ return x.PreviousEpochRequests != int64(0)
+ case "inference.inference.EpochGroupData.validation_params":
+ return x.ValidationParams != nil
+ case "inference.inference.EpochGroupData.total_weight":
+ return x.TotalWeight != int64(0)
+ case "inference.inference.EpochGroupData.model_id":
+ return x.ModelId != ""
+ case "inference.inference.EpochGroupData.sub_group_models":
+ return len(x.SubGroupModels) != 0
+ case "inference.inference.EpochGroupData.epoch_index":
+ return x.EpochIndex != uint64(0)
+ case "inference.inference.EpochGroupData.model_snapshot":
+ return x.ModelSnapshot != nil
+ case "inference.inference.EpochGroupData.total_throughput":
+ return x.TotalThroughput != int64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.EpochGroupData"))
+ }
+ panic(fmt.Errorf("message inference.inference.EpochGroupData 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_EpochGroupData) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.EpochGroupData.poc_start_block_height":
+ x.PocStartBlockHeight = uint64(0)
+ case "inference.inference.EpochGroupData.epoch_group_id":
+ x.EpochGroupId = uint64(0)
+ case "inference.inference.EpochGroupData.epoch_policy":
+ x.EpochPolicy = ""
+ case "inference.inference.EpochGroupData.effective_block_height":
+ x.EffectiveBlockHeight = int64(0)
+ case "inference.inference.EpochGroupData.last_block_height":
+ x.LastBlockHeight = int64(0)
+ case "inference.inference.EpochGroupData.member_seed_signatures":
+ x.MemberSeedSignatures = nil
+ case "inference.inference.EpochGroupData.validation_weights":
+ x.ValidationWeights = nil
+ case "inference.inference.EpochGroupData.unit_of_compute_price":
+ x.UnitOfComputePrice = int64(0)
+ case "inference.inference.EpochGroupData.number_of_requests":
+ x.NumberOfRequests = int64(0)
+ case "inference.inference.EpochGroupData.previous_epoch_requests":
+ x.PreviousEpochRequests = int64(0)
+ case "inference.inference.EpochGroupData.validation_params":
+ x.ValidationParams = nil
+ case "inference.inference.EpochGroupData.total_weight":
+ x.TotalWeight = int64(0)
+ case "inference.inference.EpochGroupData.model_id":
+ x.ModelId = ""
+ case "inference.inference.EpochGroupData.sub_group_models":
+ x.SubGroupModels = nil
+ case "inference.inference.EpochGroupData.epoch_index":
+ x.EpochIndex = uint64(0)
+ case "inference.inference.EpochGroupData.model_snapshot":
+ x.ModelSnapshot = nil
+ case "inference.inference.EpochGroupData.total_throughput":
+ x.TotalThroughput = int64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.EpochGroupData"))
+ }
+ panic(fmt.Errorf("message inference.inference.EpochGroupData 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_EpochGroupData) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.EpochGroupData.poc_start_block_height":
+ value := x.PocStartBlockHeight
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.EpochGroupData.epoch_group_id":
+ value := x.EpochGroupId
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.EpochGroupData.epoch_policy":
+ value := x.EpochPolicy
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.EpochGroupData.effective_block_height":
+ value := x.EffectiveBlockHeight
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.EpochGroupData.last_block_height":
+ value := x.LastBlockHeight
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.EpochGroupData.member_seed_signatures":
+ if len(x.MemberSeedSignatures) == 0 {
+ return protoreflect.ValueOfList(&_EpochGroupData_6_list{})
+ }
+ listValue := &_EpochGroupData_6_list{list: &x.MemberSeedSignatures}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.inference.EpochGroupData.validation_weights":
+ if len(x.ValidationWeights) == 0 {
+ return protoreflect.ValueOfList(&_EpochGroupData_8_list{})
+ }
+ listValue := &_EpochGroupData_8_list{list: &x.ValidationWeights}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.inference.EpochGroupData.unit_of_compute_price":
+ value := x.UnitOfComputePrice
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.EpochGroupData.number_of_requests":
+ value := x.NumberOfRequests
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.EpochGroupData.previous_epoch_requests":
+ value := x.PreviousEpochRequests
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.EpochGroupData.validation_params":
+ value := x.ValidationParams
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.EpochGroupData.total_weight":
+ value := x.TotalWeight
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.EpochGroupData.model_id":
+ value := x.ModelId
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.EpochGroupData.sub_group_models":
+ if len(x.SubGroupModels) == 0 {
+ return protoreflect.ValueOfList(&_EpochGroupData_15_list{})
+ }
+ listValue := &_EpochGroupData_15_list{list: &x.SubGroupModels}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.inference.EpochGroupData.epoch_index":
+ value := x.EpochIndex
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.EpochGroupData.model_snapshot":
+ value := x.ModelSnapshot
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.EpochGroupData.total_throughput":
+ value := x.TotalThroughput
+ return protoreflect.ValueOfInt64(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.EpochGroupData"))
+ }
+ panic(fmt.Errorf("message inference.inference.EpochGroupData 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_EpochGroupData) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.EpochGroupData.poc_start_block_height":
+ x.PocStartBlockHeight = value.Uint()
+ case "inference.inference.EpochGroupData.epoch_group_id":
+ x.EpochGroupId = value.Uint()
+ case "inference.inference.EpochGroupData.epoch_policy":
+ x.EpochPolicy = value.Interface().(string)
+ case "inference.inference.EpochGroupData.effective_block_height":
+ x.EffectiveBlockHeight = value.Int()
+ case "inference.inference.EpochGroupData.last_block_height":
+ x.LastBlockHeight = value.Int()
+ case "inference.inference.EpochGroupData.member_seed_signatures":
+ lv := value.List()
+ clv := lv.(*_EpochGroupData_6_list)
+ x.MemberSeedSignatures = *clv.list
+ case "inference.inference.EpochGroupData.validation_weights":
+ lv := value.List()
+ clv := lv.(*_EpochGroupData_8_list)
+ x.ValidationWeights = *clv.list
+ case "inference.inference.EpochGroupData.unit_of_compute_price":
+ x.UnitOfComputePrice = value.Int()
+ case "inference.inference.EpochGroupData.number_of_requests":
+ x.NumberOfRequests = value.Int()
+ case "inference.inference.EpochGroupData.previous_epoch_requests":
+ x.PreviousEpochRequests = value.Int()
+ case "inference.inference.EpochGroupData.validation_params":
+ x.ValidationParams = value.Message().Interface().(*ValidationParams)
+ case "inference.inference.EpochGroupData.total_weight":
+ x.TotalWeight = value.Int()
+ case "inference.inference.EpochGroupData.model_id":
+ x.ModelId = value.Interface().(string)
+ case "inference.inference.EpochGroupData.sub_group_models":
+ lv := value.List()
+ clv := lv.(*_EpochGroupData_15_list)
+ x.SubGroupModels = *clv.list
+ case "inference.inference.EpochGroupData.epoch_index":
+ x.EpochIndex = value.Uint()
+ case "inference.inference.EpochGroupData.model_snapshot":
+ x.ModelSnapshot = value.Message().Interface().(*Model)
+ case "inference.inference.EpochGroupData.total_throughput":
+ x.TotalThroughput = value.Int()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.EpochGroupData"))
+ }
+ panic(fmt.Errorf("message inference.inference.EpochGroupData 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_EpochGroupData) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.EpochGroupData.member_seed_signatures":
+ if x.MemberSeedSignatures == nil {
+ x.MemberSeedSignatures = []*SeedSignature{}
+ }
+ value := &_EpochGroupData_6_list{list: &x.MemberSeedSignatures}
+ return protoreflect.ValueOfList(value)
+ case "inference.inference.EpochGroupData.validation_weights":
+ if x.ValidationWeights == nil {
+ x.ValidationWeights = []*ValidationWeight{}
+ }
+ value := &_EpochGroupData_8_list{list: &x.ValidationWeights}
+ return protoreflect.ValueOfList(value)
+ case "inference.inference.EpochGroupData.validation_params":
+ if x.ValidationParams == nil {
+ x.ValidationParams = new(ValidationParams)
+ }
+ return protoreflect.ValueOfMessage(x.ValidationParams.ProtoReflect())
+ case "inference.inference.EpochGroupData.sub_group_models":
+ if x.SubGroupModels == nil {
+ x.SubGroupModels = []string{}
+ }
+ value := &_EpochGroupData_15_list{list: &x.SubGroupModels}
+ return protoreflect.ValueOfList(value)
+ case "inference.inference.EpochGroupData.model_snapshot":
+ if x.ModelSnapshot == nil {
+ x.ModelSnapshot = new(Model)
+ }
+ return protoreflect.ValueOfMessage(x.ModelSnapshot.ProtoReflect())
+ case "inference.inference.EpochGroupData.poc_start_block_height":
+ panic(fmt.Errorf("field poc_start_block_height of message inference.inference.EpochGroupData is not mutable"))
+ case "inference.inference.EpochGroupData.epoch_group_id":
+ panic(fmt.Errorf("field epoch_group_id of message inference.inference.EpochGroupData is not mutable"))
+ case "inference.inference.EpochGroupData.epoch_policy":
+ panic(fmt.Errorf("field epoch_policy of message inference.inference.EpochGroupData is not mutable"))
+ case "inference.inference.EpochGroupData.effective_block_height":
+ panic(fmt.Errorf("field effective_block_height of message inference.inference.EpochGroupData is not mutable"))
+ case "inference.inference.EpochGroupData.last_block_height":
+ panic(fmt.Errorf("field last_block_height of message inference.inference.EpochGroupData is not mutable"))
+ case "inference.inference.EpochGroupData.unit_of_compute_price":
+ panic(fmt.Errorf("field unit_of_compute_price of message inference.inference.EpochGroupData is not mutable"))
+ case "inference.inference.EpochGroupData.number_of_requests":
+ panic(fmt.Errorf("field number_of_requests of message inference.inference.EpochGroupData is not mutable"))
+ case "inference.inference.EpochGroupData.previous_epoch_requests":
+ panic(fmt.Errorf("field previous_epoch_requests of message inference.inference.EpochGroupData is not mutable"))
+ case "inference.inference.EpochGroupData.total_weight":
+ panic(fmt.Errorf("field total_weight of message inference.inference.EpochGroupData is not mutable"))
+ case "inference.inference.EpochGroupData.model_id":
+ panic(fmt.Errorf("field model_id of message inference.inference.EpochGroupData is not mutable"))
+ case "inference.inference.EpochGroupData.epoch_index":
+ panic(fmt.Errorf("field epoch_index of message inference.inference.EpochGroupData is not mutable"))
+ case "inference.inference.EpochGroupData.total_throughput":
+ panic(fmt.Errorf("field total_throughput of message inference.inference.EpochGroupData is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.EpochGroupData"))
+ }
+ panic(fmt.Errorf("message inference.inference.EpochGroupData 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_EpochGroupData) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.EpochGroupData.poc_start_block_height":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.EpochGroupData.epoch_group_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.EpochGroupData.epoch_policy":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.EpochGroupData.effective_block_height":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.EpochGroupData.last_block_height":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.EpochGroupData.member_seed_signatures":
+ list := []*SeedSignature{}
+ return protoreflect.ValueOfList(&_EpochGroupData_6_list{list: &list})
+ case "inference.inference.EpochGroupData.validation_weights":
+ list := []*ValidationWeight{}
+ return protoreflect.ValueOfList(&_EpochGroupData_8_list{list: &list})
+ case "inference.inference.EpochGroupData.unit_of_compute_price":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.EpochGroupData.number_of_requests":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.EpochGroupData.previous_epoch_requests":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.EpochGroupData.validation_params":
+ m := new(ValidationParams)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.EpochGroupData.total_weight":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.EpochGroupData.model_id":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.EpochGroupData.sub_group_models":
+ list := []string{}
+ return protoreflect.ValueOfList(&_EpochGroupData_15_list{list: &list})
+ case "inference.inference.EpochGroupData.epoch_index":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.EpochGroupData.model_snapshot":
+ m := new(Model)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.EpochGroupData.total_throughput":
+ return protoreflect.ValueOfInt64(int64(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.EpochGroupData"))
+ }
+ panic(fmt.Errorf("message inference.inference.EpochGroupData 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_EpochGroupData) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.EpochGroupData", 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_EpochGroupData) 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_EpochGroupData) 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_EpochGroupData) 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_EpochGroupData) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*EpochGroupData)
+ 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.PocStartBlockHeight != 0 {
+ n += 1 + runtime.Sov(uint64(x.PocStartBlockHeight))
+ }
+ if x.EpochGroupId != 0 {
+ n += 1 + runtime.Sov(uint64(x.EpochGroupId))
+ }
+ l = len(x.EpochPolicy)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.EffectiveBlockHeight != 0 {
+ n += 1 + runtime.Sov(uint64(x.EffectiveBlockHeight))
+ }
+ if x.LastBlockHeight != 0 {
+ n += 1 + runtime.Sov(uint64(x.LastBlockHeight))
+ }
+ if len(x.MemberSeedSignatures) > 0 {
+ for _, e := range x.MemberSeedSignatures {
+ l = options.Size(e)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ }
+ if len(x.ValidationWeights) > 0 {
+ for _, e := range x.ValidationWeights {
+ l = options.Size(e)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ }
+ if x.UnitOfComputePrice != 0 {
+ n += 1 + runtime.Sov(uint64(x.UnitOfComputePrice))
+ }
+ if x.NumberOfRequests != 0 {
+ n += 1 + runtime.Sov(uint64(x.NumberOfRequests))
+ }
+ if x.PreviousEpochRequests != 0 {
+ n += 1 + runtime.Sov(uint64(x.PreviousEpochRequests))
+ }
+ if x.ValidationParams != nil {
+ l = options.Size(x.ValidationParams)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.TotalWeight != 0 {
+ n += 1 + runtime.Sov(uint64(x.TotalWeight))
+ }
+ l = len(x.ModelId)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if len(x.SubGroupModels) > 0 {
+ for _, s := range x.SubGroupModels {
+ l = len(s)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ }
+ if x.EpochIndex != 0 {
+ n += 2 + runtime.Sov(uint64(x.EpochIndex))
+ }
+ if x.ModelSnapshot != nil {
+ l = options.Size(x.ModelSnapshot)
+ n += 2 + l + runtime.Sov(uint64(l))
+ }
+ if x.TotalThroughput != 0 {
+ n += 2 + runtime.Sov(uint64(x.TotalThroughput))
+ }
+ 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().(*EpochGroupData)
+ 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.TotalThroughput != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.TotalThroughput))
+ i--
+ dAtA[i] = 0x1
+ i--
+ dAtA[i] = 0x90
+ }
+ if x.ModelSnapshot != nil {
+ encoded, err := options.Marshal(x.ModelSnapshot)
+ 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.EpochIndex != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochIndex))
+ i--
+ dAtA[i] = 0x1
+ i--
+ dAtA[i] = 0x80
+ }
+ if len(x.SubGroupModels) > 0 {
+ for iNdEx := len(x.SubGroupModels) - 1; iNdEx >= 0; iNdEx-- {
+ i -= len(x.SubGroupModels[iNdEx])
+ copy(dAtA[i:], x.SubGroupModels[iNdEx])
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.SubGroupModels[iNdEx])))
+ i--
+ dAtA[i] = 0x7a
+ }
+ }
+ 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] = 0x72
+ }
+ if x.TotalWeight != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.TotalWeight))
+ i--
+ dAtA[i] = 0x68
+ }
+ if x.ValidationParams != nil {
+ encoded, err := options.Marshal(x.ValidationParams)
+ 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] = 0x62
+ }
+ if x.PreviousEpochRequests != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.PreviousEpochRequests))
+ i--
+ dAtA[i] = 0x58
+ }
+ if x.NumberOfRequests != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.NumberOfRequests))
+ i--
+ dAtA[i] = 0x50
+ }
+ if x.UnitOfComputePrice != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.UnitOfComputePrice))
+ i--
+ dAtA[i] = 0x48
+ }
+ if len(x.ValidationWeights) > 0 {
+ for iNdEx := len(x.ValidationWeights) - 1; iNdEx >= 0; iNdEx-- {
+ encoded, err := options.Marshal(x.ValidationWeights[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] = 0x42
+ }
+ }
+ if len(x.MemberSeedSignatures) > 0 {
+ for iNdEx := len(x.MemberSeedSignatures) - 1; iNdEx >= 0; iNdEx-- {
+ encoded, err := options.Marshal(x.MemberSeedSignatures[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 x.LastBlockHeight != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.LastBlockHeight))
+ i--
+ dAtA[i] = 0x28
+ }
+ if x.EffectiveBlockHeight != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.EffectiveBlockHeight))
+ i--
+ dAtA[i] = 0x20
+ }
+ if len(x.EpochPolicy) > 0 {
+ i -= len(x.EpochPolicy)
+ copy(dAtA[i:], x.EpochPolicy)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.EpochPolicy)))
+ i--
+ dAtA[i] = 0x1a
+ }
+ if x.EpochGroupId != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochGroupId))
+ i--
+ dAtA[i] = 0x10
+ }
+ if x.PocStartBlockHeight != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.PocStartBlockHeight))
+ 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().(*EpochGroupData)
+ 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: EpochGroupData: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: EpochGroupData: 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 PocStartBlockHeight", wireType)
+ }
+ x.PocStartBlockHeight = 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.PocStartBlockHeight |= 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 EpochGroupId", wireType)
+ }
+ x.EpochGroupId = 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.EpochGroupId |= 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 EpochPolicy", 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.EpochPolicy = 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 EffectiveBlockHeight", wireType)
+ }
+ x.EffectiveBlockHeight = 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.EffectiveBlockHeight |= int64(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 LastBlockHeight", wireType)
+ }
+ x.LastBlockHeight = 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.LastBlockHeight |= int64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 6:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MemberSeedSignatures", 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.MemberSeedSignatures = append(x.MemberSeedSignatures, &SeedSignature{})
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.MemberSeedSignatures[len(x.MemberSeedSignatures)-1]); err != nil {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+ }
+ iNdEx = postIndex
+ case 8:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidationWeights", 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.ValidationWeights = append(x.ValidationWeights, &ValidationWeight{})
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ValidationWeights[len(x.ValidationWeights)-1]); err != nil {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+ }
+ iNdEx = postIndex
+ case 9:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field UnitOfComputePrice", wireType)
+ }
+ x.UnitOfComputePrice = 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.UnitOfComputePrice |= int64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 10:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field NumberOfRequests", wireType)
+ }
+ x.NumberOfRequests = 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.NumberOfRequests |= int64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 11:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PreviousEpochRequests", wireType)
+ }
+ x.PreviousEpochRequests = 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.PreviousEpochRequests |= int64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 12:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidationParams", 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.ValidationParams == nil {
+ x.ValidationParams = &ValidationParams{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ValidationParams); err != nil {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+ }
+ iNdEx = postIndex
+ case 13:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TotalWeight", wireType)
+ }
+ x.TotalWeight = 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.TotalWeight |= int64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 14:
+ 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 15:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field SubGroupModels", 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.SubGroupModels = append(x.SubGroupModels, string(dAtA[iNdEx:postIndex]))
+ iNdEx = postIndex
+ case 16:
+ 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 17:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ModelSnapshot", 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.ModelSnapshot == nil {
+ x.ModelSnapshot = &Model{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ModelSnapshot); err != nil {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+ }
+ iNdEx = postIndex
+ case 18:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TotalThroughput", wireType)
+ }
+ x.TotalThroughput = 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.TotalThroughput |= 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 _ protoreflect.List = (*_ValidationWeight_4_list)(nil)
+
+type _ValidationWeight_4_list struct {
+ list *[]*MLNodeInfo
+}
+
+func (x *_ValidationWeight_4_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_ValidationWeight_4_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_ValidationWeight_4_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*MLNodeInfo)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_ValidationWeight_4_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*MLNodeInfo)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_ValidationWeight_4_list) AppendMutable() protoreflect.Value {
+ v := new(MLNodeInfo)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_ValidationWeight_4_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_ValidationWeight_4_list) NewElement() protoreflect.Value {
+ v := new(MLNodeInfo)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_ValidationWeight_4_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_ValidationWeight protoreflect.MessageDescriptor
+ fd_ValidationWeight_member_address protoreflect.FieldDescriptor
+ fd_ValidationWeight_weight protoreflect.FieldDescriptor
+ fd_ValidationWeight_reputation protoreflect.FieldDescriptor
+ fd_ValidationWeight_ml_nodes protoreflect.FieldDescriptor
+ fd_ValidationWeight_confirmation_weight protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_epoch_group_data_proto_init()
+ md_ValidationWeight = File_inference_inference_epoch_group_data_proto.Messages().ByName("ValidationWeight")
+ fd_ValidationWeight_member_address = md_ValidationWeight.Fields().ByName("member_address")
+ fd_ValidationWeight_weight = md_ValidationWeight.Fields().ByName("weight")
+ fd_ValidationWeight_reputation = md_ValidationWeight.Fields().ByName("reputation")
+ fd_ValidationWeight_ml_nodes = md_ValidationWeight.Fields().ByName("ml_nodes")
+ fd_ValidationWeight_confirmation_weight = md_ValidationWeight.Fields().ByName("confirmation_weight")
+}
+
+var _ protoreflect.Message = (*fastReflection_ValidationWeight)(nil)
+
+type fastReflection_ValidationWeight ValidationWeight
+
+func (x *ValidationWeight) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_ValidationWeight)(x)
+}
+
+func (x *ValidationWeight) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_epoch_group_data_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_ValidationWeight_messageType fastReflection_ValidationWeight_messageType
+var _ protoreflect.MessageType = fastReflection_ValidationWeight_messageType{}
+
+type fastReflection_ValidationWeight_messageType struct{}
+
+func (x fastReflection_ValidationWeight_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_ValidationWeight)(nil)
+}
+func (x fastReflection_ValidationWeight_messageType) New() protoreflect.Message {
+ return new(fastReflection_ValidationWeight)
+}
+func (x fastReflection_ValidationWeight_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_ValidationWeight
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_ValidationWeight) Descriptor() protoreflect.MessageDescriptor {
+ return md_ValidationWeight
+}
+
+// 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_ValidationWeight) Type() protoreflect.MessageType {
+ return _fastReflection_ValidationWeight_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_ValidationWeight) New() protoreflect.Message {
+ return new(fastReflection_ValidationWeight)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_ValidationWeight) Interface() protoreflect.ProtoMessage {
+ return (*ValidationWeight)(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_ValidationWeight) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.MemberAddress != "" {
+ value := protoreflect.ValueOfString(x.MemberAddress)
+ if !f(fd_ValidationWeight_member_address, value) {
+ return
+ }
+ }
+ if x.Weight != int64(0) {
+ value := protoreflect.ValueOfInt64(x.Weight)
+ if !f(fd_ValidationWeight_weight, value) {
+ return
+ }
+ }
+ if x.Reputation != int32(0) {
+ value := protoreflect.ValueOfInt32(x.Reputation)
+ if !f(fd_ValidationWeight_reputation, value) {
+ return
+ }
+ }
+ if len(x.MlNodes) != 0 {
+ value := protoreflect.ValueOfList(&_ValidationWeight_4_list{list: &x.MlNodes})
+ if !f(fd_ValidationWeight_ml_nodes, value) {
+ return
+ }
+ }
+ if x.ConfirmationWeight != int64(0) {
+ value := protoreflect.ValueOfInt64(x.ConfirmationWeight)
+ if !f(fd_ValidationWeight_confirmation_weight, 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_ValidationWeight) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.ValidationWeight.member_address":
+ return x.MemberAddress != ""
+ case "inference.inference.ValidationWeight.weight":
+ return x.Weight != int64(0)
+ case "inference.inference.ValidationWeight.reputation":
+ return x.Reputation != int32(0)
+ case "inference.inference.ValidationWeight.ml_nodes":
+ return len(x.MlNodes) != 0
+ case "inference.inference.ValidationWeight.confirmation_weight":
+ return x.ConfirmationWeight != int64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ValidationWeight"))
+ }
+ panic(fmt.Errorf("message inference.inference.ValidationWeight 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_ValidationWeight) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.ValidationWeight.member_address":
+ x.MemberAddress = ""
+ case "inference.inference.ValidationWeight.weight":
+ x.Weight = int64(0)
+ case "inference.inference.ValidationWeight.reputation":
+ x.Reputation = int32(0)
+ case "inference.inference.ValidationWeight.ml_nodes":
+ x.MlNodes = nil
+ case "inference.inference.ValidationWeight.confirmation_weight":
+ x.ConfirmationWeight = int64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ValidationWeight"))
+ }
+ panic(fmt.Errorf("message inference.inference.ValidationWeight 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_ValidationWeight) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.ValidationWeight.member_address":
+ value := x.MemberAddress
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.ValidationWeight.weight":
+ value := x.Weight
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.ValidationWeight.reputation":
+ value := x.Reputation
+ return protoreflect.ValueOfInt32(value)
+ case "inference.inference.ValidationWeight.ml_nodes":
+ if len(x.MlNodes) == 0 {
+ return protoreflect.ValueOfList(&_ValidationWeight_4_list{})
+ }
+ listValue := &_ValidationWeight_4_list{list: &x.MlNodes}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.inference.ValidationWeight.confirmation_weight":
+ value := x.ConfirmationWeight
+ return protoreflect.ValueOfInt64(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ValidationWeight"))
+ }
+ panic(fmt.Errorf("message inference.inference.ValidationWeight 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_ValidationWeight) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.ValidationWeight.member_address":
+ x.MemberAddress = value.Interface().(string)
+ case "inference.inference.ValidationWeight.weight":
+ x.Weight = value.Int()
+ case "inference.inference.ValidationWeight.reputation":
+ x.Reputation = int32(value.Int())
+ case "inference.inference.ValidationWeight.ml_nodes":
+ lv := value.List()
+ clv := lv.(*_ValidationWeight_4_list)
+ x.MlNodes = *clv.list
+ case "inference.inference.ValidationWeight.confirmation_weight":
+ x.ConfirmationWeight = value.Int()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ValidationWeight"))
+ }
+ panic(fmt.Errorf("message inference.inference.ValidationWeight 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_ValidationWeight) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.ValidationWeight.ml_nodes":
+ if x.MlNodes == nil {
+ x.MlNodes = []*MLNodeInfo{}
+ }
+ value := &_ValidationWeight_4_list{list: &x.MlNodes}
+ return protoreflect.ValueOfList(value)
+ case "inference.inference.ValidationWeight.member_address":
+ panic(fmt.Errorf("field member_address of message inference.inference.ValidationWeight is not mutable"))
+ case "inference.inference.ValidationWeight.weight":
+ panic(fmt.Errorf("field weight of message inference.inference.ValidationWeight is not mutable"))
+ case "inference.inference.ValidationWeight.reputation":
+ panic(fmt.Errorf("field reputation of message inference.inference.ValidationWeight is not mutable"))
+ case "inference.inference.ValidationWeight.confirmation_weight":
+ panic(fmt.Errorf("field confirmation_weight of message inference.inference.ValidationWeight is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ValidationWeight"))
+ }
+ panic(fmt.Errorf("message inference.inference.ValidationWeight 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_ValidationWeight) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.ValidationWeight.member_address":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.ValidationWeight.weight":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.ValidationWeight.reputation":
+ return protoreflect.ValueOfInt32(int32(0))
+ case "inference.inference.ValidationWeight.ml_nodes":
+ list := []*MLNodeInfo{}
+ return protoreflect.ValueOfList(&_ValidationWeight_4_list{list: &list})
+ case "inference.inference.ValidationWeight.confirmation_weight":
+ return protoreflect.ValueOfInt64(int64(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ValidationWeight"))
+ }
+ panic(fmt.Errorf("message inference.inference.ValidationWeight 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_ValidationWeight) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.ValidationWeight", 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_ValidationWeight) 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_ValidationWeight) 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_ValidationWeight) 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_ValidationWeight) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*ValidationWeight)
+ 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.MemberAddress)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(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.MlNodes) > 0 {
+ for _, e := range x.MlNodes {
+ l = options.Size(e)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ }
+ if x.ConfirmationWeight != 0 {
+ n += 1 + runtime.Sov(uint64(x.ConfirmationWeight))
+ }
+ 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().(*ValidationWeight)
+ 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.ConfirmationWeight != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.ConfirmationWeight))
+ i--
+ dAtA[i] = 0x28
+ }
+ if len(x.MlNodes) > 0 {
+ for iNdEx := len(x.MlNodes) - 1; iNdEx >= 0; iNdEx-- {
+ encoded, err := options.Marshal(x.MlNodes[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.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.MemberAddress) > 0 {
+ i -= len(x.MemberAddress)
+ copy(dAtA[i:], x.MemberAddress)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.MemberAddress)))
+ 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().(*ValidationWeight)
+ 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: ValidationWeight: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ValidationWeight: 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 MemberAddress", 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.MemberAddress = 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 |= 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 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 != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MlNodes", 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.MlNodes = append(x.MlNodes, &MLNodeInfo{})
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.MlNodes[len(x.MlNodes)-1]); err != nil {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+ }
+ iNdEx = postIndex
+ case 5:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ConfirmationWeight", wireType)
+ }
+ x.ConfirmationWeight = 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.ConfirmationWeight |= 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_SeedSignature protoreflect.MessageDescriptor
+ fd_SeedSignature_member_address protoreflect.FieldDescriptor
+ fd_SeedSignature_signature protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_epoch_group_data_proto_init()
+ md_SeedSignature = File_inference_inference_epoch_group_data_proto.Messages().ByName("SeedSignature")
+ fd_SeedSignature_member_address = md_SeedSignature.Fields().ByName("member_address")
+ fd_SeedSignature_signature = md_SeedSignature.Fields().ByName("signature")
+}
+
+var _ protoreflect.Message = (*fastReflection_SeedSignature)(nil)
+
+type fastReflection_SeedSignature SeedSignature
+
+func (x *SeedSignature) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_SeedSignature)(x)
+}
+
+func (x *SeedSignature) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_epoch_group_data_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_SeedSignature_messageType fastReflection_SeedSignature_messageType
+var _ protoreflect.MessageType = fastReflection_SeedSignature_messageType{}
+
+type fastReflection_SeedSignature_messageType struct{}
+
+func (x fastReflection_SeedSignature_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_SeedSignature)(nil)
+}
+func (x fastReflection_SeedSignature_messageType) New() protoreflect.Message {
+ return new(fastReflection_SeedSignature)
+}
+func (x fastReflection_SeedSignature_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_SeedSignature
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_SeedSignature) Descriptor() protoreflect.MessageDescriptor {
+ return md_SeedSignature
+}
+
+// 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_SeedSignature) Type() protoreflect.MessageType {
+ return _fastReflection_SeedSignature_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_SeedSignature) New() protoreflect.Message {
+ return new(fastReflection_SeedSignature)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_SeedSignature) Interface() protoreflect.ProtoMessage {
+ return (*SeedSignature)(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_SeedSignature) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.MemberAddress != "" {
+ value := protoreflect.ValueOfString(x.MemberAddress)
+ if !f(fd_SeedSignature_member_address, value) {
+ return
+ }
+ }
+ if x.Signature != "" {
+ value := protoreflect.ValueOfString(x.Signature)
+ if !f(fd_SeedSignature_signature, 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_SeedSignature) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.SeedSignature.member_address":
+ return x.MemberAddress != ""
+ case "inference.inference.SeedSignature.signature":
+ return x.Signature != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.SeedSignature"))
+ }
+ panic(fmt.Errorf("message inference.inference.SeedSignature 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_SeedSignature) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.SeedSignature.member_address":
+ x.MemberAddress = ""
+ case "inference.inference.SeedSignature.signature":
+ x.Signature = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.SeedSignature"))
+ }
+ panic(fmt.Errorf("message inference.inference.SeedSignature 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_SeedSignature) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.SeedSignature.member_address":
+ value := x.MemberAddress
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.SeedSignature.signature":
+ value := x.Signature
+ return protoreflect.ValueOfString(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.SeedSignature"))
+ }
+ panic(fmt.Errorf("message inference.inference.SeedSignature 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_SeedSignature) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.SeedSignature.member_address":
+ x.MemberAddress = value.Interface().(string)
+ case "inference.inference.SeedSignature.signature":
+ x.Signature = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.SeedSignature"))
+ }
+ panic(fmt.Errorf("message inference.inference.SeedSignature 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_SeedSignature) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.SeedSignature.member_address":
+ panic(fmt.Errorf("field member_address of message inference.inference.SeedSignature is not mutable"))
+ case "inference.inference.SeedSignature.signature":
+ panic(fmt.Errorf("field signature of message inference.inference.SeedSignature is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.SeedSignature"))
+ }
+ panic(fmt.Errorf("message inference.inference.SeedSignature 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_SeedSignature) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.SeedSignature.member_address":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.SeedSignature.signature":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.SeedSignature"))
+ }
+ panic(fmt.Errorf("message inference.inference.SeedSignature 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_SeedSignature) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.SeedSignature", 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_SeedSignature) 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_SeedSignature) 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_SeedSignature) 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_SeedSignature) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*SeedSignature)
+ 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.MemberAddress)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ l = len(x.Signature)
+ 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().(*SeedSignature)
+ 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.Signature) > 0 {
+ i -= len(x.Signature)
+ copy(dAtA[i:], x.Signature)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Signature)))
+ i--
+ dAtA[i] = 0x12
+ }
+ if len(x.MemberAddress) > 0 {
+ i -= len(x.MemberAddress)
+ copy(dAtA[i:], x.MemberAddress)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.MemberAddress)))
+ 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().(*SeedSignature)
+ 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: SeedSignature: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: SeedSignature: 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 MemberAddress", 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.MemberAddress = 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 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:])
+ 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 = (*_MLNodeInfo_4_list)(nil)
+
+type _MLNodeInfo_4_list struct {
+ list *[]bool
+}
+
+func (x *_MLNodeInfo_4_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_MLNodeInfo_4_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfBool((*x.list)[i])
+}
+
+func (x *_MLNodeInfo_4_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Bool()
+ concreteValue := valueUnwrapped
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_MLNodeInfo_4_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Bool()
+ concreteValue := valueUnwrapped
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_MLNodeInfo_4_list) AppendMutable() protoreflect.Value {
+ panic(fmt.Errorf("AppendMutable can not be called on message MLNodeInfo at list field TimeslotAllocation as it is not of Message kind"))
+}
+
+func (x *_MLNodeInfo_4_list) Truncate(n int) {
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_MLNodeInfo_4_list) NewElement() protoreflect.Value {
+ v := false
+ return protoreflect.ValueOfBool(v)
+}
+
+func (x *_MLNodeInfo_4_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_MLNodeInfo protoreflect.MessageDescriptor
+ fd_MLNodeInfo_node_id protoreflect.FieldDescriptor
+ fd_MLNodeInfo_throughput protoreflect.FieldDescriptor
+ fd_MLNodeInfo_poc_weight protoreflect.FieldDescriptor
+ fd_MLNodeInfo_timeslot_allocation protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_epoch_group_data_proto_init()
+ md_MLNodeInfo = File_inference_inference_epoch_group_data_proto.Messages().ByName("MLNodeInfo")
+ fd_MLNodeInfo_node_id = md_MLNodeInfo.Fields().ByName("node_id")
+ fd_MLNodeInfo_throughput = md_MLNodeInfo.Fields().ByName("throughput")
+ fd_MLNodeInfo_poc_weight = md_MLNodeInfo.Fields().ByName("poc_weight")
+ fd_MLNodeInfo_timeslot_allocation = md_MLNodeInfo.Fields().ByName("timeslot_allocation")
+}
+
+var _ protoreflect.Message = (*fastReflection_MLNodeInfo)(nil)
+
+type fastReflection_MLNodeInfo MLNodeInfo
+
+func (x *MLNodeInfo) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_MLNodeInfo)(x)
+}
+
+func (x *MLNodeInfo) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_epoch_group_data_proto_msgTypes[3]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_MLNodeInfo_messageType fastReflection_MLNodeInfo_messageType
+var _ protoreflect.MessageType = fastReflection_MLNodeInfo_messageType{}
+
+type fastReflection_MLNodeInfo_messageType struct{}
+
+func (x fastReflection_MLNodeInfo_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_MLNodeInfo)(nil)
+}
+func (x fastReflection_MLNodeInfo_messageType) New() protoreflect.Message {
+ return new(fastReflection_MLNodeInfo)
+}
+func (x fastReflection_MLNodeInfo_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_MLNodeInfo
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MLNodeInfo) Descriptor() protoreflect.MessageDescriptor {
+ return md_MLNodeInfo
+}
+
+// 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_MLNodeInfo) Type() protoreflect.MessageType {
+ return _fastReflection_MLNodeInfo_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MLNodeInfo) New() protoreflect.Message {
+ return new(fastReflection_MLNodeInfo)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MLNodeInfo) Interface() protoreflect.ProtoMessage {
+ return (*MLNodeInfo)(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_MLNodeInfo) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.NodeId != "" {
+ value := protoreflect.ValueOfString(x.NodeId)
+ if !f(fd_MLNodeInfo_node_id, value) {
+ return
+ }
+ }
+ if x.Throughput != int64(0) {
+ value := protoreflect.ValueOfInt64(x.Throughput)
+ if !f(fd_MLNodeInfo_throughput, value) {
+ return
+ }
+ }
+ if x.PocWeight != int64(0) {
+ value := protoreflect.ValueOfInt64(x.PocWeight)
+ if !f(fd_MLNodeInfo_poc_weight, value) {
+ return
+ }
+ }
+ if len(x.TimeslotAllocation) != 0 {
+ value := protoreflect.ValueOfList(&_MLNodeInfo_4_list{list: &x.TimeslotAllocation})
+ if !f(fd_MLNodeInfo_timeslot_allocation, 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_MLNodeInfo) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.MLNodeInfo.node_id":
+ return x.NodeId != ""
+ case "inference.inference.MLNodeInfo.throughput":
+ return x.Throughput != int64(0)
+ case "inference.inference.MLNodeInfo.poc_weight":
+ return x.PocWeight != int64(0)
+ case "inference.inference.MLNodeInfo.timeslot_allocation":
+ return len(x.TimeslotAllocation) != 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MLNodeInfo"))
+ }
+ panic(fmt.Errorf("message inference.inference.MLNodeInfo 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_MLNodeInfo) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.MLNodeInfo.node_id":
+ x.NodeId = ""
+ case "inference.inference.MLNodeInfo.throughput":
+ x.Throughput = int64(0)
+ case "inference.inference.MLNodeInfo.poc_weight":
+ x.PocWeight = int64(0)
+ case "inference.inference.MLNodeInfo.timeslot_allocation":
+ x.TimeslotAllocation = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MLNodeInfo"))
+ }
+ panic(fmt.Errorf("message inference.inference.MLNodeInfo 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_MLNodeInfo) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.MLNodeInfo.node_id":
+ value := x.NodeId
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.MLNodeInfo.throughput":
+ value := x.Throughput
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.MLNodeInfo.poc_weight":
+ value := x.PocWeight
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.MLNodeInfo.timeslot_allocation":
+ if len(x.TimeslotAllocation) == 0 {
+ return protoreflect.ValueOfList(&_MLNodeInfo_4_list{})
+ }
+ listValue := &_MLNodeInfo_4_list{list: &x.TimeslotAllocation}
+ return protoreflect.ValueOfList(listValue)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MLNodeInfo"))
+ }
+ panic(fmt.Errorf("message inference.inference.MLNodeInfo 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_MLNodeInfo) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.MLNodeInfo.node_id":
+ x.NodeId = value.Interface().(string)
+ case "inference.inference.MLNodeInfo.throughput":
+ x.Throughput = value.Int()
+ case "inference.inference.MLNodeInfo.poc_weight":
+ x.PocWeight = value.Int()
+ case "inference.inference.MLNodeInfo.timeslot_allocation":
+ lv := value.List()
+ clv := lv.(*_MLNodeInfo_4_list)
+ x.TimeslotAllocation = *clv.list
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MLNodeInfo"))
+ }
+ panic(fmt.Errorf("message inference.inference.MLNodeInfo 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_MLNodeInfo) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.MLNodeInfo.timeslot_allocation":
+ if x.TimeslotAllocation == nil {
+ x.TimeslotAllocation = []bool{}
+ }
+ value := &_MLNodeInfo_4_list{list: &x.TimeslotAllocation}
+ return protoreflect.ValueOfList(value)
+ case "inference.inference.MLNodeInfo.node_id":
+ panic(fmt.Errorf("field node_id of message inference.inference.MLNodeInfo is not mutable"))
+ case "inference.inference.MLNodeInfo.throughput":
+ panic(fmt.Errorf("field throughput of message inference.inference.MLNodeInfo is not mutable"))
+ case "inference.inference.MLNodeInfo.poc_weight":
+ panic(fmt.Errorf("field poc_weight of message inference.inference.MLNodeInfo is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MLNodeInfo"))
+ }
+ panic(fmt.Errorf("message inference.inference.MLNodeInfo 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_MLNodeInfo) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.MLNodeInfo.node_id":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.MLNodeInfo.throughput":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.MLNodeInfo.poc_weight":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.MLNodeInfo.timeslot_allocation":
+ list := []bool{}
+ return protoreflect.ValueOfList(&_MLNodeInfo_4_list{list: &list})
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MLNodeInfo"))
+ }
+ panic(fmt.Errorf("message inference.inference.MLNodeInfo 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_MLNodeInfo) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.MLNodeInfo", 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_MLNodeInfo) 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_MLNodeInfo) 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_MLNodeInfo) 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_MLNodeInfo) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*MLNodeInfo)
+ 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.NodeId)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.Throughput != 0 {
+ n += 1 + runtime.Sov(uint64(x.Throughput))
+ }
+ if x.PocWeight != 0 {
+ n += 1 + runtime.Sov(uint64(x.PocWeight))
+ }
+ if len(x.TimeslotAllocation) > 0 {
+ n += 1 + runtime.Sov(uint64(len(x.TimeslotAllocation))) + len(x.TimeslotAllocation)*1
+ }
+ 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().(*MLNodeInfo)
+ 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.TimeslotAllocation) > 0 {
+ for iNdEx := len(x.TimeslotAllocation) - 1; iNdEx >= 0; iNdEx-- {
+ i--
+ if x.TimeslotAllocation[iNdEx] {
+ dAtA[i] = 1
+ } else {
+ dAtA[i] = 0
+ }
+ }
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.TimeslotAllocation)))
+ i--
+ dAtA[i] = 0x22
+ }
+ if x.PocWeight != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.PocWeight))
+ i--
+ dAtA[i] = 0x18
+ }
+ if x.Throughput != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.Throughput))
+ i--
+ dAtA[i] = 0x10
+ }
+ 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] = 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().(*MLNodeInfo)
+ 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: MLNodeInfo: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MLNodeInfo: 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 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
+ case 2:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Throughput", wireType)
+ }
+ x.Throughput = 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.Throughput |= 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 PocWeight", wireType)
+ }
+ x.PocWeight = 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.PocWeight |= int64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 4:
+ if wireType == 0 {
+ 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.TimeslotAllocation = append(x.TimeslotAllocation, bool(v != 0))
+ } 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
+ if elementCount != 0 && len(x.TimeslotAllocation) == 0 {
+ x.TimeslotAllocation = make([]bool, 0, elementCount)
+ }
+ for iNdEx < postIndex {
+ 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.TimeslotAllocation = append(x.TimeslotAllocation, bool(v != 0))
+ }
+ } else {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TimeslotAllocation", wireType)
+ }
+ 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/epoch_group_data.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)
+)
+
+// Enum for timeslot types
+type TimeslotType int32
+
+const (
+ TimeslotType_PRE_POC_SLOT TimeslotType = 0
+ TimeslotType_POC_SLOT TimeslotType = 1
+)
+
+// Enum value maps for TimeslotType.
+var (
+ TimeslotType_name = map[int32]string{
+ 0: "PRE_POC_SLOT",
+ 1: "POC_SLOT",
+ }
+ TimeslotType_value = map[string]int32{
+ "PRE_POC_SLOT": 0,
+ "POC_SLOT": 1,
+ }
+)
+
+func (x TimeslotType) Enum() *TimeslotType {
+ p := new(TimeslotType)
+ *p = x
+ return p
+}
+
+func (x TimeslotType) String() string {
+ return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (TimeslotType) Descriptor() protoreflect.EnumDescriptor {
+ return file_inference_inference_epoch_group_data_proto_enumTypes[0].Descriptor()
+}
+
+func (TimeslotType) Type() protoreflect.EnumType {
+ return &file_inference_inference_epoch_group_data_proto_enumTypes[0]
+}
+
+func (x TimeslotType) Number() protoreflect.EnumNumber {
+ return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use TimeslotType.Descriptor instead.
+func (TimeslotType) EnumDescriptor() ([]byte, []int) {
+ return file_inference_inference_epoch_group_data_proto_rawDescGZIP(), []int{0}
+}
+
+// These top two values are uint64s because they are IDs, not numerical values.
+type EpochGroupData struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ PocStartBlockHeight uint64 `protobuf:"varint,1,opt,name=poc_start_block_height,json=pocStartBlockHeight,proto3" json:"poc_start_block_height,omitempty"`
+ EpochGroupId uint64 `protobuf:"varint,2,opt,name=epoch_group_id,json=epochGroupId,proto3" json:"epoch_group_id,omitempty"`
+ EpochPolicy string `protobuf:"bytes,3,opt,name=epoch_policy,json=epochPolicy,proto3" json:"epoch_policy,omitempty"`
+ EffectiveBlockHeight int64 `protobuf:"varint,4,opt,name=effective_block_height,json=effectiveBlockHeight,proto3" json:"effective_block_height,omitempty"`
+ LastBlockHeight int64 `protobuf:"varint,5,opt,name=last_block_height,json=lastBlockHeight,proto3" json:"last_block_height,omitempty"`
+ MemberSeedSignatures []*SeedSignature `protobuf:"bytes,6,rep,name=member_seed_signatures,json=memberSeedSignatures,proto3" json:"member_seed_signatures,omitempty"`
+ ValidationWeights []*ValidationWeight `protobuf:"bytes,8,rep,name=validation_weights,json=validationWeights,proto3" json:"validation_weights,omitempty"`
+ UnitOfComputePrice int64 `protobuf:"varint,9,opt,name=unit_of_compute_price,json=unitOfComputePrice,proto3" json:"unit_of_compute_price,omitempty"`
+ NumberOfRequests int64 `protobuf:"varint,10,opt,name=number_of_requests,json=numberOfRequests,proto3" json:"number_of_requests,omitempty"`
+ PreviousEpochRequests int64 `protobuf:"varint,11,opt,name=previous_epoch_requests,json=previousEpochRequests,proto3" json:"previous_epoch_requests,omitempty"`
+ ValidationParams *ValidationParams `protobuf:"bytes,12,opt,name=validation_params,json=validationParams,proto3" json:"validation_params,omitempty"`
+ TotalWeight int64 `protobuf:"varint,13,opt,name=total_weight,json=totalWeight,proto3" json:"total_weight,omitempty"`
+ // If model_id is empty, this is the parent EpochGroup
+ // If model_id is set, this is a sub EpochGroup for that specific model
+ ModelId string `protobuf:"bytes,14,opt,name=model_id,json=modelId,proto3" json:"model_id,omitempty"`
+ // List of model IDs for sub EpochGroups, only used in parent EpochGroup
+ SubGroupModels []string `protobuf:"bytes,15,rep,name=sub_group_models,json=subGroupModels,proto3" json:"sub_group_models,omitempty"`
+ EpochIndex uint64 `protobuf:"varint,16,opt,name=epoch_index,json=epochIndex,proto3" json:"epoch_index,omitempty"`
+ ModelSnapshot *Model `protobuf:"bytes,17,opt,name=model_snapshot,json=modelSnapshot,proto3" json:"model_snapshot,omitempty"`
+ TotalThroughput int64 `protobuf:"varint,18,opt,name=total_throughput,json=totalThroughput,proto3" json:"total_throughput,omitempty"`
+}
+
+func (x *EpochGroupData) Reset() {
+ *x = EpochGroupData{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_epoch_group_data_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *EpochGroupData) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*EpochGroupData) ProtoMessage() {}
+
+// Deprecated: Use EpochGroupData.ProtoReflect.Descriptor instead.
+func (*EpochGroupData) Descriptor() ([]byte, []int) {
+ return file_inference_inference_epoch_group_data_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *EpochGroupData) GetPocStartBlockHeight() uint64 {
+ if x != nil {
+ return x.PocStartBlockHeight
+ }
+ return 0
+}
+
+func (x *EpochGroupData) GetEpochGroupId() uint64 {
+ if x != nil {
+ return x.EpochGroupId
+ }
+ return 0
+}
+
+func (x *EpochGroupData) GetEpochPolicy() string {
+ if x != nil {
+ return x.EpochPolicy
+ }
+ return ""
+}
+
+func (x *EpochGroupData) GetEffectiveBlockHeight() int64 {
+ if x != nil {
+ return x.EffectiveBlockHeight
+ }
+ return 0
+}
+
+func (x *EpochGroupData) GetLastBlockHeight() int64 {
+ if x != nil {
+ return x.LastBlockHeight
+ }
+ return 0
+}
+
+func (x *EpochGroupData) GetMemberSeedSignatures() []*SeedSignature {
+ if x != nil {
+ return x.MemberSeedSignatures
+ }
+ return nil
+}
+
+func (x *EpochGroupData) GetValidationWeights() []*ValidationWeight {
+ if x != nil {
+ return x.ValidationWeights
+ }
+ return nil
+}
+
+func (x *EpochGroupData) GetUnitOfComputePrice() int64 {
+ if x != nil {
+ return x.UnitOfComputePrice
+ }
+ return 0
+}
+
+func (x *EpochGroupData) GetNumberOfRequests() int64 {
+ if x != nil {
+ return x.NumberOfRequests
+ }
+ return 0
+}
+
+func (x *EpochGroupData) GetPreviousEpochRequests() int64 {
+ if x != nil {
+ return x.PreviousEpochRequests
+ }
+ return 0
+}
+
+func (x *EpochGroupData) GetValidationParams() *ValidationParams {
+ if x != nil {
+ return x.ValidationParams
+ }
+ return nil
+}
+
+func (x *EpochGroupData) GetTotalWeight() int64 {
+ if x != nil {
+ return x.TotalWeight
+ }
+ return 0
+}
+
+func (x *EpochGroupData) GetModelId() string {
+ if x != nil {
+ return x.ModelId
+ }
+ return ""
+}
+
+func (x *EpochGroupData) GetSubGroupModels() []string {
+ if x != nil {
+ return x.SubGroupModels
+ }
+ return nil
+}
+
+func (x *EpochGroupData) GetEpochIndex() uint64 {
+ if x != nil {
+ return x.EpochIndex
+ }
+ return 0
+}
+
+func (x *EpochGroupData) GetModelSnapshot() *Model {
+ if x != nil {
+ return x.ModelSnapshot
+ }
+ return nil
+}
+
+func (x *EpochGroupData) GetTotalThroughput() int64 {
+ if x != nil {
+ return x.TotalThroughput
+ }
+ return 0
+}
+
+type ValidationWeight struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ MemberAddress string `protobuf:"bytes,1,opt,name=member_address,json=memberAddress,proto3" json:"member_address,omitempty"`
+ Weight int64 `protobuf:"varint,2,opt,name=weight,proto3" json:"weight,omitempty"`
+ Reputation int32 `protobuf:"varint,3,opt,name=reputation,proto3" json:"reputation,omitempty"`
+ // We may decide to move ml_nodes directly to EpochGroupData,
+ // but for now, this is a good solution.
+ MlNodes []*MLNodeInfo `protobuf:"bytes,4,rep,name=ml_nodes,json=mlNodes,proto3" json:"ml_nodes,omitempty"`
+ // confirmation_weight is the final confirmed weight for epoch (from confirmation PoC events)
+ ConfirmationWeight int64 `protobuf:"varint,5,opt,name=confirmation_weight,json=confirmationWeight,proto3" json:"confirmation_weight,omitempty"`
+}
+
+func (x *ValidationWeight) Reset() {
+ *x = ValidationWeight{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_epoch_group_data_proto_msgTypes[1]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *ValidationWeight) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ValidationWeight) ProtoMessage() {}
+
+// Deprecated: Use ValidationWeight.ProtoReflect.Descriptor instead.
+func (*ValidationWeight) Descriptor() ([]byte, []int) {
+ return file_inference_inference_epoch_group_data_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *ValidationWeight) GetMemberAddress() string {
+ if x != nil {
+ return x.MemberAddress
+ }
+ return ""
+}
+
+func (x *ValidationWeight) GetWeight() int64 {
+ if x != nil {
+ return x.Weight
+ }
+ return 0
+}
+
+func (x *ValidationWeight) GetReputation() int32 {
+ if x != nil {
+ return x.Reputation
+ }
+ return 0
+}
+
+func (x *ValidationWeight) GetMlNodes() []*MLNodeInfo {
+ if x != nil {
+ return x.MlNodes
+ }
+ return nil
+}
+
+func (x *ValidationWeight) GetConfirmationWeight() int64 {
+ if x != nil {
+ return x.ConfirmationWeight
+ }
+ return 0
+}
+
+type SeedSignature struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ MemberAddress string `protobuf:"bytes,1,opt,name=member_address,json=memberAddress,proto3" json:"member_address,omitempty"`
+ Signature string `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
+}
+
+func (x *SeedSignature) Reset() {
+ *x = SeedSignature{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_epoch_group_data_proto_msgTypes[2]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *SeedSignature) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*SeedSignature) ProtoMessage() {}
+
+// Deprecated: Use SeedSignature.ProtoReflect.Descriptor instead.
+func (*SeedSignature) Descriptor() ([]byte, []int) {
+ return file_inference_inference_epoch_group_data_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *SeedSignature) GetMemberAddress() string {
+ if x != nil {
+ return x.MemberAddress
+ }
+ return ""
+}
+
+func (x *SeedSignature) GetSignature() string {
+ if x != nil {
+ return x.Signature
+ }
+ return ""
+}
+
+type MLNodeInfo struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ NodeId string `protobuf:"bytes,1,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
+ Throughput int64 `protobuf:"varint,2,opt,name=throughput,proto3" json:"throughput,omitempty"`
+ PocWeight int64 `protobuf:"varint,3,opt,name=poc_weight,json=pocWeight,proto3" json:"poc_weight,omitempty"`
+ TimeslotAllocation []bool `protobuf:"varint,4,rep,packed,name=timeslot_allocation,json=timeslotAllocation,proto3" json:"timeslot_allocation,omitempty"`
+}
+
+func (x *MLNodeInfo) Reset() {
+ *x = MLNodeInfo{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_epoch_group_data_proto_msgTypes[3]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *MLNodeInfo) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MLNodeInfo) ProtoMessage() {}
+
+// Deprecated: Use MLNodeInfo.ProtoReflect.Descriptor instead.
+func (*MLNodeInfo) Descriptor() ([]byte, []int) {
+ return file_inference_inference_epoch_group_data_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *MLNodeInfo) GetNodeId() string {
+ if x != nil {
+ return x.NodeId
+ }
+ return ""
+}
+
+func (x *MLNodeInfo) GetThroughput() int64 {
+ if x != nil {
+ return x.Throughput
+ }
+ return 0
+}
+
+func (x *MLNodeInfo) GetPocWeight() int64 {
+ if x != nil {
+ return x.PocWeight
+ }
+ return 0
+}
+
+func (x *MLNodeInfo) GetTimeslotAllocation() []bool {
+ if x != nil {
+ return x.TimeslotAllocation
+ }
+ return nil
+}
+
+var File_inference_inference_epoch_group_data_proto protoreflect.FileDescriptor
+
+var file_inference_inference_epoch_group_data_proto_rawDesc = []byte{
+ 0x0a, 0x2a, 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, 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, 0x1a, 0x25, 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, 0x2e, 0x70, 0x72, 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, 0x1a, 0x1f, 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, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x84, 0x07, 0x0a, 0x0e,
+ 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x44, 0x61, 0x74, 0x61, 0x12, 0x33,
+ 0x0a, 0x16, 0x70, 0x6f, 0x63, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63,
+ 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x13,
+ 0x70, 0x6f, 0x63, 0x53, 0x74, 0x61, 0x72, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69,
+ 0x67, 0x68, 0x74, 0x12, 0x24, 0x0a, 0x0e, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x67, 0x72, 0x6f,
+ 0x75, 0x70, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0c, 0x65, 0x70, 0x6f,
+ 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x65, 0x70, 0x6f,
+ 0x63, 0x68, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52,
+ 0x0b, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x34, 0x0a, 0x16,
+ 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f,
+ 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x14, 0x65, 0x66,
+ 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67,
+ 0x68, 0x74, 0x12, 0x2a, 0x0a, 0x11, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b,
+ 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0f, 0x6c,
+ 0x61, 0x73, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x58,
+ 0x0a, 0x16, 0x6d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x5f, 0x73, 0x65, 0x65, 0x64, 0x5f, 0x73, 0x69,
+ 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x18, 0x06, 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, 0x53, 0x65, 0x65, 0x64, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75,
+ 0x72, 0x65, 0x52, 0x14, 0x6d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x53, 0x65, 0x65, 0x64, 0x53, 0x69,
+ 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x12, 0x54, 0x0a, 0x12, 0x76, 0x61, 0x6c, 0x69,
+ 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x73, 0x18, 0x08,
+ 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, 0x56, 0x61, 0x6c, 0x69, 0x64,
+ 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x52, 0x11, 0x76, 0x61, 0x6c,
+ 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x73, 0x12, 0x31,
+ 0x0a, 0x15, 0x75, 0x6e, 0x69, 0x74, 0x5f, 0x6f, 0x66, 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x75, 0x74,
+ 0x65, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x03, 0x52, 0x12, 0x75,
+ 0x6e, 0x69, 0x74, 0x4f, 0x66, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x50, 0x72, 0x69, 0x63,
+ 0x65, 0x12, 0x2c, 0x0a, 0x12, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x5f, 0x6f, 0x66, 0x5f, 0x72,
+ 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x03, 0x52, 0x10, 0x6e,
+ 0x75, 0x6d, 0x62, 0x65, 0x72, 0x4f, 0x66, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x12,
+ 0x36, 0x0a, 0x17, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x5f, 0x65, 0x70, 0x6f, 0x63,
+ 0x68, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x03,
+ 0x52, 0x15, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x52,
+ 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x12, 0x52, 0x0a, 0x11, 0x76, 0x61, 0x6c, 0x69, 0x64,
+ 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x0c, 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, 0x10, 0x76, 0x61, 0x6c, 0x69, 0x64,
+ 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x74,
+ 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x0d, 0x20, 0x01, 0x28,
+ 0x03, 0x52, 0x0b, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x19,
+ 0x0a, 0x08, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x09,
+ 0x52, 0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64, 0x12, 0x28, 0x0a, 0x10, 0x73, 0x75, 0x62,
+ 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x18, 0x0f, 0x20,
+ 0x03, 0x28, 0x09, 0x52, 0x0e, 0x73, 0x75, 0x62, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x6f, 0x64,
+ 0x65, 0x6c, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x6e, 0x64,
+ 0x65, 0x78, 0x18, 0x10, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x49,
+ 0x6e, 0x64, 0x65, 0x78, 0x12, 0x41, 0x0a, 0x0e, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x73, 0x6e,
+ 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x18, 0x11, 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, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x52, 0x0d, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x53,
+ 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x12, 0x29, 0x0a, 0x10, 0x74, 0x6f, 0x74, 0x61, 0x6c,
+ 0x5f, 0x74, 0x68, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x70, 0x75, 0x74, 0x18, 0x12, 0x20, 0x01, 0x28,
+ 0x03, 0x52, 0x0f, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x54, 0x68, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x70,
+ 0x75, 0x74, 0x22, 0xde, 0x01, 0x0a, 0x10, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f,
+ 0x6e, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x6d, 0x65, 0x6d, 0x62, 0x65,
+ 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
+ 0x0d, 0x6d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x16,
+ 0x0a, 0x06, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06,
+ 0x77, 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, 0x3a, 0x0a, 0x08, 0x6d, 0x6c, 0x5f, 0x6e, 0x6f, 0x64,
+ 0x65, 0x73, 0x18, 0x04, 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,
+ 0x4c, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x07, 0x6d, 0x6c, 0x4e, 0x6f, 0x64,
+ 0x65, 0x73, 0x12, 0x2f, 0x0a, 0x13, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69,
+ 0x6f, 0x6e, 0x5f, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52,
+ 0x12, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x65, 0x69,
+ 0x67, 0x68, 0x74, 0x22, 0x54, 0x0a, 0x0d, 0x53, 0x65, 0x65, 0x64, 0x53, 0x69, 0x67, 0x6e, 0x61,
+ 0x74, 0x75, 0x72, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x6d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x5f, 0x61,
+ 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x6d, 0x65,
+ 0x6d, 0x62, 0x65, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x1c, 0x0a, 0x09, 0x73,
+ 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09,
+ 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x22, 0x95, 0x01, 0x0a, 0x0a, 0x4d, 0x4c,
+ 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x17, 0x0a, 0x07, 0x6e, 0x6f, 0x64, 0x65,
+ 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49,
+ 0x64, 0x12, 0x1e, 0x0a, 0x0a, 0x74, 0x68, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x70, 0x75, 0x74, 0x18,
+ 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x74, 0x68, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x70, 0x75,
+ 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x70, 0x6f, 0x63, 0x5f, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18,
+ 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x70, 0x6f, 0x63, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74,
+ 0x12, 0x2f, 0x0a, 0x13, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x6c, 0x6f, 0x74, 0x5f, 0x61, 0x6c, 0x6c,
+ 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x03, 0x28, 0x08, 0x52, 0x12, 0x74,
+ 0x69, 0x6d, 0x65, 0x73, 0x6c, 0x6f, 0x74, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f,
+ 0x6e, 0x2a, 0x2e, 0x0a, 0x0c, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x6c, 0x6f, 0x74, 0x54, 0x79, 0x70,
+ 0x65, 0x12, 0x10, 0x0a, 0x0c, 0x50, 0x52, 0x45, 0x5f, 0x50, 0x4f, 0x43, 0x5f, 0x53, 0x4c, 0x4f,
+ 0x54, 0x10, 0x00, 0x12, 0x0c, 0x0a, 0x08, 0x50, 0x4f, 0x43, 0x5f, 0x53, 0x4c, 0x4f, 0x54, 0x10,
+ 0x01, 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, 0x45,
+ 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x44, 0x61, 0x74, 0x61, 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_epoch_group_data_proto_rawDescOnce sync.Once
+ file_inference_inference_epoch_group_data_proto_rawDescData = file_inference_inference_epoch_group_data_proto_rawDesc
+)
+
+func file_inference_inference_epoch_group_data_proto_rawDescGZIP() []byte {
+ file_inference_inference_epoch_group_data_proto_rawDescOnce.Do(func() {
+ file_inference_inference_epoch_group_data_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_inference_epoch_group_data_proto_rawDescData)
+ })
+ return file_inference_inference_epoch_group_data_proto_rawDescData
+}
+
+var file_inference_inference_epoch_group_data_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
+var file_inference_inference_epoch_group_data_proto_msgTypes = make([]protoimpl.MessageInfo, 4)
+var file_inference_inference_epoch_group_data_proto_goTypes = []interface{}{
+ (TimeslotType)(0), // 0: inference.inference.TimeslotType
+ (*EpochGroupData)(nil), // 1: inference.inference.EpochGroupData
+ (*ValidationWeight)(nil), // 2: inference.inference.ValidationWeight
+ (*SeedSignature)(nil), // 3: inference.inference.SeedSignature
+ (*MLNodeInfo)(nil), // 4: inference.inference.MLNodeInfo
+ (*ValidationParams)(nil), // 5: inference.inference.ValidationParams
+ (*Model)(nil), // 6: inference.inference.Model
+}
+var file_inference_inference_epoch_group_data_proto_depIdxs = []int32{
+ 3, // 0: inference.inference.EpochGroupData.member_seed_signatures:type_name -> inference.inference.SeedSignature
+ 2, // 1: inference.inference.EpochGroupData.validation_weights:type_name -> inference.inference.ValidationWeight
+ 5, // 2: inference.inference.EpochGroupData.validation_params:type_name -> inference.inference.ValidationParams
+ 6, // 3: inference.inference.EpochGroupData.model_snapshot:type_name -> inference.inference.Model
+ 4, // 4: inference.inference.ValidationWeight.ml_nodes:type_name -> inference.inference.MLNodeInfo
+ 5, // [5:5] is the sub-list for method output_type
+ 5, // [5:5] is the sub-list for method input_type
+ 5, // [5:5] is the sub-list for extension type_name
+ 5, // [5:5] is the sub-list for extension extendee
+ 0, // [0:5] is the sub-list for field type_name
+}
+
+func init() { file_inference_inference_epoch_group_data_proto_init() }
+func file_inference_inference_epoch_group_data_proto_init() {
+ if File_inference_inference_epoch_group_data_proto != nil {
+ return
+ }
+ file_inference_inference_participant_proto_init()
+ file_inference_inference_params_proto_init()
+ file_inference_inference_model_proto_init()
+ if !protoimpl.UnsafeEnabled {
+ file_inference_inference_epoch_group_data_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*EpochGroupData); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_inference_epoch_group_data_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*ValidationWeight); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_inference_epoch_group_data_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*SeedSignature); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_inference_epoch_group_data_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*MLNodeInfo); 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_epoch_group_data_proto_rawDesc,
+ NumEnums: 1,
+ NumMessages: 4,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_inference_epoch_group_data_proto_goTypes,
+ DependencyIndexes: file_inference_inference_epoch_group_data_proto_depIdxs,
+ EnumInfos: file_inference_inference_epoch_group_data_proto_enumTypes,
+ MessageInfos: file_inference_inference_epoch_group_data_proto_msgTypes,
+ }.Build()
+ File_inference_inference_epoch_group_data_proto = out.File
+ file_inference_inference_epoch_group_data_proto_rawDesc = nil
+ file_inference_inference_epoch_group_data_proto_goTypes = nil
+ file_inference_inference_epoch_group_data_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/inference/epoch_group_datav1.pulsar.go b/inference-chain/api/inference/inference/epoch_group_datav1.pulsar.go
new file mode 100644
index 000000000..f70cc3e38
--- /dev/null
+++ b/inference-chain/api/inference/inference/epoch_group_datav1.pulsar.go
@@ -0,0 +1,1453 @@
+// 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 _ protoreflect.List = (*_EpochGroupDataV1_6_list)(nil)
+
+type _EpochGroupDataV1_6_list struct {
+ list *[]*SeedSignature
+}
+
+func (x *_EpochGroupDataV1_6_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_EpochGroupDataV1_6_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_EpochGroupDataV1_6_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*SeedSignature)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_EpochGroupDataV1_6_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*SeedSignature)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_EpochGroupDataV1_6_list) AppendMutable() protoreflect.Value {
+ v := new(SeedSignature)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_EpochGroupDataV1_6_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_EpochGroupDataV1_6_list) NewElement() protoreflect.Value {
+ v := new(SeedSignature)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_EpochGroupDataV1_6_list) IsValid() bool {
+ return x.list != nil
+}
+
+var _ protoreflect.List = (*_EpochGroupDataV1_8_list)(nil)
+
+type _EpochGroupDataV1_8_list struct {
+ list *[]*ValidationWeight
+}
+
+func (x *_EpochGroupDataV1_8_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_EpochGroupDataV1_8_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_EpochGroupDataV1_8_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*ValidationWeight)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_EpochGroupDataV1_8_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*ValidationWeight)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_EpochGroupDataV1_8_list) AppendMutable() protoreflect.Value {
+ v := new(ValidationWeight)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_EpochGroupDataV1_8_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_EpochGroupDataV1_8_list) NewElement() protoreflect.Value {
+ v := new(ValidationWeight)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_EpochGroupDataV1_8_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_EpochGroupDataV1 protoreflect.MessageDescriptor
+ fd_EpochGroupDataV1_poc_start_block_height protoreflect.FieldDescriptor
+ fd_EpochGroupDataV1_epoch_group_id protoreflect.FieldDescriptor
+ fd_EpochGroupDataV1_epoch_policy protoreflect.FieldDescriptor
+ fd_EpochGroupDataV1_effective_block_height protoreflect.FieldDescriptor
+ fd_EpochGroupDataV1_last_block_height protoreflect.FieldDescriptor
+ fd_EpochGroupDataV1_member_seed_signatures protoreflect.FieldDescriptor
+ fd_EpochGroupDataV1_validation_weights protoreflect.FieldDescriptor
+ fd_EpochGroupDataV1_unit_of_compute_price protoreflect.FieldDescriptor
+ fd_EpochGroupDataV1_number_of_requests protoreflect.FieldDescriptor
+ fd_EpochGroupDataV1_previous_epoch_requests protoreflect.FieldDescriptor
+ fd_EpochGroupDataV1_validation_params protoreflect.FieldDescriptor
+ fd_EpochGroupDataV1_total_weight protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_epoch_group_datav1_proto_init()
+ md_EpochGroupDataV1 = File_inference_inference_epoch_group_datav1_proto.Messages().ByName("EpochGroupDataV1")
+ fd_EpochGroupDataV1_poc_start_block_height = md_EpochGroupDataV1.Fields().ByName("poc_start_block_height")
+ fd_EpochGroupDataV1_epoch_group_id = md_EpochGroupDataV1.Fields().ByName("epoch_group_id")
+ fd_EpochGroupDataV1_epoch_policy = md_EpochGroupDataV1.Fields().ByName("epoch_policy")
+ fd_EpochGroupDataV1_effective_block_height = md_EpochGroupDataV1.Fields().ByName("effective_block_height")
+ fd_EpochGroupDataV1_last_block_height = md_EpochGroupDataV1.Fields().ByName("last_block_height")
+ fd_EpochGroupDataV1_member_seed_signatures = md_EpochGroupDataV1.Fields().ByName("member_seed_signatures")
+ fd_EpochGroupDataV1_validation_weights = md_EpochGroupDataV1.Fields().ByName("validation_weights")
+ fd_EpochGroupDataV1_unit_of_compute_price = md_EpochGroupDataV1.Fields().ByName("unit_of_compute_price")
+ fd_EpochGroupDataV1_number_of_requests = md_EpochGroupDataV1.Fields().ByName("number_of_requests")
+ fd_EpochGroupDataV1_previous_epoch_requests = md_EpochGroupDataV1.Fields().ByName("previous_epoch_requests")
+ fd_EpochGroupDataV1_validation_params = md_EpochGroupDataV1.Fields().ByName("validation_params")
+ fd_EpochGroupDataV1_total_weight = md_EpochGroupDataV1.Fields().ByName("total_weight")
+}
+
+var _ protoreflect.Message = (*fastReflection_EpochGroupDataV1)(nil)
+
+type fastReflection_EpochGroupDataV1 EpochGroupDataV1
+
+func (x *EpochGroupDataV1) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_EpochGroupDataV1)(x)
+}
+
+func (x *EpochGroupDataV1) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_epoch_group_datav1_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_EpochGroupDataV1_messageType fastReflection_EpochGroupDataV1_messageType
+var _ protoreflect.MessageType = fastReflection_EpochGroupDataV1_messageType{}
+
+type fastReflection_EpochGroupDataV1_messageType struct{}
+
+func (x fastReflection_EpochGroupDataV1_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_EpochGroupDataV1)(nil)
+}
+func (x fastReflection_EpochGroupDataV1_messageType) New() protoreflect.Message {
+ return new(fastReflection_EpochGroupDataV1)
+}
+func (x fastReflection_EpochGroupDataV1_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_EpochGroupDataV1
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_EpochGroupDataV1) Descriptor() protoreflect.MessageDescriptor {
+ return md_EpochGroupDataV1
+}
+
+// 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_EpochGroupDataV1) Type() protoreflect.MessageType {
+ return _fastReflection_EpochGroupDataV1_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_EpochGroupDataV1) New() protoreflect.Message {
+ return new(fastReflection_EpochGroupDataV1)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_EpochGroupDataV1) Interface() protoreflect.ProtoMessage {
+ return (*EpochGroupDataV1)(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_EpochGroupDataV1) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.PocStartBlockHeight != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.PocStartBlockHeight)
+ if !f(fd_EpochGroupDataV1_poc_start_block_height, value) {
+ return
+ }
+ }
+ if x.EpochGroupId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.EpochGroupId)
+ if !f(fd_EpochGroupDataV1_epoch_group_id, value) {
+ return
+ }
+ }
+ if x.EpochPolicy != "" {
+ value := protoreflect.ValueOfString(x.EpochPolicy)
+ if !f(fd_EpochGroupDataV1_epoch_policy, value) {
+ return
+ }
+ }
+ if x.EffectiveBlockHeight != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.EffectiveBlockHeight)
+ if !f(fd_EpochGroupDataV1_effective_block_height, value) {
+ return
+ }
+ }
+ if x.LastBlockHeight != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.LastBlockHeight)
+ if !f(fd_EpochGroupDataV1_last_block_height, value) {
+ return
+ }
+ }
+ if len(x.MemberSeedSignatures) != 0 {
+ value := protoreflect.ValueOfList(&_EpochGroupDataV1_6_list{list: &x.MemberSeedSignatures})
+ if !f(fd_EpochGroupDataV1_member_seed_signatures, value) {
+ return
+ }
+ }
+ if len(x.ValidationWeights) != 0 {
+ value := protoreflect.ValueOfList(&_EpochGroupDataV1_8_list{list: &x.ValidationWeights})
+ if !f(fd_EpochGroupDataV1_validation_weights, value) {
+ return
+ }
+ }
+ if x.UnitOfComputePrice != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.UnitOfComputePrice)
+ if !f(fd_EpochGroupDataV1_unit_of_compute_price, value) {
+ return
+ }
+ }
+ if x.NumberOfRequests != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.NumberOfRequests)
+ if !f(fd_EpochGroupDataV1_number_of_requests, value) {
+ return
+ }
+ }
+ if x.PreviousEpochRequests != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.PreviousEpochRequests)
+ if !f(fd_EpochGroupDataV1_previous_epoch_requests, value) {
+ return
+ }
+ }
+ if x.ValidationParams != nil {
+ value := protoreflect.ValueOfMessage(x.ValidationParams.ProtoReflect())
+ if !f(fd_EpochGroupDataV1_validation_params, value) {
+ return
+ }
+ }
+ if x.TotalWeight != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.TotalWeight)
+ if !f(fd_EpochGroupDataV1_total_weight, 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_EpochGroupDataV1) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.EpochGroupDataV1.poc_start_block_height":
+ return x.PocStartBlockHeight != uint64(0)
+ case "inference.inference.EpochGroupDataV1.epoch_group_id":
+ return x.EpochGroupId != uint64(0)
+ case "inference.inference.EpochGroupDataV1.epoch_policy":
+ return x.EpochPolicy != ""
+ case "inference.inference.EpochGroupDataV1.effective_block_height":
+ return x.EffectiveBlockHeight != uint64(0)
+ case "inference.inference.EpochGroupDataV1.last_block_height":
+ return x.LastBlockHeight != uint64(0)
+ case "inference.inference.EpochGroupDataV1.member_seed_signatures":
+ return len(x.MemberSeedSignatures) != 0
+ case "inference.inference.EpochGroupDataV1.validation_weights":
+ return len(x.ValidationWeights) != 0
+ case "inference.inference.EpochGroupDataV1.unit_of_compute_price":
+ return x.UnitOfComputePrice != uint64(0)
+ case "inference.inference.EpochGroupDataV1.number_of_requests":
+ return x.NumberOfRequests != uint64(0)
+ case "inference.inference.EpochGroupDataV1.previous_epoch_requests":
+ return x.PreviousEpochRequests != uint64(0)
+ case "inference.inference.EpochGroupDataV1.validation_params":
+ return x.ValidationParams != nil
+ case "inference.inference.EpochGroupDataV1.total_weight":
+ return x.TotalWeight != uint64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.EpochGroupDataV1"))
+ }
+ panic(fmt.Errorf("message inference.inference.EpochGroupDataV1 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_EpochGroupDataV1) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.EpochGroupDataV1.poc_start_block_height":
+ x.PocStartBlockHeight = uint64(0)
+ case "inference.inference.EpochGroupDataV1.epoch_group_id":
+ x.EpochGroupId = uint64(0)
+ case "inference.inference.EpochGroupDataV1.epoch_policy":
+ x.EpochPolicy = ""
+ case "inference.inference.EpochGroupDataV1.effective_block_height":
+ x.EffectiveBlockHeight = uint64(0)
+ case "inference.inference.EpochGroupDataV1.last_block_height":
+ x.LastBlockHeight = uint64(0)
+ case "inference.inference.EpochGroupDataV1.member_seed_signatures":
+ x.MemberSeedSignatures = nil
+ case "inference.inference.EpochGroupDataV1.validation_weights":
+ x.ValidationWeights = nil
+ case "inference.inference.EpochGroupDataV1.unit_of_compute_price":
+ x.UnitOfComputePrice = uint64(0)
+ case "inference.inference.EpochGroupDataV1.number_of_requests":
+ x.NumberOfRequests = uint64(0)
+ case "inference.inference.EpochGroupDataV1.previous_epoch_requests":
+ x.PreviousEpochRequests = uint64(0)
+ case "inference.inference.EpochGroupDataV1.validation_params":
+ x.ValidationParams = nil
+ case "inference.inference.EpochGroupDataV1.total_weight":
+ x.TotalWeight = uint64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.EpochGroupDataV1"))
+ }
+ panic(fmt.Errorf("message inference.inference.EpochGroupDataV1 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_EpochGroupDataV1) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.EpochGroupDataV1.poc_start_block_height":
+ value := x.PocStartBlockHeight
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.EpochGroupDataV1.epoch_group_id":
+ value := x.EpochGroupId
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.EpochGroupDataV1.epoch_policy":
+ value := x.EpochPolicy
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.EpochGroupDataV1.effective_block_height":
+ value := x.EffectiveBlockHeight
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.EpochGroupDataV1.last_block_height":
+ value := x.LastBlockHeight
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.EpochGroupDataV1.member_seed_signatures":
+ if len(x.MemberSeedSignatures) == 0 {
+ return protoreflect.ValueOfList(&_EpochGroupDataV1_6_list{})
+ }
+ listValue := &_EpochGroupDataV1_6_list{list: &x.MemberSeedSignatures}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.inference.EpochGroupDataV1.validation_weights":
+ if len(x.ValidationWeights) == 0 {
+ return protoreflect.ValueOfList(&_EpochGroupDataV1_8_list{})
+ }
+ listValue := &_EpochGroupDataV1_8_list{list: &x.ValidationWeights}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.inference.EpochGroupDataV1.unit_of_compute_price":
+ value := x.UnitOfComputePrice
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.EpochGroupDataV1.number_of_requests":
+ value := x.NumberOfRequests
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.EpochGroupDataV1.previous_epoch_requests":
+ value := x.PreviousEpochRequests
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.EpochGroupDataV1.validation_params":
+ value := x.ValidationParams
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.EpochGroupDataV1.total_weight":
+ value := x.TotalWeight
+ return protoreflect.ValueOfUint64(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.EpochGroupDataV1"))
+ }
+ panic(fmt.Errorf("message inference.inference.EpochGroupDataV1 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_EpochGroupDataV1) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.EpochGroupDataV1.poc_start_block_height":
+ x.PocStartBlockHeight = value.Uint()
+ case "inference.inference.EpochGroupDataV1.epoch_group_id":
+ x.EpochGroupId = value.Uint()
+ case "inference.inference.EpochGroupDataV1.epoch_policy":
+ x.EpochPolicy = value.Interface().(string)
+ case "inference.inference.EpochGroupDataV1.effective_block_height":
+ x.EffectiveBlockHeight = value.Uint()
+ case "inference.inference.EpochGroupDataV1.last_block_height":
+ x.LastBlockHeight = value.Uint()
+ case "inference.inference.EpochGroupDataV1.member_seed_signatures":
+ lv := value.List()
+ clv := lv.(*_EpochGroupDataV1_6_list)
+ x.MemberSeedSignatures = *clv.list
+ case "inference.inference.EpochGroupDataV1.validation_weights":
+ lv := value.List()
+ clv := lv.(*_EpochGroupDataV1_8_list)
+ x.ValidationWeights = *clv.list
+ case "inference.inference.EpochGroupDataV1.unit_of_compute_price":
+ x.UnitOfComputePrice = value.Uint()
+ case "inference.inference.EpochGroupDataV1.number_of_requests":
+ x.NumberOfRequests = value.Uint()
+ case "inference.inference.EpochGroupDataV1.previous_epoch_requests":
+ x.PreviousEpochRequests = value.Uint()
+ case "inference.inference.EpochGroupDataV1.validation_params":
+ x.ValidationParams = value.Message().Interface().(*ValidationParamsV1)
+ case "inference.inference.EpochGroupDataV1.total_weight":
+ x.TotalWeight = value.Uint()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.EpochGroupDataV1"))
+ }
+ panic(fmt.Errorf("message inference.inference.EpochGroupDataV1 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_EpochGroupDataV1) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.EpochGroupDataV1.member_seed_signatures":
+ if x.MemberSeedSignatures == nil {
+ x.MemberSeedSignatures = []*SeedSignature{}
+ }
+ value := &_EpochGroupDataV1_6_list{list: &x.MemberSeedSignatures}
+ return protoreflect.ValueOfList(value)
+ case "inference.inference.EpochGroupDataV1.validation_weights":
+ if x.ValidationWeights == nil {
+ x.ValidationWeights = []*ValidationWeight{}
+ }
+ value := &_EpochGroupDataV1_8_list{list: &x.ValidationWeights}
+ return protoreflect.ValueOfList(value)
+ case "inference.inference.EpochGroupDataV1.validation_params":
+ if x.ValidationParams == nil {
+ x.ValidationParams = new(ValidationParamsV1)
+ }
+ return protoreflect.ValueOfMessage(x.ValidationParams.ProtoReflect())
+ case "inference.inference.EpochGroupDataV1.poc_start_block_height":
+ panic(fmt.Errorf("field poc_start_block_height of message inference.inference.EpochGroupDataV1 is not mutable"))
+ case "inference.inference.EpochGroupDataV1.epoch_group_id":
+ panic(fmt.Errorf("field epoch_group_id of message inference.inference.EpochGroupDataV1 is not mutable"))
+ case "inference.inference.EpochGroupDataV1.epoch_policy":
+ panic(fmt.Errorf("field epoch_policy of message inference.inference.EpochGroupDataV1 is not mutable"))
+ case "inference.inference.EpochGroupDataV1.effective_block_height":
+ panic(fmt.Errorf("field effective_block_height of message inference.inference.EpochGroupDataV1 is not mutable"))
+ case "inference.inference.EpochGroupDataV1.last_block_height":
+ panic(fmt.Errorf("field last_block_height of message inference.inference.EpochGroupDataV1 is not mutable"))
+ case "inference.inference.EpochGroupDataV1.unit_of_compute_price":
+ panic(fmt.Errorf("field unit_of_compute_price of message inference.inference.EpochGroupDataV1 is not mutable"))
+ case "inference.inference.EpochGroupDataV1.number_of_requests":
+ panic(fmt.Errorf("field number_of_requests of message inference.inference.EpochGroupDataV1 is not mutable"))
+ case "inference.inference.EpochGroupDataV1.previous_epoch_requests":
+ panic(fmt.Errorf("field previous_epoch_requests of message inference.inference.EpochGroupDataV1 is not mutable"))
+ case "inference.inference.EpochGroupDataV1.total_weight":
+ panic(fmt.Errorf("field total_weight of message inference.inference.EpochGroupDataV1 is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.EpochGroupDataV1"))
+ }
+ panic(fmt.Errorf("message inference.inference.EpochGroupDataV1 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_EpochGroupDataV1) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.EpochGroupDataV1.poc_start_block_height":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.EpochGroupDataV1.epoch_group_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.EpochGroupDataV1.epoch_policy":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.EpochGroupDataV1.effective_block_height":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.EpochGroupDataV1.last_block_height":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.EpochGroupDataV1.member_seed_signatures":
+ list := []*SeedSignature{}
+ return protoreflect.ValueOfList(&_EpochGroupDataV1_6_list{list: &list})
+ case "inference.inference.EpochGroupDataV1.validation_weights":
+ list := []*ValidationWeight{}
+ return protoreflect.ValueOfList(&_EpochGroupDataV1_8_list{list: &list})
+ case "inference.inference.EpochGroupDataV1.unit_of_compute_price":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.EpochGroupDataV1.number_of_requests":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.EpochGroupDataV1.previous_epoch_requests":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.EpochGroupDataV1.validation_params":
+ m := new(ValidationParamsV1)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.EpochGroupDataV1.total_weight":
+ return protoreflect.ValueOfUint64(uint64(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.EpochGroupDataV1"))
+ }
+ panic(fmt.Errorf("message inference.inference.EpochGroupDataV1 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_EpochGroupDataV1) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.EpochGroupDataV1", 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_EpochGroupDataV1) 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_EpochGroupDataV1) 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_EpochGroupDataV1) 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_EpochGroupDataV1) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*EpochGroupDataV1)
+ 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.PocStartBlockHeight != 0 {
+ n += 1 + runtime.Sov(uint64(x.PocStartBlockHeight))
+ }
+ if x.EpochGroupId != 0 {
+ n += 1 + runtime.Sov(uint64(x.EpochGroupId))
+ }
+ l = len(x.EpochPolicy)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.EffectiveBlockHeight != 0 {
+ n += 1 + runtime.Sov(uint64(x.EffectiveBlockHeight))
+ }
+ if x.LastBlockHeight != 0 {
+ n += 1 + runtime.Sov(uint64(x.LastBlockHeight))
+ }
+ if len(x.MemberSeedSignatures) > 0 {
+ for _, e := range x.MemberSeedSignatures {
+ l = options.Size(e)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ }
+ if len(x.ValidationWeights) > 0 {
+ for _, e := range x.ValidationWeights {
+ l = options.Size(e)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ }
+ if x.UnitOfComputePrice != 0 {
+ n += 1 + runtime.Sov(uint64(x.UnitOfComputePrice))
+ }
+ if x.NumberOfRequests != 0 {
+ n += 1 + runtime.Sov(uint64(x.NumberOfRequests))
+ }
+ if x.PreviousEpochRequests != 0 {
+ n += 1 + runtime.Sov(uint64(x.PreviousEpochRequests))
+ }
+ if x.ValidationParams != nil {
+ l = options.Size(x.ValidationParams)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.TotalWeight != 0 {
+ n += 1 + runtime.Sov(uint64(x.TotalWeight))
+ }
+ 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().(*EpochGroupDataV1)
+ 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.TotalWeight != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.TotalWeight))
+ i--
+ dAtA[i] = 0x68
+ }
+ if x.ValidationParams != nil {
+ encoded, err := options.Marshal(x.ValidationParams)
+ 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] = 0x62
+ }
+ if x.PreviousEpochRequests != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.PreviousEpochRequests))
+ i--
+ dAtA[i] = 0x58
+ }
+ if x.NumberOfRequests != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.NumberOfRequests))
+ i--
+ dAtA[i] = 0x50
+ }
+ if x.UnitOfComputePrice != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.UnitOfComputePrice))
+ i--
+ dAtA[i] = 0x48
+ }
+ if len(x.ValidationWeights) > 0 {
+ for iNdEx := len(x.ValidationWeights) - 1; iNdEx >= 0; iNdEx-- {
+ encoded, err := options.Marshal(x.ValidationWeights[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] = 0x42
+ }
+ }
+ if len(x.MemberSeedSignatures) > 0 {
+ for iNdEx := len(x.MemberSeedSignatures) - 1; iNdEx >= 0; iNdEx-- {
+ encoded, err := options.Marshal(x.MemberSeedSignatures[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 x.LastBlockHeight != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.LastBlockHeight))
+ i--
+ dAtA[i] = 0x28
+ }
+ if x.EffectiveBlockHeight != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.EffectiveBlockHeight))
+ i--
+ dAtA[i] = 0x20
+ }
+ if len(x.EpochPolicy) > 0 {
+ i -= len(x.EpochPolicy)
+ copy(dAtA[i:], x.EpochPolicy)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.EpochPolicy)))
+ i--
+ dAtA[i] = 0x1a
+ }
+ if x.EpochGroupId != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochGroupId))
+ i--
+ dAtA[i] = 0x10
+ }
+ if x.PocStartBlockHeight != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.PocStartBlockHeight))
+ 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().(*EpochGroupDataV1)
+ 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: EpochGroupDataV1: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: EpochGroupDataV1: 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 PocStartBlockHeight", wireType)
+ }
+ x.PocStartBlockHeight = 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.PocStartBlockHeight |= 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 EpochGroupId", wireType)
+ }
+ x.EpochGroupId = 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.EpochGroupId |= 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 EpochPolicy", 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.EpochPolicy = 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 EffectiveBlockHeight", wireType)
+ }
+ x.EffectiveBlockHeight = 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.EffectiveBlockHeight |= 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 LastBlockHeight", wireType)
+ }
+ x.LastBlockHeight = 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.LastBlockHeight |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 6:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MemberSeedSignatures", 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.MemberSeedSignatures = append(x.MemberSeedSignatures, &SeedSignature{})
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.MemberSeedSignatures[len(x.MemberSeedSignatures)-1]); err != nil {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+ }
+ iNdEx = postIndex
+ case 8:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidationWeights", 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.ValidationWeights = append(x.ValidationWeights, &ValidationWeight{})
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ValidationWeights[len(x.ValidationWeights)-1]); err != nil {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+ }
+ iNdEx = postIndex
+ case 9:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field UnitOfComputePrice", wireType)
+ }
+ x.UnitOfComputePrice = 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.UnitOfComputePrice |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 10:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field NumberOfRequests", wireType)
+ }
+ x.NumberOfRequests = 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.NumberOfRequests |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 11:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PreviousEpochRequests", wireType)
+ }
+ x.PreviousEpochRequests = 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.PreviousEpochRequests |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 12:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidationParams", 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.ValidationParams == nil {
+ x.ValidationParams = &ValidationParamsV1{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ValidationParams); err != nil {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+ }
+ iNdEx = postIndex
+ case 13:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TotalWeight", wireType)
+ }
+ x.TotalWeight = 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.TotalWeight |= 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,
+ }
+}
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// protoc-gen-go v1.27.0
+// protoc (unknown)
+// source: inference/inference/epoch_group_datav1.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)
+)
+
+type EpochGroupDataV1 struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ PocStartBlockHeight uint64 `protobuf:"varint,1,opt,name=poc_start_block_height,json=pocStartBlockHeight,proto3" json:"poc_start_block_height,omitempty"`
+ EpochGroupId uint64 `protobuf:"varint,2,opt,name=epoch_group_id,json=epochGroupId,proto3" json:"epoch_group_id,omitempty"`
+ EpochPolicy string `protobuf:"bytes,3,opt,name=epoch_policy,json=epochPolicy,proto3" json:"epoch_policy,omitempty"`
+ EffectiveBlockHeight uint64 `protobuf:"varint,4,opt,name=effective_block_height,json=effectiveBlockHeight,proto3" json:"effective_block_height,omitempty"`
+ LastBlockHeight uint64 `protobuf:"varint,5,opt,name=last_block_height,json=lastBlockHeight,proto3" json:"last_block_height,omitempty"`
+ MemberSeedSignatures []*SeedSignature `protobuf:"bytes,6,rep,name=member_seed_signatures,json=memberSeedSignatures,proto3" json:"member_seed_signatures,omitempty"`
+ ValidationWeights []*ValidationWeight `protobuf:"bytes,8,rep,name=validation_weights,json=validationWeights,proto3" json:"validation_weights,omitempty"`
+ UnitOfComputePrice uint64 `protobuf:"varint,9,opt,name=unit_of_compute_price,json=unitOfComputePrice,proto3" json:"unit_of_compute_price,omitempty"`
+ NumberOfRequests uint64 `protobuf:"varint,10,opt,name=number_of_requests,json=numberOfRequests,proto3" json:"number_of_requests,omitempty"`
+ PreviousEpochRequests uint64 `protobuf:"varint,11,opt,name=previous_epoch_requests,json=previousEpochRequests,proto3" json:"previous_epoch_requests,omitempty"`
+ ValidationParams *ValidationParamsV1 `protobuf:"bytes,12,opt,name=validation_params,json=validationParams,proto3" json:"validation_params,omitempty"`
+ TotalWeight uint64 `protobuf:"varint,13,opt,name=total_weight,json=totalWeight,proto3" json:"total_weight,omitempty"`
+}
+
+func (x *EpochGroupDataV1) Reset() {
+ *x = EpochGroupDataV1{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_epoch_group_datav1_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *EpochGroupDataV1) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*EpochGroupDataV1) ProtoMessage() {}
+
+// Deprecated: Use EpochGroupDataV1.ProtoReflect.Descriptor instead.
+func (*EpochGroupDataV1) Descriptor() ([]byte, []int) {
+ return file_inference_inference_epoch_group_datav1_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *EpochGroupDataV1) GetPocStartBlockHeight() uint64 {
+ if x != nil {
+ return x.PocStartBlockHeight
+ }
+ return 0
+}
+
+func (x *EpochGroupDataV1) GetEpochGroupId() uint64 {
+ if x != nil {
+ return x.EpochGroupId
+ }
+ return 0
+}
+
+func (x *EpochGroupDataV1) GetEpochPolicy() string {
+ if x != nil {
+ return x.EpochPolicy
+ }
+ return ""
+}
+
+func (x *EpochGroupDataV1) GetEffectiveBlockHeight() uint64 {
+ if x != nil {
+ return x.EffectiveBlockHeight
+ }
+ return 0
+}
+
+func (x *EpochGroupDataV1) GetLastBlockHeight() uint64 {
+ if x != nil {
+ return x.LastBlockHeight
+ }
+ return 0
+}
+
+func (x *EpochGroupDataV1) GetMemberSeedSignatures() []*SeedSignature {
+ if x != nil {
+ return x.MemberSeedSignatures
+ }
+ return nil
+}
+
+func (x *EpochGroupDataV1) GetValidationWeights() []*ValidationWeight {
+ if x != nil {
+ return x.ValidationWeights
+ }
+ return nil
+}
+
+func (x *EpochGroupDataV1) GetUnitOfComputePrice() uint64 {
+ if x != nil {
+ return x.UnitOfComputePrice
+ }
+ return 0
+}
+
+func (x *EpochGroupDataV1) GetNumberOfRequests() uint64 {
+ if x != nil {
+ return x.NumberOfRequests
+ }
+ return 0
+}
+
+func (x *EpochGroupDataV1) GetPreviousEpochRequests() uint64 {
+ if x != nil {
+ return x.PreviousEpochRequests
+ }
+ return 0
+}
+
+func (x *EpochGroupDataV1) GetValidationParams() *ValidationParamsV1 {
+ if x != nil {
+ return x.ValidationParams
+ }
+ return nil
+}
+
+func (x *EpochGroupDataV1) GetTotalWeight() uint64 {
+ if x != nil {
+ return x.TotalWeight
+ }
+ return 0
+}
+
+var File_inference_inference_epoch_group_datav1_proto protoreflect.FileDescriptor
+
+var file_inference_inference_epoch_group_datav1_proto_rawDesc = []byte{
+ 0x0a, 0x2c, 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, 0x76, 0x31, 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, 0x1a, 0x25, 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, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x22, 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, 0x76, 0x31, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x2a,
+ 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, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xb4, 0x05, 0x0a, 0x10, 0x45,
+ 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x44, 0x61, 0x74, 0x61, 0x56, 0x31, 0x12,
+ 0x33, 0x0a, 0x16, 0x70, 0x6f, 0x63, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x62, 0x6c, 0x6f,
+ 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52,
+ 0x13, 0x70, 0x6f, 0x63, 0x53, 0x74, 0x61, 0x72, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65,
+ 0x69, 0x67, 0x68, 0x74, 0x12, 0x24, 0x0a, 0x0e, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x67, 0x72,
+ 0x6f, 0x75, 0x70, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0c, 0x65, 0x70,
+ 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x65, 0x70,
+ 0x6f, 0x63, 0x68, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09,
+ 0x52, 0x0b, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x34, 0x0a,
+ 0x16, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b,
+ 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x14, 0x65,
+ 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69,
+ 0x67, 0x68, 0x74, 0x12, 0x2a, 0x0a, 0x11, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63,
+ 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0f,
+ 0x6c, 0x61, 0x73, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12,
+ 0x58, 0x0a, 0x16, 0x6d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x5f, 0x73, 0x65, 0x65, 0x64, 0x5f, 0x73,
+ 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x18, 0x06, 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, 0x53, 0x65, 0x65, 0x64, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74,
+ 0x75, 0x72, 0x65, 0x52, 0x14, 0x6d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x53, 0x65, 0x65, 0x64, 0x53,
+ 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x12, 0x54, 0x0a, 0x12, 0x76, 0x61, 0x6c,
+ 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x73, 0x18,
+ 0x08, 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, 0x56, 0x61, 0x6c, 0x69,
+ 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x52, 0x11, 0x76, 0x61,
+ 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x73, 0x12,
+ 0x31, 0x0a, 0x15, 0x75, 0x6e, 0x69, 0x74, 0x5f, 0x6f, 0x66, 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x75,
+ 0x74, 0x65, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x04, 0x52, 0x12,
+ 0x75, 0x6e, 0x69, 0x74, 0x4f, 0x66, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x50, 0x72, 0x69,
+ 0x63, 0x65, 0x12, 0x2c, 0x0a, 0x12, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x5f, 0x6f, 0x66, 0x5f,
+ 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x04, 0x52, 0x10,
+ 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x4f, 0x66, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73,
+ 0x12, 0x36, 0x0a, 0x17, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x5f, 0x65, 0x70, 0x6f,
+ 0x63, 0x68, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x18, 0x0b, 0x20, 0x01, 0x28,
+ 0x04, 0x52, 0x15, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x45, 0x70, 0x6f, 0x63, 0x68,
+ 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x12, 0x54, 0x0a, 0x11, 0x76, 0x61, 0x6c, 0x69,
+ 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x0c, 0x20,
+ 0x01, 0x28, 0x0b, 0x32, 0x27, 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, 0x56, 0x31, 0x52, 0x10, 0x76, 0x61,
+ 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x21,
+ 0x0a, 0x0c, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x0d,
+ 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x57, 0x65, 0x69, 0x67, 0x68,
+ 0x74, 0x42, 0xc3, 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, 0x15, 0x45,
+ 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x44, 0x61, 0x74, 0x61, 0x76, 0x31, 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_epoch_group_datav1_proto_rawDescOnce sync.Once
+ file_inference_inference_epoch_group_datav1_proto_rawDescData = file_inference_inference_epoch_group_datav1_proto_rawDesc
+)
+
+func file_inference_inference_epoch_group_datav1_proto_rawDescGZIP() []byte {
+ file_inference_inference_epoch_group_datav1_proto_rawDescOnce.Do(func() {
+ file_inference_inference_epoch_group_datav1_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_inference_epoch_group_datav1_proto_rawDescData)
+ })
+ return file_inference_inference_epoch_group_datav1_proto_rawDescData
+}
+
+var file_inference_inference_epoch_group_datav1_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_inference_inference_epoch_group_datav1_proto_goTypes = []interface{}{
+ (*EpochGroupDataV1)(nil), // 0: inference.inference.EpochGroupDataV1
+ (*SeedSignature)(nil), // 1: inference.inference.SeedSignature
+ (*ValidationWeight)(nil), // 2: inference.inference.ValidationWeight
+ (*ValidationParamsV1)(nil), // 3: inference.inference.ValidationParamsV1
+}
+var file_inference_inference_epoch_group_datav1_proto_depIdxs = []int32{
+ 1, // 0: inference.inference.EpochGroupDataV1.member_seed_signatures:type_name -> inference.inference.SeedSignature
+ 2, // 1: inference.inference.EpochGroupDataV1.validation_weights:type_name -> inference.inference.ValidationWeight
+ 3, // 2: inference.inference.EpochGroupDataV1.validation_params:type_name -> inference.inference.ValidationParamsV1
+ 3, // [3:3] is the sub-list for method output_type
+ 3, // [3:3] is the sub-list for method input_type
+ 3, // [3:3] is the sub-list for extension type_name
+ 3, // [3:3] is the sub-list for extension extendee
+ 0, // [0:3] is the sub-list for field type_name
+}
+
+func init() { file_inference_inference_epoch_group_datav1_proto_init() }
+func file_inference_inference_epoch_group_datav1_proto_init() {
+ if File_inference_inference_epoch_group_datav1_proto != nil {
+ return
+ }
+ file_inference_inference_participant_proto_init()
+ file_inference_inference_paramsv1_proto_init()
+ file_inference_inference_epoch_group_data_proto_init()
+ if !protoimpl.UnsafeEnabled {
+ file_inference_inference_epoch_group_datav1_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*EpochGroupDataV1); 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_epoch_group_datav1_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 1,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_inference_epoch_group_datav1_proto_goTypes,
+ DependencyIndexes: file_inference_inference_epoch_group_datav1_proto_depIdxs,
+ MessageInfos: file_inference_inference_epoch_group_datav1_proto_msgTypes,
+ }.Build()
+ File_inference_inference_epoch_group_datav1_proto = out.File
+ file_inference_inference_epoch_group_datav1_proto_rawDesc = nil
+ file_inference_inference_epoch_group_datav1_proto_goTypes = nil
+ file_inference_inference_epoch_group_datav1_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/inference/epoch_group_validations.pulsar.go b/inference-chain/api/inference/inference/epoch_group_validations.pulsar.go
new file mode 100644
index 000000000..3f2ebbe52
--- /dev/null
+++ b/inference-chain/api/inference/inference/epoch_group_validations.pulsar.go
@@ -0,0 +1,764 @@
+// 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 _ protoreflect.List = (*_EpochGroupValidations_3_list)(nil)
+
+type _EpochGroupValidations_3_list struct {
+ list *[]string
+}
+
+func (x *_EpochGroupValidations_3_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_EpochGroupValidations_3_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfString((*x.list)[i])
+}
+
+func (x *_EpochGroupValidations_3_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.String()
+ concreteValue := valueUnwrapped
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_EpochGroupValidations_3_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.String()
+ concreteValue := valueUnwrapped
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_EpochGroupValidations_3_list) AppendMutable() protoreflect.Value {
+ panic(fmt.Errorf("AppendMutable can not be called on message EpochGroupValidations at list field ValidatedInferences as it is not of Message kind"))
+}
+
+func (x *_EpochGroupValidations_3_list) Truncate(n int) {
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_EpochGroupValidations_3_list) NewElement() protoreflect.Value {
+ v := ""
+ return protoreflect.ValueOfString(v)
+}
+
+func (x *_EpochGroupValidations_3_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_EpochGroupValidations protoreflect.MessageDescriptor
+ fd_EpochGroupValidations_participant protoreflect.FieldDescriptor
+ fd_EpochGroupValidations_epoch_index protoreflect.FieldDescriptor
+ fd_EpochGroupValidations_validated_inferences protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_epoch_group_validations_proto_init()
+ md_EpochGroupValidations = File_inference_inference_epoch_group_validations_proto.Messages().ByName("EpochGroupValidations")
+ fd_EpochGroupValidations_participant = md_EpochGroupValidations.Fields().ByName("participant")
+ fd_EpochGroupValidations_epoch_index = md_EpochGroupValidations.Fields().ByName("epoch_index")
+ fd_EpochGroupValidations_validated_inferences = md_EpochGroupValidations.Fields().ByName("validated_inferences")
+}
+
+var _ protoreflect.Message = (*fastReflection_EpochGroupValidations)(nil)
+
+type fastReflection_EpochGroupValidations EpochGroupValidations
+
+func (x *EpochGroupValidations) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_EpochGroupValidations)(x)
+}
+
+func (x *EpochGroupValidations) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_epoch_group_validations_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_EpochGroupValidations_messageType fastReflection_EpochGroupValidations_messageType
+var _ protoreflect.MessageType = fastReflection_EpochGroupValidations_messageType{}
+
+type fastReflection_EpochGroupValidations_messageType struct{}
+
+func (x fastReflection_EpochGroupValidations_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_EpochGroupValidations)(nil)
+}
+func (x fastReflection_EpochGroupValidations_messageType) New() protoreflect.Message {
+ return new(fastReflection_EpochGroupValidations)
+}
+func (x fastReflection_EpochGroupValidations_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_EpochGroupValidations
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_EpochGroupValidations) Descriptor() protoreflect.MessageDescriptor {
+ return md_EpochGroupValidations
+}
+
+// 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_EpochGroupValidations) Type() protoreflect.MessageType {
+ return _fastReflection_EpochGroupValidations_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_EpochGroupValidations) New() protoreflect.Message {
+ return new(fastReflection_EpochGroupValidations)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_EpochGroupValidations) Interface() protoreflect.ProtoMessage {
+ return (*EpochGroupValidations)(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_EpochGroupValidations) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Participant != "" {
+ value := protoreflect.ValueOfString(x.Participant)
+ if !f(fd_EpochGroupValidations_participant, value) {
+ return
+ }
+ }
+ if x.EpochIndex != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.EpochIndex)
+ if !f(fd_EpochGroupValidations_epoch_index, value) {
+ return
+ }
+ }
+ if len(x.ValidatedInferences) != 0 {
+ value := protoreflect.ValueOfList(&_EpochGroupValidations_3_list{list: &x.ValidatedInferences})
+ if !f(fd_EpochGroupValidations_validated_inferences, 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_EpochGroupValidations) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.EpochGroupValidations.participant":
+ return x.Participant != ""
+ case "inference.inference.EpochGroupValidations.epoch_index":
+ return x.EpochIndex != uint64(0)
+ case "inference.inference.EpochGroupValidations.validated_inferences":
+ return len(x.ValidatedInferences) != 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.EpochGroupValidations"))
+ }
+ panic(fmt.Errorf("message inference.inference.EpochGroupValidations 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_EpochGroupValidations) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.EpochGroupValidations.participant":
+ x.Participant = ""
+ case "inference.inference.EpochGroupValidations.epoch_index":
+ x.EpochIndex = uint64(0)
+ case "inference.inference.EpochGroupValidations.validated_inferences":
+ x.ValidatedInferences = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.EpochGroupValidations"))
+ }
+ panic(fmt.Errorf("message inference.inference.EpochGroupValidations 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_EpochGroupValidations) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.EpochGroupValidations.participant":
+ value := x.Participant
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.EpochGroupValidations.epoch_index":
+ value := x.EpochIndex
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.EpochGroupValidations.validated_inferences":
+ if len(x.ValidatedInferences) == 0 {
+ return protoreflect.ValueOfList(&_EpochGroupValidations_3_list{})
+ }
+ listValue := &_EpochGroupValidations_3_list{list: &x.ValidatedInferences}
+ return protoreflect.ValueOfList(listValue)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.EpochGroupValidations"))
+ }
+ panic(fmt.Errorf("message inference.inference.EpochGroupValidations 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_EpochGroupValidations) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.EpochGroupValidations.participant":
+ x.Participant = value.Interface().(string)
+ case "inference.inference.EpochGroupValidations.epoch_index":
+ x.EpochIndex = value.Uint()
+ case "inference.inference.EpochGroupValidations.validated_inferences":
+ lv := value.List()
+ clv := lv.(*_EpochGroupValidations_3_list)
+ x.ValidatedInferences = *clv.list
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.EpochGroupValidations"))
+ }
+ panic(fmt.Errorf("message inference.inference.EpochGroupValidations 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_EpochGroupValidations) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.EpochGroupValidations.validated_inferences":
+ if x.ValidatedInferences == nil {
+ x.ValidatedInferences = []string{}
+ }
+ value := &_EpochGroupValidations_3_list{list: &x.ValidatedInferences}
+ return protoreflect.ValueOfList(value)
+ case "inference.inference.EpochGroupValidations.participant":
+ panic(fmt.Errorf("field participant of message inference.inference.EpochGroupValidations is not mutable"))
+ case "inference.inference.EpochGroupValidations.epoch_index":
+ panic(fmt.Errorf("field epoch_index of message inference.inference.EpochGroupValidations is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.EpochGroupValidations"))
+ }
+ panic(fmt.Errorf("message inference.inference.EpochGroupValidations 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_EpochGroupValidations) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.EpochGroupValidations.participant":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.EpochGroupValidations.epoch_index":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.EpochGroupValidations.validated_inferences":
+ list := []string{}
+ return protoreflect.ValueOfList(&_EpochGroupValidations_3_list{list: &list})
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.EpochGroupValidations"))
+ }
+ panic(fmt.Errorf("message inference.inference.EpochGroupValidations 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_EpochGroupValidations) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.EpochGroupValidations", 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_EpochGroupValidations) 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_EpochGroupValidations) 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_EpochGroupValidations) 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_EpochGroupValidations) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*EpochGroupValidations)
+ 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.EpochIndex != 0 {
+ n += 1 + runtime.Sov(uint64(x.EpochIndex))
+ }
+ if len(x.ValidatedInferences) > 0 {
+ for _, s := range x.ValidatedInferences {
+ 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().(*EpochGroupValidations)
+ 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.ValidatedInferences) > 0 {
+ for iNdEx := len(x.ValidatedInferences) - 1; iNdEx >= 0; iNdEx-- {
+ i -= len(x.ValidatedInferences[iNdEx])
+ copy(dAtA[i:], x.ValidatedInferences[iNdEx])
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ValidatedInferences[iNdEx])))
+ i--
+ dAtA[i] = 0x1a
+ }
+ }
+ 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
+ }
+ 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().(*EpochGroupValidations)
+ 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: EpochGroupValidations: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: EpochGroupValidations: 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 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 ValidatedInferences", 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.ValidatedInferences = append(x.ValidatedInferences, 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/epoch_group_validations.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)
+)
+
+type EpochGroupValidations 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"`
+ ValidatedInferences []string `protobuf:"bytes,3,rep,name=validated_inferences,json=validatedInferences,proto3" json:"validated_inferences,omitempty"`
+}
+
+func (x *EpochGroupValidations) Reset() {
+ *x = EpochGroupValidations{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_epoch_group_validations_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *EpochGroupValidations) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*EpochGroupValidations) ProtoMessage() {}
+
+// Deprecated: Use EpochGroupValidations.ProtoReflect.Descriptor instead.
+func (*EpochGroupValidations) Descriptor() ([]byte, []int) {
+ return file_inference_inference_epoch_group_validations_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *EpochGroupValidations) GetParticipant() string {
+ if x != nil {
+ return x.Participant
+ }
+ return ""
+}
+
+func (x *EpochGroupValidations) GetEpochIndex() uint64 {
+ if x != nil {
+ return x.EpochIndex
+ }
+ return 0
+}
+
+func (x *EpochGroupValidations) GetValidatedInferences() []string {
+ if x != nil {
+ return x.ValidatedInferences
+ }
+ return nil
+}
+
+var File_inference_inference_epoch_group_validations_proto protoreflect.FileDescriptor
+
+var file_inference_inference_epoch_group_validations_proto_rawDesc = []byte{
+ 0x0a, 0x31, 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, 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, 0x8d, 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, 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, 0x31, 0x0a, 0x14, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
+ 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x18, 0x03, 0x20,
+ 0x03, 0x28, 0x09, 0x52, 0x13, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x64, 0x49, 0x6e,
+ 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x42, 0xc8, 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, 0x1a, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70,
+ 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 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 (
+ file_inference_inference_epoch_group_validations_proto_rawDescOnce sync.Once
+ file_inference_inference_epoch_group_validations_proto_rawDescData = file_inference_inference_epoch_group_validations_proto_rawDesc
+)
+
+func file_inference_inference_epoch_group_validations_proto_rawDescGZIP() []byte {
+ file_inference_inference_epoch_group_validations_proto_rawDescOnce.Do(func() {
+ file_inference_inference_epoch_group_validations_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_inference_epoch_group_validations_proto_rawDescData)
+ })
+ return file_inference_inference_epoch_group_validations_proto_rawDescData
+}
+
+var file_inference_inference_epoch_group_validations_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_inference_inference_epoch_group_validations_proto_goTypes = []interface{}{
+ (*EpochGroupValidations)(nil), // 0: inference.inference.EpochGroupValidations
+}
+var file_inference_inference_epoch_group_validations_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_epoch_group_validations_proto_init() }
+func file_inference_inference_epoch_group_validations_proto_init() {
+ if File_inference_inference_epoch_group_validations_proto != nil {
+ return
+ }
+ if !protoimpl.UnsafeEnabled {
+ file_inference_inference_epoch_group_validations_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*EpochGroupValidations); 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_epoch_group_validations_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 1,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_inference_epoch_group_validations_proto_goTypes,
+ DependencyIndexes: file_inference_inference_epoch_group_validations_proto_depIdxs,
+ MessageInfos: file_inference_inference_epoch_group_validations_proto_msgTypes,
+ }.Build()
+ File_inference_inference_epoch_group_validations_proto = out.File
+ file_inference_inference_epoch_group_validations_proto_rawDesc = nil
+ file_inference_inference_epoch_group_validations_proto_goTypes = nil
+ file_inference_inference_epoch_group_validations_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/inference/epoch_performance_summary.pulsar.go b/inference-chain/api/inference/inference/epoch_performance_summary.pulsar.go
new file mode 100644
index 000000000..3bff02be1
--- /dev/null
+++ b/inference-chain/api/inference/inference/epoch_performance_summary.pulsar.go
@@ -0,0 +1,1104 @@
+// 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_EpochPerformanceSummary protoreflect.MessageDescriptor
+ fd_EpochPerformanceSummary_epoch_index protoreflect.FieldDescriptor
+ fd_EpochPerformanceSummary_participant_id protoreflect.FieldDescriptor
+ fd_EpochPerformanceSummary_inference_count protoreflect.FieldDescriptor
+ fd_EpochPerformanceSummary_missed_requests protoreflect.FieldDescriptor
+ fd_EpochPerformanceSummary_earned_coins protoreflect.FieldDescriptor
+ fd_EpochPerformanceSummary_rewarded_coins protoreflect.FieldDescriptor
+ fd_EpochPerformanceSummary_burned_coins protoreflect.FieldDescriptor
+ fd_EpochPerformanceSummary_validated_inferences protoreflect.FieldDescriptor
+ fd_EpochPerformanceSummary_invalidated_inferences protoreflect.FieldDescriptor
+ fd_EpochPerformanceSummary_claimed protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_epoch_performance_summary_proto_init()
+ md_EpochPerformanceSummary = File_inference_inference_epoch_performance_summary_proto.Messages().ByName("EpochPerformanceSummary")
+ fd_EpochPerformanceSummary_epoch_index = md_EpochPerformanceSummary.Fields().ByName("epoch_index")
+ fd_EpochPerformanceSummary_participant_id = md_EpochPerformanceSummary.Fields().ByName("participant_id")
+ fd_EpochPerformanceSummary_inference_count = md_EpochPerformanceSummary.Fields().ByName("inference_count")
+ fd_EpochPerformanceSummary_missed_requests = md_EpochPerformanceSummary.Fields().ByName("missed_requests")
+ fd_EpochPerformanceSummary_earned_coins = md_EpochPerformanceSummary.Fields().ByName("earned_coins")
+ fd_EpochPerformanceSummary_rewarded_coins = md_EpochPerformanceSummary.Fields().ByName("rewarded_coins")
+ fd_EpochPerformanceSummary_burned_coins = md_EpochPerformanceSummary.Fields().ByName("burned_coins")
+ fd_EpochPerformanceSummary_validated_inferences = md_EpochPerformanceSummary.Fields().ByName("validated_inferences")
+ fd_EpochPerformanceSummary_invalidated_inferences = md_EpochPerformanceSummary.Fields().ByName("invalidated_inferences")
+ fd_EpochPerformanceSummary_claimed = md_EpochPerformanceSummary.Fields().ByName("claimed")
+}
+
+var _ protoreflect.Message = (*fastReflection_EpochPerformanceSummary)(nil)
+
+type fastReflection_EpochPerformanceSummary EpochPerformanceSummary
+
+func (x *EpochPerformanceSummary) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_EpochPerformanceSummary)(x)
+}
+
+func (x *EpochPerformanceSummary) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_epoch_performance_summary_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_EpochPerformanceSummary_messageType fastReflection_EpochPerformanceSummary_messageType
+var _ protoreflect.MessageType = fastReflection_EpochPerformanceSummary_messageType{}
+
+type fastReflection_EpochPerformanceSummary_messageType struct{}
+
+func (x fastReflection_EpochPerformanceSummary_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_EpochPerformanceSummary)(nil)
+}
+func (x fastReflection_EpochPerformanceSummary_messageType) New() protoreflect.Message {
+ return new(fastReflection_EpochPerformanceSummary)
+}
+func (x fastReflection_EpochPerformanceSummary_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_EpochPerformanceSummary
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_EpochPerformanceSummary) Descriptor() protoreflect.MessageDescriptor {
+ return md_EpochPerformanceSummary
+}
+
+// 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_EpochPerformanceSummary) Type() protoreflect.MessageType {
+ return _fastReflection_EpochPerformanceSummary_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_EpochPerformanceSummary) New() protoreflect.Message {
+ return new(fastReflection_EpochPerformanceSummary)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_EpochPerformanceSummary) Interface() protoreflect.ProtoMessage {
+ return (*EpochPerformanceSummary)(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_EpochPerformanceSummary) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.EpochIndex != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.EpochIndex)
+ if !f(fd_EpochPerformanceSummary_epoch_index, value) {
+ return
+ }
+ }
+ if x.ParticipantId != "" {
+ value := protoreflect.ValueOfString(x.ParticipantId)
+ if !f(fd_EpochPerformanceSummary_participant_id, value) {
+ return
+ }
+ }
+ if x.InferenceCount != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.InferenceCount)
+ if !f(fd_EpochPerformanceSummary_inference_count, value) {
+ return
+ }
+ }
+ if x.MissedRequests != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.MissedRequests)
+ if !f(fd_EpochPerformanceSummary_missed_requests, value) {
+ return
+ }
+ }
+ if x.EarnedCoins != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.EarnedCoins)
+ if !f(fd_EpochPerformanceSummary_earned_coins, value) {
+ return
+ }
+ }
+ if x.RewardedCoins != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.RewardedCoins)
+ if !f(fd_EpochPerformanceSummary_rewarded_coins, value) {
+ return
+ }
+ }
+ if x.BurnedCoins != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.BurnedCoins)
+ if !f(fd_EpochPerformanceSummary_burned_coins, value) {
+ return
+ }
+ }
+ if x.ValidatedInferences != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.ValidatedInferences)
+ if !f(fd_EpochPerformanceSummary_validated_inferences, value) {
+ return
+ }
+ }
+ if x.InvalidatedInferences != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.InvalidatedInferences)
+ if !f(fd_EpochPerformanceSummary_invalidated_inferences, value) {
+ return
+ }
+ }
+ if x.Claimed != false {
+ value := protoreflect.ValueOfBool(x.Claimed)
+ if !f(fd_EpochPerformanceSummary_claimed, 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_EpochPerformanceSummary) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.EpochPerformanceSummary.epoch_index":
+ return x.EpochIndex != uint64(0)
+ case "inference.inference.EpochPerformanceSummary.participant_id":
+ return x.ParticipantId != ""
+ case "inference.inference.EpochPerformanceSummary.inference_count":
+ return x.InferenceCount != uint64(0)
+ case "inference.inference.EpochPerformanceSummary.missed_requests":
+ return x.MissedRequests != uint64(0)
+ case "inference.inference.EpochPerformanceSummary.earned_coins":
+ return x.EarnedCoins != uint64(0)
+ case "inference.inference.EpochPerformanceSummary.rewarded_coins":
+ return x.RewardedCoins != uint64(0)
+ case "inference.inference.EpochPerformanceSummary.burned_coins":
+ return x.BurnedCoins != uint64(0)
+ case "inference.inference.EpochPerformanceSummary.validated_inferences":
+ return x.ValidatedInferences != uint64(0)
+ case "inference.inference.EpochPerformanceSummary.invalidated_inferences":
+ return x.InvalidatedInferences != uint64(0)
+ case "inference.inference.EpochPerformanceSummary.claimed":
+ return x.Claimed != false
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.EpochPerformanceSummary"))
+ }
+ panic(fmt.Errorf("message inference.inference.EpochPerformanceSummary 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_EpochPerformanceSummary) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.EpochPerformanceSummary.epoch_index":
+ x.EpochIndex = uint64(0)
+ case "inference.inference.EpochPerformanceSummary.participant_id":
+ x.ParticipantId = ""
+ case "inference.inference.EpochPerformanceSummary.inference_count":
+ x.InferenceCount = uint64(0)
+ case "inference.inference.EpochPerformanceSummary.missed_requests":
+ x.MissedRequests = uint64(0)
+ case "inference.inference.EpochPerformanceSummary.earned_coins":
+ x.EarnedCoins = uint64(0)
+ case "inference.inference.EpochPerformanceSummary.rewarded_coins":
+ x.RewardedCoins = uint64(0)
+ case "inference.inference.EpochPerformanceSummary.burned_coins":
+ x.BurnedCoins = uint64(0)
+ case "inference.inference.EpochPerformanceSummary.validated_inferences":
+ x.ValidatedInferences = uint64(0)
+ case "inference.inference.EpochPerformanceSummary.invalidated_inferences":
+ x.InvalidatedInferences = uint64(0)
+ case "inference.inference.EpochPerformanceSummary.claimed":
+ x.Claimed = false
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.EpochPerformanceSummary"))
+ }
+ panic(fmt.Errorf("message inference.inference.EpochPerformanceSummary 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_EpochPerformanceSummary) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.EpochPerformanceSummary.epoch_index":
+ value := x.EpochIndex
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.EpochPerformanceSummary.participant_id":
+ value := x.ParticipantId
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.EpochPerformanceSummary.inference_count":
+ value := x.InferenceCount
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.EpochPerformanceSummary.missed_requests":
+ value := x.MissedRequests
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.EpochPerformanceSummary.earned_coins":
+ value := x.EarnedCoins
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.EpochPerformanceSummary.rewarded_coins":
+ value := x.RewardedCoins
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.EpochPerformanceSummary.burned_coins":
+ value := x.BurnedCoins
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.EpochPerformanceSummary.validated_inferences":
+ value := x.ValidatedInferences
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.EpochPerformanceSummary.invalidated_inferences":
+ value := x.InvalidatedInferences
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.EpochPerformanceSummary.claimed":
+ value := x.Claimed
+ return protoreflect.ValueOfBool(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.EpochPerformanceSummary"))
+ }
+ panic(fmt.Errorf("message inference.inference.EpochPerformanceSummary 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_EpochPerformanceSummary) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.EpochPerformanceSummary.epoch_index":
+ x.EpochIndex = value.Uint()
+ case "inference.inference.EpochPerformanceSummary.participant_id":
+ x.ParticipantId = value.Interface().(string)
+ case "inference.inference.EpochPerformanceSummary.inference_count":
+ x.InferenceCount = value.Uint()
+ case "inference.inference.EpochPerformanceSummary.missed_requests":
+ x.MissedRequests = value.Uint()
+ case "inference.inference.EpochPerformanceSummary.earned_coins":
+ x.EarnedCoins = value.Uint()
+ case "inference.inference.EpochPerformanceSummary.rewarded_coins":
+ x.RewardedCoins = value.Uint()
+ case "inference.inference.EpochPerformanceSummary.burned_coins":
+ x.BurnedCoins = value.Uint()
+ case "inference.inference.EpochPerformanceSummary.validated_inferences":
+ x.ValidatedInferences = value.Uint()
+ case "inference.inference.EpochPerformanceSummary.invalidated_inferences":
+ x.InvalidatedInferences = value.Uint()
+ case "inference.inference.EpochPerformanceSummary.claimed":
+ x.Claimed = value.Bool()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.EpochPerformanceSummary"))
+ }
+ panic(fmt.Errorf("message inference.inference.EpochPerformanceSummary 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_EpochPerformanceSummary) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.EpochPerformanceSummary.epoch_index":
+ panic(fmt.Errorf("field epoch_index of message inference.inference.EpochPerformanceSummary is not mutable"))
+ case "inference.inference.EpochPerformanceSummary.participant_id":
+ panic(fmt.Errorf("field participant_id of message inference.inference.EpochPerformanceSummary is not mutable"))
+ case "inference.inference.EpochPerformanceSummary.inference_count":
+ panic(fmt.Errorf("field inference_count of message inference.inference.EpochPerformanceSummary is not mutable"))
+ case "inference.inference.EpochPerformanceSummary.missed_requests":
+ panic(fmt.Errorf("field missed_requests of message inference.inference.EpochPerformanceSummary is not mutable"))
+ case "inference.inference.EpochPerformanceSummary.earned_coins":
+ panic(fmt.Errorf("field earned_coins of message inference.inference.EpochPerformanceSummary is not mutable"))
+ case "inference.inference.EpochPerformanceSummary.rewarded_coins":
+ panic(fmt.Errorf("field rewarded_coins of message inference.inference.EpochPerformanceSummary is not mutable"))
+ case "inference.inference.EpochPerformanceSummary.burned_coins":
+ panic(fmt.Errorf("field burned_coins of message inference.inference.EpochPerformanceSummary is not mutable"))
+ case "inference.inference.EpochPerformanceSummary.validated_inferences":
+ panic(fmt.Errorf("field validated_inferences of message inference.inference.EpochPerformanceSummary is not mutable"))
+ case "inference.inference.EpochPerformanceSummary.invalidated_inferences":
+ panic(fmt.Errorf("field invalidated_inferences of message inference.inference.EpochPerformanceSummary is not mutable"))
+ case "inference.inference.EpochPerformanceSummary.claimed":
+ panic(fmt.Errorf("field claimed of message inference.inference.EpochPerformanceSummary is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.EpochPerformanceSummary"))
+ }
+ panic(fmt.Errorf("message inference.inference.EpochPerformanceSummary 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_EpochPerformanceSummary) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.EpochPerformanceSummary.epoch_index":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.EpochPerformanceSummary.participant_id":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.EpochPerformanceSummary.inference_count":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.EpochPerformanceSummary.missed_requests":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.EpochPerformanceSummary.earned_coins":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.EpochPerformanceSummary.rewarded_coins":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.EpochPerformanceSummary.burned_coins":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.EpochPerformanceSummary.validated_inferences":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.EpochPerformanceSummary.invalidated_inferences":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.EpochPerformanceSummary.claimed":
+ return protoreflect.ValueOfBool(false)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.EpochPerformanceSummary"))
+ }
+ panic(fmt.Errorf("message inference.inference.EpochPerformanceSummary 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_EpochPerformanceSummary) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.EpochPerformanceSummary", 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_EpochPerformanceSummary) 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_EpochPerformanceSummary) 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_EpochPerformanceSummary) 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_EpochPerformanceSummary) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*EpochPerformanceSummary)
+ 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.ParticipantId)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.InferenceCount != 0 {
+ n += 1 + runtime.Sov(uint64(x.InferenceCount))
+ }
+ if x.MissedRequests != 0 {
+ n += 1 + runtime.Sov(uint64(x.MissedRequests))
+ }
+ if x.EarnedCoins != 0 {
+ n += 1 + runtime.Sov(uint64(x.EarnedCoins))
+ }
+ if x.RewardedCoins != 0 {
+ n += 1 + runtime.Sov(uint64(x.RewardedCoins))
+ }
+ if x.BurnedCoins != 0 {
+ n += 1 + runtime.Sov(uint64(x.BurnedCoins))
+ }
+ if x.ValidatedInferences != 0 {
+ n += 1 + runtime.Sov(uint64(x.ValidatedInferences))
+ }
+ if x.InvalidatedInferences != 0 {
+ n += 1 + runtime.Sov(uint64(x.InvalidatedInferences))
+ }
+ if x.Claimed {
+ 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().(*EpochPerformanceSummary)
+ 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.Claimed {
+ i--
+ if x.Claimed {
+ dAtA[i] = 1
+ } else {
+ dAtA[i] = 0
+ }
+ i--
+ dAtA[i] = 0x50
+ }
+ if x.InvalidatedInferences != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.InvalidatedInferences))
+ i--
+ dAtA[i] = 0x48
+ }
+ if x.ValidatedInferences != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.ValidatedInferences))
+ i--
+ dAtA[i] = 0x40
+ }
+ if x.BurnedCoins != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.BurnedCoins))
+ i--
+ dAtA[i] = 0x38
+ }
+ if x.RewardedCoins != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.RewardedCoins))
+ i--
+ dAtA[i] = 0x30
+ }
+ if x.EarnedCoins != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.EarnedCoins))
+ i--
+ dAtA[i] = 0x28
+ }
+ if x.MissedRequests != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.MissedRequests))
+ i--
+ dAtA[i] = 0x20
+ }
+ if x.InferenceCount != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.InferenceCount))
+ i--
+ dAtA[i] = 0x18
+ }
+ 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--
+ 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().(*EpochPerformanceSummary)
+ 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: EpochPerformanceSummary: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: EpochPerformanceSummary: 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 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 3:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field InferenceCount", wireType)
+ }
+ x.InferenceCount = 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.InferenceCount |= 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 MissedRequests", wireType)
+ }
+ x.MissedRequests = 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.MissedRequests |= 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 EarnedCoins", wireType)
+ }
+ x.EarnedCoins = 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.EarnedCoins |= 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 RewardedCoins", wireType)
+ }
+ x.RewardedCoins = 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.RewardedCoins |= 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 BurnedCoins", wireType)
+ }
+ x.BurnedCoins = 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.BurnedCoins |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 8:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidatedInferences", wireType)
+ }
+ x.ValidatedInferences = 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.ValidatedInferences |= 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 InvalidatedInferences", wireType)
+ }
+ x.InvalidatedInferences = 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.InvalidatedInferences |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 10:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Claimed", 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.Claimed = 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,
+ }
+}
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// protoc-gen-go v1.27.0
+// protoc (unknown)
+// source: inference/inference/epoch_performance_summary.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)
+)
+
+type EpochPerformanceSummary 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=participant_id,json=participantId,proto3" json:"participant_id,omitempty"`
+ InferenceCount uint64 `protobuf:"varint,3,opt,name=inference_count,json=inferenceCount,proto3" json:"inference_count,omitempty"`
+ MissedRequests uint64 `protobuf:"varint,4,opt,name=missed_requests,json=missedRequests,proto3" json:"missed_requests,omitempty"`
+ EarnedCoins uint64 `protobuf:"varint,5,opt,name=earned_coins,json=earnedCoins,proto3" json:"earned_coins,omitempty"`
+ RewardedCoins uint64 `protobuf:"varint,6,opt,name=rewarded_coins,json=rewardedCoins,proto3" json:"rewarded_coins,omitempty"`
+ BurnedCoins uint64 `protobuf:"varint,7,opt,name=burned_coins,json=burnedCoins,proto3" json:"burned_coins,omitempty"`
+ ValidatedInferences uint64 `protobuf:"varint,8,opt,name=validated_inferences,json=validatedInferences,proto3" json:"validated_inferences,omitempty"`
+ InvalidatedInferences uint64 `protobuf:"varint,9,opt,name=invalidated_inferences,json=invalidatedInferences,proto3" json:"invalidated_inferences,omitempty"`
+ Claimed bool `protobuf:"varint,10,opt,name=claimed,proto3" json:"claimed,omitempty"`
+}
+
+func (x *EpochPerformanceSummary) Reset() {
+ *x = EpochPerformanceSummary{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_epoch_performance_summary_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *EpochPerformanceSummary) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*EpochPerformanceSummary) ProtoMessage() {}
+
+// Deprecated: Use EpochPerformanceSummary.ProtoReflect.Descriptor instead.
+func (*EpochPerformanceSummary) Descriptor() ([]byte, []int) {
+ return file_inference_inference_epoch_performance_summary_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *EpochPerformanceSummary) GetEpochIndex() uint64 {
+ if x != nil {
+ return x.EpochIndex
+ }
+ return 0
+}
+
+func (x *EpochPerformanceSummary) GetParticipantId() string {
+ if x != nil {
+ return x.ParticipantId
+ }
+ return ""
+}
+
+func (x *EpochPerformanceSummary) GetInferenceCount() uint64 {
+ if x != nil {
+ return x.InferenceCount
+ }
+ return 0
+}
+
+func (x *EpochPerformanceSummary) GetMissedRequests() uint64 {
+ if x != nil {
+ return x.MissedRequests
+ }
+ return 0
+}
+
+func (x *EpochPerformanceSummary) GetEarnedCoins() uint64 {
+ if x != nil {
+ return x.EarnedCoins
+ }
+ return 0
+}
+
+func (x *EpochPerformanceSummary) GetRewardedCoins() uint64 {
+ if x != nil {
+ return x.RewardedCoins
+ }
+ return 0
+}
+
+func (x *EpochPerformanceSummary) GetBurnedCoins() uint64 {
+ if x != nil {
+ return x.BurnedCoins
+ }
+ return 0
+}
+
+func (x *EpochPerformanceSummary) GetValidatedInferences() uint64 {
+ if x != nil {
+ return x.ValidatedInferences
+ }
+ return 0
+}
+
+func (x *EpochPerformanceSummary) GetInvalidatedInferences() uint64 {
+ if x != nil {
+ return x.InvalidatedInferences
+ }
+ return 0
+}
+
+func (x *EpochPerformanceSummary) GetClaimed() bool {
+ if x != nil {
+ return x.Claimed
+ }
+ return false
+}
+
+var File_inference_inference_epoch_performance_summary_proto protoreflect.FileDescriptor
+
+var file_inference_inference_epoch_performance_summary_proto_rawDesc = []byte{
+ 0x0a, 0x33, 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, 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, 0xa4, 0x03, 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, 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, 0x25, 0x0a, 0x0e, 0x70, 0x61, 0x72, 0x74, 0x69,
+ 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
+ 0x0d, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x49, 0x64, 0x12, 0x27,
+ 0x0a, 0x0f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5f, 0x63, 0x6f, 0x75, 0x6e,
+ 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+ 0x63, 0x65, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x27, 0x0a, 0x0f, 0x6d, 0x69, 0x73, 0x73, 0x65,
+ 0x64, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04,
+ 0x52, 0x0e, 0x6d, 0x69, 0x73, 0x73, 0x65, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73,
+ 0x12, 0x21, 0x0a, 0x0c, 0x65, 0x61, 0x72, 0x6e, 0x65, 0x64, 0x5f, 0x63, 0x6f, 0x69, 0x6e, 0x73,
+ 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x65, 0x61, 0x72, 0x6e, 0x65, 0x64, 0x43, 0x6f,
+ 0x69, 0x6e, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x77, 0x61, 0x72, 0x64, 0x65, 0x64, 0x5f,
+ 0x63, 0x6f, 0x69, 0x6e, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0d, 0x72, 0x65, 0x77,
+ 0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x69, 0x6e, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x62, 0x75,
+ 0x72, 0x6e, 0x65, 0x64, 0x5f, 0x63, 0x6f, 0x69, 0x6e, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x04,
+ 0x52, 0x0b, 0x62, 0x75, 0x72, 0x6e, 0x65, 0x64, 0x43, 0x6f, 0x69, 0x6e, 0x73, 0x12, 0x31, 0x0a,
+ 0x14, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x66, 0x65, 0x72,
+ 0x65, 0x6e, 0x63, 0x65, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x04, 0x52, 0x13, 0x76, 0x61, 0x6c,
+ 0x69, 0x64, 0x61, 0x74, 0x65, 0x64, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73,
+ 0x12, 0x35, 0x0a, 0x16, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x64, 0x5f,
+ 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x04,
+ 0x52, 0x15, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x64, 0x49, 0x6e, 0x66,
+ 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x6c, 0x61, 0x69, 0x6d,
+ 0x65, 0x64, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x65,
+ 0x64, 0x42, 0xca, 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, 0x1c, 0x45,
+ 0x70, 0x6f, 0x63, 0x68, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x53,
+ 0x75, 0x6d, 0x6d, 0x61, 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,
+}
+
+var (
+ file_inference_inference_epoch_performance_summary_proto_rawDescOnce sync.Once
+ file_inference_inference_epoch_performance_summary_proto_rawDescData = file_inference_inference_epoch_performance_summary_proto_rawDesc
+)
+
+func file_inference_inference_epoch_performance_summary_proto_rawDescGZIP() []byte {
+ file_inference_inference_epoch_performance_summary_proto_rawDescOnce.Do(func() {
+ file_inference_inference_epoch_performance_summary_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_inference_epoch_performance_summary_proto_rawDescData)
+ })
+ return file_inference_inference_epoch_performance_summary_proto_rawDescData
+}
+
+var file_inference_inference_epoch_performance_summary_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_inference_inference_epoch_performance_summary_proto_goTypes = []interface{}{
+ (*EpochPerformanceSummary)(nil), // 0: inference.inference.EpochPerformanceSummary
+}
+var file_inference_inference_epoch_performance_summary_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_epoch_performance_summary_proto_init() }
+func file_inference_inference_epoch_performance_summary_proto_init() {
+ if File_inference_inference_epoch_performance_summary_proto != nil {
+ return
+ }
+ if !protoimpl.UnsafeEnabled {
+ file_inference_inference_epoch_performance_summary_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*EpochPerformanceSummary); 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_epoch_performance_summary_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 1,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_inference_epoch_performance_summary_proto_goTypes,
+ DependencyIndexes: file_inference_inference_epoch_performance_summary_proto_depIdxs,
+ MessageInfos: file_inference_inference_epoch_performance_summary_proto_msgTypes,
+ }.Build()
+ File_inference_inference_epoch_performance_summary_proto = out.File
+ file_inference_inference_epoch_performance_summary_proto_rawDesc = nil
+ file_inference_inference_epoch_performance_summary_proto_goTypes = nil
+ file_inference_inference_epoch_performance_summary_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/inference/excluded_participant.pulsar.go b/inference-chain/api/inference/inference/excluded_participant.pulsar.go
new file mode 100644
index 000000000..308363ac6
--- /dev/null
+++ b/inference-chain/api/inference/inference/excluded_participant.pulsar.go
@@ -0,0 +1,765 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package inference
+
+import (
+ fmt "fmt"
+ runtime "github.com/cosmos/cosmos-proto/runtime"
+ _ "github.com/cosmos/gogoproto/gogoproto"
+ 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_ExcludedParticipant protoreflect.MessageDescriptor
+ fd_ExcludedParticipant_address protoreflect.FieldDescriptor
+ fd_ExcludedParticipant_epoch_index protoreflect.FieldDescriptor
+ fd_ExcludedParticipant_reason protoreflect.FieldDescriptor
+ fd_ExcludedParticipant_exclusion_block_height protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_excluded_participant_proto_init()
+ md_ExcludedParticipant = File_inference_inference_excluded_participant_proto.Messages().ByName("ExcludedParticipant")
+ fd_ExcludedParticipant_address = md_ExcludedParticipant.Fields().ByName("address")
+ fd_ExcludedParticipant_epoch_index = md_ExcludedParticipant.Fields().ByName("epoch_index")
+ fd_ExcludedParticipant_reason = md_ExcludedParticipant.Fields().ByName("reason")
+ fd_ExcludedParticipant_exclusion_block_height = md_ExcludedParticipant.Fields().ByName("exclusion_block_height")
+}
+
+var _ protoreflect.Message = (*fastReflection_ExcludedParticipant)(nil)
+
+type fastReflection_ExcludedParticipant ExcludedParticipant
+
+func (x *ExcludedParticipant) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_ExcludedParticipant)(x)
+}
+
+func (x *ExcludedParticipant) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_excluded_participant_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_ExcludedParticipant_messageType fastReflection_ExcludedParticipant_messageType
+var _ protoreflect.MessageType = fastReflection_ExcludedParticipant_messageType{}
+
+type fastReflection_ExcludedParticipant_messageType struct{}
+
+func (x fastReflection_ExcludedParticipant_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_ExcludedParticipant)(nil)
+}
+func (x fastReflection_ExcludedParticipant_messageType) New() protoreflect.Message {
+ return new(fastReflection_ExcludedParticipant)
+}
+func (x fastReflection_ExcludedParticipant_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_ExcludedParticipant
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_ExcludedParticipant) Descriptor() protoreflect.MessageDescriptor {
+ return md_ExcludedParticipant
+}
+
+// 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_ExcludedParticipant) Type() protoreflect.MessageType {
+ return _fastReflection_ExcludedParticipant_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_ExcludedParticipant) New() protoreflect.Message {
+ return new(fastReflection_ExcludedParticipant)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_ExcludedParticipant) Interface() protoreflect.ProtoMessage {
+ return (*ExcludedParticipant)(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_ExcludedParticipant) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Address != "" {
+ value := protoreflect.ValueOfString(x.Address)
+ if !f(fd_ExcludedParticipant_address, value) {
+ return
+ }
+ }
+ if x.EpochIndex != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.EpochIndex)
+ if !f(fd_ExcludedParticipant_epoch_index, value) {
+ return
+ }
+ }
+ if x.Reason != "" {
+ value := protoreflect.ValueOfString(x.Reason)
+ if !f(fd_ExcludedParticipant_reason, value) {
+ return
+ }
+ }
+ if x.ExclusionBlockHeight != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.ExclusionBlockHeight)
+ if !f(fd_ExcludedParticipant_exclusion_block_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_ExcludedParticipant) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.ExcludedParticipant.address":
+ return x.Address != ""
+ case "inference.inference.ExcludedParticipant.epoch_index":
+ return x.EpochIndex != uint64(0)
+ case "inference.inference.ExcludedParticipant.reason":
+ return x.Reason != ""
+ case "inference.inference.ExcludedParticipant.exclusion_block_height":
+ return x.ExclusionBlockHeight != uint64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ExcludedParticipant"))
+ }
+ panic(fmt.Errorf("message inference.inference.ExcludedParticipant 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_ExcludedParticipant) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.ExcludedParticipant.address":
+ x.Address = ""
+ case "inference.inference.ExcludedParticipant.epoch_index":
+ x.EpochIndex = uint64(0)
+ case "inference.inference.ExcludedParticipant.reason":
+ x.Reason = ""
+ case "inference.inference.ExcludedParticipant.exclusion_block_height":
+ x.ExclusionBlockHeight = uint64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ExcludedParticipant"))
+ }
+ panic(fmt.Errorf("message inference.inference.ExcludedParticipant 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_ExcludedParticipant) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.ExcludedParticipant.address":
+ value := x.Address
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.ExcludedParticipant.epoch_index":
+ value := x.EpochIndex
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.ExcludedParticipant.reason":
+ value := x.Reason
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.ExcludedParticipant.exclusion_block_height":
+ value := x.ExclusionBlockHeight
+ return protoreflect.ValueOfUint64(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ExcludedParticipant"))
+ }
+ panic(fmt.Errorf("message inference.inference.ExcludedParticipant 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_ExcludedParticipant) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.ExcludedParticipant.address":
+ x.Address = value.Interface().(string)
+ case "inference.inference.ExcludedParticipant.epoch_index":
+ x.EpochIndex = value.Uint()
+ case "inference.inference.ExcludedParticipant.reason":
+ x.Reason = value.Interface().(string)
+ case "inference.inference.ExcludedParticipant.exclusion_block_height":
+ x.ExclusionBlockHeight = value.Uint()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ExcludedParticipant"))
+ }
+ panic(fmt.Errorf("message inference.inference.ExcludedParticipant 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_ExcludedParticipant) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.ExcludedParticipant.address":
+ panic(fmt.Errorf("field address of message inference.inference.ExcludedParticipant is not mutable"))
+ case "inference.inference.ExcludedParticipant.epoch_index":
+ panic(fmt.Errorf("field epoch_index of message inference.inference.ExcludedParticipant is not mutable"))
+ case "inference.inference.ExcludedParticipant.reason":
+ panic(fmt.Errorf("field reason of message inference.inference.ExcludedParticipant is not mutable"))
+ case "inference.inference.ExcludedParticipant.exclusion_block_height":
+ panic(fmt.Errorf("field exclusion_block_height of message inference.inference.ExcludedParticipant is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ExcludedParticipant"))
+ }
+ panic(fmt.Errorf("message inference.inference.ExcludedParticipant 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_ExcludedParticipant) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.ExcludedParticipant.address":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.ExcludedParticipant.epoch_index":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.ExcludedParticipant.reason":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.ExcludedParticipant.exclusion_block_height":
+ return protoreflect.ValueOfUint64(uint64(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ExcludedParticipant"))
+ }
+ panic(fmt.Errorf("message inference.inference.ExcludedParticipant 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_ExcludedParticipant) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.ExcludedParticipant", 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_ExcludedParticipant) 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_ExcludedParticipant) 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_ExcludedParticipant) 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_ExcludedParticipant) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*ExcludedParticipant)
+ 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.Address)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.EpochIndex != 0 {
+ n += 1 + runtime.Sov(uint64(x.EpochIndex))
+ }
+ l = len(x.Reason)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.ExclusionBlockHeight != 0 {
+ n += 1 + runtime.Sov(uint64(x.ExclusionBlockHeight))
+ }
+ 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().(*ExcludedParticipant)
+ 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.ExclusionBlockHeight != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.ExclusionBlockHeight))
+ i--
+ dAtA[i] = 0x20
+ }
+ 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] = 0x1a
+ }
+ if x.EpochIndex != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochIndex))
+ 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)))
+ 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().(*ExcludedParticipant)
+ 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: ExcludedParticipant: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ExcludedParticipant: 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 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 Reason", 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.Reason = 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 ExclusionBlockHeight", wireType)
+ }
+ x.ExclusionBlockHeight = 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.ExclusionBlockHeight |= 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,
+ }
+}
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// protoc-gen-go v1.27.0
+// protoc (unknown)
+// source: inference/inference/excluded_participant.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)
+)
+
+// ExcludedParticipant represents a participant excluded for a given epoch.
+// Upgrade-safety: New, additive message. Epoch-scoped; no migration required.
+type ExcludedParticipant struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` // Bech32 address of the participant
+ EpochIndex uint64 `protobuf:"varint,2,opt,name=epoch_index,json=epochIndex,proto3" json:"epoch_index,omitempty"` // Epoch index for which the participant is excluded
+ Reason string `protobuf:"bytes,3,opt,name=reason,proto3" json:"reason,omitempty"` // Free-form reason string (e.g., "invalidated")
+ ExclusionBlockHeight uint64 `protobuf:"varint,4,opt,name=exclusion_block_height,json=exclusionBlockHeight,proto3" json:"exclusion_block_height,omitempty"` // Block height when exclusion took effect
+}
+
+func (x *ExcludedParticipant) Reset() {
+ *x = ExcludedParticipant{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_excluded_participant_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *ExcludedParticipant) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ExcludedParticipant) ProtoMessage() {}
+
+// Deprecated: Use ExcludedParticipant.ProtoReflect.Descriptor instead.
+func (*ExcludedParticipant) Descriptor() ([]byte, []int) {
+ return file_inference_inference_excluded_participant_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *ExcludedParticipant) GetAddress() string {
+ if x != nil {
+ return x.Address
+ }
+ return ""
+}
+
+func (x *ExcludedParticipant) GetEpochIndex() uint64 {
+ if x != nil {
+ return x.EpochIndex
+ }
+ return 0
+}
+
+func (x *ExcludedParticipant) GetReason() string {
+ if x != nil {
+ return x.Reason
+ }
+ return ""
+}
+
+func (x *ExcludedParticipant) GetExclusionBlockHeight() uint64 {
+ if x != nil {
+ return x.ExclusionBlockHeight
+ }
+ return 0
+}
+
+var File_inference_inference_excluded_participant_proto protoreflect.FileDescriptor
+
+var file_inference_inference_excluded_participant_proto_rawDesc = []byte{
+ 0x0a, 0x2e, 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, 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, 0x1a, 0x14, 0x67, 0x6f, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+ 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x9e, 0x01, 0x0a, 0x13,
+ 0x45, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70,
+ 0x61, 0x6e, 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, 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, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06,
+ 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x12, 0x34, 0x0a, 0x16, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73,
+ 0x69, 0x6f, 0x6e, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74,
+ 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x14, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x6f,
+ 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x42, 0xc6, 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, 0x18, 0x45, 0x78, 0x63, 0x6c, 0x75, 0x64,
+ 0x65, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 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_excluded_participant_proto_rawDescOnce sync.Once
+ file_inference_inference_excluded_participant_proto_rawDescData = file_inference_inference_excluded_participant_proto_rawDesc
+)
+
+func file_inference_inference_excluded_participant_proto_rawDescGZIP() []byte {
+ file_inference_inference_excluded_participant_proto_rawDescOnce.Do(func() {
+ file_inference_inference_excluded_participant_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_inference_excluded_participant_proto_rawDescData)
+ })
+ return file_inference_inference_excluded_participant_proto_rawDescData
+}
+
+var file_inference_inference_excluded_participant_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_inference_inference_excluded_participant_proto_goTypes = []interface{}{
+ (*ExcludedParticipant)(nil), // 0: inference.inference.ExcludedParticipant
+}
+var file_inference_inference_excluded_participant_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_excluded_participant_proto_init() }
+func file_inference_inference_excluded_participant_proto_init() {
+ if File_inference_inference_excluded_participant_proto != nil {
+ return
+ }
+ if !protoimpl.UnsafeEnabled {
+ file_inference_inference_excluded_participant_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*ExcludedParticipant); 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_excluded_participant_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 1,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_inference_excluded_participant_proto_goTypes,
+ DependencyIndexes: file_inference_inference_excluded_participant_proto_depIdxs,
+ MessageInfos: file_inference_inference_excluded_participant_proto_msgTypes,
+ }.Build()
+ File_inference_inference_excluded_participant_proto = out.File
+ file_inference_inference_excluded_participant_proto_rawDesc = nil
+ file_inference_inference_excluded_participant_proto_goTypes = nil
+ file_inference_inference_excluded_participant_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/inference/genesis.pulsar.go b/inference-chain/api/inference/inference/genesis.pulsar.go
new file mode 100644
index 000000000..f495efa1b
--- /dev/null
+++ b/inference-chain/api/inference/inference/genesis.pulsar.go
@@ -0,0 +1,1865 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package inference
+
+import (
+ _ "cosmossdk.io/api/amino"
+ fmt "fmt"
+ runtime "github.com/cosmos/cosmos-proto/runtime"
+ _ "github.com/cosmos/gogoproto/gogoproto"
+ 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_CosmWasmParams protoreflect.MessageDescriptor
+ fd_CosmWasmParams_cw20_code protoreflect.FieldDescriptor
+ fd_CosmWasmParams_cw20_code_id protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_genesis_proto_init()
+ md_CosmWasmParams = File_inference_inference_genesis_proto.Messages().ByName("CosmWasmParams")
+ fd_CosmWasmParams_cw20_code = md_CosmWasmParams.Fields().ByName("cw20_code")
+ fd_CosmWasmParams_cw20_code_id = md_CosmWasmParams.Fields().ByName("cw20_code_id")
+}
+
+var _ protoreflect.Message = (*fastReflection_CosmWasmParams)(nil)
+
+type fastReflection_CosmWasmParams CosmWasmParams
+
+func (x *CosmWasmParams) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_CosmWasmParams)(x)
+}
+
+func (x *CosmWasmParams) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_genesis_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_CosmWasmParams_messageType fastReflection_CosmWasmParams_messageType
+var _ protoreflect.MessageType = fastReflection_CosmWasmParams_messageType{}
+
+type fastReflection_CosmWasmParams_messageType struct{}
+
+func (x fastReflection_CosmWasmParams_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_CosmWasmParams)(nil)
+}
+func (x fastReflection_CosmWasmParams_messageType) New() protoreflect.Message {
+ return new(fastReflection_CosmWasmParams)
+}
+func (x fastReflection_CosmWasmParams_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_CosmWasmParams
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_CosmWasmParams) Descriptor() protoreflect.MessageDescriptor {
+ return md_CosmWasmParams
+}
+
+// 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_CosmWasmParams) Type() protoreflect.MessageType {
+ return _fastReflection_CosmWasmParams_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_CosmWasmParams) New() protoreflect.Message {
+ return new(fastReflection_CosmWasmParams)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_CosmWasmParams) Interface() protoreflect.ProtoMessage {
+ return (*CosmWasmParams)(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_CosmWasmParams) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if len(x.Cw20Code) != 0 {
+ value := protoreflect.ValueOfBytes(x.Cw20Code)
+ if !f(fd_CosmWasmParams_cw20_code, value) {
+ return
+ }
+ }
+ if x.Cw20CodeId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.Cw20CodeId)
+ if !f(fd_CosmWasmParams_cw20_code_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_CosmWasmParams) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.CosmWasmParams.cw20_code":
+ return len(x.Cw20Code) != 0
+ case "inference.inference.CosmWasmParams.cw20_code_id":
+ return x.Cw20CodeId != uint64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.CosmWasmParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.CosmWasmParams 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_CosmWasmParams) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.CosmWasmParams.cw20_code":
+ x.Cw20Code = nil
+ case "inference.inference.CosmWasmParams.cw20_code_id":
+ x.Cw20CodeId = uint64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.CosmWasmParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.CosmWasmParams 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_CosmWasmParams) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.CosmWasmParams.cw20_code":
+ value := x.Cw20Code
+ return protoreflect.ValueOfBytes(value)
+ case "inference.inference.CosmWasmParams.cw20_code_id":
+ value := x.Cw20CodeId
+ return protoreflect.ValueOfUint64(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.CosmWasmParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.CosmWasmParams 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_CosmWasmParams) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.CosmWasmParams.cw20_code":
+ x.Cw20Code = value.Bytes()
+ case "inference.inference.CosmWasmParams.cw20_code_id":
+ x.Cw20CodeId = value.Uint()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.CosmWasmParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.CosmWasmParams 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_CosmWasmParams) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.CosmWasmParams.cw20_code":
+ panic(fmt.Errorf("field cw20_code of message inference.inference.CosmWasmParams is not mutable"))
+ case "inference.inference.CosmWasmParams.cw20_code_id":
+ panic(fmt.Errorf("field cw20_code_id of message inference.inference.CosmWasmParams is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.CosmWasmParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.CosmWasmParams 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_CosmWasmParams) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.CosmWasmParams.cw20_code":
+ return protoreflect.ValueOfBytes(nil)
+ case "inference.inference.CosmWasmParams.cw20_code_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.CosmWasmParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.CosmWasmParams 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_CosmWasmParams) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.CosmWasmParams", 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_CosmWasmParams) 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_CosmWasmParams) 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_CosmWasmParams) 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_CosmWasmParams) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*CosmWasmParams)
+ 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.Cw20Code)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.Cw20CodeId != 0 {
+ n += 1 + runtime.Sov(uint64(x.Cw20CodeId))
+ }
+ 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().(*CosmWasmParams)
+ 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.Cw20CodeId != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.Cw20CodeId))
+ i--
+ dAtA[i] = 0x10
+ }
+ if len(x.Cw20Code) > 0 {
+ i -= len(x.Cw20Code)
+ copy(dAtA[i:], x.Cw20Code)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Cw20Code)))
+ 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().(*CosmWasmParams)
+ 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: CosmWasmParams: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: CosmWasmParams: 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 Cw20Code", 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.Cw20Code = append(x.Cw20Code[:0], dAtA[iNdEx:postIndex]...)
+ if x.Cw20Code == nil {
+ x.Cw20Code = []byte{}
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Cw20CodeId", wireType)
+ }
+ x.Cw20CodeId = 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.Cw20CodeId |= 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 _ protoreflect.List = (*_GenesisState_3_list)(nil)
+
+type _GenesisState_3_list struct {
+ list *[]*Model
+}
+
+func (x *_GenesisState_3_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_GenesisState_3_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_GenesisState_3_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*Model)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_GenesisState_3_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*Model)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_GenesisState_3_list) AppendMutable() protoreflect.Value {
+ v := new(Model)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_GenesisState_3_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_GenesisState_3_list) NewElement() protoreflect.Value {
+ v := new(Model)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_GenesisState_3_list) IsValid() bool {
+ return x.list != nil
+}
+
+var _ protoreflect.List = (*_GenesisState_5_list)(nil)
+
+type _GenesisState_5_list struct {
+ list *[]*Participant
+}
+
+func (x *_GenesisState_5_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_GenesisState_5_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_GenesisState_5_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*Participant)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_GenesisState_5_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*Participant)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_GenesisState_5_list) AppendMutable() protoreflect.Value {
+ v := new(Participant)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_GenesisState_5_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_GenesisState_5_list) NewElement() protoreflect.Value {
+ v := new(Participant)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_GenesisState_5_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_GenesisState protoreflect.MessageDescriptor
+ fd_GenesisState_params protoreflect.FieldDescriptor
+ fd_GenesisState_genesis_only_params protoreflect.FieldDescriptor
+ fd_GenesisState_model_list protoreflect.FieldDescriptor
+ fd_GenesisState_cosm_wasm_params protoreflect.FieldDescriptor
+ fd_GenesisState_participant_list protoreflect.FieldDescriptor
+ fd_GenesisState_mlnode_version protoreflect.FieldDescriptor
+ fd_GenesisState_bridge protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_genesis_proto_init()
+ md_GenesisState = File_inference_inference_genesis_proto.Messages().ByName("GenesisState")
+ fd_GenesisState_params = md_GenesisState.Fields().ByName("params")
+ fd_GenesisState_genesis_only_params = md_GenesisState.Fields().ByName("genesis_only_params")
+ fd_GenesisState_model_list = md_GenesisState.Fields().ByName("model_list")
+ fd_GenesisState_cosm_wasm_params = md_GenesisState.Fields().ByName("cosm_wasm_params")
+ fd_GenesisState_participant_list = md_GenesisState.Fields().ByName("participant_list")
+ fd_GenesisState_mlnode_version = md_GenesisState.Fields().ByName("mlnode_version")
+ fd_GenesisState_bridge = md_GenesisState.Fields().ByName("bridge")
+}
+
+var _ protoreflect.Message = (*fastReflection_GenesisState)(nil)
+
+type fastReflection_GenesisState GenesisState
+
+func (x *GenesisState) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_GenesisState)(x)
+}
+
+func (x *GenesisState) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_genesis_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_GenesisState_messageType fastReflection_GenesisState_messageType
+var _ protoreflect.MessageType = fastReflection_GenesisState_messageType{}
+
+type fastReflection_GenesisState_messageType struct{}
+
+func (x fastReflection_GenesisState_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_GenesisState)(nil)
+}
+func (x fastReflection_GenesisState_messageType) New() protoreflect.Message {
+ return new(fastReflection_GenesisState)
+}
+func (x fastReflection_GenesisState_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_GenesisState
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_GenesisState) Descriptor() protoreflect.MessageDescriptor {
+ return md_GenesisState
+}
+
+// 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_GenesisState) Type() protoreflect.MessageType {
+ return _fastReflection_GenesisState_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_GenesisState) New() protoreflect.Message {
+ return new(fastReflection_GenesisState)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_GenesisState) Interface() protoreflect.ProtoMessage {
+ return (*GenesisState)(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_GenesisState) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Params != nil {
+ value := protoreflect.ValueOfMessage(x.Params.ProtoReflect())
+ if !f(fd_GenesisState_params, value) {
+ return
+ }
+ }
+ if x.GenesisOnlyParams != nil {
+ value := protoreflect.ValueOfMessage(x.GenesisOnlyParams.ProtoReflect())
+ if !f(fd_GenesisState_genesis_only_params, value) {
+ return
+ }
+ }
+ if len(x.ModelList) != 0 {
+ value := protoreflect.ValueOfList(&_GenesisState_3_list{list: &x.ModelList})
+ if !f(fd_GenesisState_model_list, value) {
+ return
+ }
+ }
+ if x.CosmWasmParams != nil {
+ value := protoreflect.ValueOfMessage(x.CosmWasmParams.ProtoReflect())
+ if !f(fd_GenesisState_cosm_wasm_params, value) {
+ return
+ }
+ }
+ if len(x.ParticipantList) != 0 {
+ value := protoreflect.ValueOfList(&_GenesisState_5_list{list: &x.ParticipantList})
+ if !f(fd_GenesisState_participant_list, value) {
+ return
+ }
+ }
+ if x.MlnodeVersion != nil {
+ value := protoreflect.ValueOfMessage(x.MlnodeVersion.ProtoReflect())
+ if !f(fd_GenesisState_mlnode_version, value) {
+ return
+ }
+ }
+ if x.Bridge != nil {
+ value := protoreflect.ValueOfMessage(x.Bridge.ProtoReflect())
+ if !f(fd_GenesisState_bridge, 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_GenesisState) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.GenesisState.params":
+ return x.Params != nil
+ case "inference.inference.GenesisState.genesis_only_params":
+ return x.GenesisOnlyParams != nil
+ case "inference.inference.GenesisState.model_list":
+ return len(x.ModelList) != 0
+ case "inference.inference.GenesisState.cosm_wasm_params":
+ return x.CosmWasmParams != nil
+ case "inference.inference.GenesisState.participant_list":
+ return len(x.ParticipantList) != 0
+ case "inference.inference.GenesisState.mlnode_version":
+ return x.MlnodeVersion != nil
+ case "inference.inference.GenesisState.bridge":
+ return x.Bridge != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GenesisState"))
+ }
+ panic(fmt.Errorf("message inference.inference.GenesisState 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_GenesisState) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.GenesisState.params":
+ x.Params = nil
+ case "inference.inference.GenesisState.genesis_only_params":
+ x.GenesisOnlyParams = nil
+ case "inference.inference.GenesisState.model_list":
+ x.ModelList = nil
+ case "inference.inference.GenesisState.cosm_wasm_params":
+ x.CosmWasmParams = nil
+ case "inference.inference.GenesisState.participant_list":
+ x.ParticipantList = nil
+ case "inference.inference.GenesisState.mlnode_version":
+ x.MlnodeVersion = nil
+ case "inference.inference.GenesisState.bridge":
+ x.Bridge = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GenesisState"))
+ }
+ panic(fmt.Errorf("message inference.inference.GenesisState 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_GenesisState) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.GenesisState.params":
+ value := x.Params
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.GenesisState.genesis_only_params":
+ value := x.GenesisOnlyParams
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.GenesisState.model_list":
+ if len(x.ModelList) == 0 {
+ return protoreflect.ValueOfList(&_GenesisState_3_list{})
+ }
+ listValue := &_GenesisState_3_list{list: &x.ModelList}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.inference.GenesisState.cosm_wasm_params":
+ value := x.CosmWasmParams
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.GenesisState.participant_list":
+ if len(x.ParticipantList) == 0 {
+ return protoreflect.ValueOfList(&_GenesisState_5_list{})
+ }
+ listValue := &_GenesisState_5_list{list: &x.ParticipantList}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.inference.GenesisState.mlnode_version":
+ value := x.MlnodeVersion
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.GenesisState.bridge":
+ value := x.Bridge
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GenesisState"))
+ }
+ panic(fmt.Errorf("message inference.inference.GenesisState 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_GenesisState) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.GenesisState.params":
+ x.Params = value.Message().Interface().(*Params)
+ case "inference.inference.GenesisState.genesis_only_params":
+ x.GenesisOnlyParams = value.Message().Interface().(*GenesisOnlyParams)
+ case "inference.inference.GenesisState.model_list":
+ lv := value.List()
+ clv := lv.(*_GenesisState_3_list)
+ x.ModelList = *clv.list
+ case "inference.inference.GenesisState.cosm_wasm_params":
+ x.CosmWasmParams = value.Message().Interface().(*CosmWasmParams)
+ case "inference.inference.GenesisState.participant_list":
+ lv := value.List()
+ clv := lv.(*_GenesisState_5_list)
+ x.ParticipantList = *clv.list
+ case "inference.inference.GenesisState.mlnode_version":
+ x.MlnodeVersion = value.Message().Interface().(*MLNodeVersion)
+ case "inference.inference.GenesisState.bridge":
+ x.Bridge = value.Message().Interface().(*Bridge)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GenesisState"))
+ }
+ panic(fmt.Errorf("message inference.inference.GenesisState 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_GenesisState) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.GenesisState.params":
+ if x.Params == nil {
+ x.Params = new(Params)
+ }
+ return protoreflect.ValueOfMessage(x.Params.ProtoReflect())
+ case "inference.inference.GenesisState.genesis_only_params":
+ if x.GenesisOnlyParams == nil {
+ x.GenesisOnlyParams = new(GenesisOnlyParams)
+ }
+ return protoreflect.ValueOfMessage(x.GenesisOnlyParams.ProtoReflect())
+ case "inference.inference.GenesisState.model_list":
+ if x.ModelList == nil {
+ x.ModelList = []*Model{}
+ }
+ value := &_GenesisState_3_list{list: &x.ModelList}
+ return protoreflect.ValueOfList(value)
+ case "inference.inference.GenesisState.cosm_wasm_params":
+ if x.CosmWasmParams == nil {
+ x.CosmWasmParams = new(CosmWasmParams)
+ }
+ return protoreflect.ValueOfMessage(x.CosmWasmParams.ProtoReflect())
+ case "inference.inference.GenesisState.participant_list":
+ if x.ParticipantList == nil {
+ x.ParticipantList = []*Participant{}
+ }
+ value := &_GenesisState_5_list{list: &x.ParticipantList}
+ return protoreflect.ValueOfList(value)
+ case "inference.inference.GenesisState.mlnode_version":
+ if x.MlnodeVersion == nil {
+ x.MlnodeVersion = new(MLNodeVersion)
+ }
+ return protoreflect.ValueOfMessage(x.MlnodeVersion.ProtoReflect())
+ case "inference.inference.GenesisState.bridge":
+ if x.Bridge == nil {
+ x.Bridge = new(Bridge)
+ }
+ return protoreflect.ValueOfMessage(x.Bridge.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GenesisState"))
+ }
+ panic(fmt.Errorf("message inference.inference.GenesisState 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_GenesisState) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.GenesisState.params":
+ m := new(Params)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.GenesisState.genesis_only_params":
+ m := new(GenesisOnlyParams)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.GenesisState.model_list":
+ list := []*Model{}
+ return protoreflect.ValueOfList(&_GenesisState_3_list{list: &list})
+ case "inference.inference.GenesisState.cosm_wasm_params":
+ m := new(CosmWasmParams)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.GenesisState.participant_list":
+ list := []*Participant{}
+ return protoreflect.ValueOfList(&_GenesisState_5_list{list: &list})
+ case "inference.inference.GenesisState.mlnode_version":
+ m := new(MLNodeVersion)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.GenesisState.bridge":
+ m := new(Bridge)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GenesisState"))
+ }
+ panic(fmt.Errorf("message inference.inference.GenesisState 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_GenesisState) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.GenesisState", 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_GenesisState) 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_GenesisState) 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_GenesisState) 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_GenesisState) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*GenesisState)
+ 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.Params != nil {
+ l = options.Size(x.Params)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.GenesisOnlyParams != nil {
+ l = options.Size(x.GenesisOnlyParams)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if len(x.ModelList) > 0 {
+ for _, e := range x.ModelList {
+ l = options.Size(e)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ }
+ if x.CosmWasmParams != nil {
+ l = options.Size(x.CosmWasmParams)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if len(x.ParticipantList) > 0 {
+ for _, e := range x.ParticipantList {
+ 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.Bridge != nil {
+ l = options.Size(x.Bridge)
+ 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().(*GenesisState)
+ 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.Bridge != nil {
+ encoded, err := options.Marshal(x.Bridge)
+ 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 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] = 0x32
+ }
+ if len(x.ParticipantList) > 0 {
+ for iNdEx := len(x.ParticipantList) - 1; iNdEx >= 0; iNdEx-- {
+ encoded, err := options.Marshal(x.ParticipantList[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] = 0x2a
+ }
+ }
+ if x.CosmWasmParams != nil {
+ encoded, err := options.Marshal(x.CosmWasmParams)
+ 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.ModelList) > 0 {
+ for iNdEx := len(x.ModelList) - 1; iNdEx >= 0; iNdEx-- {
+ encoded, err := options.Marshal(x.ModelList[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.GenesisOnlyParams != nil {
+ encoded, err := options.Marshal(x.GenesisOnlyParams)
+ 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.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] = 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().(*GenesisState)
+ 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: GenesisState: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: GenesisState: 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 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 2:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field GenesisOnlyParams", 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.GenesisOnlyParams == nil {
+ x.GenesisOnlyParams = &GenesisOnlyParams{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.GenesisOnlyParams); 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 ModelList", 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.ModelList = append(x.ModelList, &Model{})
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ModelList[len(x.ModelList)-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 CosmWasmParams", 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.CosmWasmParams == nil {
+ x.CosmWasmParams = &CosmWasmParams{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.CosmWasmParams); 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 ParticipantList", 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.ParticipantList = append(x.ParticipantList, &Participant{})
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ParticipantList[len(x.ParticipantList)-1]); err != nil {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+ }
+ iNdEx = postIndex
+ case 6:
+ if wireType != 2 {
+ 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 {
+ if shift >= 64 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.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.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
+ case 7:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Bridge", 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.Bridge == nil {
+ x.Bridge = &Bridge{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Bridge); 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/genesis.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)
+)
+
+// Deprecated: kept for backward compatibility with existing genesis data
+type CosmWasmParams struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Cw20Code []byte `protobuf:"bytes,1,opt,name=cw20_code,json=cw20Code,proto3" json:"cw20_code,omitempty"`
+ Cw20CodeId uint64 `protobuf:"varint,2,opt,name=cw20_code_id,json=cw20CodeId,proto3" json:"cw20_code_id,omitempty"`
+}
+
+func (x *CosmWasmParams) Reset() {
+ *x = CosmWasmParams{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_genesis_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *CosmWasmParams) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*CosmWasmParams) ProtoMessage() {}
+
+// Deprecated: Use CosmWasmParams.ProtoReflect.Descriptor instead.
+func (*CosmWasmParams) Descriptor() ([]byte, []int) {
+ return file_inference_inference_genesis_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *CosmWasmParams) GetCw20Code() []byte {
+ if x != nil {
+ return x.Cw20Code
+ }
+ return nil
+}
+
+func (x *CosmWasmParams) GetCw20CodeId() uint64 {
+ if x != nil {
+ return x.Cw20CodeId
+ }
+ return 0
+}
+
+// GenesisState defines the inference module's genesis state.
+type GenesisState struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // params defines all the parameters of the module.
+ Params *Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params,omitempty"`
+ GenesisOnlyParams *GenesisOnlyParams `protobuf:"bytes,2,opt,name=genesis_only_params,json=genesisOnlyParams,proto3" json:"genesis_only_params,omitempty"`
+ ModelList []*Model `protobuf:"bytes,3,rep,name=model_list,json=modelList,proto3" json:"model_list,omitempty"`
+ // Deprecated: kept for backward compatibility with existing genesis data. This field is ignored during InitGenesis.
+ //
+ // Deprecated: Do not use.
+ CosmWasmParams *CosmWasmParams `protobuf:"bytes,4,opt,name=cosm_wasm_params,json=cosmWasmParams,proto3" json:"cosm_wasm_params,omitempty"`
+ ParticipantList []*Participant `protobuf:"bytes,5,rep,name=participant_list,json=participantList,proto3" json:"participant_list,omitempty"`
+ MlnodeVersion *MLNodeVersion `protobuf:"bytes,6,opt,name=mlnode_version,json=mlnodeVersion,proto3" json:"mlnode_version,omitempty"`
+ Bridge *Bridge `protobuf:"bytes,7,opt,name=bridge,proto3" json:"bridge,omitempty"`
+}
+
+func (x *GenesisState) Reset() {
+ *x = GenesisState{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_genesis_proto_msgTypes[1]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *GenesisState) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GenesisState) ProtoMessage() {}
+
+// Deprecated: Use GenesisState.ProtoReflect.Descriptor instead.
+func (*GenesisState) Descriptor() ([]byte, []int) {
+ return file_inference_inference_genesis_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *GenesisState) GetParams() *Params {
+ if x != nil {
+ return x.Params
+ }
+ return nil
+}
+
+func (x *GenesisState) GetGenesisOnlyParams() *GenesisOnlyParams {
+ if x != nil {
+ return x.GenesisOnlyParams
+ }
+ return nil
+}
+
+func (x *GenesisState) GetModelList() []*Model {
+ if x != nil {
+ return x.ModelList
+ }
+ return nil
+}
+
+// Deprecated: Do not use.
+func (x *GenesisState) GetCosmWasmParams() *CosmWasmParams {
+ if x != nil {
+ return x.CosmWasmParams
+ }
+ return nil
+}
+
+func (x *GenesisState) GetParticipantList() []*Participant {
+ if x != nil {
+ return x.ParticipantList
+ }
+ return nil
+}
+
+func (x *GenesisState) GetMlnodeVersion() *MLNodeVersion {
+ if x != nil {
+ return x.MlnodeVersion
+ }
+ return nil
+}
+
+func (x *GenesisState) GetBridge() *Bridge {
+ if x != nil {
+ return x.Bridge
+ }
+ return nil
+}
+
+var File_inference_inference_genesis_proto protoreflect.FileDescriptor
+
+var file_inference_inference_genesis_proto_rawDesc = []byte{
+ 0x0a, 0x21, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65,
+ 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 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, 0x1a, 0x11, 0x61, 0x6d, 0x69, 0x6e, 0x6f, 0x2f,
+ 0x61, 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, 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, 0x1a, 0x23, 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, 0x2e, 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, 0x70, 0x61,
+ 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a,
+ 0x2a, 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, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x27, 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, 0x2e, 0x70,
+ 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x31, 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, 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, 0x74, 0x6f, 0x6b,
+ 0x65, 0x6e, 0x6f, 0x6d, 0x69, 0x63, 0x73, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x70, 0x72, 0x6f,
+ 0x74, 0x6f, 0x1a, 0x1f, 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, 0x2e, 0x70, 0x72,
+ 0x6f, 0x74, 0x6f, 0x1a, 0x23, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69,
+ 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x74, 0x6f, 0x70, 0x5f, 0x6d, 0x69, 0x6e,
+ 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x2b, 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, 0x2e,
+ 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x36, 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, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x33, 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, 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, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x5f,
+ 0x75, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x2e, 0x70, 0x72, 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, 0x62, 0x72, 0x69, 0x64, 0x67, 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, 0x6d, 0x6c, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73,
+ 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x55, 0x0a, 0x0e, 0x43, 0x6f, 0x73,
+ 0x6d, 0x57, 0x61, 0x73, 0x6d, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x1b, 0x0a, 0x09, 0x63,
+ 0x77, 0x32, 0x30, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08,
+ 0x63, 0x77, 0x32, 0x30, 0x43, 0x6f, 0x64, 0x65, 0x12, 0x20, 0x0a, 0x0c, 0x63, 0x77, 0x32, 0x30,
+ 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a,
+ 0x63, 0x77, 0x32, 0x30, 0x43, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01,
+ 0x22, 0x9d, 0x04, 0x0a, 0x0c, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x53, 0x74, 0x61, 0x74,
+ 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, 0x12, 0x61, 0x0a, 0x13, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x5f, 0x6f, 0x6e, 0x6c,
+ 0x79, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x02, 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, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x4f, 0x6e, 0x6c, 0x79,
+ 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a,
+ 0x01, 0x52, 0x11, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x4f, 0x6e, 0x6c, 0x79, 0x50, 0x61,
+ 0x72, 0x61, 0x6d, 0x73, 0x12, 0x3f, 0x0a, 0x0a, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x6c, 0x69,
+ 0x73, 0x74, 0x18, 0x03, 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, 0x09, 0x6d, 0x6f, 0x64, 0x65,
+ 0x6c, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x51, 0x0a, 0x10, 0x63, 0x6f, 0x73, 0x6d, 0x5f, 0x77, 0x61,
+ 0x73, 0x6d, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x04, 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, 0x43, 0x6f, 0x73, 0x6d, 0x57, 0x61, 0x73, 0x6d, 0x50, 0x61,
+ 0x72, 0x61, 0x6d, 0x73, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0e, 0x63, 0x6f, 0x73, 0x6d, 0x57, 0x61,
+ 0x73, 0x6d, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x56, 0x0a, 0x10, 0x70, 0x61, 0x72, 0x74,
+ 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x5f, 0x6c, 0x69, 0x73, 0x74, 0x18, 0x05, 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, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52,
+ 0x0f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x4c, 0x69, 0x73, 0x74,
+ 0x12, 0x49, 0x0a, 0x0e, 0x6d, 0x6c, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69,
+ 0x6f, 0x6e, 0x18, 0x06, 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, 0x52, 0x0d, 0x6d, 0x6c,
+ 0x6e, 0x6f, 0x64, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x33, 0x0a, 0x06, 0x62,
+ 0x72, 0x69, 0x64, 0x67, 0x65, 0x18, 0x07, 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, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x52, 0x06, 0x62, 0x72, 0x69, 0x64, 0x67, 0x65,
+ 0x42, 0xba, 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, 0x0c, 0x47, 0x65,
+ 0x6e, 0x65, 0x73, 0x69, 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 (
+ file_inference_inference_genesis_proto_rawDescOnce sync.Once
+ file_inference_inference_genesis_proto_rawDescData = file_inference_inference_genesis_proto_rawDesc
+)
+
+func file_inference_inference_genesis_proto_rawDescGZIP() []byte {
+ file_inference_inference_genesis_proto_rawDescOnce.Do(func() {
+ file_inference_inference_genesis_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_inference_genesis_proto_rawDescData)
+ })
+ return file_inference_inference_genesis_proto_rawDescData
+}
+
+var file_inference_inference_genesis_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
+var file_inference_inference_genesis_proto_goTypes = []interface{}{
+ (*CosmWasmParams)(nil), // 0: inference.inference.CosmWasmParams
+ (*GenesisState)(nil), // 1: inference.inference.GenesisState
+ (*Params)(nil), // 2: inference.inference.Params
+ (*GenesisOnlyParams)(nil), // 3: inference.inference.GenesisOnlyParams
+ (*Model)(nil), // 4: inference.inference.Model
+ (*Participant)(nil), // 5: inference.inference.Participant
+ (*MLNodeVersion)(nil), // 6: inference.inference.MLNodeVersion
+ (*Bridge)(nil), // 7: inference.inference.Bridge
+}
+var file_inference_inference_genesis_proto_depIdxs = []int32{
+ 2, // 0: inference.inference.GenesisState.params:type_name -> inference.inference.Params
+ 3, // 1: inference.inference.GenesisState.genesis_only_params:type_name -> inference.inference.GenesisOnlyParams
+ 4, // 2: inference.inference.GenesisState.model_list:type_name -> inference.inference.Model
+ 0, // 3: inference.inference.GenesisState.cosm_wasm_params:type_name -> inference.inference.CosmWasmParams
+ 5, // 4: inference.inference.GenesisState.participant_list:type_name -> inference.inference.Participant
+ 6, // 5: inference.inference.GenesisState.mlnode_version:type_name -> inference.inference.MLNodeVersion
+ 7, // 6: inference.inference.GenesisState.bridge:type_name -> inference.inference.Bridge
+ 7, // [7:7] is the sub-list for method output_type
+ 7, // [7:7] is the sub-list for method input_type
+ 7, // [7:7] is the sub-list for extension type_name
+ 7, // [7:7] is the sub-list for extension extendee
+ 0, // [0:7] is the sub-list for field type_name
+}
+
+func init() { file_inference_inference_genesis_proto_init() }
+func file_inference_inference_genesis_proto_init() {
+ if File_inference_inference_genesis_proto != nil {
+ return
+ }
+ file_inference_inference_params_proto_init()
+ file_inference_inference_inference_proto_init()
+ file_inference_inference_participant_proto_init()
+ file_inference_inference_epoch_group_data_proto_init()
+ file_inference_inference_settle_amount_proto_init()
+ file_inference_inference_epoch_group_validations_proto_init()
+ file_inference_inference_tokenomics_data_proto_init()
+ file_inference_inference_model_proto_init()
+ file_inference_inference_top_miner_proto_init()
+ file_inference_inference_inference_timeout_proto_init()
+ file_inference_inference_inference_validation_details_proto_init()
+ file_inference_inference_epoch_performance_summary_proto_init()
+ file_inference_inference_partial_upgrade_proto_init()
+ file_inference_inference_bridge_proto_init()
+ file_inference_inference_mlnode_version_proto_init()
+ if !protoimpl.UnsafeEnabled {
+ file_inference_inference_genesis_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*CosmWasmParams); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_inference_genesis_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*GenesisState); 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_genesis_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 2,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_inference_genesis_proto_goTypes,
+ DependencyIndexes: file_inference_inference_genesis_proto_depIdxs,
+ MessageInfos: file_inference_inference_genesis_proto_msgTypes,
+ }.Build()
+ File_inference_inference_genesis_proto = out.File
+ file_inference_inference_genesis_proto_rawDesc = nil
+ file_inference_inference_genesis_proto_goTypes = nil
+ file_inference_inference_genesis_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/inference/hardware_node.pulsar.go b/inference-chain/api/inference/inference/hardware_node.pulsar.go
new file mode 100644
index 000000000..6aa850a7b
--- /dev/null
+++ b/inference-chain/api/inference/inference/hardware_node.pulsar.go
@@ -0,0 +1,2279 @@
+// 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 _ protoreflect.List = (*_HardwareNodes_2_list)(nil)
+
+type _HardwareNodes_2_list struct {
+ list *[]*HardwareNode
+}
+
+func (x *_HardwareNodes_2_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_HardwareNodes_2_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_HardwareNodes_2_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*HardwareNode)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_HardwareNodes_2_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*HardwareNode)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_HardwareNodes_2_list) AppendMutable() protoreflect.Value {
+ v := new(HardwareNode)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_HardwareNodes_2_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_HardwareNodes_2_list) NewElement() protoreflect.Value {
+ v := new(HardwareNode)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_HardwareNodes_2_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_HardwareNodes protoreflect.MessageDescriptor
+ fd_HardwareNodes_participant protoreflect.FieldDescriptor
+ fd_HardwareNodes_hardware_nodes protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_hardware_node_proto_init()
+ md_HardwareNodes = File_inference_inference_hardware_node_proto.Messages().ByName("HardwareNodes")
+ fd_HardwareNodes_participant = md_HardwareNodes.Fields().ByName("participant")
+ fd_HardwareNodes_hardware_nodes = md_HardwareNodes.Fields().ByName("hardware_nodes")
+}
+
+var _ protoreflect.Message = (*fastReflection_HardwareNodes)(nil)
+
+type fastReflection_HardwareNodes HardwareNodes
+
+func (x *HardwareNodes) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_HardwareNodes)(x)
+}
+
+func (x *HardwareNodes) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_hardware_node_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_HardwareNodes_messageType fastReflection_HardwareNodes_messageType
+var _ protoreflect.MessageType = fastReflection_HardwareNodes_messageType{}
+
+type fastReflection_HardwareNodes_messageType struct{}
+
+func (x fastReflection_HardwareNodes_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_HardwareNodes)(nil)
+}
+func (x fastReflection_HardwareNodes_messageType) New() protoreflect.Message {
+ return new(fastReflection_HardwareNodes)
+}
+func (x fastReflection_HardwareNodes_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_HardwareNodes
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_HardwareNodes) Descriptor() protoreflect.MessageDescriptor {
+ return md_HardwareNodes
+}
+
+// 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_HardwareNodes) Type() protoreflect.MessageType {
+ return _fastReflection_HardwareNodes_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_HardwareNodes) New() protoreflect.Message {
+ return new(fastReflection_HardwareNodes)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_HardwareNodes) Interface() protoreflect.ProtoMessage {
+ return (*HardwareNodes)(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_HardwareNodes) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Participant != "" {
+ value := protoreflect.ValueOfString(x.Participant)
+ if !f(fd_HardwareNodes_participant, value) {
+ return
+ }
+ }
+ if len(x.HardwareNodes) != 0 {
+ value := protoreflect.ValueOfList(&_HardwareNodes_2_list{list: &x.HardwareNodes})
+ if !f(fd_HardwareNodes_hardware_nodes, 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_HardwareNodes) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.HardwareNodes.participant":
+ return x.Participant != ""
+ case "inference.inference.HardwareNodes.hardware_nodes":
+ return len(x.HardwareNodes) != 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.HardwareNodes"))
+ }
+ panic(fmt.Errorf("message inference.inference.HardwareNodes 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_HardwareNodes) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.HardwareNodes.participant":
+ x.Participant = ""
+ case "inference.inference.HardwareNodes.hardware_nodes":
+ x.HardwareNodes = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.HardwareNodes"))
+ }
+ panic(fmt.Errorf("message inference.inference.HardwareNodes 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_HardwareNodes) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.HardwareNodes.participant":
+ value := x.Participant
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.HardwareNodes.hardware_nodes":
+ if len(x.HardwareNodes) == 0 {
+ return protoreflect.ValueOfList(&_HardwareNodes_2_list{})
+ }
+ listValue := &_HardwareNodes_2_list{list: &x.HardwareNodes}
+ return protoreflect.ValueOfList(listValue)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.HardwareNodes"))
+ }
+ panic(fmt.Errorf("message inference.inference.HardwareNodes 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_HardwareNodes) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.HardwareNodes.participant":
+ x.Participant = value.Interface().(string)
+ case "inference.inference.HardwareNodes.hardware_nodes":
+ lv := value.List()
+ clv := lv.(*_HardwareNodes_2_list)
+ x.HardwareNodes = *clv.list
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.HardwareNodes"))
+ }
+ panic(fmt.Errorf("message inference.inference.HardwareNodes 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_HardwareNodes) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.HardwareNodes.hardware_nodes":
+ if x.HardwareNodes == nil {
+ x.HardwareNodes = []*HardwareNode{}
+ }
+ value := &_HardwareNodes_2_list{list: &x.HardwareNodes}
+ return protoreflect.ValueOfList(value)
+ case "inference.inference.HardwareNodes.participant":
+ panic(fmt.Errorf("field participant of message inference.inference.HardwareNodes is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.HardwareNodes"))
+ }
+ panic(fmt.Errorf("message inference.inference.HardwareNodes 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_HardwareNodes) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.HardwareNodes.participant":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.HardwareNodes.hardware_nodes":
+ list := []*HardwareNode{}
+ return protoreflect.ValueOfList(&_HardwareNodes_2_list{list: &list})
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.HardwareNodes"))
+ }
+ panic(fmt.Errorf("message inference.inference.HardwareNodes 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_HardwareNodes) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.HardwareNodes", 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_HardwareNodes) 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_HardwareNodes) 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_HardwareNodes) 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_HardwareNodes) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*HardwareNodes)
+ 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 len(x.HardwareNodes) > 0 {
+ for _, e := range x.HardwareNodes {
+ 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().(*HardwareNodes)
+ 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.HardwareNodes) > 0 {
+ for iNdEx := len(x.HardwareNodes) - 1; iNdEx >= 0; iNdEx-- {
+ encoded, err := options.Marshal(x.HardwareNodes[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.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().(*HardwareNodes)
+ 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: HardwareNodes: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: HardwareNodes: 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 HardwareNodes", 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.HardwareNodes = append(x.HardwareNodes, &HardwareNode{})
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.HardwareNodes[len(x.HardwareNodes)-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 _ protoreflect.List = (*_HardwareNode_3_list)(nil)
+
+type _HardwareNode_3_list struct {
+ list *[]string
+}
+
+func (x *_HardwareNode_3_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_HardwareNode_3_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfString((*x.list)[i])
+}
+
+func (x *_HardwareNode_3_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.String()
+ concreteValue := valueUnwrapped
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_HardwareNode_3_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.String()
+ concreteValue := valueUnwrapped
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_HardwareNode_3_list) AppendMutable() protoreflect.Value {
+ panic(fmt.Errorf("AppendMutable can not be called on message HardwareNode at list field Models as it is not of Message kind"))
+}
+
+func (x *_HardwareNode_3_list) Truncate(n int) {
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_HardwareNode_3_list) NewElement() protoreflect.Value {
+ v := ""
+ return protoreflect.ValueOfString(v)
+}
+
+func (x *_HardwareNode_3_list) IsValid() bool {
+ return x.list != nil
+}
+
+var _ protoreflect.List = (*_HardwareNode_4_list)(nil)
+
+type _HardwareNode_4_list struct {
+ list *[]*Hardware
+}
+
+func (x *_HardwareNode_4_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_HardwareNode_4_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_HardwareNode_4_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*Hardware)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_HardwareNode_4_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*Hardware)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_HardwareNode_4_list) AppendMutable() protoreflect.Value {
+ v := new(Hardware)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_HardwareNode_4_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_HardwareNode_4_list) NewElement() protoreflect.Value {
+ v := new(Hardware)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_HardwareNode_4_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_HardwareNode protoreflect.MessageDescriptor
+ fd_HardwareNode_local_id protoreflect.FieldDescriptor
+ fd_HardwareNode_status protoreflect.FieldDescriptor
+ fd_HardwareNode_models protoreflect.FieldDescriptor
+ fd_HardwareNode_hardware protoreflect.FieldDescriptor
+ fd_HardwareNode_host protoreflect.FieldDescriptor
+ fd_HardwareNode_port protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_hardware_node_proto_init()
+ md_HardwareNode = File_inference_inference_hardware_node_proto.Messages().ByName("HardwareNode")
+ fd_HardwareNode_local_id = md_HardwareNode.Fields().ByName("local_id")
+ fd_HardwareNode_status = md_HardwareNode.Fields().ByName("status")
+ fd_HardwareNode_models = md_HardwareNode.Fields().ByName("models")
+ fd_HardwareNode_hardware = md_HardwareNode.Fields().ByName("hardware")
+ fd_HardwareNode_host = md_HardwareNode.Fields().ByName("host")
+ fd_HardwareNode_port = md_HardwareNode.Fields().ByName("port")
+}
+
+var _ protoreflect.Message = (*fastReflection_HardwareNode)(nil)
+
+type fastReflection_HardwareNode HardwareNode
+
+func (x *HardwareNode) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_HardwareNode)(x)
+}
+
+func (x *HardwareNode) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_hardware_node_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_HardwareNode_messageType fastReflection_HardwareNode_messageType
+var _ protoreflect.MessageType = fastReflection_HardwareNode_messageType{}
+
+type fastReflection_HardwareNode_messageType struct{}
+
+func (x fastReflection_HardwareNode_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_HardwareNode)(nil)
+}
+func (x fastReflection_HardwareNode_messageType) New() protoreflect.Message {
+ return new(fastReflection_HardwareNode)
+}
+func (x fastReflection_HardwareNode_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_HardwareNode
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_HardwareNode) Descriptor() protoreflect.MessageDescriptor {
+ return md_HardwareNode
+}
+
+// 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_HardwareNode) Type() protoreflect.MessageType {
+ return _fastReflection_HardwareNode_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_HardwareNode) New() protoreflect.Message {
+ return new(fastReflection_HardwareNode)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_HardwareNode) Interface() protoreflect.ProtoMessage {
+ return (*HardwareNode)(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_HardwareNode) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.LocalId != "" {
+ value := protoreflect.ValueOfString(x.LocalId)
+ if !f(fd_HardwareNode_local_id, value) {
+ return
+ }
+ }
+ if x.Status != 0 {
+ value := protoreflect.ValueOfEnum((protoreflect.EnumNumber)(x.Status))
+ if !f(fd_HardwareNode_status, value) {
+ return
+ }
+ }
+ if len(x.Models) != 0 {
+ value := protoreflect.ValueOfList(&_HardwareNode_3_list{list: &x.Models})
+ if !f(fd_HardwareNode_models, value) {
+ return
+ }
+ }
+ if len(x.Hardware) != 0 {
+ value := protoreflect.ValueOfList(&_HardwareNode_4_list{list: &x.Hardware})
+ if !f(fd_HardwareNode_hardware, value) {
+ return
+ }
+ }
+ if x.Host != "" {
+ value := protoreflect.ValueOfString(x.Host)
+ if !f(fd_HardwareNode_host, value) {
+ return
+ }
+ }
+ if x.Port != "" {
+ value := protoreflect.ValueOfString(x.Port)
+ if !f(fd_HardwareNode_port, 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_HardwareNode) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.HardwareNode.local_id":
+ return x.LocalId != ""
+ case "inference.inference.HardwareNode.status":
+ return x.Status != 0
+ case "inference.inference.HardwareNode.models":
+ return len(x.Models) != 0
+ case "inference.inference.HardwareNode.hardware":
+ return len(x.Hardware) != 0
+ case "inference.inference.HardwareNode.host":
+ return x.Host != ""
+ case "inference.inference.HardwareNode.port":
+ return x.Port != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.HardwareNode"))
+ }
+ panic(fmt.Errorf("message inference.inference.HardwareNode 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_HardwareNode) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.HardwareNode.local_id":
+ x.LocalId = ""
+ case "inference.inference.HardwareNode.status":
+ x.Status = 0
+ case "inference.inference.HardwareNode.models":
+ x.Models = nil
+ case "inference.inference.HardwareNode.hardware":
+ x.Hardware = nil
+ case "inference.inference.HardwareNode.host":
+ x.Host = ""
+ case "inference.inference.HardwareNode.port":
+ x.Port = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.HardwareNode"))
+ }
+ panic(fmt.Errorf("message inference.inference.HardwareNode 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_HardwareNode) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.HardwareNode.local_id":
+ value := x.LocalId
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.HardwareNode.status":
+ value := x.Status
+ return protoreflect.ValueOfEnum((protoreflect.EnumNumber)(value))
+ case "inference.inference.HardwareNode.models":
+ if len(x.Models) == 0 {
+ return protoreflect.ValueOfList(&_HardwareNode_3_list{})
+ }
+ listValue := &_HardwareNode_3_list{list: &x.Models}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.inference.HardwareNode.hardware":
+ if len(x.Hardware) == 0 {
+ return protoreflect.ValueOfList(&_HardwareNode_4_list{})
+ }
+ listValue := &_HardwareNode_4_list{list: &x.Hardware}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.inference.HardwareNode.host":
+ value := x.Host
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.HardwareNode.port":
+ value := x.Port
+ return protoreflect.ValueOfString(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.HardwareNode"))
+ }
+ panic(fmt.Errorf("message inference.inference.HardwareNode 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_HardwareNode) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.HardwareNode.local_id":
+ x.LocalId = value.Interface().(string)
+ case "inference.inference.HardwareNode.status":
+ x.Status = (HardwareNodeStatus)(value.Enum())
+ case "inference.inference.HardwareNode.models":
+ lv := value.List()
+ clv := lv.(*_HardwareNode_3_list)
+ x.Models = *clv.list
+ case "inference.inference.HardwareNode.hardware":
+ lv := value.List()
+ clv := lv.(*_HardwareNode_4_list)
+ x.Hardware = *clv.list
+ case "inference.inference.HardwareNode.host":
+ x.Host = value.Interface().(string)
+ case "inference.inference.HardwareNode.port":
+ x.Port = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.HardwareNode"))
+ }
+ panic(fmt.Errorf("message inference.inference.HardwareNode 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_HardwareNode) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.HardwareNode.models":
+ if x.Models == nil {
+ x.Models = []string{}
+ }
+ value := &_HardwareNode_3_list{list: &x.Models}
+ return protoreflect.ValueOfList(value)
+ case "inference.inference.HardwareNode.hardware":
+ if x.Hardware == nil {
+ x.Hardware = []*Hardware{}
+ }
+ value := &_HardwareNode_4_list{list: &x.Hardware}
+ return protoreflect.ValueOfList(value)
+ case "inference.inference.HardwareNode.local_id":
+ panic(fmt.Errorf("field local_id of message inference.inference.HardwareNode is not mutable"))
+ case "inference.inference.HardwareNode.status":
+ panic(fmt.Errorf("field status of message inference.inference.HardwareNode is not mutable"))
+ case "inference.inference.HardwareNode.host":
+ panic(fmt.Errorf("field host of message inference.inference.HardwareNode is not mutable"))
+ case "inference.inference.HardwareNode.port":
+ panic(fmt.Errorf("field port of message inference.inference.HardwareNode is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.HardwareNode"))
+ }
+ panic(fmt.Errorf("message inference.inference.HardwareNode 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_HardwareNode) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.HardwareNode.local_id":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.HardwareNode.status":
+ return protoreflect.ValueOfEnum(0)
+ case "inference.inference.HardwareNode.models":
+ list := []string{}
+ return protoreflect.ValueOfList(&_HardwareNode_3_list{list: &list})
+ case "inference.inference.HardwareNode.hardware":
+ list := []*Hardware{}
+ return protoreflect.ValueOfList(&_HardwareNode_4_list{list: &list})
+ case "inference.inference.HardwareNode.host":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.HardwareNode.port":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.HardwareNode"))
+ }
+ panic(fmt.Errorf("message inference.inference.HardwareNode 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_HardwareNode) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.HardwareNode", 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_HardwareNode) 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_HardwareNode) 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_HardwareNode) 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_HardwareNode) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*HardwareNode)
+ 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.LocalId)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.Status != 0 {
+ n += 1 + runtime.Sov(uint64(x.Status))
+ }
+ if len(x.Models) > 0 {
+ for _, s := range x.Models {
+ l = len(s)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ }
+ if len(x.Hardware) > 0 {
+ for _, e := range x.Hardware {
+ l = options.Size(e)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ }
+ l = len(x.Host)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ l = len(x.Port)
+ 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().(*HardwareNode)
+ 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.Port) > 0 {
+ i -= len(x.Port)
+ copy(dAtA[i:], x.Port)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Port)))
+ i--
+ dAtA[i] = 0x32
+ }
+ if len(x.Host) > 0 {
+ i -= len(x.Host)
+ copy(dAtA[i:], x.Host)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Host)))
+ i--
+ dAtA[i] = 0x2a
+ }
+ if len(x.Hardware) > 0 {
+ for iNdEx := len(x.Hardware) - 1; iNdEx >= 0; iNdEx-- {
+ encoded, err := options.Marshal(x.Hardware[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.Models) > 0 {
+ for iNdEx := len(x.Models) - 1; iNdEx >= 0; iNdEx-- {
+ i -= len(x.Models[iNdEx])
+ copy(dAtA[i:], x.Models[iNdEx])
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Models[iNdEx])))
+ i--
+ dAtA[i] = 0x1a
+ }
+ }
+ if x.Status != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.Status))
+ i--
+ dAtA[i] = 0x10
+ }
+ if len(x.LocalId) > 0 {
+ i -= len(x.LocalId)
+ copy(dAtA[i:], x.LocalId)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.LocalId)))
+ 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().(*HardwareNode)
+ 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: HardwareNode: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: HardwareNode: 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 LocalId", 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.LocalId = 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 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 |= HardwareNodeStatus(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 Models", 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.Models = append(x.Models, 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 Hardware", 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.Hardware = append(x.Hardware, &Hardware{})
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Hardware[len(x.Hardware)-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 Host", 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.Host = 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 Port", 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.Port = 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_Hardware protoreflect.MessageDescriptor
+ fd_Hardware_type protoreflect.FieldDescriptor
+ fd_Hardware_count protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_hardware_node_proto_init()
+ md_Hardware = File_inference_inference_hardware_node_proto.Messages().ByName("Hardware")
+ fd_Hardware_type = md_Hardware.Fields().ByName("type")
+ fd_Hardware_count = md_Hardware.Fields().ByName("count")
+}
+
+var _ protoreflect.Message = (*fastReflection_Hardware)(nil)
+
+type fastReflection_Hardware Hardware
+
+func (x *Hardware) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_Hardware)(x)
+}
+
+func (x *Hardware) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_hardware_node_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_Hardware_messageType fastReflection_Hardware_messageType
+var _ protoreflect.MessageType = fastReflection_Hardware_messageType{}
+
+type fastReflection_Hardware_messageType struct{}
+
+func (x fastReflection_Hardware_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_Hardware)(nil)
+}
+func (x fastReflection_Hardware_messageType) New() protoreflect.Message {
+ return new(fastReflection_Hardware)
+}
+func (x fastReflection_Hardware_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_Hardware
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_Hardware) Descriptor() protoreflect.MessageDescriptor {
+ return md_Hardware
+}
+
+// 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_Hardware) Type() protoreflect.MessageType {
+ return _fastReflection_Hardware_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_Hardware) New() protoreflect.Message {
+ return new(fastReflection_Hardware)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_Hardware) Interface() protoreflect.ProtoMessage {
+ return (*Hardware)(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_Hardware) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Type_ != "" {
+ value := protoreflect.ValueOfString(x.Type_)
+ if !f(fd_Hardware_type, value) {
+ return
+ }
+ }
+ if x.Count != uint32(0) {
+ value := protoreflect.ValueOfUint32(x.Count)
+ if !f(fd_Hardware_count, 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_Hardware) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.Hardware.type":
+ return x.Type_ != ""
+ case "inference.inference.Hardware.count":
+ return x.Count != uint32(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Hardware"))
+ }
+ panic(fmt.Errorf("message inference.inference.Hardware 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_Hardware) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.Hardware.type":
+ x.Type_ = ""
+ case "inference.inference.Hardware.count":
+ x.Count = uint32(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Hardware"))
+ }
+ panic(fmt.Errorf("message inference.inference.Hardware 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_Hardware) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.Hardware.type":
+ value := x.Type_
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.Hardware.count":
+ value := x.Count
+ return protoreflect.ValueOfUint32(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Hardware"))
+ }
+ panic(fmt.Errorf("message inference.inference.Hardware 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_Hardware) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.Hardware.type":
+ x.Type_ = value.Interface().(string)
+ case "inference.inference.Hardware.count":
+ x.Count = uint32(value.Uint())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Hardware"))
+ }
+ panic(fmt.Errorf("message inference.inference.Hardware 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_Hardware) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.Hardware.type":
+ panic(fmt.Errorf("field type of message inference.inference.Hardware is not mutable"))
+ case "inference.inference.Hardware.count":
+ panic(fmt.Errorf("field count of message inference.inference.Hardware is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Hardware"))
+ }
+ panic(fmt.Errorf("message inference.inference.Hardware 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_Hardware) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.Hardware.type":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.Hardware.count":
+ return protoreflect.ValueOfUint32(uint32(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Hardware"))
+ }
+ panic(fmt.Errorf("message inference.inference.Hardware 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_Hardware) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.Hardware", 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_Hardware) 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_Hardware) 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_Hardware) 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_Hardware) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*Hardware)
+ 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.Type_)
+ if l > 0 {
+ 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)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*Hardware)
+ 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.Count != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.Count))
+ i--
+ dAtA[i] = 0x10
+ }
+ if len(x.Type_) > 0 {
+ i -= len(x.Type_)
+ copy(dAtA[i:], x.Type_)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Type_)))
+ 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().(*Hardware)
+ 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: Hardware: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Hardware: 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 Type_", 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.Type_ = 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
+ }
+ }
+ 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/hardware_node.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)
+)
+
+type HardwareNodeStatus int32
+
+const (
+ HardwareNodeStatus_UNKNOWN HardwareNodeStatus = 0
+ HardwareNodeStatus_INFERENCE HardwareNodeStatus = 1
+ HardwareNodeStatus_POC HardwareNodeStatus = 2
+ HardwareNodeStatus_TRAINING HardwareNodeStatus = 3
+ HardwareNodeStatus_STOPPED HardwareNodeStatus = 4
+ HardwareNodeStatus_FAILED HardwareNodeStatus = 5
+)
+
+// Enum value maps for HardwareNodeStatus.
+var (
+ HardwareNodeStatus_name = map[int32]string{
+ 0: "UNKNOWN",
+ 1: "INFERENCE",
+ 2: "POC",
+ 3: "TRAINING",
+ 4: "STOPPED",
+ 5: "FAILED",
+ }
+ HardwareNodeStatus_value = map[string]int32{
+ "UNKNOWN": 0,
+ "INFERENCE": 1,
+ "POC": 2,
+ "TRAINING": 3,
+ "STOPPED": 4,
+ "FAILED": 5,
+ }
+)
+
+func (x HardwareNodeStatus) Enum() *HardwareNodeStatus {
+ p := new(HardwareNodeStatus)
+ *p = x
+ return p
+}
+
+func (x HardwareNodeStatus) String() string {
+ return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (HardwareNodeStatus) Descriptor() protoreflect.EnumDescriptor {
+ return file_inference_inference_hardware_node_proto_enumTypes[0].Descriptor()
+}
+
+func (HardwareNodeStatus) Type() protoreflect.EnumType {
+ return &file_inference_inference_hardware_node_proto_enumTypes[0]
+}
+
+func (x HardwareNodeStatus) Number() protoreflect.EnumNumber {
+ return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use HardwareNodeStatus.Descriptor instead.
+func (HardwareNodeStatus) EnumDescriptor() ([]byte, []int) {
+ return file_inference_inference_hardware_node_proto_rawDescGZIP(), []int{0}
+}
+
+// IF YOU CHANGE ANY OF THESE STRUCTURES BE SURE TO CHANGE InferenceNode struct in decentralized-api!!!
+type HardwareNodes struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Participant string `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
+ HardwareNodes []*HardwareNode `protobuf:"bytes,2,rep,name=hardware_nodes,json=hardwareNodes,proto3" json:"hardware_nodes,omitempty"`
+}
+
+func (x *HardwareNodes) Reset() {
+ *x = HardwareNodes{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_hardware_node_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *HardwareNodes) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*HardwareNodes) ProtoMessage() {}
+
+// Deprecated: Use HardwareNodes.ProtoReflect.Descriptor instead.
+func (*HardwareNodes) Descriptor() ([]byte, []int) {
+ return file_inference_inference_hardware_node_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *HardwareNodes) GetParticipant() string {
+ if x != nil {
+ return x.Participant
+ }
+ return ""
+}
+
+func (x *HardwareNodes) GetHardwareNodes() []*HardwareNode {
+ if x != nil {
+ return x.HardwareNodes
+ }
+ return nil
+}
+
+type HardwareNode struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ LocalId string `protobuf:"bytes,1,opt,name=local_id,json=localId,proto3" json:"local_id,omitempty"`
+ Status HardwareNodeStatus `protobuf:"varint,2,opt,name=status,proto3,enum=inference.inference.HardwareNodeStatus" json:"status,omitempty"`
+ Models []string `protobuf:"bytes,3,rep,name=models,proto3" json:"models,omitempty"`
+ Hardware []*Hardware `protobuf:"bytes,4,rep,name=hardware,proto3" json:"hardware,omitempty"`
+ Host string `protobuf:"bytes,5,opt,name=host,proto3" json:"host,omitempty"`
+ Port string `protobuf:"bytes,6,opt,name=port,proto3" json:"port,omitempty"`
+}
+
+func (x *HardwareNode) Reset() {
+ *x = HardwareNode{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_hardware_node_proto_msgTypes[1]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *HardwareNode) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*HardwareNode) ProtoMessage() {}
+
+// Deprecated: Use HardwareNode.ProtoReflect.Descriptor instead.
+func (*HardwareNode) Descriptor() ([]byte, []int) {
+ return file_inference_inference_hardware_node_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *HardwareNode) GetLocalId() string {
+ if x != nil {
+ return x.LocalId
+ }
+ return ""
+}
+
+func (x *HardwareNode) GetStatus() HardwareNodeStatus {
+ if x != nil {
+ return x.Status
+ }
+ return HardwareNodeStatus_UNKNOWN
+}
+
+func (x *HardwareNode) GetModels() []string {
+ if x != nil {
+ return x.Models
+ }
+ return nil
+}
+
+func (x *HardwareNode) GetHardware() []*Hardware {
+ if x != nil {
+ return x.Hardware
+ }
+ return nil
+}
+
+func (x *HardwareNode) GetHost() string {
+ if x != nil {
+ return x.Host
+ }
+ return ""
+}
+
+func (x *HardwareNode) GetPort() string {
+ if x != nil {
+ return x.Port
+ }
+ return ""
+}
+
+type Hardware struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Type_ string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
+ Count uint32 `protobuf:"varint,2,opt,name=count,proto3" json:"count,omitempty"`
+}
+
+func (x *Hardware) Reset() {
+ *x = Hardware{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_hardware_node_proto_msgTypes[2]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *Hardware) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Hardware) ProtoMessage() {}
+
+// Deprecated: Use Hardware.ProtoReflect.Descriptor instead.
+func (*Hardware) Descriptor() ([]byte, []int) {
+ return file_inference_inference_hardware_node_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *Hardware) GetType_() string {
+ if x != nil {
+ return x.Type_
+ }
+ return ""
+}
+
+func (x *Hardware) GetCount() uint32 {
+ if x != nil {
+ return x.Count
+ }
+ return 0
+}
+
+var File_inference_inference_hardware_node_proto protoreflect.FileDescriptor
+
+var file_inference_inference_hardware_node_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, 0x68, 0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x5f, 0x6e,
+ 0x6f, 0x64, 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, 0x7b,
+ 0x0a, 0x0d, 0x48, 0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x4e, 0x6f, 0x64, 0x65, 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, 0x48, 0x0a, 0x0e, 0x68, 0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x5f, 0x6e, 0x6f,
+ 0x64, 0x65, 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,
+ 0x48, 0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x0d, 0x68, 0x61,
+ 0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x22, 0xe5, 0x01, 0x0a, 0x0c,
+ 0x48, 0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x19, 0x0a, 0x08,
+ 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07,
+ 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x49, 0x64, 0x12, 0x3f, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75,
+ 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x27, 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, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73,
+ 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x6d, 0x6f, 0x64, 0x65,
+ 0x6c, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73,
+ 0x12, 0x39, 0x0a, 0x08, 0x68, 0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 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, 0x48, 0x61, 0x72, 0x64, 0x77, 0x61, 0x72,
+ 0x65, 0x52, 0x08, 0x68, 0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x68,
+ 0x6f, 0x73, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x68, 0x6f, 0x73, 0x74, 0x12,
+ 0x12, 0x0a, 0x04, 0x70, 0x6f, 0x72, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x70,
+ 0x6f, 0x72, 0x74, 0x22, 0x34, 0x0a, 0x08, 0x48, 0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x12,
+ 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74,
+ 0x79, 0x70, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01,
+ 0x28, 0x0d, 0x52, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x2a, 0x60, 0x0a, 0x12, 0x48, 0x61, 0x72,
+ 0x64, 0x77, 0x61, 0x72, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12,
+ 0x0b, 0x0a, 0x07, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x0d, 0x0a, 0x09,
+ 0x49, 0x4e, 0x46, 0x45, 0x52, 0x45, 0x4e, 0x43, 0x45, 0x10, 0x01, 0x12, 0x07, 0x0a, 0x03, 0x50,
+ 0x4f, 0x43, 0x10, 0x02, 0x12, 0x0c, 0x0a, 0x08, 0x54, 0x52, 0x41, 0x49, 0x4e, 0x49, 0x4e, 0x47,
+ 0x10, 0x03, 0x12, 0x0b, 0x0a, 0x07, 0x53, 0x54, 0x4f, 0x50, 0x50, 0x45, 0x44, 0x10, 0x04, 0x12,
+ 0x0a, 0x0a, 0x06, 0x46, 0x41, 0x49, 0x4c, 0x45, 0x44, 0x10, 0x05, 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, 0x48, 0x61, 0x72, 0x64, 0x77, 0x61, 0x72,
+ 0x65, 0x4e, 0x6f, 0x64, 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_hardware_node_proto_rawDescOnce sync.Once
+ file_inference_inference_hardware_node_proto_rawDescData = file_inference_inference_hardware_node_proto_rawDesc
+)
+
+func file_inference_inference_hardware_node_proto_rawDescGZIP() []byte {
+ file_inference_inference_hardware_node_proto_rawDescOnce.Do(func() {
+ file_inference_inference_hardware_node_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_inference_hardware_node_proto_rawDescData)
+ })
+ return file_inference_inference_hardware_node_proto_rawDescData
+}
+
+var file_inference_inference_hardware_node_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
+var file_inference_inference_hardware_node_proto_msgTypes = make([]protoimpl.MessageInfo, 3)
+var file_inference_inference_hardware_node_proto_goTypes = []interface{}{
+ (HardwareNodeStatus)(0), // 0: inference.inference.HardwareNodeStatus
+ (*HardwareNodes)(nil), // 1: inference.inference.HardwareNodes
+ (*HardwareNode)(nil), // 2: inference.inference.HardwareNode
+ (*Hardware)(nil), // 3: inference.inference.Hardware
+}
+var file_inference_inference_hardware_node_proto_depIdxs = []int32{
+ 2, // 0: inference.inference.HardwareNodes.hardware_nodes:type_name -> inference.inference.HardwareNode
+ 0, // 1: inference.inference.HardwareNode.status:type_name -> inference.inference.HardwareNodeStatus
+ 3, // 2: inference.inference.HardwareNode.hardware:type_name -> inference.inference.Hardware
+ 3, // [3:3] is the sub-list for method output_type
+ 3, // [3:3] is the sub-list for method input_type
+ 3, // [3:3] is the sub-list for extension type_name
+ 3, // [3:3] is the sub-list for extension extendee
+ 0, // [0:3] is the sub-list for field type_name
+}
+
+func init() { file_inference_inference_hardware_node_proto_init() }
+func file_inference_inference_hardware_node_proto_init() {
+ if File_inference_inference_hardware_node_proto != nil {
+ return
+ }
+ if !protoimpl.UnsafeEnabled {
+ file_inference_inference_hardware_node_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*HardwareNodes); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_inference_hardware_node_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*HardwareNode); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_inference_hardware_node_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*Hardware); 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_hardware_node_proto_rawDesc,
+ NumEnums: 1,
+ NumMessages: 3,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_inference_hardware_node_proto_goTypes,
+ DependencyIndexes: file_inference_inference_hardware_node_proto_depIdxs,
+ EnumInfos: file_inference_inference_hardware_node_proto_enumTypes,
+ MessageInfos: file_inference_inference_hardware_node_proto_msgTypes,
+ }.Build()
+ File_inference_inference_hardware_node_proto = out.File
+ file_inference_inference_hardware_node_proto_rawDesc = nil
+ file_inference_inference_hardware_node_proto_goTypes = nil
+ file_inference_inference_hardware_node_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/inference/inference.pulsar.go b/inference-chain/api/inference/inference/inference.pulsar.go
new file mode 100644
index 000000000..4c5b1ba3a
--- /dev/null
+++ b/inference-chain/api/inference/inference/inference.pulsar.go
@@ -0,0 +1,3410 @@
+// 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_ProposalDetails protoreflect.MessageDescriptor
+ fd_ProposalDetails_re_validate_policy_id protoreflect.FieldDescriptor
+ fd_ProposalDetails_invalidate_policy_id protoreflect.FieldDescriptor
+ fd_ProposalDetails_policy_address protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_inference_proto_init()
+ md_ProposalDetails = File_inference_inference_inference_proto.Messages().ByName("ProposalDetails")
+ fd_ProposalDetails_re_validate_policy_id = md_ProposalDetails.Fields().ByName("re_validate_policy_id")
+ fd_ProposalDetails_invalidate_policy_id = md_ProposalDetails.Fields().ByName("invalidate_policy_id")
+ fd_ProposalDetails_policy_address = md_ProposalDetails.Fields().ByName("policy_address")
+}
+
+var _ protoreflect.Message = (*fastReflection_ProposalDetails)(nil)
+
+type fastReflection_ProposalDetails ProposalDetails
+
+func (x *ProposalDetails) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_ProposalDetails)(x)
+}
+
+func (x *ProposalDetails) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_inference_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_ProposalDetails_messageType fastReflection_ProposalDetails_messageType
+var _ protoreflect.MessageType = fastReflection_ProposalDetails_messageType{}
+
+type fastReflection_ProposalDetails_messageType struct{}
+
+func (x fastReflection_ProposalDetails_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_ProposalDetails)(nil)
+}
+func (x fastReflection_ProposalDetails_messageType) New() protoreflect.Message {
+ return new(fastReflection_ProposalDetails)
+}
+func (x fastReflection_ProposalDetails_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_ProposalDetails
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_ProposalDetails) Descriptor() protoreflect.MessageDescriptor {
+ return md_ProposalDetails
+}
+
+// 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_ProposalDetails) Type() protoreflect.MessageType {
+ return _fastReflection_ProposalDetails_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_ProposalDetails) New() protoreflect.Message {
+ return new(fastReflection_ProposalDetails)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_ProposalDetails) Interface() protoreflect.ProtoMessage {
+ return (*ProposalDetails)(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_ProposalDetails) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.ReValidatePolicyId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.ReValidatePolicyId)
+ if !f(fd_ProposalDetails_re_validate_policy_id, value) {
+ return
+ }
+ }
+ if x.InvalidatePolicyId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.InvalidatePolicyId)
+ if !f(fd_ProposalDetails_invalidate_policy_id, value) {
+ return
+ }
+ }
+ if x.PolicyAddress != "" {
+ value := protoreflect.ValueOfString(x.PolicyAddress)
+ if !f(fd_ProposalDetails_policy_address, 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_ProposalDetails) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.ProposalDetails.re_validate_policy_id":
+ return x.ReValidatePolicyId != uint64(0)
+ case "inference.inference.ProposalDetails.invalidate_policy_id":
+ return x.InvalidatePolicyId != uint64(0)
+ case "inference.inference.ProposalDetails.policy_address":
+ return x.PolicyAddress != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ProposalDetails"))
+ }
+ panic(fmt.Errorf("message inference.inference.ProposalDetails 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_ProposalDetails) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.ProposalDetails.re_validate_policy_id":
+ x.ReValidatePolicyId = uint64(0)
+ case "inference.inference.ProposalDetails.invalidate_policy_id":
+ x.InvalidatePolicyId = uint64(0)
+ case "inference.inference.ProposalDetails.policy_address":
+ x.PolicyAddress = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ProposalDetails"))
+ }
+ panic(fmt.Errorf("message inference.inference.ProposalDetails 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_ProposalDetails) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.ProposalDetails.re_validate_policy_id":
+ value := x.ReValidatePolicyId
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.ProposalDetails.invalidate_policy_id":
+ value := x.InvalidatePolicyId
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.ProposalDetails.policy_address":
+ value := x.PolicyAddress
+ return protoreflect.ValueOfString(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ProposalDetails"))
+ }
+ panic(fmt.Errorf("message inference.inference.ProposalDetails 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_ProposalDetails) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.ProposalDetails.re_validate_policy_id":
+ x.ReValidatePolicyId = value.Uint()
+ case "inference.inference.ProposalDetails.invalidate_policy_id":
+ x.InvalidatePolicyId = value.Uint()
+ case "inference.inference.ProposalDetails.policy_address":
+ x.PolicyAddress = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ProposalDetails"))
+ }
+ panic(fmt.Errorf("message inference.inference.ProposalDetails 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_ProposalDetails) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.ProposalDetails.re_validate_policy_id":
+ panic(fmt.Errorf("field re_validate_policy_id of message inference.inference.ProposalDetails is not mutable"))
+ case "inference.inference.ProposalDetails.invalidate_policy_id":
+ panic(fmt.Errorf("field invalidate_policy_id of message inference.inference.ProposalDetails is not mutable"))
+ case "inference.inference.ProposalDetails.policy_address":
+ panic(fmt.Errorf("field policy_address of message inference.inference.ProposalDetails is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ProposalDetails"))
+ }
+ panic(fmt.Errorf("message inference.inference.ProposalDetails 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_ProposalDetails) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.ProposalDetails.re_validate_policy_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.ProposalDetails.invalidate_policy_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.ProposalDetails.policy_address":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ProposalDetails"))
+ }
+ panic(fmt.Errorf("message inference.inference.ProposalDetails 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_ProposalDetails) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.ProposalDetails", 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_ProposalDetails) 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_ProposalDetails) 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_ProposalDetails) 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_ProposalDetails) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*ProposalDetails)
+ 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.ReValidatePolicyId != 0 {
+ n += 1 + runtime.Sov(uint64(x.ReValidatePolicyId))
+ }
+ if x.InvalidatePolicyId != 0 {
+ n += 1 + runtime.Sov(uint64(x.InvalidatePolicyId))
+ }
+ l = len(x.PolicyAddress)
+ 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().(*ProposalDetails)
+ 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.PolicyAddress) > 0 {
+ i -= len(x.PolicyAddress)
+ copy(dAtA[i:], x.PolicyAddress)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.PolicyAddress)))
+ i--
+ dAtA[i] = 0x1a
+ }
+ if x.InvalidatePolicyId != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.InvalidatePolicyId))
+ i--
+ dAtA[i] = 0x10
+ }
+ if x.ReValidatePolicyId != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.ReValidatePolicyId))
+ 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().(*ProposalDetails)
+ 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: ProposalDetails: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ProposalDetails: 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 ReValidatePolicyId", wireType)
+ }
+ x.ReValidatePolicyId = 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.ReValidatePolicyId |= 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 InvalidatePolicyId", wireType)
+ }
+ x.InvalidatePolicyId = 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.InvalidatePolicyId |= 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 PolicyAddress", 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.PolicyAddress = 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 = (*_Inference_23_list)(nil)
+
+type _Inference_23_list struct {
+ list *[]string
+}
+
+func (x *_Inference_23_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_Inference_23_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfString((*x.list)[i])
+}
+
+func (x *_Inference_23_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.String()
+ concreteValue := valueUnwrapped
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_Inference_23_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.String()
+ concreteValue := valueUnwrapped
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_Inference_23_list) AppendMutable() protoreflect.Value {
+ panic(fmt.Errorf("AppendMutable can not be called on message Inference at list field ValidatedBy as it is not of Message kind"))
+}
+
+func (x *_Inference_23_list) Truncate(n int) {
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_Inference_23_list) NewElement() protoreflect.Value {
+ v := ""
+ return protoreflect.ValueOfString(v)
+}
+
+func (x *_Inference_23_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_Inference protoreflect.MessageDescriptor
+ fd_Inference_index protoreflect.FieldDescriptor
+ fd_Inference_inference_id protoreflect.FieldDescriptor
+ fd_Inference_prompt_hash protoreflect.FieldDescriptor
+ fd_Inference_prompt_payload protoreflect.FieldDescriptor
+ fd_Inference_response_hash protoreflect.FieldDescriptor
+ fd_Inference_response_payload protoreflect.FieldDescriptor
+ fd_Inference_prompt_token_count protoreflect.FieldDescriptor
+ fd_Inference_completion_token_count protoreflect.FieldDescriptor
+ fd_Inference_requested_by protoreflect.FieldDescriptor
+ fd_Inference_executed_by protoreflect.FieldDescriptor
+ fd_Inference_status protoreflect.FieldDescriptor
+ fd_Inference_start_block_height protoreflect.FieldDescriptor
+ fd_Inference_end_block_height protoreflect.FieldDescriptor
+ fd_Inference_start_block_timestamp protoreflect.FieldDescriptor
+ fd_Inference_end_block_timestamp protoreflect.FieldDescriptor
+ fd_Inference_model protoreflect.FieldDescriptor
+ fd_Inference_max_tokens protoreflect.FieldDescriptor
+ fd_Inference_actual_cost protoreflect.FieldDescriptor
+ fd_Inference_escrow_amount protoreflect.FieldDescriptor
+ fd_Inference_proposal_details protoreflect.FieldDescriptor
+ fd_Inference_epoch_group_id protoreflect.FieldDescriptor
+ fd_Inference_assigned_to protoreflect.FieldDescriptor
+ fd_Inference_validated_by protoreflect.FieldDescriptor
+ fd_Inference_node_version protoreflect.FieldDescriptor
+ fd_Inference_epoch_id protoreflect.FieldDescriptor
+ fd_Inference_epoch_poc_start_block_height protoreflect.FieldDescriptor
+ fd_Inference_transferred_by protoreflect.FieldDescriptor
+ fd_Inference_request_timestamp protoreflect.FieldDescriptor
+ fd_Inference_transfer_signature protoreflect.FieldDescriptor
+ fd_Inference_execution_signature protoreflect.FieldDescriptor
+ fd_Inference_original_prompt protoreflect.FieldDescriptor
+ fd_Inference_per_token_price protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_inference_proto_init()
+ md_Inference = File_inference_inference_inference_proto.Messages().ByName("Inference")
+ fd_Inference_index = md_Inference.Fields().ByName("index")
+ fd_Inference_inference_id = md_Inference.Fields().ByName("inference_id")
+ fd_Inference_prompt_hash = md_Inference.Fields().ByName("prompt_hash")
+ fd_Inference_prompt_payload = md_Inference.Fields().ByName("prompt_payload")
+ fd_Inference_response_hash = md_Inference.Fields().ByName("response_hash")
+ fd_Inference_response_payload = md_Inference.Fields().ByName("response_payload")
+ fd_Inference_prompt_token_count = md_Inference.Fields().ByName("prompt_token_count")
+ fd_Inference_completion_token_count = md_Inference.Fields().ByName("completion_token_count")
+ fd_Inference_requested_by = md_Inference.Fields().ByName("requested_by")
+ fd_Inference_executed_by = md_Inference.Fields().ByName("executed_by")
+ fd_Inference_status = md_Inference.Fields().ByName("status")
+ fd_Inference_start_block_height = md_Inference.Fields().ByName("start_block_height")
+ fd_Inference_end_block_height = md_Inference.Fields().ByName("end_block_height")
+ fd_Inference_start_block_timestamp = md_Inference.Fields().ByName("start_block_timestamp")
+ fd_Inference_end_block_timestamp = md_Inference.Fields().ByName("end_block_timestamp")
+ fd_Inference_model = md_Inference.Fields().ByName("model")
+ fd_Inference_max_tokens = md_Inference.Fields().ByName("max_tokens")
+ fd_Inference_actual_cost = md_Inference.Fields().ByName("actual_cost")
+ fd_Inference_escrow_amount = md_Inference.Fields().ByName("escrow_amount")
+ fd_Inference_proposal_details = md_Inference.Fields().ByName("proposal_details")
+ fd_Inference_epoch_group_id = md_Inference.Fields().ByName("epoch_group_id")
+ fd_Inference_assigned_to = md_Inference.Fields().ByName("assigned_to")
+ fd_Inference_validated_by = md_Inference.Fields().ByName("validated_by")
+ fd_Inference_node_version = md_Inference.Fields().ByName("node_version")
+ fd_Inference_epoch_id = md_Inference.Fields().ByName("epoch_id")
+ fd_Inference_epoch_poc_start_block_height = md_Inference.Fields().ByName("epoch_poc_start_block_height")
+ fd_Inference_transferred_by = md_Inference.Fields().ByName("transferred_by")
+ fd_Inference_request_timestamp = md_Inference.Fields().ByName("request_timestamp")
+ fd_Inference_transfer_signature = md_Inference.Fields().ByName("transfer_signature")
+ fd_Inference_execution_signature = md_Inference.Fields().ByName("execution_signature")
+ fd_Inference_original_prompt = md_Inference.Fields().ByName("original_prompt")
+ fd_Inference_per_token_price = md_Inference.Fields().ByName("per_token_price")
+}
+
+var _ protoreflect.Message = (*fastReflection_Inference)(nil)
+
+type fastReflection_Inference Inference
+
+func (x *Inference) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_Inference)(x)
+}
+
+func (x *Inference) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_inference_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_Inference_messageType fastReflection_Inference_messageType
+var _ protoreflect.MessageType = fastReflection_Inference_messageType{}
+
+type fastReflection_Inference_messageType struct{}
+
+func (x fastReflection_Inference_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_Inference)(nil)
+}
+func (x fastReflection_Inference_messageType) New() protoreflect.Message {
+ return new(fastReflection_Inference)
+}
+func (x fastReflection_Inference_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_Inference
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_Inference) Descriptor() protoreflect.MessageDescriptor {
+ return md_Inference
+}
+
+// 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_Inference) Type() protoreflect.MessageType {
+ return _fastReflection_Inference_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_Inference) New() protoreflect.Message {
+ return new(fastReflection_Inference)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_Inference) Interface() protoreflect.ProtoMessage {
+ return (*Inference)(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_Inference) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Index != "" {
+ value := protoreflect.ValueOfString(x.Index)
+ if !f(fd_Inference_index, value) {
+ return
+ }
+ }
+ if x.InferenceId != "" {
+ value := protoreflect.ValueOfString(x.InferenceId)
+ if !f(fd_Inference_inference_id, value) {
+ return
+ }
+ }
+ if x.PromptHash != "" {
+ value := protoreflect.ValueOfString(x.PromptHash)
+ if !f(fd_Inference_prompt_hash, value) {
+ return
+ }
+ }
+ if x.PromptPayload != "" {
+ value := protoreflect.ValueOfString(x.PromptPayload)
+ if !f(fd_Inference_prompt_payload, value) {
+ return
+ }
+ }
+ if x.ResponseHash != "" {
+ value := protoreflect.ValueOfString(x.ResponseHash)
+ if !f(fd_Inference_response_hash, value) {
+ return
+ }
+ }
+ if x.ResponsePayload != "" {
+ value := protoreflect.ValueOfString(x.ResponsePayload)
+ if !f(fd_Inference_response_payload, value) {
+ return
+ }
+ }
+ if x.PromptTokenCount != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.PromptTokenCount)
+ if !f(fd_Inference_prompt_token_count, value) {
+ return
+ }
+ }
+ if x.CompletionTokenCount != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.CompletionTokenCount)
+ if !f(fd_Inference_completion_token_count, value) {
+ return
+ }
+ }
+ if x.RequestedBy != "" {
+ value := protoreflect.ValueOfString(x.RequestedBy)
+ if !f(fd_Inference_requested_by, value) {
+ return
+ }
+ }
+ if x.ExecutedBy != "" {
+ value := protoreflect.ValueOfString(x.ExecutedBy)
+ if !f(fd_Inference_executed_by, value) {
+ return
+ }
+ }
+ if x.Status != 0 {
+ value := protoreflect.ValueOfEnum((protoreflect.EnumNumber)(x.Status))
+ if !f(fd_Inference_status, value) {
+ return
+ }
+ }
+ if x.StartBlockHeight != int64(0) {
+ value := protoreflect.ValueOfInt64(x.StartBlockHeight)
+ if !f(fd_Inference_start_block_height, value) {
+ return
+ }
+ }
+ if x.EndBlockHeight != int64(0) {
+ value := protoreflect.ValueOfInt64(x.EndBlockHeight)
+ if !f(fd_Inference_end_block_height, value) {
+ return
+ }
+ }
+ if x.StartBlockTimestamp != int64(0) {
+ value := protoreflect.ValueOfInt64(x.StartBlockTimestamp)
+ if !f(fd_Inference_start_block_timestamp, value) {
+ return
+ }
+ }
+ if x.EndBlockTimestamp != int64(0) {
+ value := protoreflect.ValueOfInt64(x.EndBlockTimestamp)
+ if !f(fd_Inference_end_block_timestamp, value) {
+ return
+ }
+ }
+ if x.Model != "" {
+ value := protoreflect.ValueOfString(x.Model)
+ if !f(fd_Inference_model, value) {
+ return
+ }
+ }
+ if x.MaxTokens != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.MaxTokens)
+ if !f(fd_Inference_max_tokens, value) {
+ return
+ }
+ }
+ if x.ActualCost != int64(0) {
+ value := protoreflect.ValueOfInt64(x.ActualCost)
+ if !f(fd_Inference_actual_cost, value) {
+ return
+ }
+ }
+ if x.EscrowAmount != int64(0) {
+ value := protoreflect.ValueOfInt64(x.EscrowAmount)
+ if !f(fd_Inference_escrow_amount, value) {
+ return
+ }
+ }
+ if x.ProposalDetails != nil {
+ value := protoreflect.ValueOfMessage(x.ProposalDetails.ProtoReflect())
+ if !f(fd_Inference_proposal_details, value) {
+ return
+ }
+ }
+ if x.EpochGroupId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.EpochGroupId)
+ if !f(fd_Inference_epoch_group_id, value) {
+ return
+ }
+ }
+ if x.AssignedTo != "" {
+ value := protoreflect.ValueOfString(x.AssignedTo)
+ if !f(fd_Inference_assigned_to, value) {
+ return
+ }
+ }
+ if len(x.ValidatedBy) != 0 {
+ value := protoreflect.ValueOfList(&_Inference_23_list{list: &x.ValidatedBy})
+ if !f(fd_Inference_validated_by, value) {
+ return
+ }
+ }
+ if x.NodeVersion != "" {
+ value := protoreflect.ValueOfString(x.NodeVersion)
+ if !f(fd_Inference_node_version, value) {
+ return
+ }
+ }
+ if x.EpochId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.EpochId)
+ if !f(fd_Inference_epoch_id, value) {
+ return
+ }
+ }
+ if x.EpochPocStartBlockHeight != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.EpochPocStartBlockHeight)
+ if !f(fd_Inference_epoch_poc_start_block_height, value) {
+ return
+ }
+ }
+ if x.TransferredBy != "" {
+ value := protoreflect.ValueOfString(x.TransferredBy)
+ if !f(fd_Inference_transferred_by, value) {
+ return
+ }
+ }
+ if x.RequestTimestamp != int64(0) {
+ value := protoreflect.ValueOfInt64(x.RequestTimestamp)
+ if !f(fd_Inference_request_timestamp, value) {
+ return
+ }
+ }
+ if x.TransferSignature != "" {
+ value := protoreflect.ValueOfString(x.TransferSignature)
+ if !f(fd_Inference_transfer_signature, value) {
+ return
+ }
+ }
+ if x.ExecutionSignature != "" {
+ value := protoreflect.ValueOfString(x.ExecutionSignature)
+ if !f(fd_Inference_execution_signature, value) {
+ return
+ }
+ }
+ if x.OriginalPrompt != "" {
+ value := protoreflect.ValueOfString(x.OriginalPrompt)
+ if !f(fd_Inference_original_prompt, value) {
+ return
+ }
+ }
+ if x.PerTokenPrice != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.PerTokenPrice)
+ if !f(fd_Inference_per_token_price, 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_Inference) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.Inference.index":
+ return x.Index != ""
+ case "inference.inference.Inference.inference_id":
+ return x.InferenceId != ""
+ case "inference.inference.Inference.prompt_hash":
+ return x.PromptHash != ""
+ case "inference.inference.Inference.prompt_payload":
+ return x.PromptPayload != ""
+ case "inference.inference.Inference.response_hash":
+ return x.ResponseHash != ""
+ case "inference.inference.Inference.response_payload":
+ return x.ResponsePayload != ""
+ case "inference.inference.Inference.prompt_token_count":
+ return x.PromptTokenCount != uint64(0)
+ case "inference.inference.Inference.completion_token_count":
+ return x.CompletionTokenCount != uint64(0)
+ case "inference.inference.Inference.requested_by":
+ return x.RequestedBy != ""
+ case "inference.inference.Inference.executed_by":
+ return x.ExecutedBy != ""
+ case "inference.inference.Inference.status":
+ return x.Status != 0
+ case "inference.inference.Inference.start_block_height":
+ return x.StartBlockHeight != int64(0)
+ case "inference.inference.Inference.end_block_height":
+ return x.EndBlockHeight != int64(0)
+ case "inference.inference.Inference.start_block_timestamp":
+ return x.StartBlockTimestamp != int64(0)
+ case "inference.inference.Inference.end_block_timestamp":
+ return x.EndBlockTimestamp != int64(0)
+ case "inference.inference.Inference.model":
+ return x.Model != ""
+ case "inference.inference.Inference.max_tokens":
+ return x.MaxTokens != uint64(0)
+ case "inference.inference.Inference.actual_cost":
+ return x.ActualCost != int64(0)
+ case "inference.inference.Inference.escrow_amount":
+ return x.EscrowAmount != int64(0)
+ case "inference.inference.Inference.proposal_details":
+ return x.ProposalDetails != nil
+ case "inference.inference.Inference.epoch_group_id":
+ return x.EpochGroupId != uint64(0)
+ case "inference.inference.Inference.assigned_to":
+ return x.AssignedTo != ""
+ case "inference.inference.Inference.validated_by":
+ return len(x.ValidatedBy) != 0
+ case "inference.inference.Inference.node_version":
+ return x.NodeVersion != ""
+ case "inference.inference.Inference.epoch_id":
+ return x.EpochId != uint64(0)
+ case "inference.inference.Inference.epoch_poc_start_block_height":
+ return x.EpochPocStartBlockHeight != uint64(0)
+ case "inference.inference.Inference.transferred_by":
+ return x.TransferredBy != ""
+ case "inference.inference.Inference.request_timestamp":
+ return x.RequestTimestamp != int64(0)
+ case "inference.inference.Inference.transfer_signature":
+ return x.TransferSignature != ""
+ case "inference.inference.Inference.execution_signature":
+ return x.ExecutionSignature != ""
+ case "inference.inference.Inference.original_prompt":
+ return x.OriginalPrompt != ""
+ case "inference.inference.Inference.per_token_price":
+ return x.PerTokenPrice != uint64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Inference"))
+ }
+ panic(fmt.Errorf("message inference.inference.Inference 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_Inference) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.Inference.index":
+ x.Index = ""
+ case "inference.inference.Inference.inference_id":
+ x.InferenceId = ""
+ case "inference.inference.Inference.prompt_hash":
+ x.PromptHash = ""
+ case "inference.inference.Inference.prompt_payload":
+ x.PromptPayload = ""
+ case "inference.inference.Inference.response_hash":
+ x.ResponseHash = ""
+ case "inference.inference.Inference.response_payload":
+ x.ResponsePayload = ""
+ case "inference.inference.Inference.prompt_token_count":
+ x.PromptTokenCount = uint64(0)
+ case "inference.inference.Inference.completion_token_count":
+ x.CompletionTokenCount = uint64(0)
+ case "inference.inference.Inference.requested_by":
+ x.RequestedBy = ""
+ case "inference.inference.Inference.executed_by":
+ x.ExecutedBy = ""
+ case "inference.inference.Inference.status":
+ x.Status = 0
+ case "inference.inference.Inference.start_block_height":
+ x.StartBlockHeight = int64(0)
+ case "inference.inference.Inference.end_block_height":
+ x.EndBlockHeight = int64(0)
+ case "inference.inference.Inference.start_block_timestamp":
+ x.StartBlockTimestamp = int64(0)
+ case "inference.inference.Inference.end_block_timestamp":
+ x.EndBlockTimestamp = int64(0)
+ case "inference.inference.Inference.model":
+ x.Model = ""
+ case "inference.inference.Inference.max_tokens":
+ x.MaxTokens = uint64(0)
+ case "inference.inference.Inference.actual_cost":
+ x.ActualCost = int64(0)
+ case "inference.inference.Inference.escrow_amount":
+ x.EscrowAmount = int64(0)
+ case "inference.inference.Inference.proposal_details":
+ x.ProposalDetails = nil
+ case "inference.inference.Inference.epoch_group_id":
+ x.EpochGroupId = uint64(0)
+ case "inference.inference.Inference.assigned_to":
+ x.AssignedTo = ""
+ case "inference.inference.Inference.validated_by":
+ x.ValidatedBy = nil
+ case "inference.inference.Inference.node_version":
+ x.NodeVersion = ""
+ case "inference.inference.Inference.epoch_id":
+ x.EpochId = uint64(0)
+ case "inference.inference.Inference.epoch_poc_start_block_height":
+ x.EpochPocStartBlockHeight = uint64(0)
+ case "inference.inference.Inference.transferred_by":
+ x.TransferredBy = ""
+ case "inference.inference.Inference.request_timestamp":
+ x.RequestTimestamp = int64(0)
+ case "inference.inference.Inference.transfer_signature":
+ x.TransferSignature = ""
+ case "inference.inference.Inference.execution_signature":
+ x.ExecutionSignature = ""
+ case "inference.inference.Inference.original_prompt":
+ x.OriginalPrompt = ""
+ case "inference.inference.Inference.per_token_price":
+ x.PerTokenPrice = uint64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Inference"))
+ }
+ panic(fmt.Errorf("message inference.inference.Inference 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_Inference) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.Inference.index":
+ value := x.Index
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.Inference.inference_id":
+ value := x.InferenceId
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.Inference.prompt_hash":
+ value := x.PromptHash
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.Inference.prompt_payload":
+ value := x.PromptPayload
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.Inference.response_hash":
+ value := x.ResponseHash
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.Inference.response_payload":
+ value := x.ResponsePayload
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.Inference.prompt_token_count":
+ value := x.PromptTokenCount
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.Inference.completion_token_count":
+ value := x.CompletionTokenCount
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.Inference.requested_by":
+ value := x.RequestedBy
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.Inference.executed_by":
+ value := x.ExecutedBy
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.Inference.status":
+ value := x.Status
+ return protoreflect.ValueOfEnum((protoreflect.EnumNumber)(value))
+ case "inference.inference.Inference.start_block_height":
+ value := x.StartBlockHeight
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.Inference.end_block_height":
+ value := x.EndBlockHeight
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.Inference.start_block_timestamp":
+ value := x.StartBlockTimestamp
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.Inference.end_block_timestamp":
+ value := x.EndBlockTimestamp
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.Inference.model":
+ value := x.Model
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.Inference.max_tokens":
+ value := x.MaxTokens
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.Inference.actual_cost":
+ value := x.ActualCost
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.Inference.escrow_amount":
+ value := x.EscrowAmount
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.Inference.proposal_details":
+ value := x.ProposalDetails
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.Inference.epoch_group_id":
+ value := x.EpochGroupId
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.Inference.assigned_to":
+ value := x.AssignedTo
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.Inference.validated_by":
+ if len(x.ValidatedBy) == 0 {
+ return protoreflect.ValueOfList(&_Inference_23_list{})
+ }
+ listValue := &_Inference_23_list{list: &x.ValidatedBy}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.inference.Inference.node_version":
+ value := x.NodeVersion
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.Inference.epoch_id":
+ value := x.EpochId
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.Inference.epoch_poc_start_block_height":
+ value := x.EpochPocStartBlockHeight
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.Inference.transferred_by":
+ value := x.TransferredBy
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.Inference.request_timestamp":
+ value := x.RequestTimestamp
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.Inference.transfer_signature":
+ value := x.TransferSignature
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.Inference.execution_signature":
+ value := x.ExecutionSignature
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.Inference.original_prompt":
+ value := x.OriginalPrompt
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.Inference.per_token_price":
+ value := x.PerTokenPrice
+ return protoreflect.ValueOfUint64(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Inference"))
+ }
+ panic(fmt.Errorf("message inference.inference.Inference 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_Inference) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.Inference.index":
+ x.Index = value.Interface().(string)
+ case "inference.inference.Inference.inference_id":
+ x.InferenceId = value.Interface().(string)
+ case "inference.inference.Inference.prompt_hash":
+ x.PromptHash = value.Interface().(string)
+ case "inference.inference.Inference.prompt_payload":
+ x.PromptPayload = value.Interface().(string)
+ case "inference.inference.Inference.response_hash":
+ x.ResponseHash = value.Interface().(string)
+ case "inference.inference.Inference.response_payload":
+ x.ResponsePayload = value.Interface().(string)
+ case "inference.inference.Inference.prompt_token_count":
+ x.PromptTokenCount = value.Uint()
+ case "inference.inference.Inference.completion_token_count":
+ x.CompletionTokenCount = value.Uint()
+ case "inference.inference.Inference.requested_by":
+ x.RequestedBy = value.Interface().(string)
+ case "inference.inference.Inference.executed_by":
+ x.ExecutedBy = value.Interface().(string)
+ case "inference.inference.Inference.status":
+ x.Status = (InferenceStatus)(value.Enum())
+ case "inference.inference.Inference.start_block_height":
+ x.StartBlockHeight = value.Int()
+ case "inference.inference.Inference.end_block_height":
+ x.EndBlockHeight = value.Int()
+ case "inference.inference.Inference.start_block_timestamp":
+ x.StartBlockTimestamp = value.Int()
+ case "inference.inference.Inference.end_block_timestamp":
+ x.EndBlockTimestamp = value.Int()
+ case "inference.inference.Inference.model":
+ x.Model = value.Interface().(string)
+ case "inference.inference.Inference.max_tokens":
+ x.MaxTokens = value.Uint()
+ case "inference.inference.Inference.actual_cost":
+ x.ActualCost = value.Int()
+ case "inference.inference.Inference.escrow_amount":
+ x.EscrowAmount = value.Int()
+ case "inference.inference.Inference.proposal_details":
+ x.ProposalDetails = value.Message().Interface().(*ProposalDetails)
+ case "inference.inference.Inference.epoch_group_id":
+ x.EpochGroupId = value.Uint()
+ case "inference.inference.Inference.assigned_to":
+ x.AssignedTo = value.Interface().(string)
+ case "inference.inference.Inference.validated_by":
+ lv := value.List()
+ clv := lv.(*_Inference_23_list)
+ x.ValidatedBy = *clv.list
+ case "inference.inference.Inference.node_version":
+ x.NodeVersion = value.Interface().(string)
+ case "inference.inference.Inference.epoch_id":
+ x.EpochId = value.Uint()
+ case "inference.inference.Inference.epoch_poc_start_block_height":
+ x.EpochPocStartBlockHeight = value.Uint()
+ case "inference.inference.Inference.transferred_by":
+ x.TransferredBy = value.Interface().(string)
+ case "inference.inference.Inference.request_timestamp":
+ x.RequestTimestamp = value.Int()
+ case "inference.inference.Inference.transfer_signature":
+ x.TransferSignature = value.Interface().(string)
+ case "inference.inference.Inference.execution_signature":
+ x.ExecutionSignature = value.Interface().(string)
+ case "inference.inference.Inference.original_prompt":
+ x.OriginalPrompt = value.Interface().(string)
+ case "inference.inference.Inference.per_token_price":
+ x.PerTokenPrice = value.Uint()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Inference"))
+ }
+ panic(fmt.Errorf("message inference.inference.Inference 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_Inference) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.Inference.proposal_details":
+ if x.ProposalDetails == nil {
+ x.ProposalDetails = new(ProposalDetails)
+ }
+ return protoreflect.ValueOfMessage(x.ProposalDetails.ProtoReflect())
+ case "inference.inference.Inference.validated_by":
+ if x.ValidatedBy == nil {
+ x.ValidatedBy = []string{}
+ }
+ value := &_Inference_23_list{list: &x.ValidatedBy}
+ return protoreflect.ValueOfList(value)
+ case "inference.inference.Inference.index":
+ panic(fmt.Errorf("field index of message inference.inference.Inference is not mutable"))
+ case "inference.inference.Inference.inference_id":
+ panic(fmt.Errorf("field inference_id of message inference.inference.Inference is not mutable"))
+ case "inference.inference.Inference.prompt_hash":
+ panic(fmt.Errorf("field prompt_hash of message inference.inference.Inference is not mutable"))
+ case "inference.inference.Inference.prompt_payload":
+ panic(fmt.Errorf("field prompt_payload of message inference.inference.Inference is not mutable"))
+ case "inference.inference.Inference.response_hash":
+ panic(fmt.Errorf("field response_hash of message inference.inference.Inference is not mutable"))
+ case "inference.inference.Inference.response_payload":
+ panic(fmt.Errorf("field response_payload of message inference.inference.Inference is not mutable"))
+ case "inference.inference.Inference.prompt_token_count":
+ panic(fmt.Errorf("field prompt_token_count of message inference.inference.Inference is not mutable"))
+ case "inference.inference.Inference.completion_token_count":
+ panic(fmt.Errorf("field completion_token_count of message inference.inference.Inference is not mutable"))
+ case "inference.inference.Inference.requested_by":
+ panic(fmt.Errorf("field requested_by of message inference.inference.Inference is not mutable"))
+ case "inference.inference.Inference.executed_by":
+ panic(fmt.Errorf("field executed_by of message inference.inference.Inference is not mutable"))
+ case "inference.inference.Inference.status":
+ panic(fmt.Errorf("field status of message inference.inference.Inference is not mutable"))
+ case "inference.inference.Inference.start_block_height":
+ panic(fmt.Errorf("field start_block_height of message inference.inference.Inference is not mutable"))
+ case "inference.inference.Inference.end_block_height":
+ panic(fmt.Errorf("field end_block_height of message inference.inference.Inference is not mutable"))
+ case "inference.inference.Inference.start_block_timestamp":
+ panic(fmt.Errorf("field start_block_timestamp of message inference.inference.Inference is not mutable"))
+ case "inference.inference.Inference.end_block_timestamp":
+ panic(fmt.Errorf("field end_block_timestamp of message inference.inference.Inference is not mutable"))
+ case "inference.inference.Inference.model":
+ panic(fmt.Errorf("field model of message inference.inference.Inference is not mutable"))
+ case "inference.inference.Inference.max_tokens":
+ panic(fmt.Errorf("field max_tokens of message inference.inference.Inference is not mutable"))
+ case "inference.inference.Inference.actual_cost":
+ panic(fmt.Errorf("field actual_cost of message inference.inference.Inference is not mutable"))
+ case "inference.inference.Inference.escrow_amount":
+ panic(fmt.Errorf("field escrow_amount of message inference.inference.Inference is not mutable"))
+ case "inference.inference.Inference.epoch_group_id":
+ panic(fmt.Errorf("field epoch_group_id of message inference.inference.Inference is not mutable"))
+ case "inference.inference.Inference.assigned_to":
+ panic(fmt.Errorf("field assigned_to of message inference.inference.Inference is not mutable"))
+ case "inference.inference.Inference.node_version":
+ panic(fmt.Errorf("field node_version of message inference.inference.Inference is not mutable"))
+ case "inference.inference.Inference.epoch_id":
+ panic(fmt.Errorf("field epoch_id of message inference.inference.Inference is not mutable"))
+ case "inference.inference.Inference.epoch_poc_start_block_height":
+ panic(fmt.Errorf("field epoch_poc_start_block_height of message inference.inference.Inference is not mutable"))
+ case "inference.inference.Inference.transferred_by":
+ panic(fmt.Errorf("field transferred_by of message inference.inference.Inference is not mutable"))
+ case "inference.inference.Inference.request_timestamp":
+ panic(fmt.Errorf("field request_timestamp of message inference.inference.Inference is not mutable"))
+ case "inference.inference.Inference.transfer_signature":
+ panic(fmt.Errorf("field transfer_signature of message inference.inference.Inference is not mutable"))
+ case "inference.inference.Inference.execution_signature":
+ panic(fmt.Errorf("field execution_signature of message inference.inference.Inference is not mutable"))
+ case "inference.inference.Inference.original_prompt":
+ panic(fmt.Errorf("field original_prompt of message inference.inference.Inference is not mutable"))
+ case "inference.inference.Inference.per_token_price":
+ panic(fmt.Errorf("field per_token_price of message inference.inference.Inference is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Inference"))
+ }
+ panic(fmt.Errorf("message inference.inference.Inference 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_Inference) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.Inference.index":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.Inference.inference_id":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.Inference.prompt_hash":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.Inference.prompt_payload":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.Inference.response_hash":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.Inference.response_payload":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.Inference.prompt_token_count":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.Inference.completion_token_count":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.Inference.requested_by":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.Inference.executed_by":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.Inference.status":
+ return protoreflect.ValueOfEnum(0)
+ case "inference.inference.Inference.start_block_height":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.Inference.end_block_height":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.Inference.start_block_timestamp":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.Inference.end_block_timestamp":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.Inference.model":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.Inference.max_tokens":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.Inference.actual_cost":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.Inference.escrow_amount":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.Inference.proposal_details":
+ m := new(ProposalDetails)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.Inference.epoch_group_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.Inference.assigned_to":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.Inference.validated_by":
+ list := []string{}
+ return protoreflect.ValueOfList(&_Inference_23_list{list: &list})
+ case "inference.inference.Inference.node_version":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.Inference.epoch_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.Inference.epoch_poc_start_block_height":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.Inference.transferred_by":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.Inference.request_timestamp":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.Inference.transfer_signature":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.Inference.execution_signature":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.Inference.original_prompt":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.Inference.per_token_price":
+ return protoreflect.ValueOfUint64(uint64(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Inference"))
+ }
+ panic(fmt.Errorf("message inference.inference.Inference 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_Inference) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.Inference", 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_Inference) 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_Inference) 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_Inference) 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_Inference) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*Inference)
+ 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.Index)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ l = len(x.InferenceId)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ l = len(x.PromptHash)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ l = len(x.PromptPayload)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ l = len(x.ResponseHash)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ l = len(x.ResponsePayload)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.PromptTokenCount != 0 {
+ n += 1 + runtime.Sov(uint64(x.PromptTokenCount))
+ }
+ if x.CompletionTokenCount != 0 {
+ n += 1 + runtime.Sov(uint64(x.CompletionTokenCount))
+ }
+ l = len(x.RequestedBy)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ l = len(x.ExecutedBy)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.Status != 0 {
+ n += 1 + runtime.Sov(uint64(x.Status))
+ }
+ if x.StartBlockHeight != 0 {
+ n += 1 + runtime.Sov(uint64(x.StartBlockHeight))
+ }
+ if x.EndBlockHeight != 0 {
+ n += 1 + runtime.Sov(uint64(x.EndBlockHeight))
+ }
+ if x.StartBlockTimestamp != 0 {
+ n += 1 + runtime.Sov(uint64(x.StartBlockTimestamp))
+ }
+ if x.EndBlockTimestamp != 0 {
+ n += 1 + runtime.Sov(uint64(x.EndBlockTimestamp))
+ }
+ l = len(x.Model)
+ if l > 0 {
+ n += 2 + l + runtime.Sov(uint64(l))
+ }
+ if x.MaxTokens != 0 {
+ n += 2 + runtime.Sov(uint64(x.MaxTokens))
+ }
+ if x.ActualCost != 0 {
+ n += 2 + runtime.Sov(uint64(x.ActualCost))
+ }
+ if x.EscrowAmount != 0 {
+ n += 2 + runtime.Sov(uint64(x.EscrowAmount))
+ }
+ if x.ProposalDetails != nil {
+ l = options.Size(x.ProposalDetails)
+ n += 2 + l + runtime.Sov(uint64(l))
+ }
+ if x.EpochGroupId != 0 {
+ n += 2 + runtime.Sov(uint64(x.EpochGroupId))
+ }
+ l = len(x.AssignedTo)
+ if l > 0 {
+ n += 2 + l + runtime.Sov(uint64(l))
+ }
+ if len(x.ValidatedBy) > 0 {
+ for _, s := range x.ValidatedBy {
+ l = len(s)
+ n += 2 + l + runtime.Sov(uint64(l))
+ }
+ }
+ l = len(x.NodeVersion)
+ if l > 0 {
+ n += 2 + l + runtime.Sov(uint64(l))
+ }
+ if x.EpochId != 0 {
+ n += 2 + runtime.Sov(uint64(x.EpochId))
+ }
+ if x.EpochPocStartBlockHeight != 0 {
+ n += 2 + runtime.Sov(uint64(x.EpochPocStartBlockHeight))
+ }
+ l = len(x.TransferredBy)
+ if l > 0 {
+ n += 2 + l + runtime.Sov(uint64(l))
+ }
+ if x.RequestTimestamp != 0 {
+ n += 2 + runtime.Sov(uint64(x.RequestTimestamp))
+ }
+ l = len(x.TransferSignature)
+ if l > 0 {
+ n += 2 + l + runtime.Sov(uint64(l))
+ }
+ l = len(x.ExecutionSignature)
+ if l > 0 {
+ n += 2 + l + runtime.Sov(uint64(l))
+ }
+ l = len(x.OriginalPrompt)
+ if l > 0 {
+ n += 2 + l + runtime.Sov(uint64(l))
+ }
+ if x.PerTokenPrice != 0 {
+ n += 2 + runtime.Sov(uint64(x.PerTokenPrice))
+ }
+ 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().(*Inference)
+ 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.PerTokenPrice != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.PerTokenPrice))
+ i--
+ dAtA[i] = 0x2
+ i--
+ dAtA[i] = 0x80
+ }
+ if len(x.OriginalPrompt) > 0 {
+ i -= len(x.OriginalPrompt)
+ copy(dAtA[i:], x.OriginalPrompt)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.OriginalPrompt)))
+ i--
+ dAtA[i] = 0x1
+ i--
+ dAtA[i] = 0xfa
+ }
+ if len(x.ExecutionSignature) > 0 {
+ i -= len(x.ExecutionSignature)
+ copy(dAtA[i:], x.ExecutionSignature)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ExecutionSignature)))
+ i--
+ dAtA[i] = 0x1
+ i--
+ dAtA[i] = 0xf2
+ }
+ if len(x.TransferSignature) > 0 {
+ i -= len(x.TransferSignature)
+ copy(dAtA[i:], x.TransferSignature)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.TransferSignature)))
+ i--
+ dAtA[i] = 0x1
+ i--
+ dAtA[i] = 0xea
+ }
+ if x.RequestTimestamp != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.RequestTimestamp))
+ i--
+ dAtA[i] = 0x1
+ i--
+ dAtA[i] = 0xe0
+ }
+ if len(x.TransferredBy) > 0 {
+ i -= len(x.TransferredBy)
+ copy(dAtA[i:], x.TransferredBy)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.TransferredBy)))
+ i--
+ dAtA[i] = 0x1
+ i--
+ dAtA[i] = 0xda
+ }
+ if x.EpochPocStartBlockHeight != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochPocStartBlockHeight))
+ i--
+ dAtA[i] = 0x1
+ i--
+ dAtA[i] = 0xd0
+ }
+ if x.EpochId != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochId))
+ i--
+ dAtA[i] = 0x1
+ i--
+ dAtA[i] = 0xc8
+ }
+ 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] = 0x1
+ i--
+ dAtA[i] = 0xc2
+ }
+ if len(x.ValidatedBy) > 0 {
+ for iNdEx := len(x.ValidatedBy) - 1; iNdEx >= 0; iNdEx-- {
+ i -= len(x.ValidatedBy[iNdEx])
+ copy(dAtA[i:], x.ValidatedBy[iNdEx])
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ValidatedBy[iNdEx])))
+ i--
+ dAtA[i] = 0x1
+ i--
+ dAtA[i] = 0xba
+ }
+ }
+ if len(x.AssignedTo) > 0 {
+ i -= len(x.AssignedTo)
+ copy(dAtA[i:], x.AssignedTo)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.AssignedTo)))
+ i--
+ dAtA[i] = 0x1
+ i--
+ dAtA[i] = 0xb2
+ }
+ if x.EpochGroupId != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochGroupId))
+ i--
+ dAtA[i] = 0x1
+ i--
+ dAtA[i] = 0xa8
+ }
+ if x.ProposalDetails != nil {
+ encoded, err := options.Marshal(x.ProposalDetails)
+ 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] = 0xa2
+ }
+ if x.EscrowAmount != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.EscrowAmount))
+ i--
+ dAtA[i] = 0x1
+ i--
+ dAtA[i] = 0x98
+ }
+ if x.ActualCost != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.ActualCost))
+ i--
+ dAtA[i] = 0x1
+ i--
+ dAtA[i] = 0x90
+ }
+ if x.MaxTokens != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.MaxTokens))
+ i--
+ dAtA[i] = 0x1
+ i--
+ dAtA[i] = 0x88
+ }
+ 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] = 0x1
+ i--
+ dAtA[i] = 0x82
+ }
+ if x.EndBlockTimestamp != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.EndBlockTimestamp))
+ i--
+ dAtA[i] = 0x78
+ }
+ if x.StartBlockTimestamp != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.StartBlockTimestamp))
+ i--
+ dAtA[i] = 0x70
+ }
+ if x.EndBlockHeight != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.EndBlockHeight))
+ i--
+ dAtA[i] = 0x68
+ }
+ if x.StartBlockHeight != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.StartBlockHeight))
+ i--
+ dAtA[i] = 0x60
+ }
+ if x.Status != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.Status))
+ i--
+ dAtA[i] = 0x58
+ }
+ if len(x.ExecutedBy) > 0 {
+ i -= len(x.ExecutedBy)
+ copy(dAtA[i:], x.ExecutedBy)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ExecutedBy)))
+ i--
+ dAtA[i] = 0x52
+ }
+ if len(x.RequestedBy) > 0 {
+ i -= len(x.RequestedBy)
+ copy(dAtA[i:], x.RequestedBy)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.RequestedBy)))
+ i--
+ dAtA[i] = 0x4a
+ }
+ if x.CompletionTokenCount != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.CompletionTokenCount))
+ i--
+ dAtA[i] = 0x40
+ }
+ if x.PromptTokenCount != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.PromptTokenCount))
+ i--
+ dAtA[i] = 0x38
+ }
+ if len(x.ResponsePayload) > 0 {
+ i -= len(x.ResponsePayload)
+ copy(dAtA[i:], x.ResponsePayload)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ResponsePayload)))
+ i--
+ dAtA[i] = 0x32
+ }
+ if len(x.ResponseHash) > 0 {
+ i -= len(x.ResponseHash)
+ copy(dAtA[i:], x.ResponseHash)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ResponseHash)))
+ i--
+ dAtA[i] = 0x2a
+ }
+ if len(x.PromptPayload) > 0 {
+ i -= len(x.PromptPayload)
+ copy(dAtA[i:], x.PromptPayload)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.PromptPayload)))
+ i--
+ dAtA[i] = 0x22
+ }
+ if len(x.PromptHash) > 0 {
+ i -= len(x.PromptHash)
+ copy(dAtA[i:], x.PromptHash)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.PromptHash)))
+ i--
+ dAtA[i] = 0x1a
+ }
+ 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 len(x.Index) > 0 {
+ i -= len(x.Index)
+ copy(dAtA[i:], x.Index)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Index)))
+ 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().(*Inference)
+ 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: Inference: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Inference: 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 Index", 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.Index = 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 InferenceId", 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.InferenceId = 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 PromptHash", 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.PromptHash = 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 PromptPayload", 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.PromptPayload = 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 ResponseHash", 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.ResponseHash = 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 ResponsePayload", 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.ResponsePayload = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 7:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PromptTokenCount", wireType)
+ }
+ x.PromptTokenCount = 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.PromptTokenCount |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 8:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field CompletionTokenCount", wireType)
+ }
+ x.CompletionTokenCount = 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.CompletionTokenCount |= 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 RequestedBy", 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.RequestedBy = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 10:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ExecutedBy", 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.ExecutedBy = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 11:
+ 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 |= InferenceStatus(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 12:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field StartBlockHeight", wireType)
+ }
+ x.StartBlockHeight = 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.StartBlockHeight |= int64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 13:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EndBlockHeight", wireType)
+ }
+ x.EndBlockHeight = 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.EndBlockHeight |= int64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 14:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field StartBlockTimestamp", wireType)
+ }
+ x.StartBlockTimestamp = 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.StartBlockTimestamp |= int64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 15:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EndBlockTimestamp", wireType)
+ }
+ x.EndBlockTimestamp = 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.EndBlockTimestamp |= int64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 16:
+ 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 17:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MaxTokens", wireType)
+ }
+ x.MaxTokens = 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.MaxTokens |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 18:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ActualCost", wireType)
+ }
+ x.ActualCost = 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.ActualCost |= int64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 19:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EscrowAmount", wireType)
+ }
+ x.EscrowAmount = 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.EscrowAmount |= int64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 20:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ProposalDetails", 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.ProposalDetails == nil {
+ x.ProposalDetails = &ProposalDetails{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ProposalDetails); err != nil {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+ }
+ iNdEx = postIndex
+ case 21:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EpochGroupId", wireType)
+ }
+ x.EpochGroupId = 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.EpochGroupId |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 22:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field AssignedTo", 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.AssignedTo = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 23:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidatedBy", 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.ValidatedBy = append(x.ValidatedBy, string(dAtA[iNdEx:postIndex]))
+ iNdEx = postIndex
+ case 24:
+ if wireType != 2 {
+ 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 {
+ if shift >= 64 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.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.NodeVersion = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 25:
+ 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 26:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EpochPocStartBlockHeight", wireType)
+ }
+ x.EpochPocStartBlockHeight = 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.EpochPocStartBlockHeight |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 27:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TransferredBy", 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.TransferredBy = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 28:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RequestTimestamp", wireType)
+ }
+ x.RequestTimestamp = 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.RequestTimestamp |= int64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 29:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TransferSignature", 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.TransferSignature = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 30:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ExecutionSignature", 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.ExecutionSignature = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 31:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field OriginalPrompt", 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.OriginalPrompt = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 32:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PerTokenPrice", wireType)
+ }
+ x.PerTokenPrice = 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.PerTokenPrice |= 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,
+ }
+}
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// protoc-gen-go v1.27.0
+// protoc (unknown)
+// source: inference/inference/inference.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)
+)
+
+type InferenceStatus int32
+
+const (
+ InferenceStatus_STARTED InferenceStatus = 0
+ InferenceStatus_FINISHED InferenceStatus = 1
+ InferenceStatus_VALIDATED InferenceStatus = 2
+ InferenceStatus_INVALIDATED InferenceStatus = 3
+ InferenceStatus_VOTING InferenceStatus = 4
+ InferenceStatus_EXPIRED InferenceStatus = 5
+)
+
+// Enum value maps for InferenceStatus.
+var (
+ InferenceStatus_name = map[int32]string{
+ 0: "STARTED",
+ 1: "FINISHED",
+ 2: "VALIDATED",
+ 3: "INVALIDATED",
+ 4: "VOTING",
+ 5: "EXPIRED",
+ }
+ InferenceStatus_value = map[string]int32{
+ "STARTED": 0,
+ "FINISHED": 1,
+ "VALIDATED": 2,
+ "INVALIDATED": 3,
+ "VOTING": 4,
+ "EXPIRED": 5,
+ }
+)
+
+func (x InferenceStatus) Enum() *InferenceStatus {
+ p := new(InferenceStatus)
+ *p = x
+ return p
+}
+
+func (x InferenceStatus) String() string {
+ return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (InferenceStatus) Descriptor() protoreflect.EnumDescriptor {
+ return file_inference_inference_inference_proto_enumTypes[0].Descriptor()
+}
+
+func (InferenceStatus) Type() protoreflect.EnumType {
+ return &file_inference_inference_inference_proto_enumTypes[0]
+}
+
+func (x InferenceStatus) Number() protoreflect.EnumNumber {
+ return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use InferenceStatus.Descriptor instead.
+func (InferenceStatus) EnumDescriptor() ([]byte, []int) {
+ return file_inference_inference_inference_proto_rawDescGZIP(), []int{0}
+}
+
+type ProposalDetails struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ ReValidatePolicyId uint64 `protobuf:"varint,1,opt,name=re_validate_policy_id,json=reValidatePolicyId,proto3" json:"re_validate_policy_id,omitempty"`
+ InvalidatePolicyId uint64 `protobuf:"varint,2,opt,name=invalidate_policy_id,json=invalidatePolicyId,proto3" json:"invalidate_policy_id,omitempty"`
+ PolicyAddress string `protobuf:"bytes,3,opt,name=policy_address,json=policyAddress,proto3" json:"policy_address,omitempty"`
+}
+
+func (x *ProposalDetails) Reset() {
+ *x = ProposalDetails{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_inference_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *ProposalDetails) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ProposalDetails) ProtoMessage() {}
+
+// Deprecated: Use ProposalDetails.ProtoReflect.Descriptor instead.
+func (*ProposalDetails) Descriptor() ([]byte, []int) {
+ return file_inference_inference_inference_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *ProposalDetails) GetReValidatePolicyId() uint64 {
+ if x != nil {
+ return x.ReValidatePolicyId
+ }
+ return 0
+}
+
+func (x *ProposalDetails) GetInvalidatePolicyId() uint64 {
+ if x != nil {
+ return x.InvalidatePolicyId
+ }
+ return 0
+}
+
+func (x *ProposalDetails) GetPolicyAddress() string {
+ if x != nil {
+ return x.PolicyAddress
+ }
+ return ""
+}
+
+type Inference struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Index string `protobuf:"bytes,1,opt,name=index,proto3" json:"index,omitempty"`
+ InferenceId string `protobuf:"bytes,2,opt,name=inference_id,json=inferenceId,proto3" json:"inference_id,omitempty"`
+ PromptHash string `protobuf:"bytes,3,opt,name=prompt_hash,json=promptHash,proto3" json:"prompt_hash,omitempty"`
+ PromptPayload string `protobuf:"bytes,4,opt,name=prompt_payload,json=promptPayload,proto3" json:"prompt_payload,omitempty"`
+ ResponseHash string `protobuf:"bytes,5,opt,name=response_hash,json=responseHash,proto3" json:"response_hash,omitempty"`
+ ResponsePayload string `protobuf:"bytes,6,opt,name=response_payload,json=responsePayload,proto3" json:"response_payload,omitempty"`
+ PromptTokenCount uint64 `protobuf:"varint,7,opt,name=prompt_token_count,json=promptTokenCount,proto3" json:"prompt_token_count,omitempty"`
+ CompletionTokenCount uint64 `protobuf:"varint,8,opt,name=completion_token_count,json=completionTokenCount,proto3" json:"completion_token_count,omitempty"`
+ RequestedBy string `protobuf:"bytes,9,opt,name=requested_by,json=requestedBy,proto3" json:"requested_by,omitempty"`
+ ExecutedBy string `protobuf:"bytes,10,opt,name=executed_by,json=executedBy,proto3" json:"executed_by,omitempty"`
+ Status InferenceStatus `protobuf:"varint,11,opt,name=status,proto3,enum=inference.inference.InferenceStatus" json:"status,omitempty"`
+ StartBlockHeight int64 `protobuf:"varint,12,opt,name=start_block_height,json=startBlockHeight,proto3" json:"start_block_height,omitempty"`
+ EndBlockHeight int64 `protobuf:"varint,13,opt,name=end_block_height,json=endBlockHeight,proto3" json:"end_block_height,omitempty"`
+ StartBlockTimestamp int64 `protobuf:"varint,14,opt,name=start_block_timestamp,json=startBlockTimestamp,proto3" json:"start_block_timestamp,omitempty"`
+ EndBlockTimestamp int64 `protobuf:"varint,15,opt,name=end_block_timestamp,json=endBlockTimestamp,proto3" json:"end_block_timestamp,omitempty"`
+ Model string `protobuf:"bytes,16,opt,name=model,proto3" json:"model,omitempty"`
+ MaxTokens uint64 `protobuf:"varint,17,opt,name=max_tokens,json=maxTokens,proto3" json:"max_tokens,omitempty"`
+ ActualCost int64 `protobuf:"varint,18,opt,name=actual_cost,json=actualCost,proto3" json:"actual_cost,omitempty"`
+ EscrowAmount int64 `protobuf:"varint,19,opt,name=escrow_amount,json=escrowAmount,proto3" json:"escrow_amount,omitempty"`
+ ProposalDetails *ProposalDetails `protobuf:"bytes,20,opt,name=proposal_details,json=proposalDetails,proto3" json:"proposal_details,omitempty"`
+ EpochGroupId uint64 `protobuf:"varint,21,opt,name=epoch_group_id,json=epochGroupId,proto3" json:"epoch_group_id,omitempty"` // DEPRECATED: now use epoch_poc_start_block_height. Renaming
+ AssignedTo string `protobuf:"bytes,22,opt,name=assigned_to,json=assignedTo,proto3" json:"assigned_to,omitempty"`
+ ValidatedBy []string `protobuf:"bytes,23,rep,name=validated_by,json=validatedBy,proto3" json:"validated_by,omitempty"`
+ NodeVersion string `protobuf:"bytes,24,opt,name=node_version,json=nodeVersion,proto3" json:"node_version,omitempty"`
+ EpochId uint64 `protobuf:"varint,25,opt,name=epoch_id,json=epochId,proto3" json:"epoch_id,omitempty"`
+ EpochPocStartBlockHeight uint64 `protobuf:"varint,26,opt,name=epoch_poc_start_block_height,json=epochPocStartBlockHeight,proto3" json:"epoch_poc_start_block_height,omitempty"`
+ TransferredBy string `protobuf:"bytes,27,opt,name=transferred_by,json=transferredBy,proto3" json:"transferred_by,omitempty"`
+ RequestTimestamp int64 `protobuf:"varint,28,opt,name=request_timestamp,json=requestTimestamp,proto3" json:"request_timestamp,omitempty"`
+ TransferSignature string `protobuf:"bytes,29,opt,name=transfer_signature,json=transferSignature,proto3" json:"transfer_signature,omitempty"`
+ ExecutionSignature string `protobuf:"bytes,30,opt,name=execution_signature,json=executionSignature,proto3" json:"execution_signature,omitempty"`
+ OriginalPrompt string `protobuf:"bytes,31,opt,name=original_prompt,json=originalPrompt,proto3" json:"original_prompt,omitempty"`
+ PerTokenPrice uint64 `protobuf:"varint,32,opt,name=per_token_price,json=perTokenPrice,proto3" json:"per_token_price,omitempty"` // Locked-in per-token price when inference started (for dynamic pricing)
+}
+
+func (x *Inference) Reset() {
+ *x = Inference{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_inference_proto_msgTypes[1]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *Inference) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Inference) ProtoMessage() {}
+
+// Deprecated: Use Inference.ProtoReflect.Descriptor instead.
+func (*Inference) Descriptor() ([]byte, []int) {
+ return file_inference_inference_inference_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *Inference) GetIndex() string {
+ if x != nil {
+ return x.Index
+ }
+ return ""
+}
+
+func (x *Inference) GetInferenceId() string {
+ if x != nil {
+ return x.InferenceId
+ }
+ return ""
+}
+
+func (x *Inference) GetPromptHash() string {
+ if x != nil {
+ return x.PromptHash
+ }
+ return ""
+}
+
+func (x *Inference) GetPromptPayload() string {
+ if x != nil {
+ return x.PromptPayload
+ }
+ return ""
+}
+
+func (x *Inference) GetResponseHash() string {
+ if x != nil {
+ return x.ResponseHash
+ }
+ return ""
+}
+
+func (x *Inference) GetResponsePayload() string {
+ if x != nil {
+ return x.ResponsePayload
+ }
+ return ""
+}
+
+func (x *Inference) GetPromptTokenCount() uint64 {
+ if x != nil {
+ return x.PromptTokenCount
+ }
+ return 0
+}
+
+func (x *Inference) GetCompletionTokenCount() uint64 {
+ if x != nil {
+ return x.CompletionTokenCount
+ }
+ return 0
+}
+
+func (x *Inference) GetRequestedBy() string {
+ if x != nil {
+ return x.RequestedBy
+ }
+ return ""
+}
+
+func (x *Inference) GetExecutedBy() string {
+ if x != nil {
+ return x.ExecutedBy
+ }
+ return ""
+}
+
+func (x *Inference) GetStatus() InferenceStatus {
+ if x != nil {
+ return x.Status
+ }
+ return InferenceStatus_STARTED
+}
+
+func (x *Inference) GetStartBlockHeight() int64 {
+ if x != nil {
+ return x.StartBlockHeight
+ }
+ return 0
+}
+
+func (x *Inference) GetEndBlockHeight() int64 {
+ if x != nil {
+ return x.EndBlockHeight
+ }
+ return 0
+}
+
+func (x *Inference) GetStartBlockTimestamp() int64 {
+ if x != nil {
+ return x.StartBlockTimestamp
+ }
+ return 0
+}
+
+func (x *Inference) GetEndBlockTimestamp() int64 {
+ if x != nil {
+ return x.EndBlockTimestamp
+ }
+ return 0
+}
+
+func (x *Inference) GetModel() string {
+ if x != nil {
+ return x.Model
+ }
+ return ""
+}
+
+func (x *Inference) GetMaxTokens() uint64 {
+ if x != nil {
+ return x.MaxTokens
+ }
+ return 0
+}
+
+func (x *Inference) GetActualCost() int64 {
+ if x != nil {
+ return x.ActualCost
+ }
+ return 0
+}
+
+func (x *Inference) GetEscrowAmount() int64 {
+ if x != nil {
+ return x.EscrowAmount
+ }
+ return 0
+}
+
+func (x *Inference) GetProposalDetails() *ProposalDetails {
+ if x != nil {
+ return x.ProposalDetails
+ }
+ return nil
+}
+
+func (x *Inference) GetEpochGroupId() uint64 {
+ if x != nil {
+ return x.EpochGroupId
+ }
+ return 0
+}
+
+func (x *Inference) GetAssignedTo() string {
+ if x != nil {
+ return x.AssignedTo
+ }
+ return ""
+}
+
+func (x *Inference) GetValidatedBy() []string {
+ if x != nil {
+ return x.ValidatedBy
+ }
+ return nil
+}
+
+func (x *Inference) GetNodeVersion() string {
+ if x != nil {
+ return x.NodeVersion
+ }
+ return ""
+}
+
+func (x *Inference) GetEpochId() uint64 {
+ if x != nil {
+ return x.EpochId
+ }
+ return 0
+}
+
+func (x *Inference) GetEpochPocStartBlockHeight() uint64 {
+ if x != nil {
+ return x.EpochPocStartBlockHeight
+ }
+ return 0
+}
+
+func (x *Inference) GetTransferredBy() string {
+ if x != nil {
+ return x.TransferredBy
+ }
+ return ""
+}
+
+func (x *Inference) GetRequestTimestamp() int64 {
+ if x != nil {
+ return x.RequestTimestamp
+ }
+ return 0
+}
+
+func (x *Inference) GetTransferSignature() string {
+ if x != nil {
+ return x.TransferSignature
+ }
+ return ""
+}
+
+func (x *Inference) GetExecutionSignature() string {
+ if x != nil {
+ return x.ExecutionSignature
+ }
+ return ""
+}
+
+func (x *Inference) GetOriginalPrompt() string {
+ if x != nil {
+ return x.OriginalPrompt
+ }
+ return ""
+}
+
+func (x *Inference) GetPerTokenPrice() uint64 {
+ if x != nil {
+ return x.PerTokenPrice
+ }
+ return 0
+}
+
+var File_inference_inference_inference_proto protoreflect.FileDescriptor
+
+var file_inference_inference_inference_proto_rawDesc = []byte{
+ 0x0a, 0x23, 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, 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, 0x9d, 0x01, 0x0a, 0x0f, 0x50,
+ 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x31,
+ 0x0a, 0x15, 0x72, 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x5f, 0x70, 0x6f,
+ 0x6c, 0x69, 0x63, 0x79, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x12, 0x72,
+ 0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x49,
+ 0x64, 0x12, 0x30, 0x0a, 0x14, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x5f,
+ 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52,
+ 0x12, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x50, 0x6f, 0x6c, 0x69, 0x63,
+ 0x79, 0x49, 0x64, 0x12, 0x25, 0x0a, 0x0e, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x5f, 0x61, 0x64,
+ 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x70, 0x6f, 0x6c,
+ 0x69, 0x63, 0x79, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0xb7, 0x0a, 0x0a, 0x09, 0x49,
+ 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x69, 0x6e, 0x64, 0x65,
+ 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 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, 0x25, 0x0a, 0x0e, 0x70, 0x72, 0x6f, 0x6d, 0x70, 0x74, 0x5f, 0x70, 0x61, 0x79,
+ 0x6c, 0x6f, 0x61, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x70, 0x72, 0x6f, 0x6d,
+ 0x70, 0x74, 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, 0x29,
+ 0x0a, 0x10, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x5f, 0x70, 0x61, 0x79, 0x6c, 0x6f,
+ 0x61, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 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,
+ 0x07, 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, 0x08, 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, 0x21, 0x0a,
+ 0x0c, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x62, 0x79, 0x18, 0x09, 0x20,
+ 0x01, 0x28, 0x09, 0x52, 0x0b, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x42, 0x79,
+ 0x12, 0x1f, 0x0a, 0x0b, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x64, 0x5f, 0x62, 0x79, 0x18,
+ 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x64, 0x42,
+ 0x79, 0x12, 0x3c, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x0b, 0x20, 0x01, 0x28,
+ 0x0e, 0x32, 0x24, 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, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12,
+ 0x2c, 0x0a, 0x12, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68,
+ 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x03, 0x52, 0x10, 0x73, 0x74, 0x61,
+ 0x72, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x28, 0x0a,
+ 0x10, 0x65, 0x6e, 0x64, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68,
+ 0x74, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, 0x65, 0x6e, 0x64, 0x42, 0x6c, 0x6f, 0x63,
+ 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x32, 0x0a, 0x15, 0x73, 0x74, 0x61, 0x72, 0x74,
+ 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70,
+ 0x18, 0x0e, 0x20, 0x01, 0x28, 0x03, 0x52, 0x13, 0x73, 0x74, 0x61, 0x72, 0x74, 0x42, 0x6c, 0x6f,
+ 0x63, 0x6b, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x2e, 0x0a, 0x13, 0x65,
+ 0x6e, 0x64, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61,
+ 0x6d, 0x70, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x03, 0x52, 0x11, 0x65, 0x6e, 0x64, 0x42, 0x6c, 0x6f,
+ 0x63, 0x6b, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x14, 0x0a, 0x05, 0x6d,
+ 0x6f, 0x64, 0x65, 0x6c, 0x18, 0x10, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x6d, 0x6f, 0x64, 0x65,
+ 0x6c, 0x12, 0x1d, 0x0a, 0x0a, 0x6d, 0x61, 0x78, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x18,
+ 0x11, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x6d, 0x61, 0x78, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73,
+ 0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x63, 0x74, 0x75, 0x61, 0x6c, 0x5f, 0x63, 0x6f, 0x73, 0x74, 0x18,
+ 0x12, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x61, 0x63, 0x74, 0x75, 0x61, 0x6c, 0x43, 0x6f, 0x73,
+ 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x65, 0x73, 0x63, 0x72, 0x6f, 0x77, 0x5f, 0x61, 0x6d, 0x6f, 0x75,
+ 0x6e, 0x74, 0x18, 0x13, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x65, 0x73, 0x63, 0x72, 0x6f, 0x77,
+ 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x4f, 0x0a, 0x10, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73,
+ 0x61, 0x6c, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x14, 0x20, 0x01, 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, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x44,
+ 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x0f, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c,
+ 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x24, 0x0a, 0x0e, 0x65, 0x70, 0x6f, 0x63, 0x68,
+ 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x69, 0x64, 0x18, 0x15, 0x20, 0x01, 0x28, 0x04, 0x52,
+ 0x0c, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x64, 0x12, 0x1f, 0x0a,
+ 0x0b, 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x5f, 0x74, 0x6f, 0x18, 0x16, 0x20, 0x01,
+ 0x28, 0x09, 0x52, 0x0a, 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x54, 0x6f, 0x12, 0x21,
+ 0x0a, 0x0c, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x62, 0x79, 0x18, 0x17,
+ 0x20, 0x03, 0x28, 0x09, 0x52, 0x0b, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x64, 0x42,
+ 0x79, 0x12, 0x21, 0x0a, 0x0c, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f,
+ 0x6e, 0x18, 0x18, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6e, 0x6f, 0x64, 0x65, 0x56, 0x65, 0x72,
+ 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x64,
+ 0x18, 0x19, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x64, 0x12,
+ 0x3e, 0x0a, 0x1c, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x70, 0x6f, 0x63, 0x5f, 0x73, 0x74, 0x61,
+ 0x72, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18,
+ 0x1a, 0x20, 0x01, 0x28, 0x04, 0x52, 0x18, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x6f, 0x63, 0x53,
+ 0x74, 0x61, 0x72, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12,
+ 0x25, 0x0a, 0x0e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x72, 0x65, 0x64, 0x5f, 0x62,
+ 0x79, 0x18, 0x1b, 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, 0x1c, 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, 0x1d, 0x20, 0x01, 0x28, 0x09, 0x52,
+ 0x11, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75,
+ 0x72, 0x65, 0x12, 0x2f, 0x0a, 0x13, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5f,
+ 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x1e, 0x20, 0x01, 0x28, 0x09, 0x52,
+ 0x12, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74,
+ 0x75, 0x72, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c, 0x5f,
+ 0x70, 0x72, 0x6f, 0x6d, 0x70, 0x74, 0x18, 0x1f, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x6f, 0x72,
+ 0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x6d, 0x70, 0x74, 0x12, 0x26, 0x0a, 0x0f,
+ 0x70, 0x65, 0x72, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18,
+ 0x20, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0d, 0x70, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x50,
+ 0x72, 0x69, 0x63, 0x65, 0x2a, 0x65, 0x0a, 0x0f, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+ 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x0b, 0x0a, 0x07, 0x53, 0x54, 0x41, 0x52, 0x54,
+ 0x45, 0x44, 0x10, 0x00, 0x12, 0x0c, 0x0a, 0x08, 0x46, 0x49, 0x4e, 0x49, 0x53, 0x48, 0x45, 0x44,
+ 0x10, 0x01, 0x12, 0x0d, 0x0a, 0x09, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x41, 0x54, 0x45, 0x44, 0x10,
+ 0x02, 0x12, 0x0f, 0x0a, 0x0b, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x41, 0x54, 0x45, 0x44,
+ 0x10, 0x03, 0x12, 0x0a, 0x0a, 0x06, 0x56, 0x4f, 0x54, 0x49, 0x4e, 0x47, 0x10, 0x04, 0x12, 0x0b,
+ 0x0a, 0x07, 0x45, 0x58, 0x50, 0x49, 0x52, 0x45, 0x44, 0x10, 0x05, 0x42, 0xbc, 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, 0x0e, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 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_inference_proto_rawDescOnce sync.Once
+ file_inference_inference_inference_proto_rawDescData = file_inference_inference_inference_proto_rawDesc
+)
+
+func file_inference_inference_inference_proto_rawDescGZIP() []byte {
+ file_inference_inference_inference_proto_rawDescOnce.Do(func() {
+ file_inference_inference_inference_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_inference_inference_proto_rawDescData)
+ })
+ return file_inference_inference_inference_proto_rawDescData
+}
+
+var file_inference_inference_inference_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
+var file_inference_inference_inference_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
+var file_inference_inference_inference_proto_goTypes = []interface{}{
+ (InferenceStatus)(0), // 0: inference.inference.InferenceStatus
+ (*ProposalDetails)(nil), // 1: inference.inference.ProposalDetails
+ (*Inference)(nil), // 2: inference.inference.Inference
+}
+var file_inference_inference_inference_proto_depIdxs = []int32{
+ 0, // 0: inference.inference.Inference.status:type_name -> inference.inference.InferenceStatus
+ 1, // 1: inference.inference.Inference.proposal_details:type_name -> inference.inference.ProposalDetails
+ 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_inference_proto_init() }
+func file_inference_inference_inference_proto_init() {
+ if File_inference_inference_inference_proto != nil {
+ return
+ }
+ if !protoimpl.UnsafeEnabled {
+ file_inference_inference_inference_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*ProposalDetails); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_inference_inference_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*Inference); 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_inference_proto_rawDesc,
+ NumEnums: 1,
+ NumMessages: 2,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_inference_inference_proto_goTypes,
+ DependencyIndexes: file_inference_inference_inference_proto_depIdxs,
+ EnumInfos: file_inference_inference_inference_proto_enumTypes,
+ MessageInfos: file_inference_inference_inference_proto_msgTypes,
+ }.Build()
+ File_inference_inference_inference_proto = out.File
+ file_inference_inference_inference_proto_rawDesc = nil
+ file_inference_inference_inference_proto_goTypes = nil
+ file_inference_inference_inference_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/inference/inference_timeout.pulsar.go b/inference-chain/api/inference/inference/inference_timeout.pulsar.go
new file mode 100644
index 000000000..897e7060b
--- /dev/null
+++ b/inference-chain/api/inference/inference/inference_timeout.pulsar.go
@@ -0,0 +1,629 @@
+// 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_InferenceTimeout protoreflect.MessageDescriptor
+ fd_InferenceTimeout_expiration_height protoreflect.FieldDescriptor
+ fd_InferenceTimeout_inference_id protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_inference_timeout_proto_init()
+ md_InferenceTimeout = File_inference_inference_inference_timeout_proto.Messages().ByName("InferenceTimeout")
+ fd_InferenceTimeout_expiration_height = md_InferenceTimeout.Fields().ByName("expiration_height")
+ fd_InferenceTimeout_inference_id = md_InferenceTimeout.Fields().ByName("inference_id")
+}
+
+var _ protoreflect.Message = (*fastReflection_InferenceTimeout)(nil)
+
+type fastReflection_InferenceTimeout InferenceTimeout
+
+func (x *InferenceTimeout) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_InferenceTimeout)(x)
+}
+
+func (x *InferenceTimeout) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_inference_timeout_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_InferenceTimeout_messageType fastReflection_InferenceTimeout_messageType
+var _ protoreflect.MessageType = fastReflection_InferenceTimeout_messageType{}
+
+type fastReflection_InferenceTimeout_messageType struct{}
+
+func (x fastReflection_InferenceTimeout_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_InferenceTimeout)(nil)
+}
+func (x fastReflection_InferenceTimeout_messageType) New() protoreflect.Message {
+ return new(fastReflection_InferenceTimeout)
+}
+func (x fastReflection_InferenceTimeout_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_InferenceTimeout
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_InferenceTimeout) Descriptor() protoreflect.MessageDescriptor {
+ return md_InferenceTimeout
+}
+
+// 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_InferenceTimeout) Type() protoreflect.MessageType {
+ return _fastReflection_InferenceTimeout_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_InferenceTimeout) New() protoreflect.Message {
+ return new(fastReflection_InferenceTimeout)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_InferenceTimeout) Interface() protoreflect.ProtoMessage {
+ return (*InferenceTimeout)(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_InferenceTimeout) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.ExpirationHeight != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.ExpirationHeight)
+ if !f(fd_InferenceTimeout_expiration_height, value) {
+ return
+ }
+ }
+ if x.InferenceId != "" {
+ value := protoreflect.ValueOfString(x.InferenceId)
+ if !f(fd_InferenceTimeout_inference_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_InferenceTimeout) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.InferenceTimeout.expiration_height":
+ return x.ExpirationHeight != uint64(0)
+ case "inference.inference.InferenceTimeout.inference_id":
+ return x.InferenceId != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.InferenceTimeout"))
+ }
+ panic(fmt.Errorf("message inference.inference.InferenceTimeout 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_InferenceTimeout) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.InferenceTimeout.expiration_height":
+ x.ExpirationHeight = uint64(0)
+ case "inference.inference.InferenceTimeout.inference_id":
+ x.InferenceId = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.InferenceTimeout"))
+ }
+ panic(fmt.Errorf("message inference.inference.InferenceTimeout 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_InferenceTimeout) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.InferenceTimeout.expiration_height":
+ value := x.ExpirationHeight
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.InferenceTimeout.inference_id":
+ value := x.InferenceId
+ return protoreflect.ValueOfString(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.InferenceTimeout"))
+ }
+ panic(fmt.Errorf("message inference.inference.InferenceTimeout 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_InferenceTimeout) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.InferenceTimeout.expiration_height":
+ x.ExpirationHeight = value.Uint()
+ case "inference.inference.InferenceTimeout.inference_id":
+ x.InferenceId = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.InferenceTimeout"))
+ }
+ panic(fmt.Errorf("message inference.inference.InferenceTimeout 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_InferenceTimeout) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.InferenceTimeout.expiration_height":
+ panic(fmt.Errorf("field expiration_height of message inference.inference.InferenceTimeout is not mutable"))
+ case "inference.inference.InferenceTimeout.inference_id":
+ panic(fmt.Errorf("field inference_id of message inference.inference.InferenceTimeout is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.InferenceTimeout"))
+ }
+ panic(fmt.Errorf("message inference.inference.InferenceTimeout 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_InferenceTimeout) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.InferenceTimeout.expiration_height":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.InferenceTimeout.inference_id":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.InferenceTimeout"))
+ }
+ panic(fmt.Errorf("message inference.inference.InferenceTimeout 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_InferenceTimeout) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.InferenceTimeout", 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_InferenceTimeout) 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_InferenceTimeout) 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_InferenceTimeout) 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_InferenceTimeout) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*InferenceTimeout)
+ 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.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 {
+ n += len(x.unknownFields)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*InferenceTimeout)
+ 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.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))
+ 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().(*InferenceTimeout)
+ 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: InferenceTimeout: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: InferenceTimeout: 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)
+ }
+ 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.InferenceId = 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/inference_timeout.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)
+)
+
+type InferenceTimeout struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ ExpirationHeight uint64 `protobuf:"varint,1,opt,name=expiration_height,json=expirationHeight,proto3" json:"expiration_height,omitempty"`
+ InferenceId string `protobuf:"bytes,2,opt,name=inference_id,json=inferenceId,proto3" json:"inference_id,omitempty"`
+}
+
+func (x *InferenceTimeout) Reset() {
+ *x = InferenceTimeout{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_inference_timeout_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *InferenceTimeout) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*InferenceTimeout) ProtoMessage() {}
+
+// Deprecated: Use InferenceTimeout.ProtoReflect.Descriptor instead.
+func (*InferenceTimeout) Descriptor() ([]byte, []int) {
+ return file_inference_inference_inference_timeout_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *InferenceTimeout) GetExpirationHeight() uint64 {
+ if x != nil {
+ return x.ExpirationHeight
+ }
+ return 0
+}
+
+func (x *InferenceTimeout) GetInferenceId() string {
+ if x != nil {
+ return x.InferenceId
+ }
+ return ""
+}
+
+var File_inference_inference_inference_timeout_proto protoreflect.FileDescriptor
+
+var file_inference_inference_inference_timeout_proto_rawDesc = []byte{
+ 0x0a, 0x2b, 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, 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, 0x62, 0x0a, 0x10, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x54,
+ 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x12, 0x2b, 0x0a, 0x11, 0x65, 0x78, 0x70, 0x69, 0x72, 0x61,
+ 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x68, 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, 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, 0x42, 0xc3, 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, 0x15, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x54, 0x69, 0x6d,
+ 0x65, 0x6f, 0x75, 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_inference_timeout_proto_rawDescOnce sync.Once
+ file_inference_inference_inference_timeout_proto_rawDescData = file_inference_inference_inference_timeout_proto_rawDesc
+)
+
+func file_inference_inference_inference_timeout_proto_rawDescGZIP() []byte {
+ file_inference_inference_inference_timeout_proto_rawDescOnce.Do(func() {
+ file_inference_inference_inference_timeout_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_inference_inference_timeout_proto_rawDescData)
+ })
+ return file_inference_inference_inference_timeout_proto_rawDescData
+}
+
+var file_inference_inference_inference_timeout_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_inference_inference_inference_timeout_proto_goTypes = []interface{}{
+ (*InferenceTimeout)(nil), // 0: inference.inference.InferenceTimeout
+}
+var file_inference_inference_inference_timeout_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_inference_timeout_proto_init() }
+func file_inference_inference_inference_timeout_proto_init() {
+ if File_inference_inference_inference_timeout_proto != nil {
+ return
+ }
+ if !protoimpl.UnsafeEnabled {
+ file_inference_inference_inference_timeout_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*InferenceTimeout); 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_inference_timeout_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 1,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_inference_inference_timeout_proto_goTypes,
+ DependencyIndexes: file_inference_inference_inference_timeout_proto_depIdxs,
+ MessageInfos: file_inference_inference_inference_timeout_proto_msgTypes,
+ }.Build()
+ File_inference_inference_inference_timeout_proto = out.File
+ file_inference_inference_inference_timeout_proto_rawDesc = nil
+ file_inference_inference_inference_timeout_proto_goTypes = nil
+ file_inference_inference_inference_timeout_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/inference/inference_timout.pulsar.go b/inference-chain/api/inference/inference/inference_timout.pulsar.go
new file mode 100644
index 000000000..f33fee365
--- /dev/null
+++ b/inference-chain/api/inference/inference/inference_timout.pulsar.go
@@ -0,0 +1,628 @@
+// 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_InferenceTimout protoreflect.MessageDescriptor
+ fd_InferenceTimout_expirationHeight protoreflect.FieldDescriptor
+ fd_InferenceTimout_inferenceId protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_inference_timout_proto_init()
+ md_InferenceTimout = File_inference_inference_inference_timout_proto.Messages().ByName("InferenceTimout")
+ fd_InferenceTimout_expirationHeight = md_InferenceTimout.Fields().ByName("expirationHeight")
+ fd_InferenceTimout_inferenceId = md_InferenceTimout.Fields().ByName("inferenceId")
+}
+
+var _ protoreflect.Message = (*fastReflection_InferenceTimout)(nil)
+
+type fastReflection_InferenceTimout InferenceTimout
+
+func (x *InferenceTimout) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_InferenceTimout)(x)
+}
+
+func (x *InferenceTimout) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_inference_timout_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_InferenceTimout_messageType fastReflection_InferenceTimout_messageType
+var _ protoreflect.MessageType = fastReflection_InferenceTimout_messageType{}
+
+type fastReflection_InferenceTimout_messageType struct{}
+
+func (x fastReflection_InferenceTimout_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_InferenceTimout)(nil)
+}
+func (x fastReflection_InferenceTimout_messageType) New() protoreflect.Message {
+ return new(fastReflection_InferenceTimout)
+}
+func (x fastReflection_InferenceTimout_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_InferenceTimout
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_InferenceTimout) Descriptor() protoreflect.MessageDescriptor {
+ return md_InferenceTimout
+}
+
+// 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_InferenceTimout) Type() protoreflect.MessageType {
+ return _fastReflection_InferenceTimout_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_InferenceTimout) New() protoreflect.Message {
+ return new(fastReflection_InferenceTimout)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_InferenceTimout) Interface() protoreflect.ProtoMessage {
+ return (*InferenceTimout)(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_InferenceTimout) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.ExpirationHeight != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.ExpirationHeight)
+ if !f(fd_InferenceTimout_expirationHeight, value) {
+ return
+ }
+ }
+ if x.InferenceId != "" {
+ value := protoreflect.ValueOfString(x.InferenceId)
+ if !f(fd_InferenceTimout_inferenceId, 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_InferenceTimout) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.InferenceTimout.expirationHeight":
+ return x.ExpirationHeight != uint64(0)
+ case "inference.inference.InferenceTimout.inferenceId":
+ return x.InferenceId != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.InferenceTimout"))
+ }
+ panic(fmt.Errorf("message inference.inference.InferenceTimout 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_InferenceTimout) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.InferenceTimout.expirationHeight":
+ x.ExpirationHeight = uint64(0)
+ case "inference.inference.InferenceTimout.inferenceId":
+ x.InferenceId = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.InferenceTimout"))
+ }
+ panic(fmt.Errorf("message inference.inference.InferenceTimout 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_InferenceTimout) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.InferenceTimout.expirationHeight":
+ value := x.ExpirationHeight
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.InferenceTimout.inferenceId":
+ value := x.InferenceId
+ return protoreflect.ValueOfString(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.InferenceTimout"))
+ }
+ panic(fmt.Errorf("message inference.inference.InferenceTimout 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_InferenceTimout) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.InferenceTimout.expirationHeight":
+ x.ExpirationHeight = value.Uint()
+ case "inference.inference.InferenceTimout.inferenceId":
+ x.InferenceId = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.InferenceTimout"))
+ }
+ panic(fmt.Errorf("message inference.inference.InferenceTimout 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_InferenceTimout) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.InferenceTimout.expirationHeight":
+ panic(fmt.Errorf("field expirationHeight of message inference.inference.InferenceTimout is not mutable"))
+ case "inference.inference.InferenceTimout.inferenceId":
+ panic(fmt.Errorf("field inferenceId of message inference.inference.InferenceTimout is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.InferenceTimout"))
+ }
+ panic(fmt.Errorf("message inference.inference.InferenceTimout 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_InferenceTimout) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.InferenceTimout.expirationHeight":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.InferenceTimout.inferenceId":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.InferenceTimout"))
+ }
+ panic(fmt.Errorf("message inference.inference.InferenceTimout 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_InferenceTimout) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.InferenceTimout", 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_InferenceTimout) 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_InferenceTimout) 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_InferenceTimout) 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_InferenceTimout) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*InferenceTimout)
+ 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.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 {
+ n += len(x.unknownFields)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*InferenceTimout)
+ 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.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))
+ 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().(*InferenceTimout)
+ 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: InferenceTimout: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: InferenceTimout: 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)
+ }
+ 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.InferenceId = 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/inference_timout.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)
+)
+
+type InferenceTimout 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 *InferenceTimout) Reset() {
+ *x = InferenceTimout{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_inference_timout_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *InferenceTimout) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*InferenceTimout) ProtoMessage() {}
+
+// Deprecated: Use InferenceTimout.ProtoReflect.Descriptor instead.
+func (*InferenceTimout) Descriptor() ([]byte, []int) {
+ return file_inference_inference_inference_timout_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *InferenceTimout) GetExpirationHeight() uint64 {
+ if x != nil {
+ return x.ExpirationHeight
+ }
+ return 0
+}
+
+func (x *InferenceTimout) GetInferenceId() string {
+ if x != nil {
+ return x.InferenceId
+ }
+ return ""
+}
+
+var File_inference_inference_inference_timout_proto protoreflect.FileDescriptor
+
+var file_inference_inference_inference_timout_proto_rawDesc = []byte{
+ 0x0a, 0x2a, 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, 0x6f, 0x75, 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, 0x5f, 0x0a, 0x0f, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x54, 0x69,
+ 0x6d, 0x6f, 0x75, 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, 0x42, 0xc2, 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, 0x14,
+ 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x54, 0x69, 0x6d, 0x6f, 0x75, 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_inference_timout_proto_rawDescOnce sync.Once
+ file_inference_inference_inference_timout_proto_rawDescData = file_inference_inference_inference_timout_proto_rawDesc
+)
+
+func file_inference_inference_inference_timout_proto_rawDescGZIP() []byte {
+ file_inference_inference_inference_timout_proto_rawDescOnce.Do(func() {
+ file_inference_inference_inference_timout_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_inference_inference_timout_proto_rawDescData)
+ })
+ return file_inference_inference_inference_timout_proto_rawDescData
+}
+
+var file_inference_inference_inference_timout_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_inference_inference_inference_timout_proto_goTypes = []interface{}{
+ (*InferenceTimout)(nil), // 0: inference.inference.InferenceTimout
+}
+var file_inference_inference_inference_timout_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_inference_timout_proto_init() }
+func file_inference_inference_inference_timout_proto_init() {
+ if File_inference_inference_inference_timout_proto != nil {
+ return
+ }
+ if !protoimpl.UnsafeEnabled {
+ file_inference_inference_inference_timout_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*InferenceTimout); 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_inference_timout_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 1,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_inference_inference_timout_proto_goTypes,
+ DependencyIndexes: file_inference_inference_inference_timout_proto_depIdxs,
+ MessageInfos: file_inference_inference_inference_timout_proto_msgTypes,
+ }.Build()
+ File_inference_inference_inference_timout_proto = out.File
+ file_inference_inference_inference_timout_proto_rawDesc = nil
+ file_inference_inference_inference_timout_proto_goTypes = nil
+ file_inference_inference_inference_timout_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/inference/inference_validation_details.pulsar.go b/inference-chain/api/inference/inference/inference_validation_details.pulsar.go
new file mode 100644
index 000000000..47a10e882
--- /dev/null
+++ b/inference-chain/api/inference/inference/inference_validation_details.pulsar.go
@@ -0,0 +1,1070 @@
+// 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_InferenceValidationDetails protoreflect.MessageDescriptor
+ fd_InferenceValidationDetails_epoch_id protoreflect.FieldDescriptor
+ fd_InferenceValidationDetails_inference_id protoreflect.FieldDescriptor
+ fd_InferenceValidationDetails_executor_id protoreflect.FieldDescriptor
+ fd_InferenceValidationDetails_executor_reputation protoreflect.FieldDescriptor
+ fd_InferenceValidationDetails_traffic_basis protoreflect.FieldDescriptor
+ fd_InferenceValidationDetails_executor_power protoreflect.FieldDescriptor
+ fd_InferenceValidationDetails_model protoreflect.FieldDescriptor
+ fd_InferenceValidationDetails_total_power protoreflect.FieldDescriptor
+ fd_InferenceValidationDetails_created_at_block_height protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_inference_validation_details_proto_init()
+ md_InferenceValidationDetails = File_inference_inference_inference_validation_details_proto.Messages().ByName("InferenceValidationDetails")
+ fd_InferenceValidationDetails_epoch_id = md_InferenceValidationDetails.Fields().ByName("epoch_id")
+ fd_InferenceValidationDetails_inference_id = md_InferenceValidationDetails.Fields().ByName("inference_id")
+ fd_InferenceValidationDetails_executor_id = md_InferenceValidationDetails.Fields().ByName("executor_id")
+ fd_InferenceValidationDetails_executor_reputation = md_InferenceValidationDetails.Fields().ByName("executor_reputation")
+ fd_InferenceValidationDetails_traffic_basis = md_InferenceValidationDetails.Fields().ByName("traffic_basis")
+ fd_InferenceValidationDetails_executor_power = md_InferenceValidationDetails.Fields().ByName("executor_power")
+ fd_InferenceValidationDetails_model = md_InferenceValidationDetails.Fields().ByName("model")
+ fd_InferenceValidationDetails_total_power = md_InferenceValidationDetails.Fields().ByName("total_power")
+ fd_InferenceValidationDetails_created_at_block_height = md_InferenceValidationDetails.Fields().ByName("created_at_block_height")
+}
+
+var _ protoreflect.Message = (*fastReflection_InferenceValidationDetails)(nil)
+
+type fastReflection_InferenceValidationDetails InferenceValidationDetails
+
+func (x *InferenceValidationDetails) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_InferenceValidationDetails)(x)
+}
+
+func (x *InferenceValidationDetails) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_inference_validation_details_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_InferenceValidationDetails_messageType fastReflection_InferenceValidationDetails_messageType
+var _ protoreflect.MessageType = fastReflection_InferenceValidationDetails_messageType{}
+
+type fastReflection_InferenceValidationDetails_messageType struct{}
+
+func (x fastReflection_InferenceValidationDetails_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_InferenceValidationDetails)(nil)
+}
+func (x fastReflection_InferenceValidationDetails_messageType) New() protoreflect.Message {
+ return new(fastReflection_InferenceValidationDetails)
+}
+func (x fastReflection_InferenceValidationDetails_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_InferenceValidationDetails
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_InferenceValidationDetails) Descriptor() protoreflect.MessageDescriptor {
+ return md_InferenceValidationDetails
+}
+
+// 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_InferenceValidationDetails) Type() protoreflect.MessageType {
+ return _fastReflection_InferenceValidationDetails_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_InferenceValidationDetails) New() protoreflect.Message {
+ return new(fastReflection_InferenceValidationDetails)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_InferenceValidationDetails) Interface() protoreflect.ProtoMessage {
+ return (*InferenceValidationDetails)(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_InferenceValidationDetails) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.EpochId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.EpochId)
+ if !f(fd_InferenceValidationDetails_epoch_id, value) {
+ return
+ }
+ }
+ if x.InferenceId != "" {
+ value := protoreflect.ValueOfString(x.InferenceId)
+ if !f(fd_InferenceValidationDetails_inference_id, value) {
+ return
+ }
+ }
+ if x.ExecutorId != "" {
+ value := protoreflect.ValueOfString(x.ExecutorId)
+ if !f(fd_InferenceValidationDetails_executor_id, value) {
+ return
+ }
+ }
+ if x.ExecutorReputation != int32(0) {
+ value := protoreflect.ValueOfInt32(x.ExecutorReputation)
+ if !f(fd_InferenceValidationDetails_executor_reputation, value) {
+ return
+ }
+ }
+ if x.TrafficBasis != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.TrafficBasis)
+ if !f(fd_InferenceValidationDetails_traffic_basis, value) {
+ return
+ }
+ }
+ if x.ExecutorPower != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.ExecutorPower)
+ if !f(fd_InferenceValidationDetails_executor_power, value) {
+ return
+ }
+ }
+ if x.Model != "" {
+ value := protoreflect.ValueOfString(x.Model)
+ if !f(fd_InferenceValidationDetails_model, value) {
+ return
+ }
+ }
+ if x.TotalPower != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.TotalPower)
+ if !f(fd_InferenceValidationDetails_total_power, value) {
+ return
+ }
+ }
+ if x.CreatedAtBlockHeight != int64(0) {
+ value := protoreflect.ValueOfInt64(x.CreatedAtBlockHeight)
+ if !f(fd_InferenceValidationDetails_created_at_block_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_InferenceValidationDetails) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.InferenceValidationDetails.epoch_id":
+ return x.EpochId != uint64(0)
+ case "inference.inference.InferenceValidationDetails.inference_id":
+ return x.InferenceId != ""
+ case "inference.inference.InferenceValidationDetails.executor_id":
+ return x.ExecutorId != ""
+ case "inference.inference.InferenceValidationDetails.executor_reputation":
+ return x.ExecutorReputation != int32(0)
+ case "inference.inference.InferenceValidationDetails.traffic_basis":
+ return x.TrafficBasis != uint64(0)
+ case "inference.inference.InferenceValidationDetails.executor_power":
+ return x.ExecutorPower != uint64(0)
+ case "inference.inference.InferenceValidationDetails.model":
+ return x.Model != ""
+ case "inference.inference.InferenceValidationDetails.total_power":
+ return x.TotalPower != uint64(0)
+ case "inference.inference.InferenceValidationDetails.created_at_block_height":
+ return x.CreatedAtBlockHeight != int64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.InferenceValidationDetails"))
+ }
+ panic(fmt.Errorf("message inference.inference.InferenceValidationDetails 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_InferenceValidationDetails) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.InferenceValidationDetails.epoch_id":
+ x.EpochId = uint64(0)
+ case "inference.inference.InferenceValidationDetails.inference_id":
+ x.InferenceId = ""
+ case "inference.inference.InferenceValidationDetails.executor_id":
+ x.ExecutorId = ""
+ case "inference.inference.InferenceValidationDetails.executor_reputation":
+ x.ExecutorReputation = int32(0)
+ case "inference.inference.InferenceValidationDetails.traffic_basis":
+ x.TrafficBasis = uint64(0)
+ case "inference.inference.InferenceValidationDetails.executor_power":
+ x.ExecutorPower = uint64(0)
+ case "inference.inference.InferenceValidationDetails.model":
+ x.Model = ""
+ case "inference.inference.InferenceValidationDetails.total_power":
+ x.TotalPower = uint64(0)
+ case "inference.inference.InferenceValidationDetails.created_at_block_height":
+ x.CreatedAtBlockHeight = int64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.InferenceValidationDetails"))
+ }
+ panic(fmt.Errorf("message inference.inference.InferenceValidationDetails 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_InferenceValidationDetails) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.InferenceValidationDetails.epoch_id":
+ value := x.EpochId
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.InferenceValidationDetails.inference_id":
+ value := x.InferenceId
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.InferenceValidationDetails.executor_id":
+ value := x.ExecutorId
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.InferenceValidationDetails.executor_reputation":
+ value := x.ExecutorReputation
+ return protoreflect.ValueOfInt32(value)
+ case "inference.inference.InferenceValidationDetails.traffic_basis":
+ value := x.TrafficBasis
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.InferenceValidationDetails.executor_power":
+ value := x.ExecutorPower
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.InferenceValidationDetails.model":
+ value := x.Model
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.InferenceValidationDetails.total_power":
+ value := x.TotalPower
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.InferenceValidationDetails.created_at_block_height":
+ value := x.CreatedAtBlockHeight
+ return protoreflect.ValueOfInt64(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.InferenceValidationDetails"))
+ }
+ panic(fmt.Errorf("message inference.inference.InferenceValidationDetails 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_InferenceValidationDetails) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.InferenceValidationDetails.epoch_id":
+ x.EpochId = value.Uint()
+ case "inference.inference.InferenceValidationDetails.inference_id":
+ x.InferenceId = value.Interface().(string)
+ case "inference.inference.InferenceValidationDetails.executor_id":
+ x.ExecutorId = value.Interface().(string)
+ case "inference.inference.InferenceValidationDetails.executor_reputation":
+ x.ExecutorReputation = int32(value.Int())
+ case "inference.inference.InferenceValidationDetails.traffic_basis":
+ x.TrafficBasis = value.Uint()
+ case "inference.inference.InferenceValidationDetails.executor_power":
+ x.ExecutorPower = value.Uint()
+ case "inference.inference.InferenceValidationDetails.model":
+ x.Model = value.Interface().(string)
+ case "inference.inference.InferenceValidationDetails.total_power":
+ x.TotalPower = value.Uint()
+ case "inference.inference.InferenceValidationDetails.created_at_block_height":
+ x.CreatedAtBlockHeight = value.Int()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.InferenceValidationDetails"))
+ }
+ panic(fmt.Errorf("message inference.inference.InferenceValidationDetails 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_InferenceValidationDetails) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.InferenceValidationDetails.epoch_id":
+ panic(fmt.Errorf("field epoch_id of message inference.inference.InferenceValidationDetails is not mutable"))
+ case "inference.inference.InferenceValidationDetails.inference_id":
+ panic(fmt.Errorf("field inference_id of message inference.inference.InferenceValidationDetails is not mutable"))
+ case "inference.inference.InferenceValidationDetails.executor_id":
+ panic(fmt.Errorf("field executor_id of message inference.inference.InferenceValidationDetails is not mutable"))
+ case "inference.inference.InferenceValidationDetails.executor_reputation":
+ panic(fmt.Errorf("field executor_reputation of message inference.inference.InferenceValidationDetails is not mutable"))
+ case "inference.inference.InferenceValidationDetails.traffic_basis":
+ panic(fmt.Errorf("field traffic_basis of message inference.inference.InferenceValidationDetails is not mutable"))
+ case "inference.inference.InferenceValidationDetails.executor_power":
+ panic(fmt.Errorf("field executor_power of message inference.inference.InferenceValidationDetails is not mutable"))
+ case "inference.inference.InferenceValidationDetails.model":
+ panic(fmt.Errorf("field model of message inference.inference.InferenceValidationDetails is not mutable"))
+ case "inference.inference.InferenceValidationDetails.total_power":
+ panic(fmt.Errorf("field total_power of message inference.inference.InferenceValidationDetails is not mutable"))
+ case "inference.inference.InferenceValidationDetails.created_at_block_height":
+ panic(fmt.Errorf("field created_at_block_height of message inference.inference.InferenceValidationDetails is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.InferenceValidationDetails"))
+ }
+ panic(fmt.Errorf("message inference.inference.InferenceValidationDetails 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_InferenceValidationDetails) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.InferenceValidationDetails.epoch_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.InferenceValidationDetails.inference_id":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.InferenceValidationDetails.executor_id":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.InferenceValidationDetails.executor_reputation":
+ return protoreflect.ValueOfInt32(int32(0))
+ case "inference.inference.InferenceValidationDetails.traffic_basis":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.InferenceValidationDetails.executor_power":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.InferenceValidationDetails.model":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.InferenceValidationDetails.total_power":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.InferenceValidationDetails.created_at_block_height":
+ return protoreflect.ValueOfInt64(int64(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.InferenceValidationDetails"))
+ }
+ panic(fmt.Errorf("message inference.inference.InferenceValidationDetails 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_InferenceValidationDetails) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.InferenceValidationDetails", 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_InferenceValidationDetails) 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_InferenceValidationDetails) 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_InferenceValidationDetails) 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_InferenceValidationDetails) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*InferenceValidationDetails)
+ 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.EpochId != 0 {
+ n += 1 + runtime.Sov(uint64(x.EpochId))
+ }
+ l = len(x.InferenceId)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ l = len(x.ExecutorId)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.ExecutorReputation != 0 {
+ n += 1 + runtime.Sov(uint64(x.ExecutorReputation))
+ }
+ if x.TrafficBasis != 0 {
+ n += 1 + runtime.Sov(uint64(x.TrafficBasis))
+ }
+ if x.ExecutorPower != 0 {
+ n += 1 + runtime.Sov(uint64(x.ExecutorPower))
+ }
+ l = len(x.Model)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.TotalPower != 0 {
+ n += 1 + runtime.Sov(uint64(x.TotalPower))
+ }
+ if x.CreatedAtBlockHeight != 0 {
+ n += 1 + runtime.Sov(uint64(x.CreatedAtBlockHeight))
+ }
+ 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().(*InferenceValidationDetails)
+ 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.CreatedAtBlockHeight != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.CreatedAtBlockHeight))
+ i--
+ dAtA[i] = 0x48
+ }
+ if x.TotalPower != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.TotalPower))
+ i--
+ dAtA[i] = 0x40
+ }
+ 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] = 0x3a
+ }
+ if x.ExecutorPower != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.ExecutorPower))
+ i--
+ dAtA[i] = 0x30
+ }
+ if x.TrafficBasis != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.TrafficBasis))
+ i--
+ dAtA[i] = 0x28
+ }
+ if x.ExecutorReputation != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.ExecutorReputation))
+ i--
+ dAtA[i] = 0x20
+ }
+ if len(x.ExecutorId) > 0 {
+ i -= len(x.ExecutorId)
+ copy(dAtA[i:], x.ExecutorId)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ExecutorId)))
+ i--
+ dAtA[i] = 0x1a
+ }
+ 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))
+ 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().(*InferenceValidationDetails)
+ 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: InferenceValidationDetails: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: InferenceValidationDetails: 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)
+ }
+ 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.InferenceId = 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 ExecutorId", 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.ExecutorId = 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 ExecutorReputation", wireType)
+ }
+ x.ExecutorReputation = 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.ExecutorReputation |= int32(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 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 6:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ExecutorPower", wireType)
+ }
+ x.ExecutorPower = 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.ExecutorPower |= uint64(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 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 8:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TotalPower", wireType)
+ }
+ x.TotalPower = 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.TotalPower |= 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 CreatedAtBlockHeight", wireType)
+ }
+ x.CreatedAtBlockHeight = 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.CreatedAtBlockHeight |= 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,
+ }
+}
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// protoc-gen-go v1.27.0
+// protoc (unknown)
+// source: inference/inference/inference_validation_details.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)
+)
+
+type InferenceValidationDetails struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ EpochId uint64 `protobuf:"varint,1,opt,name=epoch_id,json=epochId,proto3" json:"epoch_id,omitempty"` // The ID of the epoch!
+ InferenceId string `protobuf:"bytes,2,opt,name=inference_id,json=inferenceId,proto3" json:"inference_id,omitempty"`
+ ExecutorId string `protobuf:"bytes,3,opt,name=executor_id,json=executorId,proto3" json:"executor_id,omitempty"`
+ ExecutorReputation int32 `protobuf:"varint,4,opt,name=executor_reputation,json=executorReputation,proto3" json:"executor_reputation,omitempty"`
+ TrafficBasis uint64 `protobuf:"varint,5,opt,name=traffic_basis,json=trafficBasis,proto3" json:"traffic_basis,omitempty"`
+ ExecutorPower uint64 `protobuf:"varint,6,opt,name=executor_power,json=executorPower,proto3" json:"executor_power,omitempty"`
+ Model string `protobuf:"bytes,7,opt,name=model,proto3" json:"model,omitempty"`
+ TotalPower uint64 `protobuf:"varint,8,opt,name=total_power,json=totalPower,proto3" json:"total_power,omitempty"`
+ CreatedAtBlockHeight int64 `protobuf:"varint,9,opt,name=created_at_block_height,json=createdAtBlockHeight,proto3" json:"created_at_block_height,omitempty"` // Should be the same as block_finished for the inference
+}
+
+func (x *InferenceValidationDetails) Reset() {
+ *x = InferenceValidationDetails{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_inference_validation_details_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *InferenceValidationDetails) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*InferenceValidationDetails) ProtoMessage() {}
+
+// Deprecated: Use InferenceValidationDetails.ProtoReflect.Descriptor instead.
+func (*InferenceValidationDetails) Descriptor() ([]byte, []int) {
+ return file_inference_inference_inference_validation_details_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *InferenceValidationDetails) GetEpochId() uint64 {
+ if x != nil {
+ return x.EpochId
+ }
+ return 0
+}
+
+func (x *InferenceValidationDetails) GetInferenceId() string {
+ if x != nil {
+ return x.InferenceId
+ }
+ return ""
+}
+
+func (x *InferenceValidationDetails) GetExecutorId() string {
+ if x != nil {
+ return x.ExecutorId
+ }
+ return ""
+}
+
+func (x *InferenceValidationDetails) GetExecutorReputation() int32 {
+ if x != nil {
+ return x.ExecutorReputation
+ }
+ return 0
+}
+
+func (x *InferenceValidationDetails) GetTrafficBasis() uint64 {
+ if x != nil {
+ return x.TrafficBasis
+ }
+ return 0
+}
+
+func (x *InferenceValidationDetails) GetExecutorPower() uint64 {
+ if x != nil {
+ return x.ExecutorPower
+ }
+ return 0
+}
+
+func (x *InferenceValidationDetails) GetModel() string {
+ if x != nil {
+ return x.Model
+ }
+ return ""
+}
+
+func (x *InferenceValidationDetails) GetTotalPower() uint64 {
+ if x != nil {
+ return x.TotalPower
+ }
+ return 0
+}
+
+func (x *InferenceValidationDetails) GetCreatedAtBlockHeight() int64 {
+ if x != nil {
+ return x.CreatedAtBlockHeight
+ }
+ return 0
+}
+
+var File_inference_inference_inference_validation_details_proto protoreflect.FileDescriptor
+
+var file_inference_inference_inference_validation_details_proto_rawDesc = []byte{
+ 0x0a, 0x36, 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, 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, 0xe6, 0x02,
+ 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, 0x19, 0x0a, 0x08,
+ 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07,
+ 0x65, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x64, 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, 0x65, 0x78,
+ 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52,
+ 0x0a, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x49, 0x64, 0x12, 0x2f, 0x0a, 0x13, 0x65,
+ 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x5f, 0x72, 0x65, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69,
+ 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x12, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74,
+ 0x6f, 0x72, 0x52, 0x65, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x23, 0x0a, 0x0d,
+ 0x74, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x5f, 0x62, 0x61, 0x73, 0x69, 0x73, 0x18, 0x05, 0x20,
+ 0x01, 0x28, 0x04, 0x52, 0x0c, 0x74, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x42, 0x61, 0x73, 0x69,
+ 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x5f, 0x70, 0x6f,
+ 0x77, 0x65, 0x72, 0x18, 0x06, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0d, 0x65, 0x78, 0x65, 0x63, 0x75,
+ 0x74, 0x6f, 0x72, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x6d, 0x6f, 0x64, 0x65,
+ 0x6c, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x12, 0x1f,
+ 0x0a, 0x0b, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x70, 0x6f, 0x77, 0x65, 0x72, 0x18, 0x08, 0x20,
+ 0x01, 0x28, 0x04, 0x52, 0x0a, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x12,
+ 0x35, 0x0a, 0x17, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x5f, 0x62, 0x6c,
+ 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x09, 0x20, 0x01, 0x28, 0x03,
+ 0x52, 0x14, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b,
+ 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x42, 0xcd, 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, 0x1f, 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, 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_inference_validation_details_proto_rawDescOnce sync.Once
+ file_inference_inference_inference_validation_details_proto_rawDescData = file_inference_inference_inference_validation_details_proto_rawDesc
+)
+
+func file_inference_inference_inference_validation_details_proto_rawDescGZIP() []byte {
+ file_inference_inference_inference_validation_details_proto_rawDescOnce.Do(func() {
+ file_inference_inference_inference_validation_details_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_inference_inference_validation_details_proto_rawDescData)
+ })
+ return file_inference_inference_inference_validation_details_proto_rawDescData
+}
+
+var file_inference_inference_inference_validation_details_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_inference_inference_inference_validation_details_proto_goTypes = []interface{}{
+ (*InferenceValidationDetails)(nil), // 0: inference.inference.InferenceValidationDetails
+}
+var file_inference_inference_inference_validation_details_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_inference_validation_details_proto_init() }
+func file_inference_inference_inference_validation_details_proto_init() {
+ if File_inference_inference_inference_validation_details_proto != nil {
+ return
+ }
+ if !protoimpl.UnsafeEnabled {
+ file_inference_inference_inference_validation_details_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*InferenceValidationDetails); 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_inference_validation_details_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 1,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_inference_inference_validation_details_proto_goTypes,
+ DependencyIndexes: file_inference_inference_inference_validation_details_proto_depIdxs,
+ MessageInfos: file_inference_inference_inference_validation_details_proto_msgTypes,
+ }.Build()
+ File_inference_inference_inference_validation_details_proto = out.File
+ file_inference_inference_inference_validation_details_proto_rawDesc = nil
+ file_inference_inference_inference_validation_details_proto_goTypes = nil
+ file_inference_inference_inference_validation_details_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/inference/liquidity_pool.pulsar.go b/inference-chain/api/inference/inference/liquidity_pool.pulsar.go
new file mode 100644
index 000000000..7b5d25540
--- /dev/null
+++ b/inference-chain/api/inference/inference/liquidity_pool.pulsar.go
@@ -0,0 +1,684 @@
+// 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_LiquidityPool protoreflect.MessageDescriptor
+ fd_LiquidityPool_address protoreflect.FieldDescriptor
+ fd_LiquidityPool_codeId protoreflect.FieldDescriptor
+ fd_LiquidityPool_block_height protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_liquidity_pool_proto_init()
+ md_LiquidityPool = File_inference_inference_liquidity_pool_proto.Messages().ByName("LiquidityPool")
+ fd_LiquidityPool_address = md_LiquidityPool.Fields().ByName("address")
+ fd_LiquidityPool_codeId = md_LiquidityPool.Fields().ByName("codeId")
+ fd_LiquidityPool_block_height = md_LiquidityPool.Fields().ByName("block_height")
+}
+
+var _ protoreflect.Message = (*fastReflection_LiquidityPool)(nil)
+
+type fastReflection_LiquidityPool LiquidityPool
+
+func (x *LiquidityPool) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_LiquidityPool)(x)
+}
+
+func (x *LiquidityPool) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_liquidity_pool_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_LiquidityPool_messageType fastReflection_LiquidityPool_messageType
+var _ protoreflect.MessageType = fastReflection_LiquidityPool_messageType{}
+
+type fastReflection_LiquidityPool_messageType struct{}
+
+func (x fastReflection_LiquidityPool_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_LiquidityPool)(nil)
+}
+func (x fastReflection_LiquidityPool_messageType) New() protoreflect.Message {
+ return new(fastReflection_LiquidityPool)
+}
+func (x fastReflection_LiquidityPool_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_LiquidityPool
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_LiquidityPool) Descriptor() protoreflect.MessageDescriptor {
+ return md_LiquidityPool
+}
+
+// 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_LiquidityPool) Type() protoreflect.MessageType {
+ return _fastReflection_LiquidityPool_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_LiquidityPool) New() protoreflect.Message {
+ return new(fastReflection_LiquidityPool)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_LiquidityPool) Interface() protoreflect.ProtoMessage {
+ return (*LiquidityPool)(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_LiquidityPool) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Address != "" {
+ value := protoreflect.ValueOfString(x.Address)
+ if !f(fd_LiquidityPool_address, value) {
+ return
+ }
+ }
+ if x.CodeId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.CodeId)
+ if !f(fd_LiquidityPool_codeId, value) {
+ return
+ }
+ }
+ if x.BlockHeight != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.BlockHeight)
+ if !f(fd_LiquidityPool_block_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_LiquidityPool) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.LiquidityPool.address":
+ return x.Address != ""
+ case "inference.inference.LiquidityPool.codeId":
+ return x.CodeId != uint64(0)
+ case "inference.inference.LiquidityPool.block_height":
+ return x.BlockHeight != uint64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.LiquidityPool"))
+ }
+ panic(fmt.Errorf("message inference.inference.LiquidityPool 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_LiquidityPool) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.LiquidityPool.address":
+ x.Address = ""
+ case "inference.inference.LiquidityPool.codeId":
+ x.CodeId = uint64(0)
+ case "inference.inference.LiquidityPool.block_height":
+ x.BlockHeight = uint64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.LiquidityPool"))
+ }
+ panic(fmt.Errorf("message inference.inference.LiquidityPool 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_LiquidityPool) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.LiquidityPool.address":
+ value := x.Address
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.LiquidityPool.codeId":
+ value := x.CodeId
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.LiquidityPool.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.LiquidityPool"))
+ }
+ panic(fmt.Errorf("message inference.inference.LiquidityPool 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_LiquidityPool) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.LiquidityPool.address":
+ x.Address = value.Interface().(string)
+ case "inference.inference.LiquidityPool.codeId":
+ x.CodeId = value.Uint()
+ case "inference.inference.LiquidityPool.block_height":
+ x.BlockHeight = value.Uint()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.LiquidityPool"))
+ }
+ panic(fmt.Errorf("message inference.inference.LiquidityPool 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_LiquidityPool) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.LiquidityPool.address":
+ panic(fmt.Errorf("field address of message inference.inference.LiquidityPool is not mutable"))
+ case "inference.inference.LiquidityPool.codeId":
+ panic(fmt.Errorf("field codeId of message inference.inference.LiquidityPool is not mutable"))
+ case "inference.inference.LiquidityPool.block_height":
+ panic(fmt.Errorf("field block_height of message inference.inference.LiquidityPool is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.LiquidityPool"))
+ }
+ panic(fmt.Errorf("message inference.inference.LiquidityPool 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_LiquidityPool) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.LiquidityPool.address":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.LiquidityPool.codeId":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.LiquidityPool.block_height":
+ return protoreflect.ValueOfUint64(uint64(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.LiquidityPool"))
+ }
+ panic(fmt.Errorf("message inference.inference.LiquidityPool 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_LiquidityPool) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.LiquidityPool", 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_LiquidityPool) 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_LiquidityPool) 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_LiquidityPool) 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_LiquidityPool) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*LiquidityPool)
+ 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.Address)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.CodeId != 0 {
+ n += 1 + runtime.Sov(uint64(x.CodeId))
+ }
+ if x.BlockHeight != 0 {
+ n += 1 + runtime.Sov(uint64(x.BlockHeight))
+ }
+ 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().(*LiquidityPool)
+ 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.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))
+ 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)))
+ 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().(*LiquidityPool)
+ 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: LiquidityPool: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: LiquidityPool: 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)
+ }
+ x.CodeId = 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.CodeId |= 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 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 |= 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,
+ }
+}
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// protoc-gen-go v1.27.0
+// protoc (unknown)
+// source: inference/inference/liquidity_pool.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)
+)
+
+type LiquidityPool struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` // Contract address of the liquidity pool
+ CodeId uint64 `protobuf:"varint,2,opt,name=codeId,proto3" json:"codeId,omitempty"` // Contract code id
+ BlockHeight uint64 `protobuf:"varint,3,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"` // Block height when pool was registered
+}
+
+func (x *LiquidityPool) Reset() {
+ *x = LiquidityPool{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_liquidity_pool_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *LiquidityPool) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*LiquidityPool) ProtoMessage() {}
+
+// Deprecated: Use LiquidityPool.ProtoReflect.Descriptor instead.
+func (*LiquidityPool) Descriptor() ([]byte, []int) {
+ return file_inference_inference_liquidity_pool_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *LiquidityPool) GetAddress() string {
+ if x != nil {
+ return x.Address
+ }
+ return ""
+}
+
+func (x *LiquidityPool) GetCodeId() uint64 {
+ if x != nil {
+ return x.CodeId
+ }
+ return 0
+}
+
+func (x *LiquidityPool) GetBlockHeight() uint64 {
+ if x != nil {
+ return x.BlockHeight
+ }
+ return 0
+}
+
+var File_inference_inference_liquidity_pool_proto protoreflect.FileDescriptor
+
+var file_inference_inference_liquidity_pool_proto_rawDesc = []byte{
+ 0x0a, 0x28, 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, 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,
+ 0x64, 0x0a, 0x0d, 0x4c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x6f, 0x6c,
+ 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, 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, 0x4c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x6f, 0x6c,
+ 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_liquidity_pool_proto_rawDescOnce sync.Once
+ file_inference_inference_liquidity_pool_proto_rawDescData = file_inference_inference_liquidity_pool_proto_rawDesc
+)
+
+func file_inference_inference_liquidity_pool_proto_rawDescGZIP() []byte {
+ file_inference_inference_liquidity_pool_proto_rawDescOnce.Do(func() {
+ file_inference_inference_liquidity_pool_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_inference_liquidity_pool_proto_rawDescData)
+ })
+ return file_inference_inference_liquidity_pool_proto_rawDescData
+}
+
+var file_inference_inference_liquidity_pool_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_inference_inference_liquidity_pool_proto_goTypes = []interface{}{
+ (*LiquidityPool)(nil), // 0: inference.inference.LiquidityPool
+}
+var file_inference_inference_liquidity_pool_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_liquidity_pool_proto_init() }
+func file_inference_inference_liquidity_pool_proto_init() {
+ if File_inference_inference_liquidity_pool_proto != nil {
+ return
+ }
+ if !protoimpl.UnsafeEnabled {
+ file_inference_inference_liquidity_pool_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*LiquidityPool); 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_liquidity_pool_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 1,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_inference_liquidity_pool_proto_goTypes,
+ DependencyIndexes: file_inference_inference_liquidity_pool_proto_depIdxs,
+ MessageInfos: file_inference_inference_liquidity_pool_proto_msgTypes,
+ }.Build()
+ File_inference_inference_liquidity_pool_proto = out.File
+ file_inference_inference_liquidity_pool_proto_rawDesc = nil
+ file_inference_inference_liquidity_pool_proto_goTypes = nil
+ file_inference_inference_liquidity_pool_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/inference/mlnode_version.pulsar.go b/inference-chain/api/inference/inference/mlnode_version.pulsar.go
new file mode 100644
index 000000000..e37765d01
--- /dev/null
+++ b/inference-chain/api/inference/inference/mlnode_version.pulsar.go
@@ -0,0 +1,570 @@
+// 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_MLNodeVersion protoreflect.MessageDescriptor
+ fd_MLNodeVersion_current_version protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_mlnode_version_proto_init()
+ md_MLNodeVersion = File_inference_inference_mlnode_version_proto.Messages().ByName("MLNodeVersion")
+ fd_MLNodeVersion_current_version = md_MLNodeVersion.Fields().ByName("current_version")
+}
+
+var _ protoreflect.Message = (*fastReflection_MLNodeVersion)(nil)
+
+type fastReflection_MLNodeVersion MLNodeVersion
+
+func (x *MLNodeVersion) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_MLNodeVersion)(x)
+}
+
+func (x *MLNodeVersion) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_mlnode_version_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_MLNodeVersion_messageType fastReflection_MLNodeVersion_messageType
+var _ protoreflect.MessageType = fastReflection_MLNodeVersion_messageType{}
+
+type fastReflection_MLNodeVersion_messageType struct{}
+
+func (x fastReflection_MLNodeVersion_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_MLNodeVersion)(nil)
+}
+func (x fastReflection_MLNodeVersion_messageType) New() protoreflect.Message {
+ return new(fastReflection_MLNodeVersion)
+}
+func (x fastReflection_MLNodeVersion_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_MLNodeVersion
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MLNodeVersion) Descriptor() protoreflect.MessageDescriptor {
+ return md_MLNodeVersion
+}
+
+// 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_MLNodeVersion) Type() protoreflect.MessageType {
+ return _fastReflection_MLNodeVersion_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MLNodeVersion) New() protoreflect.Message {
+ return new(fastReflection_MLNodeVersion)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MLNodeVersion) Interface() protoreflect.ProtoMessage {
+ return (*MLNodeVersion)(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_MLNodeVersion) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.CurrentVersion != "" {
+ value := protoreflect.ValueOfString(x.CurrentVersion)
+ if !f(fd_MLNodeVersion_current_version, 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_MLNodeVersion) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.MLNodeVersion.current_version":
+ return x.CurrentVersion != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MLNodeVersion"))
+ }
+ panic(fmt.Errorf("message inference.inference.MLNodeVersion 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_MLNodeVersion) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.MLNodeVersion.current_version":
+ x.CurrentVersion = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MLNodeVersion"))
+ }
+ panic(fmt.Errorf("message inference.inference.MLNodeVersion 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_MLNodeVersion) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.MLNodeVersion.current_version":
+ value := x.CurrentVersion
+ return protoreflect.ValueOfString(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MLNodeVersion"))
+ }
+ panic(fmt.Errorf("message inference.inference.MLNodeVersion 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_MLNodeVersion) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.MLNodeVersion.current_version":
+ x.CurrentVersion = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MLNodeVersion"))
+ }
+ panic(fmt.Errorf("message inference.inference.MLNodeVersion 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_MLNodeVersion) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.MLNodeVersion.current_version":
+ panic(fmt.Errorf("field current_version of message inference.inference.MLNodeVersion is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MLNodeVersion"))
+ }
+ panic(fmt.Errorf("message inference.inference.MLNodeVersion 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_MLNodeVersion) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.MLNodeVersion.current_version":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MLNodeVersion"))
+ }
+ panic(fmt.Errorf("message inference.inference.MLNodeVersion 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_MLNodeVersion) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.MLNodeVersion", 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_MLNodeVersion) 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_MLNodeVersion) 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_MLNodeVersion) 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_MLNodeVersion) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*MLNodeVersion)
+ 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.CurrentVersion)
+ 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().(*MLNodeVersion)
+ 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.CurrentVersion) > 0 {
+ i -= len(x.CurrentVersion)
+ copy(dAtA[i:], x.CurrentVersion)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.CurrentVersion)))
+ 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().(*MLNodeVersion)
+ 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: MLNodeVersion: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MLNodeVersion: 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 CurrentVersion", 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.CurrentVersion = 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/mlnode_version.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)
+)
+
+type MLNodeVersion struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ CurrentVersion string `protobuf:"bytes,1,opt,name=current_version,json=currentVersion,proto3" json:"current_version,omitempty"`
+}
+
+func (x *MLNodeVersion) Reset() {
+ *x = MLNodeVersion{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_mlnode_version_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *MLNodeVersion) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MLNodeVersion) ProtoMessage() {}
+
+// Deprecated: Use MLNodeVersion.ProtoReflect.Descriptor instead.
+func (*MLNodeVersion) Descriptor() ([]byte, []int) {
+ return file_inference_inference_mlnode_version_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *MLNodeVersion) GetCurrentVersion() string {
+ if x != nil {
+ return x.CurrentVersion
+ }
+ return ""
+}
+
+var File_inference_inference_mlnode_version_proto protoreflect.FileDescriptor
+
+var file_inference_inference_mlnode_version_proto_rawDesc = []byte{
+ 0x0a, 0x28, 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, 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,
+ 0x38, 0x0a, 0x0d, 0x4d, 0x4c, 0x4e, 0x6f, 0x64, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e,
+ 0x12, 0x27, 0x0a, 0x0f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x76, 0x65, 0x72, 0x73,
+ 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x63, 0x75, 0x72, 0x72, 0x65,
+ 0x6e, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 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, 0x4d, 0x6c, 0x6e, 0x6f, 0x64, 0x65, 0x56, 0x65, 0x72,
+ 0x73, 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 (
+ file_inference_inference_mlnode_version_proto_rawDescOnce sync.Once
+ file_inference_inference_mlnode_version_proto_rawDescData = file_inference_inference_mlnode_version_proto_rawDesc
+)
+
+func file_inference_inference_mlnode_version_proto_rawDescGZIP() []byte {
+ file_inference_inference_mlnode_version_proto_rawDescOnce.Do(func() {
+ file_inference_inference_mlnode_version_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_inference_mlnode_version_proto_rawDescData)
+ })
+ return file_inference_inference_mlnode_version_proto_rawDescData
+}
+
+var file_inference_inference_mlnode_version_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_inference_inference_mlnode_version_proto_goTypes = []interface{}{
+ (*MLNodeVersion)(nil), // 0: inference.inference.MLNodeVersion
+}
+var file_inference_inference_mlnode_version_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_mlnode_version_proto_init() }
+func file_inference_inference_mlnode_version_proto_init() {
+ if File_inference_inference_mlnode_version_proto != nil {
+ return
+ }
+ if !protoimpl.UnsafeEnabled {
+ file_inference_inference_mlnode_version_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*MLNodeVersion); 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_mlnode_version_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 1,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_inference_mlnode_version_proto_goTypes,
+ DependencyIndexes: file_inference_inference_mlnode_version_proto_depIdxs,
+ MessageInfos: file_inference_inference_mlnode_version_proto_msgTypes,
+ }.Build()
+ File_inference_inference_mlnode_version_proto = out.File
+ file_inference_inference_mlnode_version_proto_rawDesc = nil
+ file_inference_inference_mlnode_version_proto_goTypes = nil
+ file_inference_inference_mlnode_version_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/inference/model.pulsar.go b/inference-chain/api/inference/inference/model.pulsar.go
new file mode 100644
index 000000000..e31b47ecf
--- /dev/null
+++ b/inference-chain/api/inference/inference/model.pulsar.go
@@ -0,0 +1,1447 @@
+// 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 _ protoreflect.List = (*_Model_10_list)(nil)
+
+type _Model_10_list struct {
+ list *[]string
+}
+
+func (x *_Model_10_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_Model_10_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfString((*x.list)[i])
+}
+
+func (x *_Model_10_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.String()
+ concreteValue := valueUnwrapped
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_Model_10_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.String()
+ concreteValue := valueUnwrapped
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_Model_10_list) AppendMutable() protoreflect.Value {
+ panic(fmt.Errorf("AppendMutable can not be called on message Model at list field ModelArgs as it is not of Message kind"))
+}
+
+func (x *_Model_10_list) Truncate(n int) {
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_Model_10_list) NewElement() protoreflect.Value {
+ v := ""
+ return protoreflect.ValueOfString(v)
+}
+
+func (x *_Model_10_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_Model protoreflect.MessageDescriptor
+ fd_Model_proposed_by protoreflect.FieldDescriptor
+ fd_Model_id protoreflect.FieldDescriptor
+ fd_Model_units_of_compute_per_token protoreflect.FieldDescriptor
+ fd_Model_context_window protoreflect.FieldDescriptor
+ fd_Model_quantization protoreflect.FieldDescriptor
+ fd_Model_coins_per_input_token protoreflect.FieldDescriptor
+ fd_Model_coins_per_output_token protoreflect.FieldDescriptor
+ fd_Model_hf_repo protoreflect.FieldDescriptor
+ fd_Model_hf_commit protoreflect.FieldDescriptor
+ fd_Model_model_args protoreflect.FieldDescriptor
+ fd_Model_v_ram protoreflect.FieldDescriptor
+ fd_Model_throughput_per_nonce protoreflect.FieldDescriptor
+ fd_Model_validation_threshold protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_model_proto_init()
+ md_Model = File_inference_inference_model_proto.Messages().ByName("Model")
+ fd_Model_proposed_by = md_Model.Fields().ByName("proposed_by")
+ fd_Model_id = md_Model.Fields().ByName("id")
+ fd_Model_units_of_compute_per_token = md_Model.Fields().ByName("units_of_compute_per_token")
+ fd_Model_context_window = md_Model.Fields().ByName("context_window")
+ fd_Model_quantization = md_Model.Fields().ByName("quantization")
+ fd_Model_coins_per_input_token = md_Model.Fields().ByName("coins_per_input_token")
+ fd_Model_coins_per_output_token = md_Model.Fields().ByName("coins_per_output_token")
+ fd_Model_hf_repo = md_Model.Fields().ByName("hf_repo")
+ fd_Model_hf_commit = md_Model.Fields().ByName("hf_commit")
+ fd_Model_model_args = md_Model.Fields().ByName("model_args")
+ fd_Model_v_ram = md_Model.Fields().ByName("v_ram")
+ fd_Model_throughput_per_nonce = md_Model.Fields().ByName("throughput_per_nonce")
+ fd_Model_validation_threshold = md_Model.Fields().ByName("validation_threshold")
+}
+
+var _ protoreflect.Message = (*fastReflection_Model)(nil)
+
+type fastReflection_Model Model
+
+func (x *Model) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_Model)(x)
+}
+
+func (x *Model) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_model_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_Model_messageType fastReflection_Model_messageType
+var _ protoreflect.MessageType = fastReflection_Model_messageType{}
+
+type fastReflection_Model_messageType struct{}
+
+func (x fastReflection_Model_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_Model)(nil)
+}
+func (x fastReflection_Model_messageType) New() protoreflect.Message {
+ return new(fastReflection_Model)
+}
+func (x fastReflection_Model_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_Model
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_Model) Descriptor() protoreflect.MessageDescriptor {
+ return md_Model
+}
+
+// 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_Model) Type() protoreflect.MessageType {
+ return _fastReflection_Model_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_Model) New() protoreflect.Message {
+ return new(fastReflection_Model)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_Model) Interface() protoreflect.ProtoMessage {
+ return (*Model)(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_Model) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.ProposedBy != "" {
+ value := protoreflect.ValueOfString(x.ProposedBy)
+ if !f(fd_Model_proposed_by, value) {
+ return
+ }
+ }
+ if x.Id != "" {
+ value := protoreflect.ValueOfString(x.Id)
+ if !f(fd_Model_id, value) {
+ return
+ }
+ }
+ if x.UnitsOfComputePerToken != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.UnitsOfComputePerToken)
+ if !f(fd_Model_units_of_compute_per_token, value) {
+ return
+ }
+ }
+ if x.ContextWindow != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.ContextWindow)
+ if !f(fd_Model_context_window, value) {
+ return
+ }
+ }
+ if x.Quantization != "" {
+ value := protoreflect.ValueOfString(x.Quantization)
+ if !f(fd_Model_quantization, value) {
+ return
+ }
+ }
+ if x.CoinsPerInputToken != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.CoinsPerInputToken)
+ if !f(fd_Model_coins_per_input_token, value) {
+ return
+ }
+ }
+ if x.CoinsPerOutputToken != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.CoinsPerOutputToken)
+ if !f(fd_Model_coins_per_output_token, value) {
+ return
+ }
+ }
+ if x.HfRepo != "" {
+ value := protoreflect.ValueOfString(x.HfRepo)
+ if !f(fd_Model_hf_repo, value) {
+ return
+ }
+ }
+ if x.HfCommit != "" {
+ value := protoreflect.ValueOfString(x.HfCommit)
+ if !f(fd_Model_hf_commit, value) {
+ return
+ }
+ }
+ if len(x.ModelArgs) != 0 {
+ value := protoreflect.ValueOfList(&_Model_10_list{list: &x.ModelArgs})
+ if !f(fd_Model_model_args, value) {
+ return
+ }
+ }
+ if x.VRam != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.VRam)
+ if !f(fd_Model_v_ram, value) {
+ return
+ }
+ }
+ if x.ThroughputPerNonce != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.ThroughputPerNonce)
+ if !f(fd_Model_throughput_per_nonce, value) {
+ return
+ }
+ }
+ if x.ValidationThreshold != nil {
+ value := protoreflect.ValueOfMessage(x.ValidationThreshold.ProtoReflect())
+ if !f(fd_Model_validation_threshold, 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_Model) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.Model.proposed_by":
+ return x.ProposedBy != ""
+ case "inference.inference.Model.id":
+ return x.Id != ""
+ case "inference.inference.Model.units_of_compute_per_token":
+ return x.UnitsOfComputePerToken != uint64(0)
+ case "inference.inference.Model.context_window":
+ return x.ContextWindow != uint64(0)
+ case "inference.inference.Model.quantization":
+ return x.Quantization != ""
+ case "inference.inference.Model.coins_per_input_token":
+ return x.CoinsPerInputToken != uint64(0)
+ case "inference.inference.Model.coins_per_output_token":
+ return x.CoinsPerOutputToken != uint64(0)
+ case "inference.inference.Model.hf_repo":
+ return x.HfRepo != ""
+ case "inference.inference.Model.hf_commit":
+ return x.HfCommit != ""
+ case "inference.inference.Model.model_args":
+ return len(x.ModelArgs) != 0
+ case "inference.inference.Model.v_ram":
+ return x.VRam != uint64(0)
+ case "inference.inference.Model.throughput_per_nonce":
+ return x.ThroughputPerNonce != uint64(0)
+ case "inference.inference.Model.validation_threshold":
+ return x.ValidationThreshold != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Model"))
+ }
+ panic(fmt.Errorf("message inference.inference.Model 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_Model) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.Model.proposed_by":
+ x.ProposedBy = ""
+ case "inference.inference.Model.id":
+ x.Id = ""
+ case "inference.inference.Model.units_of_compute_per_token":
+ x.UnitsOfComputePerToken = uint64(0)
+ case "inference.inference.Model.context_window":
+ x.ContextWindow = uint64(0)
+ case "inference.inference.Model.quantization":
+ x.Quantization = ""
+ case "inference.inference.Model.coins_per_input_token":
+ x.CoinsPerInputToken = uint64(0)
+ case "inference.inference.Model.coins_per_output_token":
+ x.CoinsPerOutputToken = uint64(0)
+ case "inference.inference.Model.hf_repo":
+ x.HfRepo = ""
+ case "inference.inference.Model.hf_commit":
+ x.HfCommit = ""
+ case "inference.inference.Model.model_args":
+ x.ModelArgs = nil
+ case "inference.inference.Model.v_ram":
+ x.VRam = uint64(0)
+ case "inference.inference.Model.throughput_per_nonce":
+ x.ThroughputPerNonce = uint64(0)
+ case "inference.inference.Model.validation_threshold":
+ x.ValidationThreshold = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Model"))
+ }
+ panic(fmt.Errorf("message inference.inference.Model 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_Model) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.Model.proposed_by":
+ value := x.ProposedBy
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.Model.id":
+ value := x.Id
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.Model.units_of_compute_per_token":
+ value := x.UnitsOfComputePerToken
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.Model.context_window":
+ value := x.ContextWindow
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.Model.quantization":
+ value := x.Quantization
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.Model.coins_per_input_token":
+ value := x.CoinsPerInputToken
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.Model.coins_per_output_token":
+ value := x.CoinsPerOutputToken
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.Model.hf_repo":
+ value := x.HfRepo
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.Model.hf_commit":
+ value := x.HfCommit
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.Model.model_args":
+ if len(x.ModelArgs) == 0 {
+ return protoreflect.ValueOfList(&_Model_10_list{})
+ }
+ listValue := &_Model_10_list{list: &x.ModelArgs}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.inference.Model.v_ram":
+ value := x.VRam
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.Model.throughput_per_nonce":
+ value := x.ThroughputPerNonce
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.Model.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.Model"))
+ }
+ panic(fmt.Errorf("message inference.inference.Model 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_Model) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.Model.proposed_by":
+ x.ProposedBy = value.Interface().(string)
+ case "inference.inference.Model.id":
+ x.Id = value.Interface().(string)
+ case "inference.inference.Model.units_of_compute_per_token":
+ x.UnitsOfComputePerToken = value.Uint()
+ case "inference.inference.Model.context_window":
+ x.ContextWindow = value.Uint()
+ case "inference.inference.Model.quantization":
+ x.Quantization = value.Interface().(string)
+ case "inference.inference.Model.coins_per_input_token":
+ x.CoinsPerInputToken = value.Uint()
+ case "inference.inference.Model.coins_per_output_token":
+ x.CoinsPerOutputToken = value.Uint()
+ case "inference.inference.Model.hf_repo":
+ x.HfRepo = value.Interface().(string)
+ case "inference.inference.Model.hf_commit":
+ x.HfCommit = value.Interface().(string)
+ case "inference.inference.Model.model_args":
+ lv := value.List()
+ clv := lv.(*_Model_10_list)
+ x.ModelArgs = *clv.list
+ case "inference.inference.Model.v_ram":
+ x.VRam = value.Uint()
+ case "inference.inference.Model.throughput_per_nonce":
+ x.ThroughputPerNonce = value.Uint()
+ case "inference.inference.Model.validation_threshold":
+ x.ValidationThreshold = value.Message().Interface().(*Decimal)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Model"))
+ }
+ panic(fmt.Errorf("message inference.inference.Model 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_Model) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.Model.model_args":
+ if x.ModelArgs == nil {
+ x.ModelArgs = []string{}
+ }
+ value := &_Model_10_list{list: &x.ModelArgs}
+ return protoreflect.ValueOfList(value)
+ case "inference.inference.Model.validation_threshold":
+ if x.ValidationThreshold == nil {
+ x.ValidationThreshold = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.ValidationThreshold.ProtoReflect())
+ case "inference.inference.Model.proposed_by":
+ panic(fmt.Errorf("field proposed_by of message inference.inference.Model is not mutable"))
+ case "inference.inference.Model.id":
+ panic(fmt.Errorf("field id of message inference.inference.Model is not mutable"))
+ case "inference.inference.Model.units_of_compute_per_token":
+ panic(fmt.Errorf("field units_of_compute_per_token of message inference.inference.Model is not mutable"))
+ case "inference.inference.Model.context_window":
+ panic(fmt.Errorf("field context_window of message inference.inference.Model is not mutable"))
+ case "inference.inference.Model.quantization":
+ panic(fmt.Errorf("field quantization of message inference.inference.Model is not mutable"))
+ case "inference.inference.Model.coins_per_input_token":
+ panic(fmt.Errorf("field coins_per_input_token of message inference.inference.Model is not mutable"))
+ case "inference.inference.Model.coins_per_output_token":
+ panic(fmt.Errorf("field coins_per_output_token of message inference.inference.Model is not mutable"))
+ case "inference.inference.Model.hf_repo":
+ panic(fmt.Errorf("field hf_repo of message inference.inference.Model is not mutable"))
+ case "inference.inference.Model.hf_commit":
+ panic(fmt.Errorf("field hf_commit of message inference.inference.Model is not mutable"))
+ case "inference.inference.Model.v_ram":
+ panic(fmt.Errorf("field v_ram of message inference.inference.Model is not mutable"))
+ case "inference.inference.Model.throughput_per_nonce":
+ panic(fmt.Errorf("field throughput_per_nonce of message inference.inference.Model is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Model"))
+ }
+ panic(fmt.Errorf("message inference.inference.Model 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_Model) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.Model.proposed_by":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.Model.id":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.Model.units_of_compute_per_token":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.Model.context_window":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.Model.quantization":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.Model.coins_per_input_token":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.Model.coins_per_output_token":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.Model.hf_repo":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.Model.hf_commit":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.Model.model_args":
+ list := []string{}
+ return protoreflect.ValueOfList(&_Model_10_list{list: &list})
+ case "inference.inference.Model.v_ram":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.Model.throughput_per_nonce":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.Model.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.Model"))
+ }
+ panic(fmt.Errorf("message inference.inference.Model 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_Model) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.Model", 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_Model) 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_Model) 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_Model) 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_Model) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*Model)
+ 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.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))
+ }
+ if x.ContextWindow != 0 {
+ n += 1 + runtime.Sov(uint64(x.ContextWindow))
+ }
+ l = len(x.Quantization)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.CoinsPerInputToken != 0 {
+ n += 1 + runtime.Sov(uint64(x.CoinsPerInputToken))
+ }
+ if x.CoinsPerOutputToken != 0 {
+ n += 1 + runtime.Sov(uint64(x.CoinsPerOutputToken))
+ }
+ 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)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*Model)
+ 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.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] = 0x6a
+ }
+ if x.ThroughputPerNonce != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.ThroughputPerNonce))
+ i--
+ dAtA[i] = 0x60
+ }
+ if x.VRam != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.VRam))
+ i--
+ dAtA[i] = 0x58
+ }
+ 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] = 0x52
+ }
+ }
+ 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] = 0x4a
+ }
+ 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] = 0x42
+ }
+ if x.CoinsPerOutputToken != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.CoinsPerOutputToken))
+ i--
+ dAtA[i] = 0x38
+ }
+ if x.CoinsPerInputToken != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.CoinsPerInputToken))
+ i--
+ dAtA[i] = 0x30
+ }
+ if len(x.Quantization) > 0 {
+ i -= len(x.Quantization)
+ copy(dAtA[i:], x.Quantization)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Quantization)))
+ i--
+ dAtA[i] = 0x2a
+ }
+ if x.ContextWindow != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.ContextWindow))
+ i--
+ dAtA[i] = 0x20
+ }
+ if x.UnitsOfComputePerToken != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.UnitsOfComputePerToken))
+ i--
+ dAtA[i] = 0x18
+ }
+ 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.ProposedBy) > 0 {
+ i -= len(x.ProposedBy)
+ copy(dAtA[i:], x.ProposedBy)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ProposedBy)))
+ 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().(*Model)
+ 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: Model: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Model: 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 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 2:
+ 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 3:
+ 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 4:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ContextWindow", wireType)
+ }
+ x.ContextWindow = 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.ContextWindow |= 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 Quantization", 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.Quantization = 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 CoinsPerInputToken", wireType)
+ }
+ x.CoinsPerInputToken = 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.CoinsPerInputToken |= 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 CoinsPerOutputToken", wireType)
+ }
+ x.CoinsPerOutputToken = 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.CoinsPerOutputToken |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 8:
+ 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 9:
+ 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 10:
+ 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 11:
+ 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 12:
+ 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 13:
+ 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
+ }
+ 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/model.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)
+)
+
+type Model struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ ProposedBy string `protobuf:"bytes,1,opt,name=proposed_by,json=proposedBy,proto3" json:"proposed_by,omitempty"`
+ Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
+ UnitsOfComputePerToken uint64 `protobuf:"varint,3,opt,name=units_of_compute_per_token,json=unitsOfComputePerToken,proto3" json:"units_of_compute_per_token,omitempty"`
+ ContextWindow uint64 `protobuf:"varint,4,opt,name=context_window,json=contextWindow,proto3" json:"context_window,omitempty"`
+ Quantization string `protobuf:"bytes,5,opt,name=quantization,proto3" json:"quantization,omitempty"`
+ CoinsPerInputToken uint64 `protobuf:"varint,6,opt,name=coins_per_input_token,json=coinsPerInputToken,proto3" json:"coins_per_input_token,omitempty"`
+ CoinsPerOutputToken uint64 `protobuf:"varint,7,opt,name=coins_per_output_token,json=coinsPerOutputToken,proto3" json:"coins_per_output_token,omitempty"`
+ HfRepo string `protobuf:"bytes,8,opt,name=hf_repo,json=hfRepo,proto3" json:"hf_repo,omitempty"`
+ HfCommit string `protobuf:"bytes,9,opt,name=hf_commit,json=hfCommit,proto3" json:"hf_commit,omitempty"`
+ ModelArgs []string `protobuf:"bytes,10,rep,name=model_args,json=modelArgs,proto3" json:"model_args,omitempty"`
+ VRam uint64 `protobuf:"varint,11,opt,name=v_ram,json=vRam,proto3" json:"v_ram,omitempty"`
+ ThroughputPerNonce uint64 `protobuf:"varint,12,opt,name=throughput_per_nonce,json=throughputPerNonce,proto3" json:"throughput_per_nonce,omitempty"`
+ ValidationThreshold *Decimal `protobuf:"bytes,13,opt,name=validation_threshold,json=validationThreshold,proto3" json:"validation_threshold,omitempty"`
+}
+
+func (x *Model) Reset() {
+ *x = Model{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_model_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *Model) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Model) ProtoMessage() {}
+
+// Deprecated: Use Model.ProtoReflect.Descriptor instead.
+func (*Model) Descriptor() ([]byte, []int) {
+ return file_inference_inference_model_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Model) GetProposedBy() string {
+ if x != nil {
+ return x.ProposedBy
+ }
+ return ""
+}
+
+func (x *Model) GetId() string {
+ if x != nil {
+ return x.Id
+ }
+ return ""
+}
+
+func (x *Model) GetUnitsOfComputePerToken() uint64 {
+ if x != nil {
+ return x.UnitsOfComputePerToken
+ }
+ return 0
+}
+
+func (x *Model) GetContextWindow() uint64 {
+ if x != nil {
+ return x.ContextWindow
+ }
+ return 0
+}
+
+func (x *Model) GetQuantization() string {
+ if x != nil {
+ return x.Quantization
+ }
+ return ""
+}
+
+func (x *Model) GetCoinsPerInputToken() uint64 {
+ if x != nil {
+ return x.CoinsPerInputToken
+ }
+ return 0
+}
+
+func (x *Model) GetCoinsPerOutputToken() uint64 {
+ if x != nil {
+ return x.CoinsPerOutputToken
+ }
+ return 0
+}
+
+func (x *Model) GetHfRepo() string {
+ if x != nil {
+ return x.HfRepo
+ }
+ return ""
+}
+
+func (x *Model) GetHfCommit() string {
+ if x != nil {
+ return x.HfCommit
+ }
+ return ""
+}
+
+func (x *Model) GetModelArgs() []string {
+ if x != nil {
+ return x.ModelArgs
+ }
+ return nil
+}
+
+func (x *Model) GetVRam() uint64 {
+ if x != nil {
+ return x.VRam
+ }
+ return 0
+}
+
+func (x *Model) GetThroughputPerNonce() uint64 {
+ if x != nil {
+ return x.ThroughputPerNonce
+ }
+ return 0
+}
+
+func (x *Model) GetValidationThreshold() *Decimal {
+ if x != nil {
+ return x.ValidationThreshold
+ }
+ return nil
+}
+
+var File_inference_inference_model_proto protoreflect.FileDescriptor
+
+var file_inference_inference_model_proto_rawDesc = []byte{
+ 0x0a, 0x1f, 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, 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, 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, 0x94, 0x04, 0x0a, 0x05, 0x4d, 0x6f, 0x64,
+ 0x65, 0x6c, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x64, 0x5f, 0x62,
+ 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65,
+ 0x64, 0x42, 0x79, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x02, 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, 0x03, 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,
+ 0x25, 0x0a, 0x0e, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x5f, 0x77, 0x69, 0x6e, 0x64, 0x6f,
+ 0x77, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0d, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74,
+ 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x12, 0x22, 0x0a, 0x0c, 0x71, 0x75, 0x61, 0x6e, 0x74, 0x69,
+ 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x71, 0x75,
+ 0x61, 0x6e, 0x74, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x31, 0x0a, 0x15, 0x63, 0x6f,
+ 0x69, 0x6e, 0x73, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x74, 0x6f,
+ 0x6b, 0x65, 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x04, 0x52, 0x12, 0x63, 0x6f, 0x69, 0x6e, 0x73,
+ 0x50, 0x65, 0x72, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x33, 0x0a,
+ 0x16, 0x63, 0x6f, 0x69, 0x6e, 0x73, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x6f, 0x75, 0x74, 0x70, 0x75,
+ 0x74, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, 0x04, 0x52, 0x13, 0x63,
+ 0x6f, 0x69, 0x6e, 0x73, 0x50, 0x65, 0x72, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x54, 0x6f, 0x6b,
+ 0x65, 0x6e, 0x12, 0x17, 0x0a, 0x07, 0x68, 0x66, 0x5f, 0x72, 0x65, 0x70, 0x6f, 0x18, 0x08, 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, 0x09, 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, 0x0a, 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, 0x0b, 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, 0x0c, 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, 0x0d, 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, 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, 0x4d, 0x6f, 0x64,
+ 0x65, 0x6c, 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_model_proto_rawDescOnce sync.Once
+ file_inference_inference_model_proto_rawDescData = file_inference_inference_model_proto_rawDesc
+)
+
+func file_inference_inference_model_proto_rawDescGZIP() []byte {
+ file_inference_inference_model_proto_rawDescOnce.Do(func() {
+ file_inference_inference_model_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_inference_model_proto_rawDescData)
+ })
+ return file_inference_inference_model_proto_rawDescData
+}
+
+var file_inference_inference_model_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_inference_inference_model_proto_goTypes = []interface{}{
+ (*Model)(nil), // 0: inference.inference.Model
+ (*Decimal)(nil), // 1: inference.inference.Decimal
+}
+var file_inference_inference_model_proto_depIdxs = []int32{
+ 1, // 0: inference.inference.Model.validation_threshold:type_name -> inference.inference.Decimal
+ 1, // [1:1] is the sub-list for method output_type
+ 1, // [1:1] is the sub-list for method input_type
+ 1, // [1:1] is the sub-list for extension type_name
+ 1, // [1:1] is the sub-list for extension extendee
+ 0, // [0:1] is the sub-list for field type_name
+}
+
+func init() { file_inference_inference_model_proto_init() }
+func file_inference_inference_model_proto_init() {
+ if File_inference_inference_model_proto != nil {
+ return
+ }
+ file_inference_inference_params_proto_init()
+ if !protoimpl.UnsafeEnabled {
+ file_inference_inference_model_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*Model); 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_model_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 1,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_inference_model_proto_goTypes,
+ DependencyIndexes: file_inference_inference_model_proto_depIdxs,
+ MessageInfos: file_inference_inference_model_proto_msgTypes,
+ }.Build()
+ File_inference_inference_model_proto = out.File
+ file_inference_inference_model_proto_rawDesc = nil
+ file_inference_inference_model_proto_goTypes = nil
+ file_inference_inference_model_proto_depIdxs = nil
+}
diff --git a/inference/api/inference/inference/module/module.pulsar.go b/inference-chain/api/inference/inference/module/module.pulsar.go
similarity index 99%
rename from inference/api/inference/inference/module/module.pulsar.go
rename to inference-chain/api/inference/inference/module/module.pulsar.go
index b7b2e6a5b..c3364c591 100644
--- a/inference/api/inference/inference/module/module.pulsar.go
+++ b/inference-chain/api/inference/inference/module/module.pulsar.go
@@ -2,16 +2,15 @@
package module
import (
- fmt "fmt"
- io "io"
- reflect "reflect"
- sync "sync"
-
_ "cosmossdk.io/api/cosmos/app/v1alpha1"
+ 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 (
diff --git a/inference-chain/api/inference/inference/network_node.pulsar.go b/inference-chain/api/inference/inference/network_node.pulsar.go
new file mode 100644
index 000000000..2da3056cb
--- /dev/null
+++ b/inference-chain/api/inference/inference/network_node.pulsar.go
@@ -0,0 +1,10056 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package inference
+
+import (
+ binary "encoding/binary"
+ 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"
+ math "math"
+ reflect "reflect"
+ sync "sync"
+)
+
+var (
+ md_JoinTrainingRequest protoreflect.MessageDescriptor
+ fd_JoinTrainingRequest_node_id protoreflect.FieldDescriptor
+ fd_JoinTrainingRequest_run_id protoreflect.FieldDescriptor
+ fd_JoinTrainingRequest_outer_step protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_network_node_proto_init()
+ md_JoinTrainingRequest = File_inference_inference_network_node_proto.Messages().ByName("JoinTrainingRequest")
+ fd_JoinTrainingRequest_node_id = md_JoinTrainingRequest.Fields().ByName("node_id")
+ fd_JoinTrainingRequest_run_id = md_JoinTrainingRequest.Fields().ByName("run_id")
+ fd_JoinTrainingRequest_outer_step = md_JoinTrainingRequest.Fields().ByName("outer_step")
+}
+
+var _ protoreflect.Message = (*fastReflection_JoinTrainingRequest)(nil)
+
+type fastReflection_JoinTrainingRequest JoinTrainingRequest
+
+func (x *JoinTrainingRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_JoinTrainingRequest)(x)
+}
+
+func (x *JoinTrainingRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_network_node_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_JoinTrainingRequest_messageType fastReflection_JoinTrainingRequest_messageType
+var _ protoreflect.MessageType = fastReflection_JoinTrainingRequest_messageType{}
+
+type fastReflection_JoinTrainingRequest_messageType struct{}
+
+func (x fastReflection_JoinTrainingRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_JoinTrainingRequest)(nil)
+}
+func (x fastReflection_JoinTrainingRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_JoinTrainingRequest)
+}
+func (x fastReflection_JoinTrainingRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_JoinTrainingRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_JoinTrainingRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_JoinTrainingRequest
+}
+
+// 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_JoinTrainingRequest) Type() protoreflect.MessageType {
+ return _fastReflection_JoinTrainingRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_JoinTrainingRequest) New() protoreflect.Message {
+ return new(fastReflection_JoinTrainingRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_JoinTrainingRequest) Interface() protoreflect.ProtoMessage {
+ return (*JoinTrainingRequest)(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_JoinTrainingRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.NodeId != "" {
+ value := protoreflect.ValueOfString(x.NodeId)
+ if !f(fd_JoinTrainingRequest_node_id, value) {
+ return
+ }
+ }
+ if x.RunId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.RunId)
+ if !f(fd_JoinTrainingRequest_run_id, value) {
+ return
+ }
+ }
+ if x.OuterStep != int32(0) {
+ value := protoreflect.ValueOfInt32(x.OuterStep)
+ if !f(fd_JoinTrainingRequest_outer_step, 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_JoinTrainingRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.JoinTrainingRequest.node_id":
+ return x.NodeId != ""
+ case "inference.inference.JoinTrainingRequest.run_id":
+ return x.RunId != uint64(0)
+ case "inference.inference.JoinTrainingRequest.outer_step":
+ return x.OuterStep != int32(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.JoinTrainingRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.JoinTrainingRequest 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_JoinTrainingRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.JoinTrainingRequest.node_id":
+ x.NodeId = ""
+ case "inference.inference.JoinTrainingRequest.run_id":
+ x.RunId = uint64(0)
+ case "inference.inference.JoinTrainingRequest.outer_step":
+ x.OuterStep = int32(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.JoinTrainingRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.JoinTrainingRequest 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_JoinTrainingRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.JoinTrainingRequest.node_id":
+ value := x.NodeId
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.JoinTrainingRequest.run_id":
+ value := x.RunId
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.JoinTrainingRequest.outer_step":
+ value := x.OuterStep
+ return protoreflect.ValueOfInt32(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.JoinTrainingRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.JoinTrainingRequest 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_JoinTrainingRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.JoinTrainingRequest.node_id":
+ x.NodeId = value.Interface().(string)
+ case "inference.inference.JoinTrainingRequest.run_id":
+ x.RunId = value.Uint()
+ case "inference.inference.JoinTrainingRequest.outer_step":
+ x.OuterStep = int32(value.Int())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.JoinTrainingRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.JoinTrainingRequest 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_JoinTrainingRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.JoinTrainingRequest.node_id":
+ panic(fmt.Errorf("field node_id of message inference.inference.JoinTrainingRequest is not mutable"))
+ case "inference.inference.JoinTrainingRequest.run_id":
+ panic(fmt.Errorf("field run_id of message inference.inference.JoinTrainingRequest is not mutable"))
+ case "inference.inference.JoinTrainingRequest.outer_step":
+ panic(fmt.Errorf("field outer_step of message inference.inference.JoinTrainingRequest is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.JoinTrainingRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.JoinTrainingRequest 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_JoinTrainingRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.JoinTrainingRequest.node_id":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.JoinTrainingRequest.run_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.JoinTrainingRequest.outer_step":
+ return protoreflect.ValueOfInt32(int32(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.JoinTrainingRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.JoinTrainingRequest 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_JoinTrainingRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.JoinTrainingRequest", 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_JoinTrainingRequest) 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_JoinTrainingRequest) 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_JoinTrainingRequest) 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_JoinTrainingRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*JoinTrainingRequest)
+ 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.NodeId)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.RunId != 0 {
+ n += 1 + runtime.Sov(uint64(x.RunId))
+ }
+ if x.OuterStep != 0 {
+ n += 1 + runtime.Sov(uint64(x.OuterStep))
+ }
+ 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().(*JoinTrainingRequest)
+ 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.OuterStep != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.OuterStep))
+ i--
+ dAtA[i] = 0x18
+ }
+ if x.RunId != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.RunId))
+ i--
+ dAtA[i] = 0x10
+ }
+ 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] = 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().(*JoinTrainingRequest)
+ 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: JoinTrainingRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: JoinTrainingRequest: 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 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
+ case 2:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RunId", wireType)
+ }
+ x.RunId = 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.RunId |= 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 OuterStep", wireType)
+ }
+ x.OuterStep = 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.OuterStep |= 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,
+ Size: size,
+ Marshal: marshal,
+ Unmarshal: unmarshal,
+ Merge: nil,
+ CheckInitialized: nil,
+ }
+}
+
+var _ protoreflect.List = (*_MLNodeTrainStatus_4_list)(nil)
+
+type _MLNodeTrainStatus_4_list struct {
+ list *[]string
+}
+
+func (x *_MLNodeTrainStatus_4_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_MLNodeTrainStatus_4_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfString((*x.list)[i])
+}
+
+func (x *_MLNodeTrainStatus_4_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.String()
+ concreteValue := valueUnwrapped
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_MLNodeTrainStatus_4_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.String()
+ concreteValue := valueUnwrapped
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_MLNodeTrainStatus_4_list) AppendMutable() protoreflect.Value {
+ panic(fmt.Errorf("AppendMutable can not be called on message MLNodeTrainStatus at list field ActiveNodes as it is not of Message kind"))
+}
+
+func (x *_MLNodeTrainStatus_4_list) Truncate(n int) {
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_MLNodeTrainStatus_4_list) NewElement() protoreflect.Value {
+ v := ""
+ return protoreflect.ValueOfString(v)
+}
+
+func (x *_MLNodeTrainStatus_4_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_MLNodeTrainStatus protoreflect.MessageDescriptor
+ fd_MLNodeTrainStatus_status protoreflect.FieldDescriptor
+ fd_MLNodeTrainStatus_node_id protoreflect.FieldDescriptor
+ fd_MLNodeTrainStatus_outer_step protoreflect.FieldDescriptor
+ fd_MLNodeTrainStatus_active_nodes protoreflect.FieldDescriptor
+ fd_MLNodeTrainStatus_rank protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_network_node_proto_init()
+ md_MLNodeTrainStatus = File_inference_inference_network_node_proto.Messages().ByName("MLNodeTrainStatus")
+ fd_MLNodeTrainStatus_status = md_MLNodeTrainStatus.Fields().ByName("status")
+ fd_MLNodeTrainStatus_node_id = md_MLNodeTrainStatus.Fields().ByName("node_id")
+ fd_MLNodeTrainStatus_outer_step = md_MLNodeTrainStatus.Fields().ByName("outer_step")
+ fd_MLNodeTrainStatus_active_nodes = md_MLNodeTrainStatus.Fields().ByName("active_nodes")
+ fd_MLNodeTrainStatus_rank = md_MLNodeTrainStatus.Fields().ByName("rank")
+}
+
+var _ protoreflect.Message = (*fastReflection_MLNodeTrainStatus)(nil)
+
+type fastReflection_MLNodeTrainStatus MLNodeTrainStatus
+
+func (x *MLNodeTrainStatus) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_MLNodeTrainStatus)(x)
+}
+
+func (x *MLNodeTrainStatus) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_network_node_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_MLNodeTrainStatus_messageType fastReflection_MLNodeTrainStatus_messageType
+var _ protoreflect.MessageType = fastReflection_MLNodeTrainStatus_messageType{}
+
+type fastReflection_MLNodeTrainStatus_messageType struct{}
+
+func (x fastReflection_MLNodeTrainStatus_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_MLNodeTrainStatus)(nil)
+}
+func (x fastReflection_MLNodeTrainStatus_messageType) New() protoreflect.Message {
+ return new(fastReflection_MLNodeTrainStatus)
+}
+func (x fastReflection_MLNodeTrainStatus_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_MLNodeTrainStatus
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MLNodeTrainStatus) Descriptor() protoreflect.MessageDescriptor {
+ return md_MLNodeTrainStatus
+}
+
+// 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_MLNodeTrainStatus) Type() protoreflect.MessageType {
+ return _fastReflection_MLNodeTrainStatus_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MLNodeTrainStatus) New() protoreflect.Message {
+ return new(fastReflection_MLNodeTrainStatus)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MLNodeTrainStatus) Interface() protoreflect.ProtoMessage {
+ return (*MLNodeTrainStatus)(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_MLNodeTrainStatus) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Status != 0 {
+ value := protoreflect.ValueOfEnum((protoreflect.EnumNumber)(x.Status))
+ if !f(fd_MLNodeTrainStatus_status, value) {
+ return
+ }
+ }
+ if x.NodeId != "" {
+ value := protoreflect.ValueOfString(x.NodeId)
+ if !f(fd_MLNodeTrainStatus_node_id, value) {
+ return
+ }
+ }
+ if x.OuterStep != int32(0) {
+ value := protoreflect.ValueOfInt32(x.OuterStep)
+ if !f(fd_MLNodeTrainStatus_outer_step, value) {
+ return
+ }
+ }
+ if len(x.ActiveNodes) != 0 {
+ value := protoreflect.ValueOfList(&_MLNodeTrainStatus_4_list{list: &x.ActiveNodes})
+ if !f(fd_MLNodeTrainStatus_active_nodes, value) {
+ return
+ }
+ }
+ if x.Rank != int32(0) {
+ value := protoreflect.ValueOfInt32(x.Rank)
+ if !f(fd_MLNodeTrainStatus_rank, 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_MLNodeTrainStatus) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.MLNodeTrainStatus.status":
+ return x.Status != 0
+ case "inference.inference.MLNodeTrainStatus.node_id":
+ return x.NodeId != ""
+ case "inference.inference.MLNodeTrainStatus.outer_step":
+ return x.OuterStep != int32(0)
+ case "inference.inference.MLNodeTrainStatus.active_nodes":
+ return len(x.ActiveNodes) != 0
+ case "inference.inference.MLNodeTrainStatus.rank":
+ return x.Rank != int32(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MLNodeTrainStatus"))
+ }
+ panic(fmt.Errorf("message inference.inference.MLNodeTrainStatus 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_MLNodeTrainStatus) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.MLNodeTrainStatus.status":
+ x.Status = 0
+ case "inference.inference.MLNodeTrainStatus.node_id":
+ x.NodeId = ""
+ case "inference.inference.MLNodeTrainStatus.outer_step":
+ x.OuterStep = int32(0)
+ case "inference.inference.MLNodeTrainStatus.active_nodes":
+ x.ActiveNodes = nil
+ case "inference.inference.MLNodeTrainStatus.rank":
+ x.Rank = int32(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MLNodeTrainStatus"))
+ }
+ panic(fmt.Errorf("message inference.inference.MLNodeTrainStatus 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_MLNodeTrainStatus) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.MLNodeTrainStatus.status":
+ value := x.Status
+ return protoreflect.ValueOfEnum((protoreflect.EnumNumber)(value))
+ case "inference.inference.MLNodeTrainStatus.node_id":
+ value := x.NodeId
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.MLNodeTrainStatus.outer_step":
+ value := x.OuterStep
+ return protoreflect.ValueOfInt32(value)
+ case "inference.inference.MLNodeTrainStatus.active_nodes":
+ if len(x.ActiveNodes) == 0 {
+ return protoreflect.ValueOfList(&_MLNodeTrainStatus_4_list{})
+ }
+ listValue := &_MLNodeTrainStatus_4_list{list: &x.ActiveNodes}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.inference.MLNodeTrainStatus.rank":
+ value := x.Rank
+ return protoreflect.ValueOfInt32(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MLNodeTrainStatus"))
+ }
+ panic(fmt.Errorf("message inference.inference.MLNodeTrainStatus 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_MLNodeTrainStatus) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.MLNodeTrainStatus.status":
+ x.Status = (MLNodeTrainStatusEnum)(value.Enum())
+ case "inference.inference.MLNodeTrainStatus.node_id":
+ x.NodeId = value.Interface().(string)
+ case "inference.inference.MLNodeTrainStatus.outer_step":
+ x.OuterStep = int32(value.Int())
+ case "inference.inference.MLNodeTrainStatus.active_nodes":
+ lv := value.List()
+ clv := lv.(*_MLNodeTrainStatus_4_list)
+ x.ActiveNodes = *clv.list
+ case "inference.inference.MLNodeTrainStatus.rank":
+ x.Rank = int32(value.Int())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MLNodeTrainStatus"))
+ }
+ panic(fmt.Errorf("message inference.inference.MLNodeTrainStatus 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_MLNodeTrainStatus) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.MLNodeTrainStatus.active_nodes":
+ if x.ActiveNodes == nil {
+ x.ActiveNodes = []string{}
+ }
+ value := &_MLNodeTrainStatus_4_list{list: &x.ActiveNodes}
+ return protoreflect.ValueOfList(value)
+ case "inference.inference.MLNodeTrainStatus.status":
+ panic(fmt.Errorf("field status of message inference.inference.MLNodeTrainStatus is not mutable"))
+ case "inference.inference.MLNodeTrainStatus.node_id":
+ panic(fmt.Errorf("field node_id of message inference.inference.MLNodeTrainStatus is not mutable"))
+ case "inference.inference.MLNodeTrainStatus.outer_step":
+ panic(fmt.Errorf("field outer_step of message inference.inference.MLNodeTrainStatus is not mutable"))
+ case "inference.inference.MLNodeTrainStatus.rank":
+ panic(fmt.Errorf("field rank of message inference.inference.MLNodeTrainStatus is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MLNodeTrainStatus"))
+ }
+ panic(fmt.Errorf("message inference.inference.MLNodeTrainStatus 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_MLNodeTrainStatus) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.MLNodeTrainStatus.status":
+ return protoreflect.ValueOfEnum(0)
+ case "inference.inference.MLNodeTrainStatus.node_id":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.MLNodeTrainStatus.outer_step":
+ return protoreflect.ValueOfInt32(int32(0))
+ case "inference.inference.MLNodeTrainStatus.active_nodes":
+ list := []string{}
+ return protoreflect.ValueOfList(&_MLNodeTrainStatus_4_list{list: &list})
+ case "inference.inference.MLNodeTrainStatus.rank":
+ return protoreflect.ValueOfInt32(int32(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MLNodeTrainStatus"))
+ }
+ panic(fmt.Errorf("message inference.inference.MLNodeTrainStatus 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_MLNodeTrainStatus) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.MLNodeTrainStatus", 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_MLNodeTrainStatus) 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_MLNodeTrainStatus) 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_MLNodeTrainStatus) 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_MLNodeTrainStatus) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*MLNodeTrainStatus)
+ 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.Status != 0 {
+ n += 1 + runtime.Sov(uint64(x.Status))
+ }
+ l = len(x.NodeId)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.OuterStep != 0 {
+ n += 1 + runtime.Sov(uint64(x.OuterStep))
+ }
+ if len(x.ActiveNodes) > 0 {
+ for _, s := range x.ActiveNodes {
+ l = len(s)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ }
+ if x.Rank != 0 {
+ n += 1 + runtime.Sov(uint64(x.Rank))
+ }
+ 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().(*MLNodeTrainStatus)
+ 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.Rank != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.Rank))
+ i--
+ dAtA[i] = 0x28
+ }
+ if len(x.ActiveNodes) > 0 {
+ for iNdEx := len(x.ActiveNodes) - 1; iNdEx >= 0; iNdEx-- {
+ i -= len(x.ActiveNodes[iNdEx])
+ copy(dAtA[i:], x.ActiveNodes[iNdEx])
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ActiveNodes[iNdEx])))
+ i--
+ dAtA[i] = 0x22
+ }
+ }
+ if x.OuterStep != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.OuterStep))
+ i--
+ dAtA[i] = 0x18
+ }
+ 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] = 0x12
+ }
+ if x.Status != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.Status))
+ 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().(*MLNodeTrainStatus)
+ 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: MLNodeTrainStatus: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MLNodeTrainStatus: 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 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 |= MLNodeTrainStatusEnum(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 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
+ case 3:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field OuterStep", wireType)
+ }
+ x.OuterStep = 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.OuterStep |= int32(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 ActiveNodes", 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.ActiveNodes = append(x.ActiveNodes, string(dAtA[iNdEx:postIndex]))
+ iNdEx = postIndex
+ case 5:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Rank", wireType)
+ }
+ x.Rank = 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.Rank |= 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,
+ Size: size,
+ Marshal: marshal,
+ Unmarshal: unmarshal,
+ Merge: nil,
+ CheckInitialized: nil,
+ }
+}
+
+var (
+ md_HeartbeatRequest protoreflect.MessageDescriptor
+ fd_HeartbeatRequest_node_id protoreflect.FieldDescriptor
+ fd_HeartbeatRequest_run_id protoreflect.FieldDescriptor
+ fd_HeartbeatRequest_local_rank protoreflect.FieldDescriptor
+ fd_HeartbeatRequest_timestamp protoreflect.FieldDescriptor
+ fd_HeartbeatRequest_inner_step protoreflect.FieldDescriptor
+ fd_HeartbeatRequest_outer_step protoreflect.FieldDescriptor
+ fd_HeartbeatRequest_epoch protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_network_node_proto_init()
+ md_HeartbeatRequest = File_inference_inference_network_node_proto.Messages().ByName("HeartbeatRequest")
+ fd_HeartbeatRequest_node_id = md_HeartbeatRequest.Fields().ByName("node_id")
+ fd_HeartbeatRequest_run_id = md_HeartbeatRequest.Fields().ByName("run_id")
+ fd_HeartbeatRequest_local_rank = md_HeartbeatRequest.Fields().ByName("local_rank")
+ fd_HeartbeatRequest_timestamp = md_HeartbeatRequest.Fields().ByName("timestamp")
+ fd_HeartbeatRequest_inner_step = md_HeartbeatRequest.Fields().ByName("inner_step")
+ fd_HeartbeatRequest_outer_step = md_HeartbeatRequest.Fields().ByName("outer_step")
+ fd_HeartbeatRequest_epoch = md_HeartbeatRequest.Fields().ByName("epoch")
+}
+
+var _ protoreflect.Message = (*fastReflection_HeartbeatRequest)(nil)
+
+type fastReflection_HeartbeatRequest HeartbeatRequest
+
+func (x *HeartbeatRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_HeartbeatRequest)(x)
+}
+
+func (x *HeartbeatRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_network_node_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_HeartbeatRequest_messageType fastReflection_HeartbeatRequest_messageType
+var _ protoreflect.MessageType = fastReflection_HeartbeatRequest_messageType{}
+
+type fastReflection_HeartbeatRequest_messageType struct{}
+
+func (x fastReflection_HeartbeatRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_HeartbeatRequest)(nil)
+}
+func (x fastReflection_HeartbeatRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_HeartbeatRequest)
+}
+func (x fastReflection_HeartbeatRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_HeartbeatRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_HeartbeatRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_HeartbeatRequest
+}
+
+// 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_HeartbeatRequest) Type() protoreflect.MessageType {
+ return _fastReflection_HeartbeatRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_HeartbeatRequest) New() protoreflect.Message {
+ return new(fastReflection_HeartbeatRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_HeartbeatRequest) Interface() protoreflect.ProtoMessage {
+ return (*HeartbeatRequest)(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_HeartbeatRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.NodeId != "" {
+ value := protoreflect.ValueOfString(x.NodeId)
+ if !f(fd_HeartbeatRequest_node_id, value) {
+ return
+ }
+ }
+ if x.RunId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.RunId)
+ if !f(fd_HeartbeatRequest_run_id, value) {
+ return
+ }
+ }
+ if x.LocalRank != int32(0) {
+ value := protoreflect.ValueOfInt32(x.LocalRank)
+ if !f(fd_HeartbeatRequest_local_rank, value) {
+ return
+ }
+ }
+ if x.Timestamp != float64(0) || math.Signbit(x.Timestamp) {
+ value := protoreflect.ValueOfFloat64(x.Timestamp)
+ if !f(fd_HeartbeatRequest_timestamp, value) {
+ return
+ }
+ }
+ if x.InnerStep != int32(0) {
+ value := protoreflect.ValueOfInt32(x.InnerStep)
+ if !f(fd_HeartbeatRequest_inner_step, value) {
+ return
+ }
+ }
+ if x.OuterStep != int32(0) {
+ value := protoreflect.ValueOfInt32(x.OuterStep)
+ if !f(fd_HeartbeatRequest_outer_step, value) {
+ return
+ }
+ }
+ if x.Epoch != int32(0) {
+ value := protoreflect.ValueOfInt32(x.Epoch)
+ if !f(fd_HeartbeatRequest_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_HeartbeatRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.HeartbeatRequest.node_id":
+ return x.NodeId != ""
+ case "inference.inference.HeartbeatRequest.run_id":
+ return x.RunId != uint64(0)
+ case "inference.inference.HeartbeatRequest.local_rank":
+ return x.LocalRank != int32(0)
+ case "inference.inference.HeartbeatRequest.timestamp":
+ return x.Timestamp != float64(0) || math.Signbit(x.Timestamp)
+ case "inference.inference.HeartbeatRequest.inner_step":
+ return x.InnerStep != int32(0)
+ case "inference.inference.HeartbeatRequest.outer_step":
+ return x.OuterStep != int32(0)
+ case "inference.inference.HeartbeatRequest.epoch":
+ return x.Epoch != int32(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.HeartbeatRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.HeartbeatRequest 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_HeartbeatRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.HeartbeatRequest.node_id":
+ x.NodeId = ""
+ case "inference.inference.HeartbeatRequest.run_id":
+ x.RunId = uint64(0)
+ case "inference.inference.HeartbeatRequest.local_rank":
+ x.LocalRank = int32(0)
+ case "inference.inference.HeartbeatRequest.timestamp":
+ x.Timestamp = float64(0)
+ case "inference.inference.HeartbeatRequest.inner_step":
+ x.InnerStep = int32(0)
+ case "inference.inference.HeartbeatRequest.outer_step":
+ x.OuterStep = int32(0)
+ case "inference.inference.HeartbeatRequest.epoch":
+ x.Epoch = int32(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.HeartbeatRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.HeartbeatRequest 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_HeartbeatRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.HeartbeatRequest.node_id":
+ value := x.NodeId
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.HeartbeatRequest.run_id":
+ value := x.RunId
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.HeartbeatRequest.local_rank":
+ value := x.LocalRank
+ return protoreflect.ValueOfInt32(value)
+ case "inference.inference.HeartbeatRequest.timestamp":
+ value := x.Timestamp
+ return protoreflect.ValueOfFloat64(value)
+ case "inference.inference.HeartbeatRequest.inner_step":
+ value := x.InnerStep
+ return protoreflect.ValueOfInt32(value)
+ case "inference.inference.HeartbeatRequest.outer_step":
+ value := x.OuterStep
+ return protoreflect.ValueOfInt32(value)
+ case "inference.inference.HeartbeatRequest.epoch":
+ value := x.Epoch
+ return protoreflect.ValueOfInt32(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.HeartbeatRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.HeartbeatRequest 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_HeartbeatRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.HeartbeatRequest.node_id":
+ x.NodeId = value.Interface().(string)
+ case "inference.inference.HeartbeatRequest.run_id":
+ x.RunId = value.Uint()
+ case "inference.inference.HeartbeatRequest.local_rank":
+ x.LocalRank = int32(value.Int())
+ case "inference.inference.HeartbeatRequest.timestamp":
+ x.Timestamp = value.Float()
+ case "inference.inference.HeartbeatRequest.inner_step":
+ x.InnerStep = int32(value.Int())
+ case "inference.inference.HeartbeatRequest.outer_step":
+ x.OuterStep = int32(value.Int())
+ case "inference.inference.HeartbeatRequest.epoch":
+ x.Epoch = int32(value.Int())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.HeartbeatRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.HeartbeatRequest 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_HeartbeatRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.HeartbeatRequest.node_id":
+ panic(fmt.Errorf("field node_id of message inference.inference.HeartbeatRequest is not mutable"))
+ case "inference.inference.HeartbeatRequest.run_id":
+ panic(fmt.Errorf("field run_id of message inference.inference.HeartbeatRequest is not mutable"))
+ case "inference.inference.HeartbeatRequest.local_rank":
+ panic(fmt.Errorf("field local_rank of message inference.inference.HeartbeatRequest is not mutable"))
+ case "inference.inference.HeartbeatRequest.timestamp":
+ panic(fmt.Errorf("field timestamp of message inference.inference.HeartbeatRequest is not mutable"))
+ case "inference.inference.HeartbeatRequest.inner_step":
+ panic(fmt.Errorf("field inner_step of message inference.inference.HeartbeatRequest is not mutable"))
+ case "inference.inference.HeartbeatRequest.outer_step":
+ panic(fmt.Errorf("field outer_step of message inference.inference.HeartbeatRequest is not mutable"))
+ case "inference.inference.HeartbeatRequest.epoch":
+ panic(fmt.Errorf("field epoch of message inference.inference.HeartbeatRequest is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.HeartbeatRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.HeartbeatRequest 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_HeartbeatRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.HeartbeatRequest.node_id":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.HeartbeatRequest.run_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.HeartbeatRequest.local_rank":
+ return protoreflect.ValueOfInt32(int32(0))
+ case "inference.inference.HeartbeatRequest.timestamp":
+ return protoreflect.ValueOfFloat64(float64(0))
+ case "inference.inference.HeartbeatRequest.inner_step":
+ return protoreflect.ValueOfInt32(int32(0))
+ case "inference.inference.HeartbeatRequest.outer_step":
+ return protoreflect.ValueOfInt32(int32(0))
+ case "inference.inference.HeartbeatRequest.epoch":
+ return protoreflect.ValueOfInt32(int32(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.HeartbeatRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.HeartbeatRequest 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_HeartbeatRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.HeartbeatRequest", 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_HeartbeatRequest) 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_HeartbeatRequest) 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_HeartbeatRequest) 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_HeartbeatRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*HeartbeatRequest)
+ 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.NodeId)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.RunId != 0 {
+ n += 1 + runtime.Sov(uint64(x.RunId))
+ }
+ if x.LocalRank != 0 {
+ n += 1 + runtime.Sov(uint64(x.LocalRank))
+ }
+ if x.Timestamp != 0 || math.Signbit(x.Timestamp) {
+ n += 9
+ }
+ if x.InnerStep != 0 {
+ n += 1 + runtime.Sov(uint64(x.InnerStep))
+ }
+ if x.OuterStep != 0 {
+ n += 1 + runtime.Sov(uint64(x.OuterStep))
+ }
+ if x.Epoch != 0 {
+ n += 1 + runtime.Sov(uint64(x.Epoch))
+ }
+ 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().(*HeartbeatRequest)
+ 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.Epoch != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.Epoch))
+ i--
+ dAtA[i] = 0x38
+ }
+ if x.OuterStep != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.OuterStep))
+ i--
+ dAtA[i] = 0x30
+ }
+ if x.InnerStep != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.InnerStep))
+ i--
+ dAtA[i] = 0x28
+ }
+ if x.Timestamp != 0 || math.Signbit(x.Timestamp) {
+ i -= 8
+ binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(x.Timestamp))))
+ i--
+ dAtA[i] = 0x21
+ }
+ if x.LocalRank != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.LocalRank))
+ i--
+ dAtA[i] = 0x18
+ }
+ if x.RunId != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.RunId))
+ i--
+ dAtA[i] = 0x10
+ }
+ 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] = 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().(*HeartbeatRequest)
+ 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: HeartbeatRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: HeartbeatRequest: 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 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
+ case 2:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RunId", wireType)
+ }
+ x.RunId = 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.RunId |= 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 LocalRank", wireType)
+ }
+ x.LocalRank = 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.LocalRank |= int32(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 4:
+ if wireType != 1 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
+ }
+ 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
+ x.Timestamp = float64(math.Float64frombits(v))
+ case 5:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field InnerStep", wireType)
+ }
+ x.InnerStep = 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.InnerStep |= int32(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 OuterStep", wireType)
+ }
+ x.OuterStep = 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.OuterStep |= int32(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 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 |= 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,
+ Size: size,
+ Marshal: marshal,
+ Unmarshal: unmarshal,
+ Merge: nil,
+ CheckInitialized: nil,
+ }
+}
+
+var (
+ md_HeartbeatResponse protoreflect.MessageDescriptor
+ fd_HeartbeatResponse_status protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_network_node_proto_init()
+ md_HeartbeatResponse = File_inference_inference_network_node_proto.Messages().ByName("HeartbeatResponse")
+ fd_HeartbeatResponse_status = md_HeartbeatResponse.Fields().ByName("status")
+}
+
+var _ protoreflect.Message = (*fastReflection_HeartbeatResponse)(nil)
+
+type fastReflection_HeartbeatResponse HeartbeatResponse
+
+func (x *HeartbeatResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_HeartbeatResponse)(x)
+}
+
+func (x *HeartbeatResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_network_node_proto_msgTypes[3]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_HeartbeatResponse_messageType fastReflection_HeartbeatResponse_messageType
+var _ protoreflect.MessageType = fastReflection_HeartbeatResponse_messageType{}
+
+type fastReflection_HeartbeatResponse_messageType struct{}
+
+func (x fastReflection_HeartbeatResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_HeartbeatResponse)(nil)
+}
+func (x fastReflection_HeartbeatResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_HeartbeatResponse)
+}
+func (x fastReflection_HeartbeatResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_HeartbeatResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_HeartbeatResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_HeartbeatResponse
+}
+
+// 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_HeartbeatResponse) Type() protoreflect.MessageType {
+ return _fastReflection_HeartbeatResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_HeartbeatResponse) New() protoreflect.Message {
+ return new(fastReflection_HeartbeatResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_HeartbeatResponse) Interface() protoreflect.ProtoMessage {
+ return (*HeartbeatResponse)(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_HeartbeatResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Status != 0 {
+ value := protoreflect.ValueOfEnum((protoreflect.EnumNumber)(x.Status))
+ if !f(fd_HeartbeatResponse_status, 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_HeartbeatResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.HeartbeatResponse.status":
+ return x.Status != 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.HeartbeatResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.HeartbeatResponse 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_HeartbeatResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.HeartbeatResponse.status":
+ x.Status = 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.HeartbeatResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.HeartbeatResponse 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_HeartbeatResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.HeartbeatResponse.status":
+ value := x.Status
+ return protoreflect.ValueOfEnum((protoreflect.EnumNumber)(value))
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.HeartbeatResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.HeartbeatResponse 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_HeartbeatResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.HeartbeatResponse.status":
+ x.Status = (HeartbeatStatusEnum)(value.Enum())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.HeartbeatResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.HeartbeatResponse 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_HeartbeatResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.HeartbeatResponse.status":
+ panic(fmt.Errorf("field status of message inference.inference.HeartbeatResponse is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.HeartbeatResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.HeartbeatResponse 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_HeartbeatResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.HeartbeatResponse.status":
+ return protoreflect.ValueOfEnum(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.HeartbeatResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.HeartbeatResponse 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_HeartbeatResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.HeartbeatResponse", 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_HeartbeatResponse) 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_HeartbeatResponse) 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_HeartbeatResponse) 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_HeartbeatResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*HeartbeatResponse)
+ 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.Status != 0 {
+ n += 1 + runtime.Sov(uint64(x.Status))
+ }
+ 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().(*HeartbeatResponse)
+ 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.Status != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.Status))
+ 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().(*HeartbeatResponse)
+ 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: HeartbeatResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: HeartbeatResponse: 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 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 |= HeartbeatStatusEnum(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_GetAliveNodesRequest protoreflect.MessageDescriptor
+ fd_GetAliveNodesRequest_run_id protoreflect.FieldDescriptor
+ fd_GetAliveNodesRequest_outer_step protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_network_node_proto_init()
+ md_GetAliveNodesRequest = File_inference_inference_network_node_proto.Messages().ByName("GetAliveNodesRequest")
+ fd_GetAliveNodesRequest_run_id = md_GetAliveNodesRequest.Fields().ByName("run_id")
+ fd_GetAliveNodesRequest_outer_step = md_GetAliveNodesRequest.Fields().ByName("outer_step")
+}
+
+var _ protoreflect.Message = (*fastReflection_GetAliveNodesRequest)(nil)
+
+type fastReflection_GetAliveNodesRequest GetAliveNodesRequest
+
+func (x *GetAliveNodesRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_GetAliveNodesRequest)(x)
+}
+
+func (x *GetAliveNodesRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_network_node_proto_msgTypes[4]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_GetAliveNodesRequest_messageType fastReflection_GetAliveNodesRequest_messageType
+var _ protoreflect.MessageType = fastReflection_GetAliveNodesRequest_messageType{}
+
+type fastReflection_GetAliveNodesRequest_messageType struct{}
+
+func (x fastReflection_GetAliveNodesRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_GetAliveNodesRequest)(nil)
+}
+func (x fastReflection_GetAliveNodesRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_GetAliveNodesRequest)
+}
+func (x fastReflection_GetAliveNodesRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_GetAliveNodesRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_GetAliveNodesRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_GetAliveNodesRequest
+}
+
+// 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_GetAliveNodesRequest) Type() protoreflect.MessageType {
+ return _fastReflection_GetAliveNodesRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_GetAliveNodesRequest) New() protoreflect.Message {
+ return new(fastReflection_GetAliveNodesRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_GetAliveNodesRequest) Interface() protoreflect.ProtoMessage {
+ return (*GetAliveNodesRequest)(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_GetAliveNodesRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.RunId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.RunId)
+ if !f(fd_GetAliveNodesRequest_run_id, value) {
+ return
+ }
+ }
+ if x.OuterStep != int32(0) {
+ value := protoreflect.ValueOfInt32(x.OuterStep)
+ if !f(fd_GetAliveNodesRequest_outer_step, 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_GetAliveNodesRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.GetAliveNodesRequest.run_id":
+ return x.RunId != uint64(0)
+ case "inference.inference.GetAliveNodesRequest.outer_step":
+ return x.OuterStep != int32(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GetAliveNodesRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.GetAliveNodesRequest 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_GetAliveNodesRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.GetAliveNodesRequest.run_id":
+ x.RunId = uint64(0)
+ case "inference.inference.GetAliveNodesRequest.outer_step":
+ x.OuterStep = int32(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GetAliveNodesRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.GetAliveNodesRequest 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_GetAliveNodesRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.GetAliveNodesRequest.run_id":
+ value := x.RunId
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.GetAliveNodesRequest.outer_step":
+ value := x.OuterStep
+ return protoreflect.ValueOfInt32(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GetAliveNodesRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.GetAliveNodesRequest 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_GetAliveNodesRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.GetAliveNodesRequest.run_id":
+ x.RunId = value.Uint()
+ case "inference.inference.GetAliveNodesRequest.outer_step":
+ x.OuterStep = int32(value.Int())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GetAliveNodesRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.GetAliveNodesRequest 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_GetAliveNodesRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.GetAliveNodesRequest.run_id":
+ panic(fmt.Errorf("field run_id of message inference.inference.GetAliveNodesRequest is not mutable"))
+ case "inference.inference.GetAliveNodesRequest.outer_step":
+ panic(fmt.Errorf("field outer_step of message inference.inference.GetAliveNodesRequest is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GetAliveNodesRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.GetAliveNodesRequest 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_GetAliveNodesRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.GetAliveNodesRequest.run_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.GetAliveNodesRequest.outer_step":
+ return protoreflect.ValueOfInt32(int32(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GetAliveNodesRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.GetAliveNodesRequest 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_GetAliveNodesRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.GetAliveNodesRequest", 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_GetAliveNodesRequest) 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_GetAliveNodesRequest) 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_GetAliveNodesRequest) 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_GetAliveNodesRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*GetAliveNodesRequest)
+ 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.RunId != 0 {
+ n += 1 + runtime.Sov(uint64(x.RunId))
+ }
+ if x.OuterStep != 0 {
+ n += 1 + runtime.Sov(uint64(x.OuterStep))
+ }
+ 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().(*GetAliveNodesRequest)
+ 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.OuterStep != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.OuterStep))
+ i--
+ dAtA[i] = 0x10
+ }
+ if x.RunId != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.RunId))
+ 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().(*GetAliveNodesRequest)
+ 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: GetAliveNodesRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: GetAliveNodesRequest: 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 RunId", wireType)
+ }
+ x.RunId = 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.RunId |= 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 OuterStep", wireType)
+ }
+ x.OuterStep = 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.OuterStep |= 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,
+ Size: size,
+ Marshal: marshal,
+ Unmarshal: unmarshal,
+ Merge: nil,
+ CheckInitialized: nil,
+ }
+}
+
+var _ protoreflect.List = (*_GetAliveNodesResponse_1_list)(nil)
+
+type _GetAliveNodesResponse_1_list struct {
+ list *[]string
+}
+
+func (x *_GetAliveNodesResponse_1_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_GetAliveNodesResponse_1_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfString((*x.list)[i])
+}
+
+func (x *_GetAliveNodesResponse_1_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.String()
+ concreteValue := valueUnwrapped
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_GetAliveNodesResponse_1_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.String()
+ concreteValue := valueUnwrapped
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_GetAliveNodesResponse_1_list) AppendMutable() protoreflect.Value {
+ panic(fmt.Errorf("AppendMutable can not be called on message GetAliveNodesResponse at list field AliveNodes as it is not of Message kind"))
+}
+
+func (x *_GetAliveNodesResponse_1_list) Truncate(n int) {
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_GetAliveNodesResponse_1_list) NewElement() protoreflect.Value {
+ v := ""
+ return protoreflect.ValueOfString(v)
+}
+
+func (x *_GetAliveNodesResponse_1_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_GetAliveNodesResponse protoreflect.MessageDescriptor
+ fd_GetAliveNodesResponse_alive_nodes protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_network_node_proto_init()
+ md_GetAliveNodesResponse = File_inference_inference_network_node_proto.Messages().ByName("GetAliveNodesResponse")
+ fd_GetAliveNodesResponse_alive_nodes = md_GetAliveNodesResponse.Fields().ByName("alive_nodes")
+}
+
+var _ protoreflect.Message = (*fastReflection_GetAliveNodesResponse)(nil)
+
+type fastReflection_GetAliveNodesResponse GetAliveNodesResponse
+
+func (x *GetAliveNodesResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_GetAliveNodesResponse)(x)
+}
+
+func (x *GetAliveNodesResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_network_node_proto_msgTypes[5]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_GetAliveNodesResponse_messageType fastReflection_GetAliveNodesResponse_messageType
+var _ protoreflect.MessageType = fastReflection_GetAliveNodesResponse_messageType{}
+
+type fastReflection_GetAliveNodesResponse_messageType struct{}
+
+func (x fastReflection_GetAliveNodesResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_GetAliveNodesResponse)(nil)
+}
+func (x fastReflection_GetAliveNodesResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_GetAliveNodesResponse)
+}
+func (x fastReflection_GetAliveNodesResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_GetAliveNodesResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_GetAliveNodesResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_GetAliveNodesResponse
+}
+
+// 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_GetAliveNodesResponse) Type() protoreflect.MessageType {
+ return _fastReflection_GetAliveNodesResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_GetAliveNodesResponse) New() protoreflect.Message {
+ return new(fastReflection_GetAliveNodesResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_GetAliveNodesResponse) Interface() protoreflect.ProtoMessage {
+ return (*GetAliveNodesResponse)(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_GetAliveNodesResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if len(x.AliveNodes) != 0 {
+ value := protoreflect.ValueOfList(&_GetAliveNodesResponse_1_list{list: &x.AliveNodes})
+ if !f(fd_GetAliveNodesResponse_alive_nodes, 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_GetAliveNodesResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.GetAliveNodesResponse.alive_nodes":
+ return len(x.AliveNodes) != 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GetAliveNodesResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.GetAliveNodesResponse 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_GetAliveNodesResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.GetAliveNodesResponse.alive_nodes":
+ x.AliveNodes = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GetAliveNodesResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.GetAliveNodesResponse 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_GetAliveNodesResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.GetAliveNodesResponse.alive_nodes":
+ if len(x.AliveNodes) == 0 {
+ return protoreflect.ValueOfList(&_GetAliveNodesResponse_1_list{})
+ }
+ listValue := &_GetAliveNodesResponse_1_list{list: &x.AliveNodes}
+ return protoreflect.ValueOfList(listValue)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GetAliveNodesResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.GetAliveNodesResponse 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_GetAliveNodesResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.GetAliveNodesResponse.alive_nodes":
+ lv := value.List()
+ clv := lv.(*_GetAliveNodesResponse_1_list)
+ x.AliveNodes = *clv.list
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GetAliveNodesResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.GetAliveNodesResponse 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_GetAliveNodesResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.GetAliveNodesResponse.alive_nodes":
+ if x.AliveNodes == nil {
+ x.AliveNodes = []string{}
+ }
+ value := &_GetAliveNodesResponse_1_list{list: &x.AliveNodes}
+ return protoreflect.ValueOfList(value)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GetAliveNodesResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.GetAliveNodesResponse 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_GetAliveNodesResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.GetAliveNodesResponse.alive_nodes":
+ list := []string{}
+ return protoreflect.ValueOfList(&_GetAliveNodesResponse_1_list{list: &list})
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GetAliveNodesResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.GetAliveNodesResponse 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_GetAliveNodesResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.GetAliveNodesResponse", 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_GetAliveNodesResponse) 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_GetAliveNodesResponse) 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_GetAliveNodesResponse) 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_GetAliveNodesResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*GetAliveNodesResponse)
+ 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.AliveNodes) > 0 {
+ for _, s := range x.AliveNodes {
+ 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().(*GetAliveNodesResponse)
+ 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.AliveNodes) > 0 {
+ for iNdEx := len(x.AliveNodes) - 1; iNdEx >= 0; iNdEx-- {
+ i -= len(x.AliveNodes[iNdEx])
+ copy(dAtA[i:], x.AliveNodes[iNdEx])
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.AliveNodes[iNdEx])))
+ 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().(*GetAliveNodesResponse)
+ 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: GetAliveNodesResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: GetAliveNodesResponse: 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 AliveNodes", 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.AliveNodes = append(x.AliveNodes, 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_SetBarrierRequest protoreflect.MessageDescriptor
+ fd_SetBarrierRequest_barrier_id protoreflect.FieldDescriptor
+ fd_SetBarrierRequest_node_id protoreflect.FieldDescriptor
+ fd_SetBarrierRequest_run_id protoreflect.FieldDescriptor
+ fd_SetBarrierRequest_outer_step protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_network_node_proto_init()
+ md_SetBarrierRequest = File_inference_inference_network_node_proto.Messages().ByName("SetBarrierRequest")
+ fd_SetBarrierRequest_barrier_id = md_SetBarrierRequest.Fields().ByName("barrier_id")
+ fd_SetBarrierRequest_node_id = md_SetBarrierRequest.Fields().ByName("node_id")
+ fd_SetBarrierRequest_run_id = md_SetBarrierRequest.Fields().ByName("run_id")
+ fd_SetBarrierRequest_outer_step = md_SetBarrierRequest.Fields().ByName("outer_step")
+}
+
+var _ protoreflect.Message = (*fastReflection_SetBarrierRequest)(nil)
+
+type fastReflection_SetBarrierRequest SetBarrierRequest
+
+func (x *SetBarrierRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_SetBarrierRequest)(x)
+}
+
+func (x *SetBarrierRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_network_node_proto_msgTypes[6]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_SetBarrierRequest_messageType fastReflection_SetBarrierRequest_messageType
+var _ protoreflect.MessageType = fastReflection_SetBarrierRequest_messageType{}
+
+type fastReflection_SetBarrierRequest_messageType struct{}
+
+func (x fastReflection_SetBarrierRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_SetBarrierRequest)(nil)
+}
+func (x fastReflection_SetBarrierRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_SetBarrierRequest)
+}
+func (x fastReflection_SetBarrierRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_SetBarrierRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_SetBarrierRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_SetBarrierRequest
+}
+
+// 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_SetBarrierRequest) Type() protoreflect.MessageType {
+ return _fastReflection_SetBarrierRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_SetBarrierRequest) New() protoreflect.Message {
+ return new(fastReflection_SetBarrierRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_SetBarrierRequest) Interface() protoreflect.ProtoMessage {
+ return (*SetBarrierRequest)(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_SetBarrierRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.BarrierId != "" {
+ value := protoreflect.ValueOfString(x.BarrierId)
+ if !f(fd_SetBarrierRequest_barrier_id, value) {
+ return
+ }
+ }
+ if x.NodeId != "" {
+ value := protoreflect.ValueOfString(x.NodeId)
+ if !f(fd_SetBarrierRequest_node_id, value) {
+ return
+ }
+ }
+ if x.RunId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.RunId)
+ if !f(fd_SetBarrierRequest_run_id, value) {
+ return
+ }
+ }
+ if x.OuterStep != int32(0) {
+ value := protoreflect.ValueOfInt32(x.OuterStep)
+ if !f(fd_SetBarrierRequest_outer_step, 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_SetBarrierRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.SetBarrierRequest.barrier_id":
+ return x.BarrierId != ""
+ case "inference.inference.SetBarrierRequest.node_id":
+ return x.NodeId != ""
+ case "inference.inference.SetBarrierRequest.run_id":
+ return x.RunId != uint64(0)
+ case "inference.inference.SetBarrierRequest.outer_step":
+ return x.OuterStep != int32(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.SetBarrierRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.SetBarrierRequest 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_SetBarrierRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.SetBarrierRequest.barrier_id":
+ x.BarrierId = ""
+ case "inference.inference.SetBarrierRequest.node_id":
+ x.NodeId = ""
+ case "inference.inference.SetBarrierRequest.run_id":
+ x.RunId = uint64(0)
+ case "inference.inference.SetBarrierRequest.outer_step":
+ x.OuterStep = int32(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.SetBarrierRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.SetBarrierRequest 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_SetBarrierRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.SetBarrierRequest.barrier_id":
+ value := x.BarrierId
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.SetBarrierRequest.node_id":
+ value := x.NodeId
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.SetBarrierRequest.run_id":
+ value := x.RunId
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.SetBarrierRequest.outer_step":
+ value := x.OuterStep
+ return protoreflect.ValueOfInt32(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.SetBarrierRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.SetBarrierRequest 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_SetBarrierRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.SetBarrierRequest.barrier_id":
+ x.BarrierId = value.Interface().(string)
+ case "inference.inference.SetBarrierRequest.node_id":
+ x.NodeId = value.Interface().(string)
+ case "inference.inference.SetBarrierRequest.run_id":
+ x.RunId = value.Uint()
+ case "inference.inference.SetBarrierRequest.outer_step":
+ x.OuterStep = int32(value.Int())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.SetBarrierRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.SetBarrierRequest 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_SetBarrierRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.SetBarrierRequest.barrier_id":
+ panic(fmt.Errorf("field barrier_id of message inference.inference.SetBarrierRequest is not mutable"))
+ case "inference.inference.SetBarrierRequest.node_id":
+ panic(fmt.Errorf("field node_id of message inference.inference.SetBarrierRequest is not mutable"))
+ case "inference.inference.SetBarrierRequest.run_id":
+ panic(fmt.Errorf("field run_id of message inference.inference.SetBarrierRequest is not mutable"))
+ case "inference.inference.SetBarrierRequest.outer_step":
+ panic(fmt.Errorf("field outer_step of message inference.inference.SetBarrierRequest is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.SetBarrierRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.SetBarrierRequest 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_SetBarrierRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.SetBarrierRequest.barrier_id":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.SetBarrierRequest.node_id":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.SetBarrierRequest.run_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.SetBarrierRequest.outer_step":
+ return protoreflect.ValueOfInt32(int32(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.SetBarrierRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.SetBarrierRequest 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_SetBarrierRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.SetBarrierRequest", 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_SetBarrierRequest) 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_SetBarrierRequest) 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_SetBarrierRequest) 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_SetBarrierRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*SetBarrierRequest)
+ 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.BarrierId)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ l = len(x.NodeId)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.RunId != 0 {
+ n += 1 + runtime.Sov(uint64(x.RunId))
+ }
+ if x.OuterStep != 0 {
+ n += 1 + runtime.Sov(uint64(x.OuterStep))
+ }
+ 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().(*SetBarrierRequest)
+ 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.OuterStep != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.OuterStep))
+ i--
+ dAtA[i] = 0x20
+ }
+ if x.RunId != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.RunId))
+ i--
+ dAtA[i] = 0x18
+ }
+ 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] = 0x12
+ }
+ if len(x.BarrierId) > 0 {
+ i -= len(x.BarrierId)
+ copy(dAtA[i:], x.BarrierId)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.BarrierId)))
+ 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().(*SetBarrierRequest)
+ 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: SetBarrierRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: SetBarrierRequest: 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 BarrierId", 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.BarrierId = 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 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
+ case 3:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RunId", wireType)
+ }
+ x.RunId = 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.RunId |= 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 OuterStep", wireType)
+ }
+ x.OuterStep = 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.OuterStep |= 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,
+ Size: size,
+ Marshal: marshal,
+ Unmarshal: unmarshal,
+ Merge: nil,
+ CheckInitialized: nil,
+ }
+}
+
+var (
+ md_SetBarrierResponse protoreflect.MessageDescriptor
+ fd_SetBarrierResponse_status protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_network_node_proto_init()
+ md_SetBarrierResponse = File_inference_inference_network_node_proto.Messages().ByName("SetBarrierResponse")
+ fd_SetBarrierResponse_status = md_SetBarrierResponse.Fields().ByName("status")
+}
+
+var _ protoreflect.Message = (*fastReflection_SetBarrierResponse)(nil)
+
+type fastReflection_SetBarrierResponse SetBarrierResponse
+
+func (x *SetBarrierResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_SetBarrierResponse)(x)
+}
+
+func (x *SetBarrierResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_network_node_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_SetBarrierResponse_messageType fastReflection_SetBarrierResponse_messageType
+var _ protoreflect.MessageType = fastReflection_SetBarrierResponse_messageType{}
+
+type fastReflection_SetBarrierResponse_messageType struct{}
+
+func (x fastReflection_SetBarrierResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_SetBarrierResponse)(nil)
+}
+func (x fastReflection_SetBarrierResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_SetBarrierResponse)
+}
+func (x fastReflection_SetBarrierResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_SetBarrierResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_SetBarrierResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_SetBarrierResponse
+}
+
+// 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_SetBarrierResponse) Type() protoreflect.MessageType {
+ return _fastReflection_SetBarrierResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_SetBarrierResponse) New() protoreflect.Message {
+ return new(fastReflection_SetBarrierResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_SetBarrierResponse) Interface() protoreflect.ProtoMessage {
+ return (*SetBarrierResponse)(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_SetBarrierResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Status != 0 {
+ value := protoreflect.ValueOfEnum((protoreflect.EnumNumber)(x.Status))
+ if !f(fd_SetBarrierResponse_status, 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_SetBarrierResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.SetBarrierResponse.status":
+ return x.Status != 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.SetBarrierResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.SetBarrierResponse 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_SetBarrierResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.SetBarrierResponse.status":
+ x.Status = 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.SetBarrierResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.SetBarrierResponse 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_SetBarrierResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.SetBarrierResponse.status":
+ value := x.Status
+ return protoreflect.ValueOfEnum((protoreflect.EnumNumber)(value))
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.SetBarrierResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.SetBarrierResponse 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_SetBarrierResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.SetBarrierResponse.status":
+ x.Status = (BarrierStatusEnum)(value.Enum())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.SetBarrierResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.SetBarrierResponse 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_SetBarrierResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.SetBarrierResponse.status":
+ panic(fmt.Errorf("field status of message inference.inference.SetBarrierResponse is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.SetBarrierResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.SetBarrierResponse 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_SetBarrierResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.SetBarrierResponse.status":
+ return protoreflect.ValueOfEnum(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.SetBarrierResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.SetBarrierResponse 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_SetBarrierResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.SetBarrierResponse", 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_SetBarrierResponse) 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_SetBarrierResponse) 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_SetBarrierResponse) 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_SetBarrierResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*SetBarrierResponse)
+ 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.Status != 0 {
+ n += 1 + runtime.Sov(uint64(x.Status))
+ }
+ 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().(*SetBarrierResponse)
+ 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.Status != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.Status))
+ 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().(*SetBarrierResponse)
+ 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: SetBarrierResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: SetBarrierResponse: 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 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 |= BarrierStatusEnum(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_GetBarrierStatusRequest protoreflect.MessageDescriptor
+ fd_GetBarrierStatusRequest_barrier_id protoreflect.FieldDescriptor
+ fd_GetBarrierStatusRequest_run_id protoreflect.FieldDescriptor
+ fd_GetBarrierStatusRequest_outer_step protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_network_node_proto_init()
+ md_GetBarrierStatusRequest = File_inference_inference_network_node_proto.Messages().ByName("GetBarrierStatusRequest")
+ fd_GetBarrierStatusRequest_barrier_id = md_GetBarrierStatusRequest.Fields().ByName("barrier_id")
+ fd_GetBarrierStatusRequest_run_id = md_GetBarrierStatusRequest.Fields().ByName("run_id")
+ fd_GetBarrierStatusRequest_outer_step = md_GetBarrierStatusRequest.Fields().ByName("outer_step")
+}
+
+var _ protoreflect.Message = (*fastReflection_GetBarrierStatusRequest)(nil)
+
+type fastReflection_GetBarrierStatusRequest GetBarrierStatusRequest
+
+func (x *GetBarrierStatusRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_GetBarrierStatusRequest)(x)
+}
+
+func (x *GetBarrierStatusRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_network_node_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_GetBarrierStatusRequest_messageType fastReflection_GetBarrierStatusRequest_messageType
+var _ protoreflect.MessageType = fastReflection_GetBarrierStatusRequest_messageType{}
+
+type fastReflection_GetBarrierStatusRequest_messageType struct{}
+
+func (x fastReflection_GetBarrierStatusRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_GetBarrierStatusRequest)(nil)
+}
+func (x fastReflection_GetBarrierStatusRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_GetBarrierStatusRequest)
+}
+func (x fastReflection_GetBarrierStatusRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_GetBarrierStatusRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_GetBarrierStatusRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_GetBarrierStatusRequest
+}
+
+// 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_GetBarrierStatusRequest) Type() protoreflect.MessageType {
+ return _fastReflection_GetBarrierStatusRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_GetBarrierStatusRequest) New() protoreflect.Message {
+ return new(fastReflection_GetBarrierStatusRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_GetBarrierStatusRequest) Interface() protoreflect.ProtoMessage {
+ return (*GetBarrierStatusRequest)(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_GetBarrierStatusRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.BarrierId != "" {
+ value := protoreflect.ValueOfString(x.BarrierId)
+ if !f(fd_GetBarrierStatusRequest_barrier_id, value) {
+ return
+ }
+ }
+ if x.RunId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.RunId)
+ if !f(fd_GetBarrierStatusRequest_run_id, value) {
+ return
+ }
+ }
+ if x.OuterStep != int32(0) {
+ value := protoreflect.ValueOfInt32(x.OuterStep)
+ if !f(fd_GetBarrierStatusRequest_outer_step, 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_GetBarrierStatusRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.GetBarrierStatusRequest.barrier_id":
+ return x.BarrierId != ""
+ case "inference.inference.GetBarrierStatusRequest.run_id":
+ return x.RunId != uint64(0)
+ case "inference.inference.GetBarrierStatusRequest.outer_step":
+ return x.OuterStep != int32(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GetBarrierStatusRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.GetBarrierStatusRequest 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_GetBarrierStatusRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.GetBarrierStatusRequest.barrier_id":
+ x.BarrierId = ""
+ case "inference.inference.GetBarrierStatusRequest.run_id":
+ x.RunId = uint64(0)
+ case "inference.inference.GetBarrierStatusRequest.outer_step":
+ x.OuterStep = int32(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GetBarrierStatusRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.GetBarrierStatusRequest 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_GetBarrierStatusRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.GetBarrierStatusRequest.barrier_id":
+ value := x.BarrierId
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.GetBarrierStatusRequest.run_id":
+ value := x.RunId
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.GetBarrierStatusRequest.outer_step":
+ value := x.OuterStep
+ return protoreflect.ValueOfInt32(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GetBarrierStatusRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.GetBarrierStatusRequest 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_GetBarrierStatusRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.GetBarrierStatusRequest.barrier_id":
+ x.BarrierId = value.Interface().(string)
+ case "inference.inference.GetBarrierStatusRequest.run_id":
+ x.RunId = value.Uint()
+ case "inference.inference.GetBarrierStatusRequest.outer_step":
+ x.OuterStep = int32(value.Int())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GetBarrierStatusRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.GetBarrierStatusRequest 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_GetBarrierStatusRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.GetBarrierStatusRequest.barrier_id":
+ panic(fmt.Errorf("field barrier_id of message inference.inference.GetBarrierStatusRequest is not mutable"))
+ case "inference.inference.GetBarrierStatusRequest.run_id":
+ panic(fmt.Errorf("field run_id of message inference.inference.GetBarrierStatusRequest is not mutable"))
+ case "inference.inference.GetBarrierStatusRequest.outer_step":
+ panic(fmt.Errorf("field outer_step of message inference.inference.GetBarrierStatusRequest is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GetBarrierStatusRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.GetBarrierStatusRequest 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_GetBarrierStatusRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.GetBarrierStatusRequest.barrier_id":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.GetBarrierStatusRequest.run_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.GetBarrierStatusRequest.outer_step":
+ return protoreflect.ValueOfInt32(int32(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GetBarrierStatusRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.GetBarrierStatusRequest 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_GetBarrierStatusRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.GetBarrierStatusRequest", 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_GetBarrierStatusRequest) 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_GetBarrierStatusRequest) 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_GetBarrierStatusRequest) 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_GetBarrierStatusRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*GetBarrierStatusRequest)
+ 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.BarrierId)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.RunId != 0 {
+ n += 1 + runtime.Sov(uint64(x.RunId))
+ }
+ if x.OuterStep != 0 {
+ n += 1 + runtime.Sov(uint64(x.OuterStep))
+ }
+ 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().(*GetBarrierStatusRequest)
+ 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.OuterStep != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.OuterStep))
+ i--
+ dAtA[i] = 0x18
+ }
+ if x.RunId != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.RunId))
+ i--
+ dAtA[i] = 0x10
+ }
+ if len(x.BarrierId) > 0 {
+ i -= len(x.BarrierId)
+ copy(dAtA[i:], x.BarrierId)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.BarrierId)))
+ 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().(*GetBarrierStatusRequest)
+ 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: GetBarrierStatusRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: GetBarrierStatusRequest: 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 BarrierId", 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.BarrierId = 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 RunId", wireType)
+ }
+ x.RunId = 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.RunId |= 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 OuterStep", wireType)
+ }
+ x.OuterStep = 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.OuterStep |= 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,
+ Size: size,
+ Marshal: marshal,
+ Unmarshal: unmarshal,
+ Merge: nil,
+ CheckInitialized: nil,
+ }
+}
+
+var _ protoreflect.List = (*_GetBarrierStatusResponse_2_list)(nil)
+
+type _GetBarrierStatusResponse_2_list struct {
+ list *[]string
+}
+
+func (x *_GetBarrierStatusResponse_2_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_GetBarrierStatusResponse_2_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfString((*x.list)[i])
+}
+
+func (x *_GetBarrierStatusResponse_2_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.String()
+ concreteValue := valueUnwrapped
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_GetBarrierStatusResponse_2_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.String()
+ concreteValue := valueUnwrapped
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_GetBarrierStatusResponse_2_list) AppendMutable() protoreflect.Value {
+ panic(fmt.Errorf("AppendMutable can not be called on message GetBarrierStatusResponse at list field NotReady as it is not of Message kind"))
+}
+
+func (x *_GetBarrierStatusResponse_2_list) Truncate(n int) {
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_GetBarrierStatusResponse_2_list) NewElement() protoreflect.Value {
+ v := ""
+ return protoreflect.ValueOfString(v)
+}
+
+func (x *_GetBarrierStatusResponse_2_list) IsValid() bool {
+ return x.list != nil
+}
+
+var _ protoreflect.List = (*_GetBarrierStatusResponse_3_list)(nil)
+
+type _GetBarrierStatusResponse_3_list struct {
+ list *[]string
+}
+
+func (x *_GetBarrierStatusResponse_3_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_GetBarrierStatusResponse_3_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfString((*x.list)[i])
+}
+
+func (x *_GetBarrierStatusResponse_3_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.String()
+ concreteValue := valueUnwrapped
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_GetBarrierStatusResponse_3_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.String()
+ concreteValue := valueUnwrapped
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_GetBarrierStatusResponse_3_list) AppendMutable() protoreflect.Value {
+ panic(fmt.Errorf("AppendMutable can not be called on message GetBarrierStatusResponse at list field AliveNodes as it is not of Message kind"))
+}
+
+func (x *_GetBarrierStatusResponse_3_list) Truncate(n int) {
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_GetBarrierStatusResponse_3_list) NewElement() protoreflect.Value {
+ v := ""
+ return protoreflect.ValueOfString(v)
+}
+
+func (x *_GetBarrierStatusResponse_3_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_GetBarrierStatusResponse protoreflect.MessageDescriptor
+ fd_GetBarrierStatusResponse_all_ready protoreflect.FieldDescriptor
+ fd_GetBarrierStatusResponse_not_ready protoreflect.FieldDescriptor
+ fd_GetBarrierStatusResponse_alive_nodes protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_network_node_proto_init()
+ md_GetBarrierStatusResponse = File_inference_inference_network_node_proto.Messages().ByName("GetBarrierStatusResponse")
+ fd_GetBarrierStatusResponse_all_ready = md_GetBarrierStatusResponse.Fields().ByName("all_ready")
+ fd_GetBarrierStatusResponse_not_ready = md_GetBarrierStatusResponse.Fields().ByName("not_ready")
+ fd_GetBarrierStatusResponse_alive_nodes = md_GetBarrierStatusResponse.Fields().ByName("alive_nodes")
+}
+
+var _ protoreflect.Message = (*fastReflection_GetBarrierStatusResponse)(nil)
+
+type fastReflection_GetBarrierStatusResponse GetBarrierStatusResponse
+
+func (x *GetBarrierStatusResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_GetBarrierStatusResponse)(x)
+}
+
+func (x *GetBarrierStatusResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_network_node_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_GetBarrierStatusResponse_messageType fastReflection_GetBarrierStatusResponse_messageType
+var _ protoreflect.MessageType = fastReflection_GetBarrierStatusResponse_messageType{}
+
+type fastReflection_GetBarrierStatusResponse_messageType struct{}
+
+func (x fastReflection_GetBarrierStatusResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_GetBarrierStatusResponse)(nil)
+}
+func (x fastReflection_GetBarrierStatusResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_GetBarrierStatusResponse)
+}
+func (x fastReflection_GetBarrierStatusResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_GetBarrierStatusResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_GetBarrierStatusResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_GetBarrierStatusResponse
+}
+
+// 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_GetBarrierStatusResponse) Type() protoreflect.MessageType {
+ return _fastReflection_GetBarrierStatusResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_GetBarrierStatusResponse) New() protoreflect.Message {
+ return new(fastReflection_GetBarrierStatusResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_GetBarrierStatusResponse) Interface() protoreflect.ProtoMessage {
+ return (*GetBarrierStatusResponse)(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_GetBarrierStatusResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.AllReady != false {
+ value := protoreflect.ValueOfBool(x.AllReady)
+ if !f(fd_GetBarrierStatusResponse_all_ready, value) {
+ return
+ }
+ }
+ if len(x.NotReady) != 0 {
+ value := protoreflect.ValueOfList(&_GetBarrierStatusResponse_2_list{list: &x.NotReady})
+ if !f(fd_GetBarrierStatusResponse_not_ready, value) {
+ return
+ }
+ }
+ if len(x.AliveNodes) != 0 {
+ value := protoreflect.ValueOfList(&_GetBarrierStatusResponse_3_list{list: &x.AliveNodes})
+ if !f(fd_GetBarrierStatusResponse_alive_nodes, 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_GetBarrierStatusResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.GetBarrierStatusResponse.all_ready":
+ return x.AllReady != false
+ case "inference.inference.GetBarrierStatusResponse.not_ready":
+ return len(x.NotReady) != 0
+ case "inference.inference.GetBarrierStatusResponse.alive_nodes":
+ return len(x.AliveNodes) != 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GetBarrierStatusResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.GetBarrierStatusResponse 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_GetBarrierStatusResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.GetBarrierStatusResponse.all_ready":
+ x.AllReady = false
+ case "inference.inference.GetBarrierStatusResponse.not_ready":
+ x.NotReady = nil
+ case "inference.inference.GetBarrierStatusResponse.alive_nodes":
+ x.AliveNodes = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GetBarrierStatusResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.GetBarrierStatusResponse 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_GetBarrierStatusResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.GetBarrierStatusResponse.all_ready":
+ value := x.AllReady
+ return protoreflect.ValueOfBool(value)
+ case "inference.inference.GetBarrierStatusResponse.not_ready":
+ if len(x.NotReady) == 0 {
+ return protoreflect.ValueOfList(&_GetBarrierStatusResponse_2_list{})
+ }
+ listValue := &_GetBarrierStatusResponse_2_list{list: &x.NotReady}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.inference.GetBarrierStatusResponse.alive_nodes":
+ if len(x.AliveNodes) == 0 {
+ return protoreflect.ValueOfList(&_GetBarrierStatusResponse_3_list{})
+ }
+ listValue := &_GetBarrierStatusResponse_3_list{list: &x.AliveNodes}
+ return protoreflect.ValueOfList(listValue)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GetBarrierStatusResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.GetBarrierStatusResponse 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_GetBarrierStatusResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.GetBarrierStatusResponse.all_ready":
+ x.AllReady = value.Bool()
+ case "inference.inference.GetBarrierStatusResponse.not_ready":
+ lv := value.List()
+ clv := lv.(*_GetBarrierStatusResponse_2_list)
+ x.NotReady = *clv.list
+ case "inference.inference.GetBarrierStatusResponse.alive_nodes":
+ lv := value.List()
+ clv := lv.(*_GetBarrierStatusResponse_3_list)
+ x.AliveNodes = *clv.list
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GetBarrierStatusResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.GetBarrierStatusResponse 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_GetBarrierStatusResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.GetBarrierStatusResponse.not_ready":
+ if x.NotReady == nil {
+ x.NotReady = []string{}
+ }
+ value := &_GetBarrierStatusResponse_2_list{list: &x.NotReady}
+ return protoreflect.ValueOfList(value)
+ case "inference.inference.GetBarrierStatusResponse.alive_nodes":
+ if x.AliveNodes == nil {
+ x.AliveNodes = []string{}
+ }
+ value := &_GetBarrierStatusResponse_3_list{list: &x.AliveNodes}
+ return protoreflect.ValueOfList(value)
+ case "inference.inference.GetBarrierStatusResponse.all_ready":
+ panic(fmt.Errorf("field all_ready of message inference.inference.GetBarrierStatusResponse is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GetBarrierStatusResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.GetBarrierStatusResponse 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_GetBarrierStatusResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.GetBarrierStatusResponse.all_ready":
+ return protoreflect.ValueOfBool(false)
+ case "inference.inference.GetBarrierStatusResponse.not_ready":
+ list := []string{}
+ return protoreflect.ValueOfList(&_GetBarrierStatusResponse_2_list{list: &list})
+ case "inference.inference.GetBarrierStatusResponse.alive_nodes":
+ list := []string{}
+ return protoreflect.ValueOfList(&_GetBarrierStatusResponse_3_list{list: &list})
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GetBarrierStatusResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.GetBarrierStatusResponse 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_GetBarrierStatusResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.GetBarrierStatusResponse", 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_GetBarrierStatusResponse) 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_GetBarrierStatusResponse) 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_GetBarrierStatusResponse) 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_GetBarrierStatusResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*GetBarrierStatusResponse)
+ 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.AllReady {
+ n += 2
+ }
+ if len(x.NotReady) > 0 {
+ for _, s := range x.NotReady {
+ l = len(s)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ }
+ if len(x.AliveNodes) > 0 {
+ for _, s := range x.AliveNodes {
+ 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().(*GetBarrierStatusResponse)
+ 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.AliveNodes) > 0 {
+ for iNdEx := len(x.AliveNodes) - 1; iNdEx >= 0; iNdEx-- {
+ i -= len(x.AliveNodes[iNdEx])
+ copy(dAtA[i:], x.AliveNodes[iNdEx])
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.AliveNodes[iNdEx])))
+ i--
+ dAtA[i] = 0x1a
+ }
+ }
+ if len(x.NotReady) > 0 {
+ for iNdEx := len(x.NotReady) - 1; iNdEx >= 0; iNdEx-- {
+ i -= len(x.NotReady[iNdEx])
+ copy(dAtA[i:], x.NotReady[iNdEx])
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.NotReady[iNdEx])))
+ i--
+ dAtA[i] = 0x12
+ }
+ }
+ if x.AllReady {
+ i--
+ if x.AllReady {
+ 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().(*GetBarrierStatusResponse)
+ 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: GetBarrierStatusResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: GetBarrierStatusResponse: 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 AllReady", 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.AllReady = 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 NotReady", 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.NotReady = append(x.NotReady, 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 AliveNodes", 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.AliveNodes = append(x.AliveNodes, 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_SetStoreRecordRequest protoreflect.MessageDescriptor
+ fd_SetStoreRecordRequest_run_id protoreflect.FieldDescriptor
+ fd_SetStoreRecordRequest_record protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_network_node_proto_init()
+ md_SetStoreRecordRequest = File_inference_inference_network_node_proto.Messages().ByName("SetStoreRecordRequest")
+ fd_SetStoreRecordRequest_run_id = md_SetStoreRecordRequest.Fields().ByName("run_id")
+ fd_SetStoreRecordRequest_record = md_SetStoreRecordRequest.Fields().ByName("record")
+}
+
+var _ protoreflect.Message = (*fastReflection_SetStoreRecordRequest)(nil)
+
+type fastReflection_SetStoreRecordRequest SetStoreRecordRequest
+
+func (x *SetStoreRecordRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_SetStoreRecordRequest)(x)
+}
+
+func (x *SetStoreRecordRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_network_node_proto_msgTypes[10]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_SetStoreRecordRequest_messageType fastReflection_SetStoreRecordRequest_messageType
+var _ protoreflect.MessageType = fastReflection_SetStoreRecordRequest_messageType{}
+
+type fastReflection_SetStoreRecordRequest_messageType struct{}
+
+func (x fastReflection_SetStoreRecordRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_SetStoreRecordRequest)(nil)
+}
+func (x fastReflection_SetStoreRecordRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_SetStoreRecordRequest)
+}
+func (x fastReflection_SetStoreRecordRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_SetStoreRecordRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_SetStoreRecordRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_SetStoreRecordRequest
+}
+
+// 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_SetStoreRecordRequest) Type() protoreflect.MessageType {
+ return _fastReflection_SetStoreRecordRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_SetStoreRecordRequest) New() protoreflect.Message {
+ return new(fastReflection_SetStoreRecordRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_SetStoreRecordRequest) Interface() protoreflect.ProtoMessage {
+ return (*SetStoreRecordRequest)(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_SetStoreRecordRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.RunId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.RunId)
+ if !f(fd_SetStoreRecordRequest_run_id, value) {
+ return
+ }
+ }
+ if x.Record != nil {
+ value := protoreflect.ValueOfMessage(x.Record.ProtoReflect())
+ if !f(fd_SetStoreRecordRequest_record, 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_SetStoreRecordRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.SetStoreRecordRequest.run_id":
+ return x.RunId != uint64(0)
+ case "inference.inference.SetStoreRecordRequest.record":
+ return x.Record != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.SetStoreRecordRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.SetStoreRecordRequest 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_SetStoreRecordRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.SetStoreRecordRequest.run_id":
+ x.RunId = uint64(0)
+ case "inference.inference.SetStoreRecordRequest.record":
+ x.Record = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.SetStoreRecordRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.SetStoreRecordRequest 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_SetStoreRecordRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.SetStoreRecordRequest.run_id":
+ value := x.RunId
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.SetStoreRecordRequest.record":
+ value := x.Record
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.SetStoreRecordRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.SetStoreRecordRequest 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_SetStoreRecordRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.SetStoreRecordRequest.run_id":
+ x.RunId = value.Uint()
+ case "inference.inference.SetStoreRecordRequest.record":
+ x.Record = value.Message().Interface().(*Record)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.SetStoreRecordRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.SetStoreRecordRequest 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_SetStoreRecordRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.SetStoreRecordRequest.record":
+ if x.Record == nil {
+ x.Record = new(Record)
+ }
+ return protoreflect.ValueOfMessage(x.Record.ProtoReflect())
+ case "inference.inference.SetStoreRecordRequest.run_id":
+ panic(fmt.Errorf("field run_id of message inference.inference.SetStoreRecordRequest is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.SetStoreRecordRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.SetStoreRecordRequest 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_SetStoreRecordRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.SetStoreRecordRequest.run_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.SetStoreRecordRequest.record":
+ m := new(Record)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.SetStoreRecordRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.SetStoreRecordRequest 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_SetStoreRecordRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.SetStoreRecordRequest", 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_SetStoreRecordRequest) 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_SetStoreRecordRequest) 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_SetStoreRecordRequest) 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_SetStoreRecordRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*SetStoreRecordRequest)
+ 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.RunId != 0 {
+ n += 1 + runtime.Sov(uint64(x.RunId))
+ }
+ if x.Record != nil {
+ l = options.Size(x.Record)
+ 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().(*SetStoreRecordRequest)
+ 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.Record != nil {
+ encoded, err := options.Marshal(x.Record)
+ 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.RunId != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.RunId))
+ 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().(*SetStoreRecordRequest)
+ 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: SetStoreRecordRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: SetStoreRecordRequest: 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 RunId", wireType)
+ }
+ x.RunId = 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.RunId |= 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 Record", 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.Record == nil {
+ x.Record = &Record{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Record); 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_Record protoreflect.MessageDescriptor
+ fd_Record_key protoreflect.FieldDescriptor
+ fd_Record_value protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_network_node_proto_init()
+ md_Record = File_inference_inference_network_node_proto.Messages().ByName("Record")
+ fd_Record_key = md_Record.Fields().ByName("key")
+ fd_Record_value = md_Record.Fields().ByName("value")
+}
+
+var _ protoreflect.Message = (*fastReflection_Record)(nil)
+
+type fastReflection_Record Record
+
+func (x *Record) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_Record)(x)
+}
+
+func (x *Record) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_network_node_proto_msgTypes[11]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_Record_messageType fastReflection_Record_messageType
+var _ protoreflect.MessageType = fastReflection_Record_messageType{}
+
+type fastReflection_Record_messageType struct{}
+
+func (x fastReflection_Record_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_Record)(nil)
+}
+func (x fastReflection_Record_messageType) New() protoreflect.Message {
+ return new(fastReflection_Record)
+}
+func (x fastReflection_Record_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_Record
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_Record) Descriptor() protoreflect.MessageDescriptor {
+ return md_Record
+}
+
+// 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_Record) Type() protoreflect.MessageType {
+ return _fastReflection_Record_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_Record) New() protoreflect.Message {
+ return new(fastReflection_Record)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_Record) Interface() protoreflect.ProtoMessage {
+ return (*Record)(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_Record) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Key != "" {
+ value := protoreflect.ValueOfString(x.Key)
+ if !f(fd_Record_key, value) {
+ return
+ }
+ }
+ if x.Value != "" {
+ value := protoreflect.ValueOfString(x.Value)
+ if !f(fd_Record_value, 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_Record) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.Record.key":
+ return x.Key != ""
+ case "inference.inference.Record.value":
+ return x.Value != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Record"))
+ }
+ panic(fmt.Errorf("message inference.inference.Record 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_Record) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.Record.key":
+ x.Key = ""
+ case "inference.inference.Record.value":
+ x.Value = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Record"))
+ }
+ panic(fmt.Errorf("message inference.inference.Record 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_Record) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.Record.key":
+ value := x.Key
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.Record.value":
+ value := x.Value
+ return protoreflect.ValueOfString(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Record"))
+ }
+ panic(fmt.Errorf("message inference.inference.Record 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_Record) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.Record.key":
+ x.Key = value.Interface().(string)
+ case "inference.inference.Record.value":
+ x.Value = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Record"))
+ }
+ panic(fmt.Errorf("message inference.inference.Record 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_Record) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.Record.key":
+ panic(fmt.Errorf("field key of message inference.inference.Record is not mutable"))
+ case "inference.inference.Record.value":
+ panic(fmt.Errorf("field value of message inference.inference.Record is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Record"))
+ }
+ panic(fmt.Errorf("message inference.inference.Record 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_Record) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.Record.key":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.Record.value":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Record"))
+ }
+ panic(fmt.Errorf("message inference.inference.Record 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_Record) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.Record", 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_Record) 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_Record) 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_Record) 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_Record) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*Record)
+ 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.Key)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ l = len(x.Value)
+ 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().(*Record)
+ 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.Value) > 0 {
+ i -= len(x.Value)
+ copy(dAtA[i:], x.Value)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Value)))
+ i--
+ dAtA[i] = 0x12
+ }
+ if len(x.Key) > 0 {
+ i -= len(x.Key)
+ copy(dAtA[i:], x.Key)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Key)))
+ 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().(*Record)
+ 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: Record: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Record: 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 Key", 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.Key = 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 Value", 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.Value = 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_SetStoreRecordResponse protoreflect.MessageDescriptor
+ fd_SetStoreRecordResponse_status protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_network_node_proto_init()
+ md_SetStoreRecordResponse = File_inference_inference_network_node_proto.Messages().ByName("SetStoreRecordResponse")
+ fd_SetStoreRecordResponse_status = md_SetStoreRecordResponse.Fields().ByName("status")
+}
+
+var _ protoreflect.Message = (*fastReflection_SetStoreRecordResponse)(nil)
+
+type fastReflection_SetStoreRecordResponse SetStoreRecordResponse
+
+func (x *SetStoreRecordResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_SetStoreRecordResponse)(x)
+}
+
+func (x *SetStoreRecordResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_network_node_proto_msgTypes[12]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_SetStoreRecordResponse_messageType fastReflection_SetStoreRecordResponse_messageType
+var _ protoreflect.MessageType = fastReflection_SetStoreRecordResponse_messageType{}
+
+type fastReflection_SetStoreRecordResponse_messageType struct{}
+
+func (x fastReflection_SetStoreRecordResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_SetStoreRecordResponse)(nil)
+}
+func (x fastReflection_SetStoreRecordResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_SetStoreRecordResponse)
+}
+func (x fastReflection_SetStoreRecordResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_SetStoreRecordResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_SetStoreRecordResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_SetStoreRecordResponse
+}
+
+// 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_SetStoreRecordResponse) Type() protoreflect.MessageType {
+ return _fastReflection_SetStoreRecordResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_SetStoreRecordResponse) New() protoreflect.Message {
+ return new(fastReflection_SetStoreRecordResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_SetStoreRecordResponse) Interface() protoreflect.ProtoMessage {
+ return (*SetStoreRecordResponse)(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_SetStoreRecordResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Status != 0 {
+ value := protoreflect.ValueOfEnum((protoreflect.EnumNumber)(x.Status))
+ if !f(fd_SetStoreRecordResponse_status, 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_SetStoreRecordResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.SetStoreRecordResponse.status":
+ return x.Status != 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.SetStoreRecordResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.SetStoreRecordResponse 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_SetStoreRecordResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.SetStoreRecordResponse.status":
+ x.Status = 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.SetStoreRecordResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.SetStoreRecordResponse 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_SetStoreRecordResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.SetStoreRecordResponse.status":
+ value := x.Status
+ return protoreflect.ValueOfEnum((protoreflect.EnumNumber)(value))
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.SetStoreRecordResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.SetStoreRecordResponse 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_SetStoreRecordResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.SetStoreRecordResponse.status":
+ x.Status = (StoreRecordStatusEnum)(value.Enum())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.SetStoreRecordResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.SetStoreRecordResponse 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_SetStoreRecordResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.SetStoreRecordResponse.status":
+ panic(fmt.Errorf("field status of message inference.inference.SetStoreRecordResponse is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.SetStoreRecordResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.SetStoreRecordResponse 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_SetStoreRecordResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.SetStoreRecordResponse.status":
+ return protoreflect.ValueOfEnum(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.SetStoreRecordResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.SetStoreRecordResponse 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_SetStoreRecordResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.SetStoreRecordResponse", 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_SetStoreRecordResponse) 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_SetStoreRecordResponse) 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_SetStoreRecordResponse) 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_SetStoreRecordResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*SetStoreRecordResponse)
+ 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.Status != 0 {
+ n += 1 + runtime.Sov(uint64(x.Status))
+ }
+ 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().(*SetStoreRecordResponse)
+ 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.Status != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.Status))
+ 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().(*SetStoreRecordResponse)
+ 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: SetStoreRecordResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: SetStoreRecordResponse: 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 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 |= StoreRecordStatusEnum(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_GetStoreRecordRequest protoreflect.MessageDescriptor
+ fd_GetStoreRecordRequest_run_id protoreflect.FieldDescriptor
+ fd_GetStoreRecordRequest_key protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_network_node_proto_init()
+ md_GetStoreRecordRequest = File_inference_inference_network_node_proto.Messages().ByName("GetStoreRecordRequest")
+ fd_GetStoreRecordRequest_run_id = md_GetStoreRecordRequest.Fields().ByName("run_id")
+ fd_GetStoreRecordRequest_key = md_GetStoreRecordRequest.Fields().ByName("key")
+}
+
+var _ protoreflect.Message = (*fastReflection_GetStoreRecordRequest)(nil)
+
+type fastReflection_GetStoreRecordRequest GetStoreRecordRequest
+
+func (x *GetStoreRecordRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_GetStoreRecordRequest)(x)
+}
+
+func (x *GetStoreRecordRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_network_node_proto_msgTypes[13]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_GetStoreRecordRequest_messageType fastReflection_GetStoreRecordRequest_messageType
+var _ protoreflect.MessageType = fastReflection_GetStoreRecordRequest_messageType{}
+
+type fastReflection_GetStoreRecordRequest_messageType struct{}
+
+func (x fastReflection_GetStoreRecordRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_GetStoreRecordRequest)(nil)
+}
+func (x fastReflection_GetStoreRecordRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_GetStoreRecordRequest)
+}
+func (x fastReflection_GetStoreRecordRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_GetStoreRecordRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_GetStoreRecordRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_GetStoreRecordRequest
+}
+
+// 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_GetStoreRecordRequest) Type() protoreflect.MessageType {
+ return _fastReflection_GetStoreRecordRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_GetStoreRecordRequest) New() protoreflect.Message {
+ return new(fastReflection_GetStoreRecordRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_GetStoreRecordRequest) Interface() protoreflect.ProtoMessage {
+ return (*GetStoreRecordRequest)(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_GetStoreRecordRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.RunId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.RunId)
+ if !f(fd_GetStoreRecordRequest_run_id, value) {
+ return
+ }
+ }
+ if x.Key != "" {
+ value := protoreflect.ValueOfString(x.Key)
+ if !f(fd_GetStoreRecordRequest_key, 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_GetStoreRecordRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.GetStoreRecordRequest.run_id":
+ return x.RunId != uint64(0)
+ case "inference.inference.GetStoreRecordRequest.key":
+ return x.Key != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GetStoreRecordRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.GetStoreRecordRequest 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_GetStoreRecordRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.GetStoreRecordRequest.run_id":
+ x.RunId = uint64(0)
+ case "inference.inference.GetStoreRecordRequest.key":
+ x.Key = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GetStoreRecordRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.GetStoreRecordRequest 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_GetStoreRecordRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.GetStoreRecordRequest.run_id":
+ value := x.RunId
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.GetStoreRecordRequest.key":
+ value := x.Key
+ return protoreflect.ValueOfString(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GetStoreRecordRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.GetStoreRecordRequest 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_GetStoreRecordRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.GetStoreRecordRequest.run_id":
+ x.RunId = value.Uint()
+ case "inference.inference.GetStoreRecordRequest.key":
+ x.Key = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GetStoreRecordRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.GetStoreRecordRequest 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_GetStoreRecordRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.GetStoreRecordRequest.run_id":
+ panic(fmt.Errorf("field run_id of message inference.inference.GetStoreRecordRequest is not mutable"))
+ case "inference.inference.GetStoreRecordRequest.key":
+ panic(fmt.Errorf("field key of message inference.inference.GetStoreRecordRequest is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GetStoreRecordRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.GetStoreRecordRequest 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_GetStoreRecordRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.GetStoreRecordRequest.run_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.GetStoreRecordRequest.key":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GetStoreRecordRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.GetStoreRecordRequest 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_GetStoreRecordRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.GetStoreRecordRequest", 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_GetStoreRecordRequest) 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_GetStoreRecordRequest) 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_GetStoreRecordRequest) 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_GetStoreRecordRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*GetStoreRecordRequest)
+ 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.RunId != 0 {
+ n += 1 + runtime.Sov(uint64(x.RunId))
+ }
+ l = len(x.Key)
+ 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().(*GetStoreRecordRequest)
+ 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.Key) > 0 {
+ i -= len(x.Key)
+ copy(dAtA[i:], x.Key)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Key)))
+ i--
+ dAtA[i] = 0x12
+ }
+ if x.RunId != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.RunId))
+ 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().(*GetStoreRecordRequest)
+ 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: GetStoreRecordRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: GetStoreRecordRequest: 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 RunId", wireType)
+ }
+ x.RunId = 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.RunId |= 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 Key", 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.Key = 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_GetStoreRecordResponse protoreflect.MessageDescriptor
+ fd_GetStoreRecordResponse_record protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_network_node_proto_init()
+ md_GetStoreRecordResponse = File_inference_inference_network_node_proto.Messages().ByName("GetStoreRecordResponse")
+ fd_GetStoreRecordResponse_record = md_GetStoreRecordResponse.Fields().ByName("record")
+}
+
+var _ protoreflect.Message = (*fastReflection_GetStoreRecordResponse)(nil)
+
+type fastReflection_GetStoreRecordResponse GetStoreRecordResponse
+
+func (x *GetStoreRecordResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_GetStoreRecordResponse)(x)
+}
+
+func (x *GetStoreRecordResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_network_node_proto_msgTypes[14]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_GetStoreRecordResponse_messageType fastReflection_GetStoreRecordResponse_messageType
+var _ protoreflect.MessageType = fastReflection_GetStoreRecordResponse_messageType{}
+
+type fastReflection_GetStoreRecordResponse_messageType struct{}
+
+func (x fastReflection_GetStoreRecordResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_GetStoreRecordResponse)(nil)
+}
+func (x fastReflection_GetStoreRecordResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_GetStoreRecordResponse)
+}
+func (x fastReflection_GetStoreRecordResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_GetStoreRecordResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_GetStoreRecordResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_GetStoreRecordResponse
+}
+
+// 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_GetStoreRecordResponse) Type() protoreflect.MessageType {
+ return _fastReflection_GetStoreRecordResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_GetStoreRecordResponse) New() protoreflect.Message {
+ return new(fastReflection_GetStoreRecordResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_GetStoreRecordResponse) Interface() protoreflect.ProtoMessage {
+ return (*GetStoreRecordResponse)(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_GetStoreRecordResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Record != nil {
+ value := protoreflect.ValueOfMessage(x.Record.ProtoReflect())
+ if !f(fd_GetStoreRecordResponse_record, 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_GetStoreRecordResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.GetStoreRecordResponse.record":
+ return x.Record != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GetStoreRecordResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.GetStoreRecordResponse 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_GetStoreRecordResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.GetStoreRecordResponse.record":
+ x.Record = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GetStoreRecordResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.GetStoreRecordResponse 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_GetStoreRecordResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.GetStoreRecordResponse.record":
+ value := x.Record
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GetStoreRecordResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.GetStoreRecordResponse 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_GetStoreRecordResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.GetStoreRecordResponse.record":
+ x.Record = value.Message().Interface().(*Record)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GetStoreRecordResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.GetStoreRecordResponse 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_GetStoreRecordResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.GetStoreRecordResponse.record":
+ if x.Record == nil {
+ x.Record = new(Record)
+ }
+ return protoreflect.ValueOfMessage(x.Record.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GetStoreRecordResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.GetStoreRecordResponse 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_GetStoreRecordResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.GetStoreRecordResponse.record":
+ m := new(Record)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GetStoreRecordResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.GetStoreRecordResponse 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_GetStoreRecordResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.GetStoreRecordResponse", 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_GetStoreRecordResponse) 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_GetStoreRecordResponse) 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_GetStoreRecordResponse) 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_GetStoreRecordResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*GetStoreRecordResponse)
+ 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.Record != nil {
+ l = options.Size(x.Record)
+ 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().(*GetStoreRecordResponse)
+ 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.Record != nil {
+ encoded, err := options.Marshal(x.Record)
+ 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().(*GetStoreRecordResponse)
+ 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: GetStoreRecordResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: GetStoreRecordResponse: 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 Record", 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.Record == nil {
+ x.Record = &Record{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Record); 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_StoreListKeysRequest protoreflect.MessageDescriptor
+ fd_StoreListKeysRequest_run_id protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_network_node_proto_init()
+ md_StoreListKeysRequest = File_inference_inference_network_node_proto.Messages().ByName("StoreListKeysRequest")
+ fd_StoreListKeysRequest_run_id = md_StoreListKeysRequest.Fields().ByName("run_id")
+}
+
+var _ protoreflect.Message = (*fastReflection_StoreListKeysRequest)(nil)
+
+type fastReflection_StoreListKeysRequest StoreListKeysRequest
+
+func (x *StoreListKeysRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_StoreListKeysRequest)(x)
+}
+
+func (x *StoreListKeysRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_network_node_proto_msgTypes[15]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_StoreListKeysRequest_messageType fastReflection_StoreListKeysRequest_messageType
+var _ protoreflect.MessageType = fastReflection_StoreListKeysRequest_messageType{}
+
+type fastReflection_StoreListKeysRequest_messageType struct{}
+
+func (x fastReflection_StoreListKeysRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_StoreListKeysRequest)(nil)
+}
+func (x fastReflection_StoreListKeysRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_StoreListKeysRequest)
+}
+func (x fastReflection_StoreListKeysRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_StoreListKeysRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_StoreListKeysRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_StoreListKeysRequest
+}
+
+// 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_StoreListKeysRequest) Type() protoreflect.MessageType {
+ return _fastReflection_StoreListKeysRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_StoreListKeysRequest) New() protoreflect.Message {
+ return new(fastReflection_StoreListKeysRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_StoreListKeysRequest) Interface() protoreflect.ProtoMessage {
+ return (*StoreListKeysRequest)(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_StoreListKeysRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.RunId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.RunId)
+ if !f(fd_StoreListKeysRequest_run_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_StoreListKeysRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.StoreListKeysRequest.run_id":
+ return x.RunId != uint64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.StoreListKeysRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.StoreListKeysRequest 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_StoreListKeysRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.StoreListKeysRequest.run_id":
+ x.RunId = uint64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.StoreListKeysRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.StoreListKeysRequest 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_StoreListKeysRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.StoreListKeysRequest.run_id":
+ value := x.RunId
+ return protoreflect.ValueOfUint64(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.StoreListKeysRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.StoreListKeysRequest 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_StoreListKeysRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.StoreListKeysRequest.run_id":
+ x.RunId = value.Uint()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.StoreListKeysRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.StoreListKeysRequest 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_StoreListKeysRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.StoreListKeysRequest.run_id":
+ panic(fmt.Errorf("field run_id of message inference.inference.StoreListKeysRequest is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.StoreListKeysRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.StoreListKeysRequest 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_StoreListKeysRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.StoreListKeysRequest.run_id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.StoreListKeysRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.StoreListKeysRequest 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_StoreListKeysRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.StoreListKeysRequest", 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_StoreListKeysRequest) 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_StoreListKeysRequest) 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_StoreListKeysRequest) 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_StoreListKeysRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*StoreListKeysRequest)
+ 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.RunId != 0 {
+ n += 1 + runtime.Sov(uint64(x.RunId))
+ }
+ 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().(*StoreListKeysRequest)
+ 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.RunId != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.RunId))
+ 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().(*StoreListKeysRequest)
+ 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: StoreListKeysRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: StoreListKeysRequest: 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 RunId", wireType)
+ }
+ x.RunId = 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.RunId |= 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 _ protoreflect.List = (*_StoreListKeysResponse_1_list)(nil)
+
+type _StoreListKeysResponse_1_list struct {
+ list *[]string
+}
+
+func (x *_StoreListKeysResponse_1_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_StoreListKeysResponse_1_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfString((*x.list)[i])
+}
+
+func (x *_StoreListKeysResponse_1_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.String()
+ concreteValue := valueUnwrapped
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_StoreListKeysResponse_1_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.String()
+ concreteValue := valueUnwrapped
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_StoreListKeysResponse_1_list) AppendMutable() protoreflect.Value {
+ panic(fmt.Errorf("AppendMutable can not be called on message StoreListKeysResponse at list field Keys as it is not of Message kind"))
+}
+
+func (x *_StoreListKeysResponse_1_list) Truncate(n int) {
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_StoreListKeysResponse_1_list) NewElement() protoreflect.Value {
+ v := ""
+ return protoreflect.ValueOfString(v)
+}
+
+func (x *_StoreListKeysResponse_1_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_StoreListKeysResponse protoreflect.MessageDescriptor
+ fd_StoreListKeysResponse_keys protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_network_node_proto_init()
+ md_StoreListKeysResponse = File_inference_inference_network_node_proto.Messages().ByName("StoreListKeysResponse")
+ fd_StoreListKeysResponse_keys = md_StoreListKeysResponse.Fields().ByName("keys")
+}
+
+var _ protoreflect.Message = (*fastReflection_StoreListKeysResponse)(nil)
+
+type fastReflection_StoreListKeysResponse StoreListKeysResponse
+
+func (x *StoreListKeysResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_StoreListKeysResponse)(x)
+}
+
+func (x *StoreListKeysResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_network_node_proto_msgTypes[16]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_StoreListKeysResponse_messageType fastReflection_StoreListKeysResponse_messageType
+var _ protoreflect.MessageType = fastReflection_StoreListKeysResponse_messageType{}
+
+type fastReflection_StoreListKeysResponse_messageType struct{}
+
+func (x fastReflection_StoreListKeysResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_StoreListKeysResponse)(nil)
+}
+func (x fastReflection_StoreListKeysResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_StoreListKeysResponse)
+}
+func (x fastReflection_StoreListKeysResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_StoreListKeysResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_StoreListKeysResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_StoreListKeysResponse
+}
+
+// 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_StoreListKeysResponse) Type() protoreflect.MessageType {
+ return _fastReflection_StoreListKeysResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_StoreListKeysResponse) New() protoreflect.Message {
+ return new(fastReflection_StoreListKeysResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_StoreListKeysResponse) Interface() protoreflect.ProtoMessage {
+ return (*StoreListKeysResponse)(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_StoreListKeysResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if len(x.Keys) != 0 {
+ value := protoreflect.ValueOfList(&_StoreListKeysResponse_1_list{list: &x.Keys})
+ if !f(fd_StoreListKeysResponse_keys, 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_StoreListKeysResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.StoreListKeysResponse.keys":
+ return len(x.Keys) != 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.StoreListKeysResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.StoreListKeysResponse 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_StoreListKeysResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.StoreListKeysResponse.keys":
+ x.Keys = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.StoreListKeysResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.StoreListKeysResponse 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_StoreListKeysResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.StoreListKeysResponse.keys":
+ if len(x.Keys) == 0 {
+ return protoreflect.ValueOfList(&_StoreListKeysResponse_1_list{})
+ }
+ listValue := &_StoreListKeysResponse_1_list{list: &x.Keys}
+ return protoreflect.ValueOfList(listValue)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.StoreListKeysResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.StoreListKeysResponse 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_StoreListKeysResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.StoreListKeysResponse.keys":
+ lv := value.List()
+ clv := lv.(*_StoreListKeysResponse_1_list)
+ x.Keys = *clv.list
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.StoreListKeysResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.StoreListKeysResponse 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_StoreListKeysResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.StoreListKeysResponse.keys":
+ if x.Keys == nil {
+ x.Keys = []string{}
+ }
+ value := &_StoreListKeysResponse_1_list{list: &x.Keys}
+ return protoreflect.ValueOfList(value)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.StoreListKeysResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.StoreListKeysResponse 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_StoreListKeysResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.StoreListKeysResponse.keys":
+ list := []string{}
+ return protoreflect.ValueOfList(&_StoreListKeysResponse_1_list{list: &list})
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.StoreListKeysResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.StoreListKeysResponse 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_StoreListKeysResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.StoreListKeysResponse", 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_StoreListKeysResponse) 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_StoreListKeysResponse) 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_StoreListKeysResponse) 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_StoreListKeysResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*StoreListKeysResponse)
+ 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.Keys) > 0 {
+ for _, s := range x.Keys {
+ 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().(*StoreListKeysResponse)
+ 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.Keys) > 0 {
+ for iNdEx := len(x.Keys) - 1; iNdEx >= 0; iNdEx-- {
+ i -= len(x.Keys[iNdEx])
+ copy(dAtA[i:], x.Keys[iNdEx])
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Keys[iNdEx])))
+ 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().(*StoreListKeysResponse)
+ 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: StoreListKeysResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: StoreListKeysResponse: 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 Keys", 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.Keys = append(x.Keys, 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/network_node.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)
+)
+
+type MLNodeTrainStatusEnum int32
+
+const (
+ MLNodeTrainStatusEnum_OK MLNodeTrainStatusEnum = 0
+ MLNodeTrainStatusEnum_ERROR MLNodeTrainStatusEnum = 1
+ MLNodeTrainStatusEnum_JOINED MLNodeTrainStatusEnum = 2
+ MLNodeTrainStatusEnum_NOT_JOINED MLNodeTrainStatusEnum = 3
+)
+
+// Enum value maps for MLNodeTrainStatusEnum.
+var (
+ MLNodeTrainStatusEnum_name = map[int32]string{
+ 0: "OK",
+ 1: "ERROR",
+ 2: "JOINED",
+ 3: "NOT_JOINED",
+ }
+ MLNodeTrainStatusEnum_value = map[string]int32{
+ "OK": 0,
+ "ERROR": 1,
+ "JOINED": 2,
+ "NOT_JOINED": 3,
+ }
+)
+
+func (x MLNodeTrainStatusEnum) Enum() *MLNodeTrainStatusEnum {
+ p := new(MLNodeTrainStatusEnum)
+ *p = x
+ return p
+}
+
+func (x MLNodeTrainStatusEnum) String() string {
+ return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (MLNodeTrainStatusEnum) Descriptor() protoreflect.EnumDescriptor {
+ return file_inference_inference_network_node_proto_enumTypes[0].Descriptor()
+}
+
+func (MLNodeTrainStatusEnum) Type() protoreflect.EnumType {
+ return &file_inference_inference_network_node_proto_enumTypes[0]
+}
+
+func (x MLNodeTrainStatusEnum) Number() protoreflect.EnumNumber {
+ return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use MLNodeTrainStatusEnum.Descriptor instead.
+func (MLNodeTrainStatusEnum) EnumDescriptor() ([]byte, []int) {
+ return file_inference_inference_network_node_proto_rawDescGZIP(), []int{0}
+}
+
+type HeartbeatStatusEnum int32
+
+const (
+ HeartbeatStatusEnum_HEARTBEAT_OK HeartbeatStatusEnum = 0
+ HeartbeatStatusEnum_HEARTBEAT_ERROR HeartbeatStatusEnum = 1
+)
+
+// Enum value maps for HeartbeatStatusEnum.
+var (
+ HeartbeatStatusEnum_name = map[int32]string{
+ 0: "HEARTBEAT_OK",
+ 1: "HEARTBEAT_ERROR",
+ }
+ HeartbeatStatusEnum_value = map[string]int32{
+ "HEARTBEAT_OK": 0,
+ "HEARTBEAT_ERROR": 1,
+ }
+)
+
+func (x HeartbeatStatusEnum) Enum() *HeartbeatStatusEnum {
+ p := new(HeartbeatStatusEnum)
+ *p = x
+ return p
+}
+
+func (x HeartbeatStatusEnum) String() string {
+ return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (HeartbeatStatusEnum) Descriptor() protoreflect.EnumDescriptor {
+ return file_inference_inference_network_node_proto_enumTypes[1].Descriptor()
+}
+
+func (HeartbeatStatusEnum) Type() protoreflect.EnumType {
+ return &file_inference_inference_network_node_proto_enumTypes[1]
+}
+
+func (x HeartbeatStatusEnum) Number() protoreflect.EnumNumber {
+ return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use HeartbeatStatusEnum.Descriptor instead.
+func (HeartbeatStatusEnum) EnumDescriptor() ([]byte, []int) {
+ return file_inference_inference_network_node_proto_rawDescGZIP(), []int{1}
+}
+
+type BarrierStatusEnum int32
+
+const (
+ BarrierStatusEnum_READY BarrierStatusEnum = 0
+ BarrierStatusEnum_NOT_READY BarrierStatusEnum = 1
+)
+
+// Enum value maps for BarrierStatusEnum.
+var (
+ BarrierStatusEnum_name = map[int32]string{
+ 0: "READY",
+ 1: "NOT_READY",
+ }
+ BarrierStatusEnum_value = map[string]int32{
+ "READY": 0,
+ "NOT_READY": 1,
+ }
+)
+
+func (x BarrierStatusEnum) Enum() *BarrierStatusEnum {
+ p := new(BarrierStatusEnum)
+ *p = x
+ return p
+}
+
+func (x BarrierStatusEnum) String() string {
+ return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (BarrierStatusEnum) Descriptor() protoreflect.EnumDescriptor {
+ return file_inference_inference_network_node_proto_enumTypes[2].Descriptor()
+}
+
+func (BarrierStatusEnum) Type() protoreflect.EnumType {
+ return &file_inference_inference_network_node_proto_enumTypes[2]
+}
+
+func (x BarrierStatusEnum) Number() protoreflect.EnumNumber {
+ return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use BarrierStatusEnum.Descriptor instead.
+func (BarrierStatusEnum) EnumDescriptor() ([]byte, []int) {
+ return file_inference_inference_network_node_proto_rawDescGZIP(), []int{2}
+}
+
+type StoreRecordStatusEnum int32
+
+const (
+ StoreRecordStatusEnum_SET_RECORD_OK StoreRecordStatusEnum = 0
+ StoreRecordStatusEnum_SET_RECORD_ERROR StoreRecordStatusEnum = 1
+)
+
+// Enum value maps for StoreRecordStatusEnum.
+var (
+ StoreRecordStatusEnum_name = map[int32]string{
+ 0: "SET_RECORD_OK",
+ 1: "SET_RECORD_ERROR",
+ }
+ StoreRecordStatusEnum_value = map[string]int32{
+ "SET_RECORD_OK": 0,
+ "SET_RECORD_ERROR": 1,
+ }
+)
+
+func (x StoreRecordStatusEnum) Enum() *StoreRecordStatusEnum {
+ p := new(StoreRecordStatusEnum)
+ *p = x
+ return p
+}
+
+func (x StoreRecordStatusEnum) String() string {
+ return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (StoreRecordStatusEnum) Descriptor() protoreflect.EnumDescriptor {
+ return file_inference_inference_network_node_proto_enumTypes[3].Descriptor()
+}
+
+func (StoreRecordStatusEnum) Type() protoreflect.EnumType {
+ return &file_inference_inference_network_node_proto_enumTypes[3]
+}
+
+func (x StoreRecordStatusEnum) Number() protoreflect.EnumNumber {
+ return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use StoreRecordStatusEnum.Descriptor instead.
+func (StoreRecordStatusEnum) EnumDescriptor() ([]byte, []int) {
+ return file_inference_inference_network_node_proto_rawDescGZIP(), []int{3}
+}
+
+type JoinTrainingRequest struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ NodeId string `protobuf:"bytes,1,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
+ RunId uint64 `protobuf:"varint,2,opt,name=run_id,json=runId,proto3" json:"run_id,omitempty"`
+ OuterStep int32 `protobuf:"varint,3,opt,name=outer_step,json=outerStep,proto3" json:"outer_step,omitempty"`
+}
+
+func (x *JoinTrainingRequest) Reset() {
+ *x = JoinTrainingRequest{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_network_node_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *JoinTrainingRequest) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*JoinTrainingRequest) ProtoMessage() {}
+
+// Deprecated: Use JoinTrainingRequest.ProtoReflect.Descriptor instead.
+func (*JoinTrainingRequest) Descriptor() ([]byte, []int) {
+ return file_inference_inference_network_node_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *JoinTrainingRequest) GetNodeId() string {
+ if x != nil {
+ return x.NodeId
+ }
+ return ""
+}
+
+func (x *JoinTrainingRequest) GetRunId() uint64 {
+ if x != nil {
+ return x.RunId
+ }
+ return 0
+}
+
+func (x *JoinTrainingRequest) GetOuterStep() int32 {
+ if x != nil {
+ return x.OuterStep
+ }
+ return 0
+}
+
+type MLNodeTrainStatus struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Status MLNodeTrainStatusEnum `protobuf:"varint,1,opt,name=status,proto3,enum=inference.inference.MLNodeTrainStatusEnum" json:"status,omitempty"`
+ NodeId string `protobuf:"bytes,2,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
+ OuterStep int32 `protobuf:"varint,3,opt,name=outer_step,json=outerStep,proto3" json:"outer_step,omitempty"`
+ ActiveNodes []string `protobuf:"bytes,4,rep,name=active_nodes,json=activeNodes,proto3" json:"active_nodes,omitempty"`
+ Rank int32 `protobuf:"varint,5,opt,name=rank,proto3" json:"rank,omitempty"`
+}
+
+func (x *MLNodeTrainStatus) Reset() {
+ *x = MLNodeTrainStatus{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_network_node_proto_msgTypes[1]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *MLNodeTrainStatus) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MLNodeTrainStatus) ProtoMessage() {}
+
+// Deprecated: Use MLNodeTrainStatus.ProtoReflect.Descriptor instead.
+func (*MLNodeTrainStatus) Descriptor() ([]byte, []int) {
+ return file_inference_inference_network_node_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *MLNodeTrainStatus) GetStatus() MLNodeTrainStatusEnum {
+ if x != nil {
+ return x.Status
+ }
+ return MLNodeTrainStatusEnum_OK
+}
+
+func (x *MLNodeTrainStatus) GetNodeId() string {
+ if x != nil {
+ return x.NodeId
+ }
+ return ""
+}
+
+func (x *MLNodeTrainStatus) GetOuterStep() int32 {
+ if x != nil {
+ return x.OuterStep
+ }
+ return 0
+}
+
+func (x *MLNodeTrainStatus) GetActiveNodes() []string {
+ if x != nil {
+ return x.ActiveNodes
+ }
+ return nil
+}
+
+func (x *MLNodeTrainStatus) GetRank() int32 {
+ if x != nil {
+ return x.Rank
+ }
+ return 0
+}
+
+type HeartbeatRequest struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ NodeId string `protobuf:"bytes,1,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
+ RunId uint64 `protobuf:"varint,2,opt,name=run_id,json=runId,proto3" json:"run_id,omitempty"`
+ LocalRank int32 `protobuf:"varint,3,opt,name=local_rank,json=localRank,proto3" json:"local_rank,omitempty"`
+ Timestamp float64 `protobuf:"fixed64,4,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
+ InnerStep int32 `protobuf:"varint,5,opt,name=inner_step,json=innerStep,proto3" json:"inner_step,omitempty"`
+ OuterStep int32 `protobuf:"varint,6,opt,name=outer_step,json=outerStep,proto3" json:"outer_step,omitempty"`
+ Epoch int32 `protobuf:"varint,7,opt,name=epoch,proto3" json:"epoch,omitempty"`
+}
+
+func (x *HeartbeatRequest) Reset() {
+ *x = HeartbeatRequest{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_network_node_proto_msgTypes[2]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *HeartbeatRequest) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*HeartbeatRequest) ProtoMessage() {}
+
+// Deprecated: Use HeartbeatRequest.ProtoReflect.Descriptor instead.
+func (*HeartbeatRequest) Descriptor() ([]byte, []int) {
+ return file_inference_inference_network_node_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *HeartbeatRequest) GetNodeId() string {
+ if x != nil {
+ return x.NodeId
+ }
+ return ""
+}
+
+func (x *HeartbeatRequest) GetRunId() uint64 {
+ if x != nil {
+ return x.RunId
+ }
+ return 0
+}
+
+func (x *HeartbeatRequest) GetLocalRank() int32 {
+ if x != nil {
+ return x.LocalRank
+ }
+ return 0
+}
+
+func (x *HeartbeatRequest) GetTimestamp() float64 {
+ if x != nil {
+ return x.Timestamp
+ }
+ return 0
+}
+
+func (x *HeartbeatRequest) GetInnerStep() int32 {
+ if x != nil {
+ return x.InnerStep
+ }
+ return 0
+}
+
+func (x *HeartbeatRequest) GetOuterStep() int32 {
+ if x != nil {
+ return x.OuterStep
+ }
+ return 0
+}
+
+func (x *HeartbeatRequest) GetEpoch() int32 {
+ if x != nil {
+ return x.Epoch
+ }
+ return 0
+}
+
+type HeartbeatResponse struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Status HeartbeatStatusEnum `protobuf:"varint,1,opt,name=status,proto3,enum=inference.inference.HeartbeatStatusEnum" json:"status,omitempty"`
+}
+
+func (x *HeartbeatResponse) Reset() {
+ *x = HeartbeatResponse{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_network_node_proto_msgTypes[3]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *HeartbeatResponse) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*HeartbeatResponse) ProtoMessage() {}
+
+// Deprecated: Use HeartbeatResponse.ProtoReflect.Descriptor instead.
+func (*HeartbeatResponse) Descriptor() ([]byte, []int) {
+ return file_inference_inference_network_node_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *HeartbeatResponse) GetStatus() HeartbeatStatusEnum {
+ if x != nil {
+ return x.Status
+ }
+ return HeartbeatStatusEnum_HEARTBEAT_OK
+}
+
+type GetAliveNodesRequest struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ RunId uint64 `protobuf:"varint,1,opt,name=run_id,json=runId,proto3" json:"run_id,omitempty"`
+ OuterStep int32 `protobuf:"varint,2,opt,name=outer_step,json=outerStep,proto3" json:"outer_step,omitempty"`
+}
+
+func (x *GetAliveNodesRequest) Reset() {
+ *x = GetAliveNodesRequest{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_network_node_proto_msgTypes[4]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *GetAliveNodesRequest) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GetAliveNodesRequest) ProtoMessage() {}
+
+// Deprecated: Use GetAliveNodesRequest.ProtoReflect.Descriptor instead.
+func (*GetAliveNodesRequest) Descriptor() ([]byte, []int) {
+ return file_inference_inference_network_node_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *GetAliveNodesRequest) GetRunId() uint64 {
+ if x != nil {
+ return x.RunId
+ }
+ return 0
+}
+
+func (x *GetAliveNodesRequest) GetOuterStep() int32 {
+ if x != nil {
+ return x.OuterStep
+ }
+ return 0
+}
+
+type GetAliveNodesResponse struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ AliveNodes []string `protobuf:"bytes,1,rep,name=alive_nodes,json=aliveNodes,proto3" json:"alive_nodes,omitempty"`
+}
+
+func (x *GetAliveNodesResponse) Reset() {
+ *x = GetAliveNodesResponse{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_network_node_proto_msgTypes[5]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *GetAliveNodesResponse) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GetAliveNodesResponse) ProtoMessage() {}
+
+// Deprecated: Use GetAliveNodesResponse.ProtoReflect.Descriptor instead.
+func (*GetAliveNodesResponse) Descriptor() ([]byte, []int) {
+ return file_inference_inference_network_node_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *GetAliveNodesResponse) GetAliveNodes() []string {
+ if x != nil {
+ return x.AliveNodes
+ }
+ return nil
+}
+
+type SetBarrierRequest struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ BarrierId string `protobuf:"bytes,1,opt,name=barrier_id,json=barrierId,proto3" json:"barrier_id,omitempty"`
+ NodeId string `protobuf:"bytes,2,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
+ RunId uint64 `protobuf:"varint,3,opt,name=run_id,json=runId,proto3" json:"run_id,omitempty"`
+ OuterStep int32 `protobuf:"varint,4,opt,name=outer_step,json=outerStep,proto3" json:"outer_step,omitempty"`
+}
+
+func (x *SetBarrierRequest) Reset() {
+ *x = SetBarrierRequest{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_network_node_proto_msgTypes[6]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *SetBarrierRequest) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*SetBarrierRequest) ProtoMessage() {}
+
+// Deprecated: Use SetBarrierRequest.ProtoReflect.Descriptor instead.
+func (*SetBarrierRequest) Descriptor() ([]byte, []int) {
+ return file_inference_inference_network_node_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *SetBarrierRequest) GetBarrierId() string {
+ if x != nil {
+ return x.BarrierId
+ }
+ return ""
+}
+
+func (x *SetBarrierRequest) GetNodeId() string {
+ if x != nil {
+ return x.NodeId
+ }
+ return ""
+}
+
+func (x *SetBarrierRequest) GetRunId() uint64 {
+ if x != nil {
+ return x.RunId
+ }
+ return 0
+}
+
+func (x *SetBarrierRequest) GetOuterStep() int32 {
+ if x != nil {
+ return x.OuterStep
+ }
+ return 0
+}
+
+type SetBarrierResponse struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Status BarrierStatusEnum `protobuf:"varint,1,opt,name=status,proto3,enum=inference.inference.BarrierStatusEnum" json:"status,omitempty"`
+}
+
+func (x *SetBarrierResponse) Reset() {
+ *x = SetBarrierResponse{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_network_node_proto_msgTypes[7]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *SetBarrierResponse) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*SetBarrierResponse) ProtoMessage() {}
+
+// Deprecated: Use SetBarrierResponse.ProtoReflect.Descriptor instead.
+func (*SetBarrierResponse) Descriptor() ([]byte, []int) {
+ return file_inference_inference_network_node_proto_rawDescGZIP(), []int{7}
+}
+
+func (x *SetBarrierResponse) GetStatus() BarrierStatusEnum {
+ if x != nil {
+ return x.Status
+ }
+ return BarrierStatusEnum_READY
+}
+
+type GetBarrierStatusRequest struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ BarrierId string `protobuf:"bytes,1,opt,name=barrier_id,json=barrierId,proto3" json:"barrier_id,omitempty"`
+ RunId uint64 `protobuf:"varint,2,opt,name=run_id,json=runId,proto3" json:"run_id,omitempty"`
+ OuterStep int32 `protobuf:"varint,3,opt,name=outer_step,json=outerStep,proto3" json:"outer_step,omitempty"`
+}
+
+func (x *GetBarrierStatusRequest) Reset() {
+ *x = GetBarrierStatusRequest{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_network_node_proto_msgTypes[8]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *GetBarrierStatusRequest) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GetBarrierStatusRequest) ProtoMessage() {}
+
+// Deprecated: Use GetBarrierStatusRequest.ProtoReflect.Descriptor instead.
+func (*GetBarrierStatusRequest) Descriptor() ([]byte, []int) {
+ return file_inference_inference_network_node_proto_rawDescGZIP(), []int{8}
+}
+
+func (x *GetBarrierStatusRequest) GetBarrierId() string {
+ if x != nil {
+ return x.BarrierId
+ }
+ return ""
+}
+
+func (x *GetBarrierStatusRequest) GetRunId() uint64 {
+ if x != nil {
+ return x.RunId
+ }
+ return 0
+}
+
+func (x *GetBarrierStatusRequest) GetOuterStep() int32 {
+ if x != nil {
+ return x.OuterStep
+ }
+ return 0
+}
+
+type GetBarrierStatusResponse struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ AllReady bool `protobuf:"varint,1,opt,name=all_ready,json=allReady,proto3" json:"all_ready,omitempty"`
+ NotReady []string `protobuf:"bytes,2,rep,name=not_ready,json=notReady,proto3" json:"not_ready,omitempty"`
+ AliveNodes []string `protobuf:"bytes,3,rep,name=alive_nodes,json=aliveNodes,proto3" json:"alive_nodes,omitempty"`
+}
+
+func (x *GetBarrierStatusResponse) Reset() {
+ *x = GetBarrierStatusResponse{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_network_node_proto_msgTypes[9]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *GetBarrierStatusResponse) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GetBarrierStatusResponse) ProtoMessage() {}
+
+// Deprecated: Use GetBarrierStatusResponse.ProtoReflect.Descriptor instead.
+func (*GetBarrierStatusResponse) Descriptor() ([]byte, []int) {
+ return file_inference_inference_network_node_proto_rawDescGZIP(), []int{9}
+}
+
+func (x *GetBarrierStatusResponse) GetAllReady() bool {
+ if x != nil {
+ return x.AllReady
+ }
+ return false
+}
+
+func (x *GetBarrierStatusResponse) GetNotReady() []string {
+ if x != nil {
+ return x.NotReady
+ }
+ return nil
+}
+
+func (x *GetBarrierStatusResponse) GetAliveNodes() []string {
+ if x != nil {
+ return x.AliveNodes
+ }
+ return nil
+}
+
+type SetStoreRecordRequest struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ RunId uint64 `protobuf:"varint,1,opt,name=run_id,json=runId,proto3" json:"run_id,omitempty"`
+ Record *Record `protobuf:"bytes,2,opt,name=record,proto3" json:"record,omitempty"`
+}
+
+func (x *SetStoreRecordRequest) Reset() {
+ *x = SetStoreRecordRequest{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_network_node_proto_msgTypes[10]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *SetStoreRecordRequest) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*SetStoreRecordRequest) ProtoMessage() {}
+
+// Deprecated: Use SetStoreRecordRequest.ProtoReflect.Descriptor instead.
+func (*SetStoreRecordRequest) Descriptor() ([]byte, []int) {
+ return file_inference_inference_network_node_proto_rawDescGZIP(), []int{10}
+}
+
+func (x *SetStoreRecordRequest) GetRunId() uint64 {
+ if x != nil {
+ return x.RunId
+ }
+ return 0
+}
+
+func (x *SetStoreRecordRequest) GetRecord() *Record {
+ if x != nil {
+ return x.Record
+ }
+ return nil
+}
+
+type Record struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
+ Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
+}
+
+func (x *Record) Reset() {
+ *x = Record{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_network_node_proto_msgTypes[11]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *Record) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Record) ProtoMessage() {}
+
+// Deprecated: Use Record.ProtoReflect.Descriptor instead.
+func (*Record) Descriptor() ([]byte, []int) {
+ return file_inference_inference_network_node_proto_rawDescGZIP(), []int{11}
+}
+
+func (x *Record) GetKey() string {
+ if x != nil {
+ return x.Key
+ }
+ return ""
+}
+
+func (x *Record) GetValue() string {
+ if x != nil {
+ return x.Value
+ }
+ return ""
+}
+
+type SetStoreRecordResponse struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Status StoreRecordStatusEnum `protobuf:"varint,1,opt,name=status,proto3,enum=inference.inference.StoreRecordStatusEnum" json:"status,omitempty"`
+}
+
+func (x *SetStoreRecordResponse) Reset() {
+ *x = SetStoreRecordResponse{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_network_node_proto_msgTypes[12]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *SetStoreRecordResponse) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*SetStoreRecordResponse) ProtoMessage() {}
+
+// Deprecated: Use SetStoreRecordResponse.ProtoReflect.Descriptor instead.
+func (*SetStoreRecordResponse) Descriptor() ([]byte, []int) {
+ return file_inference_inference_network_node_proto_rawDescGZIP(), []int{12}
+}
+
+func (x *SetStoreRecordResponse) GetStatus() StoreRecordStatusEnum {
+ if x != nil {
+ return x.Status
+ }
+ return StoreRecordStatusEnum_SET_RECORD_OK
+}
+
+type GetStoreRecordRequest struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ RunId uint64 `protobuf:"varint,1,opt,name=run_id,json=runId,proto3" json:"run_id,omitempty"`
+ Key string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
+}
+
+func (x *GetStoreRecordRequest) Reset() {
+ *x = GetStoreRecordRequest{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_network_node_proto_msgTypes[13]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *GetStoreRecordRequest) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GetStoreRecordRequest) ProtoMessage() {}
+
+// Deprecated: Use GetStoreRecordRequest.ProtoReflect.Descriptor instead.
+func (*GetStoreRecordRequest) Descriptor() ([]byte, []int) {
+ return file_inference_inference_network_node_proto_rawDescGZIP(), []int{13}
+}
+
+func (x *GetStoreRecordRequest) GetRunId() uint64 {
+ if x != nil {
+ return x.RunId
+ }
+ return 0
+}
+
+func (x *GetStoreRecordRequest) GetKey() string {
+ if x != nil {
+ return x.Key
+ }
+ return ""
+}
+
+type GetStoreRecordResponse struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Record *Record `protobuf:"bytes,1,opt,name=record,proto3" json:"record,omitempty"`
+}
+
+func (x *GetStoreRecordResponse) Reset() {
+ *x = GetStoreRecordResponse{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_network_node_proto_msgTypes[14]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *GetStoreRecordResponse) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GetStoreRecordResponse) ProtoMessage() {}
+
+// Deprecated: Use GetStoreRecordResponse.ProtoReflect.Descriptor instead.
+func (*GetStoreRecordResponse) Descriptor() ([]byte, []int) {
+ return file_inference_inference_network_node_proto_rawDescGZIP(), []int{14}
+}
+
+func (x *GetStoreRecordResponse) GetRecord() *Record {
+ if x != nil {
+ return x.Record
+ }
+ return nil
+}
+
+type StoreListKeysRequest struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ RunId uint64 `protobuf:"varint,1,opt,name=run_id,json=runId,proto3" json:"run_id,omitempty"`
+}
+
+func (x *StoreListKeysRequest) Reset() {
+ *x = StoreListKeysRequest{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_network_node_proto_msgTypes[15]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *StoreListKeysRequest) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*StoreListKeysRequest) ProtoMessage() {}
+
+// Deprecated: Use StoreListKeysRequest.ProtoReflect.Descriptor instead.
+func (*StoreListKeysRequest) Descriptor() ([]byte, []int) {
+ return file_inference_inference_network_node_proto_rawDescGZIP(), []int{15}
+}
+
+func (x *StoreListKeysRequest) GetRunId() uint64 {
+ if x != nil {
+ return x.RunId
+ }
+ return 0
+}
+
+type StoreListKeysResponse struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Keys []string `protobuf:"bytes,1,rep,name=keys,proto3" json:"keys,omitempty"`
+}
+
+func (x *StoreListKeysResponse) Reset() {
+ *x = StoreListKeysResponse{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_network_node_proto_msgTypes[16]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *StoreListKeysResponse) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*StoreListKeysResponse) ProtoMessage() {}
+
+// Deprecated: Use StoreListKeysResponse.ProtoReflect.Descriptor instead.
+func (*StoreListKeysResponse) Descriptor() ([]byte, []int) {
+ return file_inference_inference_network_node_proto_rawDescGZIP(), []int{16}
+}
+
+func (x *StoreListKeysResponse) GetKeys() []string {
+ if x != nil {
+ return x.Keys
+ }
+ return nil
+}
+
+var File_inference_inference_network_node_proto protoreflect.FileDescriptor
+
+var file_inference_inference_network_node_proto_rawDesc = []byte{
+ 0x0a, 0x26, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65,
+ 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x5f, 0x6e, 0x6f,
+ 0x64, 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, 0x64, 0x0a,
+ 0x13, 0x4a, 0x6f, 0x69, 0x6e, 0x54, 0x72, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x71,
+ 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x18,
+ 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x12, 0x15, 0x0a,
+ 0x06, 0x72, 0x75, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x72,
+ 0x75, 0x6e, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x5f, 0x73, 0x74,
+ 0x65, 0x70, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x53,
+ 0x74, 0x65, 0x70, 0x22, 0xc6, 0x01, 0x0a, 0x11, 0x4d, 0x4c, 0x4e, 0x6f, 0x64, 0x65, 0x54, 0x72,
+ 0x61, 0x69, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x42, 0x0a, 0x06, 0x73, 0x74, 0x61,
+ 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2a, 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, 0x54, 0x72, 0x61, 0x69, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75,
+ 0x73, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x17, 0x0a,
+ 0x07, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06,
+ 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x5f,
+ 0x73, 0x74, 0x65, 0x70, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x6f, 0x75, 0x74, 0x65,
+ 0x72, 0x53, 0x74, 0x65, 0x70, 0x12, 0x21, 0x0a, 0x0c, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x5f,
+ 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0b, 0x61, 0x63, 0x74,
+ 0x69, 0x76, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x72, 0x61, 0x6e, 0x6b,
+ 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x72, 0x61, 0x6e, 0x6b, 0x22, 0xd3, 0x01, 0x0a,
+ 0x10, 0x48, 0x65, 0x61, 0x72, 0x74, 0x62, 0x65, 0x61, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+ 0x74, 0x12, 0x17, 0x0a, 0x07, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01,
+ 0x28, 0x09, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x12, 0x15, 0x0a, 0x06, 0x72, 0x75,
+ 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x72, 0x75, 0x6e, 0x49,
+ 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x5f, 0x72, 0x61, 0x6e, 0x6b, 0x18,
+ 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x52, 0x61, 0x6e, 0x6b,
+ 0x12, 0x1c, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x04, 0x20,
+ 0x01, 0x28, 0x01, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x1d,
+ 0x0a, 0x0a, 0x69, 0x6e, 0x6e, 0x65, 0x72, 0x5f, 0x73, 0x74, 0x65, 0x70, 0x18, 0x05, 0x20, 0x01,
+ 0x28, 0x05, 0x52, 0x09, 0x69, 0x6e, 0x6e, 0x65, 0x72, 0x53, 0x74, 0x65, 0x70, 0x12, 0x1d, 0x0a,
+ 0x0a, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x5f, 0x73, 0x74, 0x65, 0x70, 0x18, 0x06, 0x20, 0x01, 0x28,
+ 0x05, 0x52, 0x09, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x53, 0x74, 0x65, 0x70, 0x12, 0x14, 0x0a, 0x05,
+ 0x65, 0x70, 0x6f, 0x63, 0x68, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x65, 0x70, 0x6f,
+ 0x63, 0x68, 0x22, 0x55, 0x0a, 0x11, 0x48, 0x65, 0x61, 0x72, 0x74, 0x62, 0x65, 0x61, 0x74, 0x52,
+ 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x40, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75,
+ 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x28, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+ 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x48, 0x65,
+ 0x61, 0x72, 0x74, 0x62, 0x65, 0x61, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x45, 0x6e, 0x75,
+ 0x6d, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x4c, 0x0a, 0x14, 0x47, 0x65, 0x74,
+ 0x41, 0x6c, 0x69, 0x76, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+ 0x74, 0x12, 0x15, 0x0a, 0x06, 0x72, 0x75, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28,
+ 0x04, 0x52, 0x05, 0x72, 0x75, 0x6e, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x6f, 0x75, 0x74, 0x65,
+ 0x72, 0x5f, 0x73, 0x74, 0x65, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x6f, 0x75,
+ 0x74, 0x65, 0x72, 0x53, 0x74, 0x65, 0x70, 0x22, 0x38, 0x0a, 0x15, 0x47, 0x65, 0x74, 0x41, 0x6c,
+ 0x69, 0x76, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+ 0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x6c, 0x69, 0x76, 0x65, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x18,
+ 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x61, 0x6c, 0x69, 0x76, 0x65, 0x4e, 0x6f, 0x64, 0x65,
+ 0x73, 0x22, 0x81, 0x01, 0x0a, 0x11, 0x53, 0x65, 0x74, 0x42, 0x61, 0x72, 0x72, 0x69, 0x65, 0x72,
+ 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x62, 0x61, 0x72, 0x72, 0x69,
+ 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x62, 0x61, 0x72,
+ 0x72, 0x69, 0x65, 0x72, 0x49, 0x64, 0x12, 0x17, 0x0a, 0x07, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69,
+ 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x12,
+ 0x15, 0x0a, 0x06, 0x72, 0x75, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52,
+ 0x05, 0x72, 0x75, 0x6e, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x5f,
+ 0x73, 0x74, 0x65, 0x70, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x6f, 0x75, 0x74, 0x65,
+ 0x72, 0x53, 0x74, 0x65, 0x70, 0x22, 0x54, 0x0a, 0x12, 0x53, 0x65, 0x74, 0x42, 0x61, 0x72, 0x72,
+ 0x69, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3e, 0x0a, 0x06, 0x73,
+ 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x69, 0x6e,
+ 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+ 0x65, 0x2e, 0x42, 0x61, 0x72, 0x72, 0x69, 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x45,
+ 0x6e, 0x75, 0x6d, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x6e, 0x0a, 0x17, 0x47,
+ 0x65, 0x74, 0x42, 0x61, 0x72, 0x72, 0x69, 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52,
+ 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x62, 0x61, 0x72, 0x72, 0x69, 0x65,
+ 0x72, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x62, 0x61, 0x72, 0x72,
+ 0x69, 0x65, 0x72, 0x49, 0x64, 0x12, 0x15, 0x0a, 0x06, 0x72, 0x75, 0x6e, 0x5f, 0x69, 0x64, 0x18,
+ 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x72, 0x75, 0x6e, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a,
+ 0x6f, 0x75, 0x74, 0x65, 0x72, 0x5f, 0x73, 0x74, 0x65, 0x70, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05,
+ 0x52, 0x09, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x53, 0x74, 0x65, 0x70, 0x22, 0x75, 0x0a, 0x18, 0x47,
+ 0x65, 0x74, 0x42, 0x61, 0x72, 0x72, 0x69, 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52,
+ 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x61, 0x6c, 0x6c, 0x5f, 0x72,
+ 0x65, 0x61, 0x64, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x61, 0x6c, 0x6c, 0x52,
+ 0x65, 0x61, 0x64, 0x79, 0x12, 0x1b, 0x0a, 0x09, 0x6e, 0x6f, 0x74, 0x5f, 0x72, 0x65, 0x61, 0x64,
+ 0x79, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x6e, 0x6f, 0x74, 0x52, 0x65, 0x61, 0x64,
+ 0x79, 0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x6c, 0x69, 0x76, 0x65, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x73,
+ 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x61, 0x6c, 0x69, 0x76, 0x65, 0x4e, 0x6f, 0x64,
+ 0x65, 0x73, 0x22, 0x63, 0x0a, 0x15, 0x53, 0x65, 0x74, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x52, 0x65,
+ 0x63, 0x6f, 0x72, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x15, 0x0a, 0x06, 0x72,
+ 0x75, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x72, 0x75, 0x6e,
+ 0x49, 0x64, 0x12, 0x33, 0x0a, 0x06, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 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, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x52,
+ 0x06, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x22, 0x30, 0x0a, 0x06, 0x52, 0x65, 0x63, 0x6f, 0x72,
+ 0x64, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03,
+ 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01,
+ 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x5c, 0x0a, 0x16, 0x53, 0x65, 0x74,
+ 0x53, 0x74, 0x6f, 0x72, 0x65, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f,
+ 0x6e, 0x73, 0x65, 0x12, 0x42, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20,
+ 0x01, 0x28, 0x0e, 0x32, 0x2a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+ 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x52,
+ 0x65, 0x63, 0x6f, 0x72, 0x64, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x45, 0x6e, 0x75, 0x6d, 0x52,
+ 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x40, 0x0a, 0x15, 0x47, 0x65, 0x74, 0x53, 0x74,
+ 0x6f, 0x72, 0x65, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+ 0x12, 0x15, 0x0a, 0x06, 0x72, 0x75, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04,
+ 0x52, 0x05, 0x72, 0x75, 0x6e, 0x49, 0x64, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x02,
+ 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x22, 0x4d, 0x0a, 0x16, 0x47, 0x65, 0x74,
+ 0x53, 0x74, 0x6f, 0x72, 0x65, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f,
+ 0x6e, 0x73, 0x65, 0x12, 0x33, 0x0a, 0x06, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 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, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64,
+ 0x52, 0x06, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x22, 0x2d, 0x0a, 0x14, 0x53, 0x74, 0x6f, 0x72,
+ 0x65, 0x4c, 0x69, 0x73, 0x74, 0x4b, 0x65, 0x79, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+ 0x12, 0x15, 0x0a, 0x06, 0x72, 0x75, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04,
+ 0x52, 0x05, 0x72, 0x75, 0x6e, 0x49, 0x64, 0x22, 0x2b, 0x0a, 0x15, 0x53, 0x74, 0x6f, 0x72, 0x65,
+ 0x4c, 0x69, 0x73, 0x74, 0x4b, 0x65, 0x79, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+ 0x12, 0x12, 0x0a, 0x04, 0x6b, 0x65, 0x79, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x04,
+ 0x6b, 0x65, 0x79, 0x73, 0x2a, 0x46, 0x0a, 0x15, 0x4d, 0x4c, 0x4e, 0x6f, 0x64, 0x65, 0x54, 0x72,
+ 0x61, 0x69, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x06, 0x0a,
+ 0x02, 0x4f, 0x4b, 0x10, 0x00, 0x12, 0x09, 0x0a, 0x05, 0x45, 0x52, 0x52, 0x4f, 0x52, 0x10, 0x01,
+ 0x12, 0x0a, 0x0a, 0x06, 0x4a, 0x4f, 0x49, 0x4e, 0x45, 0x44, 0x10, 0x02, 0x12, 0x0e, 0x0a, 0x0a,
+ 0x4e, 0x4f, 0x54, 0x5f, 0x4a, 0x4f, 0x49, 0x4e, 0x45, 0x44, 0x10, 0x03, 0x2a, 0x3c, 0x0a, 0x13,
+ 0x48, 0x65, 0x61, 0x72, 0x74, 0x62, 0x65, 0x61, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x45,
+ 0x6e, 0x75, 0x6d, 0x12, 0x10, 0x0a, 0x0c, 0x48, 0x45, 0x41, 0x52, 0x54, 0x42, 0x45, 0x41, 0x54,
+ 0x5f, 0x4f, 0x4b, 0x10, 0x00, 0x12, 0x13, 0x0a, 0x0f, 0x48, 0x45, 0x41, 0x52, 0x54, 0x42, 0x45,
+ 0x41, 0x54, 0x5f, 0x45, 0x52, 0x52, 0x4f, 0x52, 0x10, 0x01, 0x2a, 0x2d, 0x0a, 0x11, 0x42, 0x61,
+ 0x72, 0x72, 0x69, 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x45, 0x6e, 0x75, 0x6d, 0x12,
+ 0x09, 0x0a, 0x05, 0x52, 0x45, 0x41, 0x44, 0x59, 0x10, 0x00, 0x12, 0x0d, 0x0a, 0x09, 0x4e, 0x4f,
+ 0x54, 0x5f, 0x52, 0x45, 0x41, 0x44, 0x59, 0x10, 0x01, 0x2a, 0x40, 0x0a, 0x15, 0x53, 0x74, 0x6f,
+ 0x72, 0x65, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x45, 0x6e,
+ 0x75, 0x6d, 0x12, 0x11, 0x0a, 0x0d, 0x53, 0x45, 0x54, 0x5f, 0x52, 0x45, 0x43, 0x4f, 0x52, 0x44,
+ 0x5f, 0x4f, 0x4b, 0x10, 0x00, 0x12, 0x14, 0x0a, 0x10, 0x53, 0x45, 0x54, 0x5f, 0x52, 0x45, 0x43,
+ 0x4f, 0x52, 0x44, 0x5f, 0x45, 0x52, 0x52, 0x4f, 0x52, 0x10, 0x01, 0x32, 0xb7, 0x07, 0x0a, 0x12,
+ 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x4e, 0x6f, 0x64, 0x65, 0x53, 0x65, 0x72, 0x76, 0x69,
+ 0x63, 0x65, 0x12, 0x60, 0x0a, 0x0c, 0x4a, 0x6f, 0x69, 0x6e, 0x54, 0x72, 0x61, 0x69, 0x6e, 0x69,
+ 0x6e, 0x67, 0x12, 0x28, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
+ 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4a, 0x6f, 0x69, 0x6e, 0x54, 0x72, 0x61,
+ 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 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, 0x54, 0x72, 0x61, 0x69, 0x6e, 0x53, 0x74,
+ 0x61, 0x74, 0x75, 0x73, 0x12, 0x69, 0x0a, 0x15, 0x47, 0x65, 0x74, 0x4a, 0x6f, 0x69, 0x6e, 0x54,
+ 0x72, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x28, 0x2e,
+ 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+ 0x6e, 0x63, 0x65, 0x2e, 0x4a, 0x6f, 0x69, 0x6e, 0x54, 0x72, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67,
+ 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 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, 0x54, 0x72, 0x61, 0x69, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12,
+ 0x5e, 0x0a, 0x0d, 0x53, 0x65, 0x6e, 0x64, 0x48, 0x65, 0x61, 0x72, 0x74, 0x62, 0x65, 0x61, 0x74,
+ 0x12, 0x25, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
+ 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x48, 0x65, 0x61, 0x72, 0x74, 0x62, 0x65, 0x61, 0x74,
+ 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+ 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x48, 0x65,
+ 0x61, 0x72, 0x74, 0x62, 0x65, 0x61, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12,
+ 0x66, 0x0a, 0x0d, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x76, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x73,
+ 0x12, 0x29, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
+ 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x76, 0x65, 0x4e,
+ 0x6f, 0x64, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x69, 0x6e,
+ 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+ 0x65, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x76, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x52,
+ 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5d, 0x0a, 0x0a, 0x53, 0x65, 0x74, 0x42, 0x61,
+ 0x72, 0x72, 0x69, 0x65, 0x72, 0x12, 0x26, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+ 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x53, 0x65, 0x74, 0x42,
+ 0x61, 0x72, 0x72, 0x69, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e,
+ 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+ 0x6e, 0x63, 0x65, 0x2e, 0x53, 0x65, 0x74, 0x42, 0x61, 0x72, 0x72, 0x69, 0x65, 0x72, 0x52, 0x65,
+ 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x6f, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x42, 0x61, 0x72,
+ 0x72, 0x69, 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x2c, 0x2e, 0x69, 0x6e, 0x66,
+ 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+ 0x2e, 0x47, 0x65, 0x74, 0x42, 0x61, 0x72, 0x72, 0x69, 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x75,
+ 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, 0x47,
+ 0x65, 0x74, 0x42, 0x61, 0x72, 0x72, 0x69, 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52,
+ 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x69, 0x0a, 0x0e, 0x53, 0x65, 0x74, 0x53, 0x74,
+ 0x6f, 0x72, 0x65, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x12, 0x2a, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+ 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+ 0x53, 0x65, 0x74, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 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, 0x53, 0x65, 0x74, 0x53,
+ 0x74, 0x6f, 0x72, 0x65, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+ 0x73, 0x65, 0x12, 0x69, 0x0a, 0x0e, 0x47, 0x65, 0x74, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x52, 0x65,
+ 0x63, 0x6f, 0x72, 0x64, 0x12, 0x2a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+ 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x74,
+ 0x6f, 0x72, 0x65, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 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, 0x47, 0x65, 0x74, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x52,
+ 0x65, 0x63, 0x6f, 0x72, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x66, 0x0a,
+ 0x0d, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x12, 0x29,
+ 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+ 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x4c, 0x69, 0x73, 0x74, 0x4b, 0x65,
+ 0x79, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+ 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+ 0x53, 0x74, 0x6f, 0x72, 0x65, 0x4c, 0x69, 0x73, 0x74, 0x4b, 0x65, 0x79, 0x73, 0x52, 0x65, 0x73,
+ 0x70, 0x6f, 0x6e, 0x73, 0x65, 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, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x4e, 0x6f, 0x64, 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_network_node_proto_rawDescOnce sync.Once
+ file_inference_inference_network_node_proto_rawDescData = file_inference_inference_network_node_proto_rawDesc
+)
+
+func file_inference_inference_network_node_proto_rawDescGZIP() []byte {
+ file_inference_inference_network_node_proto_rawDescOnce.Do(func() {
+ file_inference_inference_network_node_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_inference_network_node_proto_rawDescData)
+ })
+ return file_inference_inference_network_node_proto_rawDescData
+}
+
+var file_inference_inference_network_node_proto_enumTypes = make([]protoimpl.EnumInfo, 4)
+var file_inference_inference_network_node_proto_msgTypes = make([]protoimpl.MessageInfo, 17)
+var file_inference_inference_network_node_proto_goTypes = []interface{}{
+ (MLNodeTrainStatusEnum)(0), // 0: inference.inference.MLNodeTrainStatusEnum
+ (HeartbeatStatusEnum)(0), // 1: inference.inference.HeartbeatStatusEnum
+ (BarrierStatusEnum)(0), // 2: inference.inference.BarrierStatusEnum
+ (StoreRecordStatusEnum)(0), // 3: inference.inference.StoreRecordStatusEnum
+ (*JoinTrainingRequest)(nil), // 4: inference.inference.JoinTrainingRequest
+ (*MLNodeTrainStatus)(nil), // 5: inference.inference.MLNodeTrainStatus
+ (*HeartbeatRequest)(nil), // 6: inference.inference.HeartbeatRequest
+ (*HeartbeatResponse)(nil), // 7: inference.inference.HeartbeatResponse
+ (*GetAliveNodesRequest)(nil), // 8: inference.inference.GetAliveNodesRequest
+ (*GetAliveNodesResponse)(nil), // 9: inference.inference.GetAliveNodesResponse
+ (*SetBarrierRequest)(nil), // 10: inference.inference.SetBarrierRequest
+ (*SetBarrierResponse)(nil), // 11: inference.inference.SetBarrierResponse
+ (*GetBarrierStatusRequest)(nil), // 12: inference.inference.GetBarrierStatusRequest
+ (*GetBarrierStatusResponse)(nil), // 13: inference.inference.GetBarrierStatusResponse
+ (*SetStoreRecordRequest)(nil), // 14: inference.inference.SetStoreRecordRequest
+ (*Record)(nil), // 15: inference.inference.Record
+ (*SetStoreRecordResponse)(nil), // 16: inference.inference.SetStoreRecordResponse
+ (*GetStoreRecordRequest)(nil), // 17: inference.inference.GetStoreRecordRequest
+ (*GetStoreRecordResponse)(nil), // 18: inference.inference.GetStoreRecordResponse
+ (*StoreListKeysRequest)(nil), // 19: inference.inference.StoreListKeysRequest
+ (*StoreListKeysResponse)(nil), // 20: inference.inference.StoreListKeysResponse
+}
+var file_inference_inference_network_node_proto_depIdxs = []int32{
+ 0, // 0: inference.inference.MLNodeTrainStatus.status:type_name -> inference.inference.MLNodeTrainStatusEnum
+ 1, // 1: inference.inference.HeartbeatResponse.status:type_name -> inference.inference.HeartbeatStatusEnum
+ 2, // 2: inference.inference.SetBarrierResponse.status:type_name -> inference.inference.BarrierStatusEnum
+ 15, // 3: inference.inference.SetStoreRecordRequest.record:type_name -> inference.inference.Record
+ 3, // 4: inference.inference.SetStoreRecordResponse.status:type_name -> inference.inference.StoreRecordStatusEnum
+ 15, // 5: inference.inference.GetStoreRecordResponse.record:type_name -> inference.inference.Record
+ 4, // 6: inference.inference.NetworkNodeService.JoinTraining:input_type -> inference.inference.JoinTrainingRequest
+ 4, // 7: inference.inference.NetworkNodeService.GetJoinTrainingStatus:input_type -> inference.inference.JoinTrainingRequest
+ 6, // 8: inference.inference.NetworkNodeService.SendHeartbeat:input_type -> inference.inference.HeartbeatRequest
+ 8, // 9: inference.inference.NetworkNodeService.GetAliveNodes:input_type -> inference.inference.GetAliveNodesRequest
+ 10, // 10: inference.inference.NetworkNodeService.SetBarrier:input_type -> inference.inference.SetBarrierRequest
+ 12, // 11: inference.inference.NetworkNodeService.GetBarrierStatus:input_type -> inference.inference.GetBarrierStatusRequest
+ 14, // 12: inference.inference.NetworkNodeService.SetStoreRecord:input_type -> inference.inference.SetStoreRecordRequest
+ 17, // 13: inference.inference.NetworkNodeService.GetStoreRecord:input_type -> inference.inference.GetStoreRecordRequest
+ 19, // 14: inference.inference.NetworkNodeService.ListStoreKeys:input_type -> inference.inference.StoreListKeysRequest
+ 5, // 15: inference.inference.NetworkNodeService.JoinTraining:output_type -> inference.inference.MLNodeTrainStatus
+ 5, // 16: inference.inference.NetworkNodeService.GetJoinTrainingStatus:output_type -> inference.inference.MLNodeTrainStatus
+ 7, // 17: inference.inference.NetworkNodeService.SendHeartbeat:output_type -> inference.inference.HeartbeatResponse
+ 9, // 18: inference.inference.NetworkNodeService.GetAliveNodes:output_type -> inference.inference.GetAliveNodesResponse
+ 11, // 19: inference.inference.NetworkNodeService.SetBarrier:output_type -> inference.inference.SetBarrierResponse
+ 13, // 20: inference.inference.NetworkNodeService.GetBarrierStatus:output_type -> inference.inference.GetBarrierStatusResponse
+ 16, // 21: inference.inference.NetworkNodeService.SetStoreRecord:output_type -> inference.inference.SetStoreRecordResponse
+ 18, // 22: inference.inference.NetworkNodeService.GetStoreRecord:output_type -> inference.inference.GetStoreRecordResponse
+ 20, // 23: inference.inference.NetworkNodeService.ListStoreKeys:output_type -> inference.inference.StoreListKeysResponse
+ 15, // [15:24] is the sub-list for method output_type
+ 6, // [6:15] is the sub-list for method input_type
+ 6, // [6:6] is the sub-list for extension type_name
+ 6, // [6:6] is the sub-list for extension extendee
+ 0, // [0:6] is the sub-list for field type_name
+}
+
+func init() { file_inference_inference_network_node_proto_init() }
+func file_inference_inference_network_node_proto_init() {
+ if File_inference_inference_network_node_proto != nil {
+ return
+ }
+ if !protoimpl.UnsafeEnabled {
+ file_inference_inference_network_node_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*JoinTrainingRequest); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_inference_network_node_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*MLNodeTrainStatus); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_inference_network_node_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*HeartbeatRequest); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_inference_network_node_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*HeartbeatResponse); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_inference_network_node_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*GetAliveNodesRequest); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_inference_network_node_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*GetAliveNodesResponse); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_inference_network_node_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*SetBarrierRequest); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_inference_network_node_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*SetBarrierResponse); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_inference_network_node_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*GetBarrierStatusRequest); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_inference_network_node_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*GetBarrierStatusResponse); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_inference_network_node_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*SetStoreRecordRequest); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_inference_network_node_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*Record); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_inference_network_node_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*SetStoreRecordResponse); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_inference_network_node_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*GetStoreRecordRequest); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_inference_network_node_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*GetStoreRecordResponse); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_inference_network_node_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*StoreListKeysRequest); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_inference_network_node_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*StoreListKeysResponse); 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_network_node_proto_rawDesc,
+ NumEnums: 4,
+ NumMessages: 17,
+ NumExtensions: 0,
+ NumServices: 1,
+ },
+ GoTypes: file_inference_inference_network_node_proto_goTypes,
+ DependencyIndexes: file_inference_inference_network_node_proto_depIdxs,
+ EnumInfos: file_inference_inference_network_node_proto_enumTypes,
+ MessageInfos: file_inference_inference_network_node_proto_msgTypes,
+ }.Build()
+ File_inference_inference_network_node_proto = out.File
+ file_inference_inference_network_node_proto_rawDesc = nil
+ file_inference_inference_network_node_proto_goTypes = nil
+ file_inference_inference_network_node_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/inference/network_node_grpc.pb.go b/inference-chain/api/inference/inference/network_node_grpc.pb.go
new file mode 100644
index 000000000..c7a5557d8
--- /dev/null
+++ b/inference-chain/api/inference/inference/network_node_grpc.pb.go
@@ -0,0 +1,405 @@
+// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
+// versions:
+// - protoc-gen-go-grpc v1.3.0
+// - protoc (unknown)
+// source: inference/inference/network_node.proto
+
+package inference
+
+import (
+ context "context"
+ grpc "google.golang.org/grpc"
+ codes "google.golang.org/grpc/codes"
+ status "google.golang.org/grpc/status"
+)
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+// Requires gRPC-Go v1.32.0 or later.
+const _ = grpc.SupportPackageIsVersion7
+
+const (
+ NetworkNodeService_JoinTraining_FullMethodName = "/inference.inference.NetworkNodeService/JoinTraining"
+ NetworkNodeService_GetJoinTrainingStatus_FullMethodName = "/inference.inference.NetworkNodeService/GetJoinTrainingStatus"
+ NetworkNodeService_SendHeartbeat_FullMethodName = "/inference.inference.NetworkNodeService/SendHeartbeat"
+ NetworkNodeService_GetAliveNodes_FullMethodName = "/inference.inference.NetworkNodeService/GetAliveNodes"
+ NetworkNodeService_SetBarrier_FullMethodName = "/inference.inference.NetworkNodeService/SetBarrier"
+ NetworkNodeService_GetBarrierStatus_FullMethodName = "/inference.inference.NetworkNodeService/GetBarrierStatus"
+ NetworkNodeService_SetStoreRecord_FullMethodName = "/inference.inference.NetworkNodeService/SetStoreRecord"
+ NetworkNodeService_GetStoreRecord_FullMethodName = "/inference.inference.NetworkNodeService/GetStoreRecord"
+ NetworkNodeService_ListStoreKeys_FullMethodName = "/inference.inference.NetworkNodeService/ListStoreKeys"
+)
+
+// NetworkNodeServiceClient is the client API for NetworkNodeService service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+type NetworkNodeServiceClient interface {
+ JoinTraining(ctx context.Context, in *JoinTrainingRequest, opts ...grpc.CallOption) (*MLNodeTrainStatus, error)
+ GetJoinTrainingStatus(ctx context.Context, in *JoinTrainingRequest, opts ...grpc.CallOption) (*MLNodeTrainStatus, error)
+ SendHeartbeat(ctx context.Context, in *HeartbeatRequest, opts ...grpc.CallOption) (*HeartbeatResponse, error)
+ GetAliveNodes(ctx context.Context, in *GetAliveNodesRequest, opts ...grpc.CallOption) (*GetAliveNodesResponse, error)
+ SetBarrier(ctx context.Context, in *SetBarrierRequest, opts ...grpc.CallOption) (*SetBarrierResponse, error)
+ GetBarrierStatus(ctx context.Context, in *GetBarrierStatusRequest, opts ...grpc.CallOption) (*GetBarrierStatusResponse, error)
+ SetStoreRecord(ctx context.Context, in *SetStoreRecordRequest, opts ...grpc.CallOption) (*SetStoreRecordResponse, error)
+ GetStoreRecord(ctx context.Context, in *GetStoreRecordRequest, opts ...grpc.CallOption) (*GetStoreRecordResponse, error)
+ ListStoreKeys(ctx context.Context, in *StoreListKeysRequest, opts ...grpc.CallOption) (*StoreListKeysResponse, error)
+}
+
+type networkNodeServiceClient struct {
+ cc grpc.ClientConnInterface
+}
+
+func NewNetworkNodeServiceClient(cc grpc.ClientConnInterface) NetworkNodeServiceClient {
+ return &networkNodeServiceClient{cc}
+}
+
+func (c *networkNodeServiceClient) JoinTraining(ctx context.Context, in *JoinTrainingRequest, opts ...grpc.CallOption) (*MLNodeTrainStatus, error) {
+ out := new(MLNodeTrainStatus)
+ err := c.cc.Invoke(ctx, NetworkNodeService_JoinTraining_FullMethodName, in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *networkNodeServiceClient) GetJoinTrainingStatus(ctx context.Context, in *JoinTrainingRequest, opts ...grpc.CallOption) (*MLNodeTrainStatus, error) {
+ out := new(MLNodeTrainStatus)
+ err := c.cc.Invoke(ctx, NetworkNodeService_GetJoinTrainingStatus_FullMethodName, in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *networkNodeServiceClient) SendHeartbeat(ctx context.Context, in *HeartbeatRequest, opts ...grpc.CallOption) (*HeartbeatResponse, error) {
+ out := new(HeartbeatResponse)
+ err := c.cc.Invoke(ctx, NetworkNodeService_SendHeartbeat_FullMethodName, in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *networkNodeServiceClient) GetAliveNodes(ctx context.Context, in *GetAliveNodesRequest, opts ...grpc.CallOption) (*GetAliveNodesResponse, error) {
+ out := new(GetAliveNodesResponse)
+ err := c.cc.Invoke(ctx, NetworkNodeService_GetAliveNodes_FullMethodName, in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *networkNodeServiceClient) SetBarrier(ctx context.Context, in *SetBarrierRequest, opts ...grpc.CallOption) (*SetBarrierResponse, error) {
+ out := new(SetBarrierResponse)
+ err := c.cc.Invoke(ctx, NetworkNodeService_SetBarrier_FullMethodName, in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *networkNodeServiceClient) GetBarrierStatus(ctx context.Context, in *GetBarrierStatusRequest, opts ...grpc.CallOption) (*GetBarrierStatusResponse, error) {
+ out := new(GetBarrierStatusResponse)
+ err := c.cc.Invoke(ctx, NetworkNodeService_GetBarrierStatus_FullMethodName, in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *networkNodeServiceClient) SetStoreRecord(ctx context.Context, in *SetStoreRecordRequest, opts ...grpc.CallOption) (*SetStoreRecordResponse, error) {
+ out := new(SetStoreRecordResponse)
+ err := c.cc.Invoke(ctx, NetworkNodeService_SetStoreRecord_FullMethodName, in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *networkNodeServiceClient) GetStoreRecord(ctx context.Context, in *GetStoreRecordRequest, opts ...grpc.CallOption) (*GetStoreRecordResponse, error) {
+ out := new(GetStoreRecordResponse)
+ err := c.cc.Invoke(ctx, NetworkNodeService_GetStoreRecord_FullMethodName, in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *networkNodeServiceClient) ListStoreKeys(ctx context.Context, in *StoreListKeysRequest, opts ...grpc.CallOption) (*StoreListKeysResponse, error) {
+ out := new(StoreListKeysResponse)
+ err := c.cc.Invoke(ctx, NetworkNodeService_ListStoreKeys_FullMethodName, in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+// NetworkNodeServiceServer is the server API for NetworkNodeService service.
+// All implementations must embed UnimplementedNetworkNodeServiceServer
+// for forward compatibility
+type NetworkNodeServiceServer interface {
+ JoinTraining(context.Context, *JoinTrainingRequest) (*MLNodeTrainStatus, error)
+ GetJoinTrainingStatus(context.Context, *JoinTrainingRequest) (*MLNodeTrainStatus, error)
+ SendHeartbeat(context.Context, *HeartbeatRequest) (*HeartbeatResponse, error)
+ GetAliveNodes(context.Context, *GetAliveNodesRequest) (*GetAliveNodesResponse, error)
+ SetBarrier(context.Context, *SetBarrierRequest) (*SetBarrierResponse, error)
+ GetBarrierStatus(context.Context, *GetBarrierStatusRequest) (*GetBarrierStatusResponse, error)
+ SetStoreRecord(context.Context, *SetStoreRecordRequest) (*SetStoreRecordResponse, error)
+ GetStoreRecord(context.Context, *GetStoreRecordRequest) (*GetStoreRecordResponse, error)
+ ListStoreKeys(context.Context, *StoreListKeysRequest) (*StoreListKeysResponse, error)
+ mustEmbedUnimplementedNetworkNodeServiceServer()
+}
+
+// UnimplementedNetworkNodeServiceServer must be embedded to have forward compatible implementations.
+type UnimplementedNetworkNodeServiceServer struct {
+}
+
+func (UnimplementedNetworkNodeServiceServer) JoinTraining(context.Context, *JoinTrainingRequest) (*MLNodeTrainStatus, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method JoinTraining not implemented")
+}
+func (UnimplementedNetworkNodeServiceServer) GetJoinTrainingStatus(context.Context, *JoinTrainingRequest) (*MLNodeTrainStatus, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method GetJoinTrainingStatus not implemented")
+}
+func (UnimplementedNetworkNodeServiceServer) SendHeartbeat(context.Context, *HeartbeatRequest) (*HeartbeatResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method SendHeartbeat not implemented")
+}
+func (UnimplementedNetworkNodeServiceServer) GetAliveNodes(context.Context, *GetAliveNodesRequest) (*GetAliveNodesResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method GetAliveNodes not implemented")
+}
+func (UnimplementedNetworkNodeServiceServer) SetBarrier(context.Context, *SetBarrierRequest) (*SetBarrierResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method SetBarrier not implemented")
+}
+func (UnimplementedNetworkNodeServiceServer) GetBarrierStatus(context.Context, *GetBarrierStatusRequest) (*GetBarrierStatusResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method GetBarrierStatus not implemented")
+}
+func (UnimplementedNetworkNodeServiceServer) SetStoreRecord(context.Context, *SetStoreRecordRequest) (*SetStoreRecordResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method SetStoreRecord not implemented")
+}
+func (UnimplementedNetworkNodeServiceServer) GetStoreRecord(context.Context, *GetStoreRecordRequest) (*GetStoreRecordResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method GetStoreRecord not implemented")
+}
+func (UnimplementedNetworkNodeServiceServer) ListStoreKeys(context.Context, *StoreListKeysRequest) (*StoreListKeysResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method ListStoreKeys not implemented")
+}
+func (UnimplementedNetworkNodeServiceServer) mustEmbedUnimplementedNetworkNodeServiceServer() {}
+
+// UnsafeNetworkNodeServiceServer may be embedded to opt out of forward compatibility for this service.
+// Use of this interface is not recommended, as added methods to NetworkNodeServiceServer will
+// result in compilation errors.
+type UnsafeNetworkNodeServiceServer interface {
+ mustEmbedUnimplementedNetworkNodeServiceServer()
+}
+
+func RegisterNetworkNodeServiceServer(s grpc.ServiceRegistrar, srv NetworkNodeServiceServer) {
+ s.RegisterService(&NetworkNodeService_ServiceDesc, srv)
+}
+
+func _NetworkNodeService_JoinTraining_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(JoinTrainingRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(NetworkNodeServiceServer).JoinTraining(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: NetworkNodeService_JoinTraining_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(NetworkNodeServiceServer).JoinTraining(ctx, req.(*JoinTrainingRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _NetworkNodeService_GetJoinTrainingStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(JoinTrainingRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(NetworkNodeServiceServer).GetJoinTrainingStatus(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: NetworkNodeService_GetJoinTrainingStatus_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(NetworkNodeServiceServer).GetJoinTrainingStatus(ctx, req.(*JoinTrainingRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _NetworkNodeService_SendHeartbeat_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(HeartbeatRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(NetworkNodeServiceServer).SendHeartbeat(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: NetworkNodeService_SendHeartbeat_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(NetworkNodeServiceServer).SendHeartbeat(ctx, req.(*HeartbeatRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _NetworkNodeService_GetAliveNodes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(GetAliveNodesRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(NetworkNodeServiceServer).GetAliveNodes(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: NetworkNodeService_GetAliveNodes_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(NetworkNodeServiceServer).GetAliveNodes(ctx, req.(*GetAliveNodesRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _NetworkNodeService_SetBarrier_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(SetBarrierRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(NetworkNodeServiceServer).SetBarrier(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: NetworkNodeService_SetBarrier_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(NetworkNodeServiceServer).SetBarrier(ctx, req.(*SetBarrierRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _NetworkNodeService_GetBarrierStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(GetBarrierStatusRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(NetworkNodeServiceServer).GetBarrierStatus(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: NetworkNodeService_GetBarrierStatus_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(NetworkNodeServiceServer).GetBarrierStatus(ctx, req.(*GetBarrierStatusRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _NetworkNodeService_SetStoreRecord_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(SetStoreRecordRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(NetworkNodeServiceServer).SetStoreRecord(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: NetworkNodeService_SetStoreRecord_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(NetworkNodeServiceServer).SetStoreRecord(ctx, req.(*SetStoreRecordRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _NetworkNodeService_GetStoreRecord_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(GetStoreRecordRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(NetworkNodeServiceServer).GetStoreRecord(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: NetworkNodeService_GetStoreRecord_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(NetworkNodeServiceServer).GetStoreRecord(ctx, req.(*GetStoreRecordRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _NetworkNodeService_ListStoreKeys_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(StoreListKeysRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(NetworkNodeServiceServer).ListStoreKeys(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: NetworkNodeService_ListStoreKeys_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(NetworkNodeServiceServer).ListStoreKeys(ctx, req.(*StoreListKeysRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+// NetworkNodeService_ServiceDesc is the grpc.ServiceDesc for NetworkNodeService service.
+// It's only intended for direct use with grpc.RegisterService,
+// and not to be introspected or modified (even as a copy)
+var NetworkNodeService_ServiceDesc = grpc.ServiceDesc{
+ ServiceName: "inference.inference.NetworkNodeService",
+ HandlerType: (*NetworkNodeServiceServer)(nil),
+ Methods: []grpc.MethodDesc{
+ {
+ MethodName: "JoinTraining",
+ Handler: _NetworkNodeService_JoinTraining_Handler,
+ },
+ {
+ MethodName: "GetJoinTrainingStatus",
+ Handler: _NetworkNodeService_GetJoinTrainingStatus_Handler,
+ },
+ {
+ MethodName: "SendHeartbeat",
+ Handler: _NetworkNodeService_SendHeartbeat_Handler,
+ },
+ {
+ MethodName: "GetAliveNodes",
+ Handler: _NetworkNodeService_GetAliveNodes_Handler,
+ },
+ {
+ MethodName: "SetBarrier",
+ Handler: _NetworkNodeService_SetBarrier_Handler,
+ },
+ {
+ MethodName: "GetBarrierStatus",
+ Handler: _NetworkNodeService_GetBarrierStatus_Handler,
+ },
+ {
+ MethodName: "SetStoreRecord",
+ Handler: _NetworkNodeService_SetStoreRecord_Handler,
+ },
+ {
+ MethodName: "GetStoreRecord",
+ Handler: _NetworkNodeService_GetStoreRecord_Handler,
+ },
+ {
+ MethodName: "ListStoreKeys",
+ Handler: _NetworkNodeService_ListStoreKeys_Handler,
+ },
+ },
+ Streams: []grpc.StreamDesc{},
+ Metadata: "inference/inference/network_node.proto",
+}
diff --git a/inference-chain/api/inference/inference/params.pulsar.go b/inference-chain/api/inference/inference/params.pulsar.go
new file mode 100644
index 000000000..64270c069
--- /dev/null
+++ b/inference-chain/api/inference/inference/params.pulsar.go
@@ -0,0 +1,12984 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package inference
+
+import (
+ _ "cosmossdk.io/api/amino"
+ fmt "fmt"
+ _ "github.com/cosmos/cosmos-proto"
+ runtime "github.com/cosmos/cosmos-proto/runtime"
+ _ "github.com/cosmos/gogoproto/gogoproto"
+ 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_Params protoreflect.MessageDescriptor
+ fd_Params_epoch_params protoreflect.FieldDescriptor
+ fd_Params_validation_params protoreflect.FieldDescriptor
+ fd_Params_poc_params protoreflect.FieldDescriptor
+ fd_Params_tokenomics_params protoreflect.FieldDescriptor
+ fd_Params_collateral_params protoreflect.FieldDescriptor
+ fd_Params_bitcoin_reward_params protoreflect.FieldDescriptor
+ fd_Params_dynamic_pricing_params protoreflect.FieldDescriptor
+ fd_Params_bandwidth_limits_params protoreflect.FieldDescriptor
+ fd_Params_confirmation_poc_params protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_params_proto_init()
+ md_Params = File_inference_inference_params_proto.Messages().ByName("Params")
+ fd_Params_epoch_params = md_Params.Fields().ByName("epoch_params")
+ fd_Params_validation_params = md_Params.Fields().ByName("validation_params")
+ fd_Params_poc_params = md_Params.Fields().ByName("poc_params")
+ fd_Params_tokenomics_params = md_Params.Fields().ByName("tokenomics_params")
+ fd_Params_collateral_params = md_Params.Fields().ByName("collateral_params")
+ fd_Params_bitcoin_reward_params = md_Params.Fields().ByName("bitcoin_reward_params")
+ fd_Params_dynamic_pricing_params = md_Params.Fields().ByName("dynamic_pricing_params")
+ fd_Params_bandwidth_limits_params = md_Params.Fields().ByName("bandwidth_limits_params")
+ fd_Params_confirmation_poc_params = md_Params.Fields().ByName("confirmation_poc_params")
+}
+
+var _ protoreflect.Message = (*fastReflection_Params)(nil)
+
+type fastReflection_Params Params
+
+func (x *Params) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_Params)(x)
+}
+
+func (x *Params) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_params_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_Params_messageType fastReflection_Params_messageType
+var _ protoreflect.MessageType = fastReflection_Params_messageType{}
+
+type fastReflection_Params_messageType struct{}
+
+func (x fastReflection_Params_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_Params)(nil)
+}
+func (x fastReflection_Params_messageType) New() protoreflect.Message {
+ return new(fastReflection_Params)
+}
+func (x fastReflection_Params_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_Params
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_Params) Descriptor() protoreflect.MessageDescriptor {
+ return md_Params
+}
+
+// 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_Params) Type() protoreflect.MessageType {
+ return _fastReflection_Params_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_Params) New() protoreflect.Message {
+ return new(fastReflection_Params)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_Params) Interface() protoreflect.ProtoMessage {
+ return (*Params)(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_Params) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.EpochParams != nil {
+ value := protoreflect.ValueOfMessage(x.EpochParams.ProtoReflect())
+ if !f(fd_Params_epoch_params, value) {
+ return
+ }
+ }
+ if x.ValidationParams != nil {
+ value := protoreflect.ValueOfMessage(x.ValidationParams.ProtoReflect())
+ if !f(fd_Params_validation_params, value) {
+ return
+ }
+ }
+ if x.PocParams != nil {
+ value := protoreflect.ValueOfMessage(x.PocParams.ProtoReflect())
+ if !f(fd_Params_poc_params, value) {
+ return
+ }
+ }
+ if x.TokenomicsParams != nil {
+ value := protoreflect.ValueOfMessage(x.TokenomicsParams.ProtoReflect())
+ if !f(fd_Params_tokenomics_params, value) {
+ return
+ }
+ }
+ if x.CollateralParams != nil {
+ value := protoreflect.ValueOfMessage(x.CollateralParams.ProtoReflect())
+ if !f(fd_Params_collateral_params, value) {
+ return
+ }
+ }
+ if x.BitcoinRewardParams != nil {
+ value := protoreflect.ValueOfMessage(x.BitcoinRewardParams.ProtoReflect())
+ if !f(fd_Params_bitcoin_reward_params, value) {
+ return
+ }
+ }
+ if x.DynamicPricingParams != nil {
+ value := protoreflect.ValueOfMessage(x.DynamicPricingParams.ProtoReflect())
+ if !f(fd_Params_dynamic_pricing_params, value) {
+ return
+ }
+ }
+ if x.BandwidthLimitsParams != nil {
+ value := protoreflect.ValueOfMessage(x.BandwidthLimitsParams.ProtoReflect())
+ if !f(fd_Params_bandwidth_limits_params, value) {
+ return
+ }
+ }
+ if x.ConfirmationPocParams != nil {
+ value := protoreflect.ValueOfMessage(x.ConfirmationPocParams.ProtoReflect())
+ if !f(fd_Params_confirmation_poc_params, 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_Params) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.Params.epoch_params":
+ return x.EpochParams != nil
+ case "inference.inference.Params.validation_params":
+ return x.ValidationParams != nil
+ case "inference.inference.Params.poc_params":
+ return x.PocParams != nil
+ case "inference.inference.Params.tokenomics_params":
+ return x.TokenomicsParams != nil
+ case "inference.inference.Params.collateral_params":
+ return x.CollateralParams != nil
+ case "inference.inference.Params.bitcoin_reward_params":
+ return x.BitcoinRewardParams != nil
+ case "inference.inference.Params.dynamic_pricing_params":
+ return x.DynamicPricingParams != nil
+ case "inference.inference.Params.bandwidth_limits_params":
+ return x.BandwidthLimitsParams != nil
+ case "inference.inference.Params.confirmation_poc_params":
+ return x.ConfirmationPocParams != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Params"))
+ }
+ panic(fmt.Errorf("message inference.inference.Params 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_Params) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.Params.epoch_params":
+ x.EpochParams = nil
+ case "inference.inference.Params.validation_params":
+ x.ValidationParams = nil
+ case "inference.inference.Params.poc_params":
+ x.PocParams = nil
+ case "inference.inference.Params.tokenomics_params":
+ x.TokenomicsParams = nil
+ case "inference.inference.Params.collateral_params":
+ x.CollateralParams = nil
+ case "inference.inference.Params.bitcoin_reward_params":
+ x.BitcoinRewardParams = nil
+ case "inference.inference.Params.dynamic_pricing_params":
+ x.DynamicPricingParams = nil
+ case "inference.inference.Params.bandwidth_limits_params":
+ x.BandwidthLimitsParams = nil
+ case "inference.inference.Params.confirmation_poc_params":
+ x.ConfirmationPocParams = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Params"))
+ }
+ panic(fmt.Errorf("message inference.inference.Params 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_Params) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.Params.epoch_params":
+ value := x.EpochParams
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.Params.validation_params":
+ value := x.ValidationParams
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.Params.poc_params":
+ value := x.PocParams
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.Params.tokenomics_params":
+ value := x.TokenomicsParams
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.Params.collateral_params":
+ value := x.CollateralParams
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.Params.bitcoin_reward_params":
+ value := x.BitcoinRewardParams
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.Params.dynamic_pricing_params":
+ value := x.DynamicPricingParams
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.Params.bandwidth_limits_params":
+ value := x.BandwidthLimitsParams
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.Params.confirmation_poc_params":
+ value := x.ConfirmationPocParams
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Params"))
+ }
+ panic(fmt.Errorf("message inference.inference.Params 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_Params) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.Params.epoch_params":
+ x.EpochParams = value.Message().Interface().(*EpochParams)
+ case "inference.inference.Params.validation_params":
+ x.ValidationParams = value.Message().Interface().(*ValidationParams)
+ case "inference.inference.Params.poc_params":
+ x.PocParams = value.Message().Interface().(*PocParams)
+ case "inference.inference.Params.tokenomics_params":
+ x.TokenomicsParams = value.Message().Interface().(*TokenomicsParams)
+ case "inference.inference.Params.collateral_params":
+ x.CollateralParams = value.Message().Interface().(*CollateralParams)
+ case "inference.inference.Params.bitcoin_reward_params":
+ x.BitcoinRewardParams = value.Message().Interface().(*BitcoinRewardParams)
+ case "inference.inference.Params.dynamic_pricing_params":
+ x.DynamicPricingParams = value.Message().Interface().(*DynamicPricingParams)
+ case "inference.inference.Params.bandwidth_limits_params":
+ x.BandwidthLimitsParams = value.Message().Interface().(*BandwidthLimitsParams)
+ case "inference.inference.Params.confirmation_poc_params":
+ x.ConfirmationPocParams = value.Message().Interface().(*ConfirmationPoCParams)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Params"))
+ }
+ panic(fmt.Errorf("message inference.inference.Params 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_Params) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.Params.epoch_params":
+ if x.EpochParams == nil {
+ x.EpochParams = new(EpochParams)
+ }
+ return protoreflect.ValueOfMessage(x.EpochParams.ProtoReflect())
+ case "inference.inference.Params.validation_params":
+ if x.ValidationParams == nil {
+ x.ValidationParams = new(ValidationParams)
+ }
+ return protoreflect.ValueOfMessage(x.ValidationParams.ProtoReflect())
+ case "inference.inference.Params.poc_params":
+ if x.PocParams == nil {
+ x.PocParams = new(PocParams)
+ }
+ return protoreflect.ValueOfMessage(x.PocParams.ProtoReflect())
+ case "inference.inference.Params.tokenomics_params":
+ if x.TokenomicsParams == nil {
+ x.TokenomicsParams = new(TokenomicsParams)
+ }
+ return protoreflect.ValueOfMessage(x.TokenomicsParams.ProtoReflect())
+ case "inference.inference.Params.collateral_params":
+ if x.CollateralParams == nil {
+ x.CollateralParams = new(CollateralParams)
+ }
+ return protoreflect.ValueOfMessage(x.CollateralParams.ProtoReflect())
+ case "inference.inference.Params.bitcoin_reward_params":
+ if x.BitcoinRewardParams == nil {
+ x.BitcoinRewardParams = new(BitcoinRewardParams)
+ }
+ return protoreflect.ValueOfMessage(x.BitcoinRewardParams.ProtoReflect())
+ case "inference.inference.Params.dynamic_pricing_params":
+ if x.DynamicPricingParams == nil {
+ x.DynamicPricingParams = new(DynamicPricingParams)
+ }
+ return protoreflect.ValueOfMessage(x.DynamicPricingParams.ProtoReflect())
+ case "inference.inference.Params.bandwidth_limits_params":
+ if x.BandwidthLimitsParams == nil {
+ x.BandwidthLimitsParams = new(BandwidthLimitsParams)
+ }
+ return protoreflect.ValueOfMessage(x.BandwidthLimitsParams.ProtoReflect())
+ case "inference.inference.Params.confirmation_poc_params":
+ if x.ConfirmationPocParams == nil {
+ x.ConfirmationPocParams = new(ConfirmationPoCParams)
+ }
+ return protoreflect.ValueOfMessage(x.ConfirmationPocParams.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Params"))
+ }
+ panic(fmt.Errorf("message inference.inference.Params 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_Params) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.Params.epoch_params":
+ m := new(EpochParams)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.Params.validation_params":
+ m := new(ValidationParams)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.Params.poc_params":
+ m := new(PocParams)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.Params.tokenomics_params":
+ m := new(TokenomicsParams)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.Params.collateral_params":
+ m := new(CollateralParams)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.Params.bitcoin_reward_params":
+ m := new(BitcoinRewardParams)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.Params.dynamic_pricing_params":
+ m := new(DynamicPricingParams)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.Params.bandwidth_limits_params":
+ m := new(BandwidthLimitsParams)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.Params.confirmation_poc_params":
+ m := new(ConfirmationPoCParams)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Params"))
+ }
+ panic(fmt.Errorf("message inference.inference.Params 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_Params) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.Params", 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_Params) 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_Params) 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_Params) 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_Params) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*Params)
+ 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.EpochParams != nil {
+ l = options.Size(x.EpochParams)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.ValidationParams != nil {
+ l = options.Size(x.ValidationParams)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.PocParams != nil {
+ l = options.Size(x.PocParams)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.TokenomicsParams != nil {
+ l = options.Size(x.TokenomicsParams)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.CollateralParams != nil {
+ l = options.Size(x.CollateralParams)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.BitcoinRewardParams != nil {
+ l = options.Size(x.BitcoinRewardParams)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.DynamicPricingParams != nil {
+ l = options.Size(x.DynamicPricingParams)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.BandwidthLimitsParams != nil {
+ l = options.Size(x.BandwidthLimitsParams)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.ConfirmationPocParams != nil {
+ l = options.Size(x.ConfirmationPocParams)
+ 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().(*Params)
+ 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.ConfirmationPocParams != nil {
+ encoded, err := options.Marshal(x.ConfirmationPocParams)
+ 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] = 0x4a
+ }
+ if x.BandwidthLimitsParams != nil {
+ encoded, err := options.Marshal(x.BandwidthLimitsParams)
+ 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] = 0x42
+ }
+ if x.DynamicPricingParams != nil {
+ encoded, err := options.Marshal(x.DynamicPricingParams)
+ 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 x.BitcoinRewardParams != nil {
+ encoded, err := options.Marshal(x.BitcoinRewardParams)
+ 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 x.CollateralParams != nil {
+ encoded, err := options.Marshal(x.CollateralParams)
+ 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.TokenomicsParams != nil {
+ encoded, err := options.Marshal(x.TokenomicsParams)
+ 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.PocParams != nil {
+ encoded, err := options.Marshal(x.PocParams)
+ 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.ValidationParams != nil {
+ encoded, err := options.Marshal(x.ValidationParams)
+ 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.EpochParams != nil {
+ encoded, err := options.Marshal(x.EpochParams)
+ 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().(*Params)
+ 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: Params: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Params: 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 EpochParams", 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.EpochParams == nil {
+ x.EpochParams = &EpochParams{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.EpochParams); 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 ValidationParams", 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.ValidationParams == nil {
+ x.ValidationParams = &ValidationParams{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ValidationParams); 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 PocParams", 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.PocParams == nil {
+ x.PocParams = &PocParams{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.PocParams); 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 TokenomicsParams", 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.TokenomicsParams == nil {
+ x.TokenomicsParams = &TokenomicsParams{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.TokenomicsParams); 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 CollateralParams", 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.CollateralParams == nil {
+ x.CollateralParams = &CollateralParams{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.CollateralParams); err != nil {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+ }
+ iNdEx = postIndex
+ case 6:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BitcoinRewardParams", 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.BitcoinRewardParams == nil {
+ x.BitcoinRewardParams = &BitcoinRewardParams{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.BitcoinRewardParams); 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 DynamicPricingParams", 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.DynamicPricingParams == nil {
+ x.DynamicPricingParams = &DynamicPricingParams{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.DynamicPricingParams); err != nil {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+ }
+ iNdEx = postIndex
+ case 8:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BandwidthLimitsParams", 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.BandwidthLimitsParams == nil {
+ x.BandwidthLimitsParams = &BandwidthLimitsParams{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.BandwidthLimitsParams); err != nil {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+ }
+ iNdEx = postIndex
+ case 9:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ConfirmationPocParams", 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.ConfirmationPocParams == nil {
+ x.ConfirmationPocParams = &ConfirmationPoCParams{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ConfirmationPocParams); 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 = (*_GenesisOnlyParams_16_list)(nil)
+
+type _GenesisOnlyParams_16_list struct {
+ list *[]string
+}
+
+func (x *_GenesisOnlyParams_16_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_GenesisOnlyParams_16_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfString((*x.list)[i])
+}
+
+func (x *_GenesisOnlyParams_16_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.String()
+ concreteValue := valueUnwrapped
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_GenesisOnlyParams_16_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.String()
+ concreteValue := valueUnwrapped
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_GenesisOnlyParams_16_list) AppendMutable() protoreflect.Value {
+ panic(fmt.Errorf("AppendMutable can not be called on message GenesisOnlyParams at list field GenesisGuardianAddresses as it is not of Message kind"))
+}
+
+func (x *_GenesisOnlyParams_16_list) Truncate(n int) {
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_GenesisOnlyParams_16_list) NewElement() protoreflect.Value {
+ v := ""
+ return protoreflect.ValueOfString(v)
+}
+
+func (x *_GenesisOnlyParams_16_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_GenesisOnlyParams protoreflect.MessageDescriptor
+ fd_GenesisOnlyParams_total_supply protoreflect.FieldDescriptor
+ fd_GenesisOnlyParams_originator_supply protoreflect.FieldDescriptor
+ fd_GenesisOnlyParams_top_reward_amount protoreflect.FieldDescriptor
+ fd_GenesisOnlyParams_standard_reward_amount protoreflect.FieldDescriptor
+ fd_GenesisOnlyParams_pre_programmed_sale_amount protoreflect.FieldDescriptor
+ fd_GenesisOnlyParams_top_rewards protoreflect.FieldDescriptor
+ fd_GenesisOnlyParams_supply_denom protoreflect.FieldDescriptor
+ fd_GenesisOnlyParams_top_reward_period protoreflect.FieldDescriptor
+ fd_GenesisOnlyParams_top_reward_payouts protoreflect.FieldDescriptor
+ fd_GenesisOnlyParams_top_reward_payouts_per_miner protoreflect.FieldDescriptor
+ fd_GenesisOnlyParams_top_reward_max_duration protoreflect.FieldDescriptor
+ fd_GenesisOnlyParams_max_individual_power_percentage protoreflect.FieldDescriptor
+ fd_GenesisOnlyParams_genesis_guardian_enabled protoreflect.FieldDescriptor
+ fd_GenesisOnlyParams_genesis_guardian_network_maturity_threshold protoreflect.FieldDescriptor
+ fd_GenesisOnlyParams_genesis_guardian_multiplier protoreflect.FieldDescriptor
+ fd_GenesisOnlyParams_genesis_guardian_addresses protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_params_proto_init()
+ md_GenesisOnlyParams = File_inference_inference_params_proto.Messages().ByName("GenesisOnlyParams")
+ fd_GenesisOnlyParams_total_supply = md_GenesisOnlyParams.Fields().ByName("total_supply")
+ fd_GenesisOnlyParams_originator_supply = md_GenesisOnlyParams.Fields().ByName("originator_supply")
+ fd_GenesisOnlyParams_top_reward_amount = md_GenesisOnlyParams.Fields().ByName("top_reward_amount")
+ fd_GenesisOnlyParams_standard_reward_amount = md_GenesisOnlyParams.Fields().ByName("standard_reward_amount")
+ fd_GenesisOnlyParams_pre_programmed_sale_amount = md_GenesisOnlyParams.Fields().ByName("pre_programmed_sale_amount")
+ fd_GenesisOnlyParams_top_rewards = md_GenesisOnlyParams.Fields().ByName("top_rewards")
+ fd_GenesisOnlyParams_supply_denom = md_GenesisOnlyParams.Fields().ByName("supply_denom")
+ fd_GenesisOnlyParams_top_reward_period = md_GenesisOnlyParams.Fields().ByName("top_reward_period")
+ fd_GenesisOnlyParams_top_reward_payouts = md_GenesisOnlyParams.Fields().ByName("top_reward_payouts")
+ fd_GenesisOnlyParams_top_reward_payouts_per_miner = md_GenesisOnlyParams.Fields().ByName("top_reward_payouts_per_miner")
+ fd_GenesisOnlyParams_top_reward_max_duration = md_GenesisOnlyParams.Fields().ByName("top_reward_max_duration")
+ fd_GenesisOnlyParams_max_individual_power_percentage = md_GenesisOnlyParams.Fields().ByName("max_individual_power_percentage")
+ fd_GenesisOnlyParams_genesis_guardian_enabled = md_GenesisOnlyParams.Fields().ByName("genesis_guardian_enabled")
+ fd_GenesisOnlyParams_genesis_guardian_network_maturity_threshold = md_GenesisOnlyParams.Fields().ByName("genesis_guardian_network_maturity_threshold")
+ fd_GenesisOnlyParams_genesis_guardian_multiplier = md_GenesisOnlyParams.Fields().ByName("genesis_guardian_multiplier")
+ fd_GenesisOnlyParams_genesis_guardian_addresses = md_GenesisOnlyParams.Fields().ByName("genesis_guardian_addresses")
+}
+
+var _ protoreflect.Message = (*fastReflection_GenesisOnlyParams)(nil)
+
+type fastReflection_GenesisOnlyParams GenesisOnlyParams
+
+func (x *GenesisOnlyParams) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_GenesisOnlyParams)(x)
+}
+
+func (x *GenesisOnlyParams) 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_GenesisOnlyParams_messageType fastReflection_GenesisOnlyParams_messageType
+var _ protoreflect.MessageType = fastReflection_GenesisOnlyParams_messageType{}
+
+type fastReflection_GenesisOnlyParams_messageType struct{}
+
+func (x fastReflection_GenesisOnlyParams_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_GenesisOnlyParams)(nil)
+}
+func (x fastReflection_GenesisOnlyParams_messageType) New() protoreflect.Message {
+ return new(fastReflection_GenesisOnlyParams)
+}
+func (x fastReflection_GenesisOnlyParams_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_GenesisOnlyParams
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_GenesisOnlyParams) Descriptor() protoreflect.MessageDescriptor {
+ return md_GenesisOnlyParams
+}
+
+// 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_GenesisOnlyParams) Type() protoreflect.MessageType {
+ return _fastReflection_GenesisOnlyParams_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_GenesisOnlyParams) New() protoreflect.Message {
+ return new(fastReflection_GenesisOnlyParams)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_GenesisOnlyParams) Interface() protoreflect.ProtoMessage {
+ return (*GenesisOnlyParams)(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_GenesisOnlyParams) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.TotalSupply != int64(0) {
+ value := protoreflect.ValueOfInt64(x.TotalSupply)
+ if !f(fd_GenesisOnlyParams_total_supply, value) {
+ return
+ }
+ }
+ if x.OriginatorSupply != int64(0) {
+ value := protoreflect.ValueOfInt64(x.OriginatorSupply)
+ if !f(fd_GenesisOnlyParams_originator_supply, value) {
+ return
+ }
+ }
+ if x.TopRewardAmount != int64(0) {
+ value := protoreflect.ValueOfInt64(x.TopRewardAmount)
+ if !f(fd_GenesisOnlyParams_top_reward_amount, value) {
+ return
+ }
+ }
+ if x.StandardRewardAmount != int64(0) {
+ value := protoreflect.ValueOfInt64(x.StandardRewardAmount)
+ if !f(fd_GenesisOnlyParams_standard_reward_amount, value) {
+ return
+ }
+ }
+ if x.PreProgrammedSaleAmount != int64(0) {
+ value := protoreflect.ValueOfInt64(x.PreProgrammedSaleAmount)
+ if !f(fd_GenesisOnlyParams_pre_programmed_sale_amount, value) {
+ return
+ }
+ }
+ if x.TopRewards != int32(0) {
+ value := protoreflect.ValueOfInt32(x.TopRewards)
+ if !f(fd_GenesisOnlyParams_top_rewards, value) {
+ return
+ }
+ }
+ if x.SupplyDenom != "" {
+ value := protoreflect.ValueOfString(x.SupplyDenom)
+ if !f(fd_GenesisOnlyParams_supply_denom, value) {
+ return
+ }
+ }
+ if x.TopRewardPeriod != int64(0) {
+ value := protoreflect.ValueOfInt64(x.TopRewardPeriod)
+ if !f(fd_GenesisOnlyParams_top_reward_period, value) {
+ return
+ }
+ }
+ if x.TopRewardPayouts != int64(0) {
+ value := protoreflect.ValueOfInt64(x.TopRewardPayouts)
+ if !f(fd_GenesisOnlyParams_top_reward_payouts, value) {
+ return
+ }
+ }
+ if x.TopRewardPayoutsPerMiner != int64(0) {
+ value := protoreflect.ValueOfInt64(x.TopRewardPayoutsPerMiner)
+ if !f(fd_GenesisOnlyParams_top_reward_payouts_per_miner, value) {
+ return
+ }
+ }
+ if x.TopRewardMaxDuration != int64(0) {
+ value := protoreflect.ValueOfInt64(x.TopRewardMaxDuration)
+ if !f(fd_GenesisOnlyParams_top_reward_max_duration, value) {
+ return
+ }
+ }
+ if x.MaxIndividualPowerPercentage != nil {
+ value := protoreflect.ValueOfMessage(x.MaxIndividualPowerPercentage.ProtoReflect())
+ if !f(fd_GenesisOnlyParams_max_individual_power_percentage, value) {
+ return
+ }
+ }
+ if x.GenesisGuardianEnabled != false {
+ value := protoreflect.ValueOfBool(x.GenesisGuardianEnabled)
+ if !f(fd_GenesisOnlyParams_genesis_guardian_enabled, value) {
+ return
+ }
+ }
+ if x.GenesisGuardianNetworkMaturityThreshold != int64(0) {
+ value := protoreflect.ValueOfInt64(x.GenesisGuardianNetworkMaturityThreshold)
+ if !f(fd_GenesisOnlyParams_genesis_guardian_network_maturity_threshold, value) {
+ return
+ }
+ }
+ if x.GenesisGuardianMultiplier != nil {
+ value := protoreflect.ValueOfMessage(x.GenesisGuardianMultiplier.ProtoReflect())
+ if !f(fd_GenesisOnlyParams_genesis_guardian_multiplier, value) {
+ return
+ }
+ }
+ if len(x.GenesisGuardianAddresses) != 0 {
+ value := protoreflect.ValueOfList(&_GenesisOnlyParams_16_list{list: &x.GenesisGuardianAddresses})
+ if !f(fd_GenesisOnlyParams_genesis_guardian_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_GenesisOnlyParams) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.GenesisOnlyParams.total_supply":
+ return x.TotalSupply != int64(0)
+ case "inference.inference.GenesisOnlyParams.originator_supply":
+ return x.OriginatorSupply != int64(0)
+ case "inference.inference.GenesisOnlyParams.top_reward_amount":
+ return x.TopRewardAmount != int64(0)
+ case "inference.inference.GenesisOnlyParams.standard_reward_amount":
+ return x.StandardRewardAmount != int64(0)
+ case "inference.inference.GenesisOnlyParams.pre_programmed_sale_amount":
+ return x.PreProgrammedSaleAmount != int64(0)
+ case "inference.inference.GenesisOnlyParams.top_rewards":
+ return x.TopRewards != int32(0)
+ case "inference.inference.GenesisOnlyParams.supply_denom":
+ return x.SupplyDenom != ""
+ case "inference.inference.GenesisOnlyParams.top_reward_period":
+ return x.TopRewardPeriod != int64(0)
+ case "inference.inference.GenesisOnlyParams.top_reward_payouts":
+ return x.TopRewardPayouts != int64(0)
+ case "inference.inference.GenesisOnlyParams.top_reward_payouts_per_miner":
+ return x.TopRewardPayoutsPerMiner != int64(0)
+ case "inference.inference.GenesisOnlyParams.top_reward_max_duration":
+ return x.TopRewardMaxDuration != int64(0)
+ case "inference.inference.GenesisOnlyParams.max_individual_power_percentage":
+ return x.MaxIndividualPowerPercentage != nil
+ case "inference.inference.GenesisOnlyParams.genesis_guardian_enabled":
+ return x.GenesisGuardianEnabled != false
+ case "inference.inference.GenesisOnlyParams.genesis_guardian_network_maturity_threshold":
+ return x.GenesisGuardianNetworkMaturityThreshold != int64(0)
+ case "inference.inference.GenesisOnlyParams.genesis_guardian_multiplier":
+ return x.GenesisGuardianMultiplier != nil
+ case "inference.inference.GenesisOnlyParams.genesis_guardian_addresses":
+ return len(x.GenesisGuardianAddresses) != 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GenesisOnlyParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.GenesisOnlyParams 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_GenesisOnlyParams) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.GenesisOnlyParams.total_supply":
+ x.TotalSupply = int64(0)
+ case "inference.inference.GenesisOnlyParams.originator_supply":
+ x.OriginatorSupply = int64(0)
+ case "inference.inference.GenesisOnlyParams.top_reward_amount":
+ x.TopRewardAmount = int64(0)
+ case "inference.inference.GenesisOnlyParams.standard_reward_amount":
+ x.StandardRewardAmount = int64(0)
+ case "inference.inference.GenesisOnlyParams.pre_programmed_sale_amount":
+ x.PreProgrammedSaleAmount = int64(0)
+ case "inference.inference.GenesisOnlyParams.top_rewards":
+ x.TopRewards = int32(0)
+ case "inference.inference.GenesisOnlyParams.supply_denom":
+ x.SupplyDenom = ""
+ case "inference.inference.GenesisOnlyParams.top_reward_period":
+ x.TopRewardPeriod = int64(0)
+ case "inference.inference.GenesisOnlyParams.top_reward_payouts":
+ x.TopRewardPayouts = int64(0)
+ case "inference.inference.GenesisOnlyParams.top_reward_payouts_per_miner":
+ x.TopRewardPayoutsPerMiner = int64(0)
+ case "inference.inference.GenesisOnlyParams.top_reward_max_duration":
+ x.TopRewardMaxDuration = int64(0)
+ case "inference.inference.GenesisOnlyParams.max_individual_power_percentage":
+ x.MaxIndividualPowerPercentage = nil
+ case "inference.inference.GenesisOnlyParams.genesis_guardian_enabled":
+ x.GenesisGuardianEnabled = false
+ case "inference.inference.GenesisOnlyParams.genesis_guardian_network_maturity_threshold":
+ x.GenesisGuardianNetworkMaturityThreshold = int64(0)
+ case "inference.inference.GenesisOnlyParams.genesis_guardian_multiplier":
+ x.GenesisGuardianMultiplier = nil
+ case "inference.inference.GenesisOnlyParams.genesis_guardian_addresses":
+ x.GenesisGuardianAddresses = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GenesisOnlyParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.GenesisOnlyParams 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_GenesisOnlyParams) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.GenesisOnlyParams.total_supply":
+ value := x.TotalSupply
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.GenesisOnlyParams.originator_supply":
+ value := x.OriginatorSupply
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.GenesisOnlyParams.top_reward_amount":
+ value := x.TopRewardAmount
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.GenesisOnlyParams.standard_reward_amount":
+ value := x.StandardRewardAmount
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.GenesisOnlyParams.pre_programmed_sale_amount":
+ value := x.PreProgrammedSaleAmount
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.GenesisOnlyParams.top_rewards":
+ value := x.TopRewards
+ return protoreflect.ValueOfInt32(value)
+ case "inference.inference.GenesisOnlyParams.supply_denom":
+ value := x.SupplyDenom
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.GenesisOnlyParams.top_reward_period":
+ value := x.TopRewardPeriod
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.GenesisOnlyParams.top_reward_payouts":
+ value := x.TopRewardPayouts
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.GenesisOnlyParams.top_reward_payouts_per_miner":
+ value := x.TopRewardPayoutsPerMiner
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.GenesisOnlyParams.top_reward_max_duration":
+ value := x.TopRewardMaxDuration
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.GenesisOnlyParams.max_individual_power_percentage":
+ value := x.MaxIndividualPowerPercentage
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.GenesisOnlyParams.genesis_guardian_enabled":
+ value := x.GenesisGuardianEnabled
+ return protoreflect.ValueOfBool(value)
+ case "inference.inference.GenesisOnlyParams.genesis_guardian_network_maturity_threshold":
+ value := x.GenesisGuardianNetworkMaturityThreshold
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.GenesisOnlyParams.genesis_guardian_multiplier":
+ value := x.GenesisGuardianMultiplier
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.GenesisOnlyParams.genesis_guardian_addresses":
+ if len(x.GenesisGuardianAddresses) == 0 {
+ return protoreflect.ValueOfList(&_GenesisOnlyParams_16_list{})
+ }
+ listValue := &_GenesisOnlyParams_16_list{list: &x.GenesisGuardianAddresses}
+ return protoreflect.ValueOfList(listValue)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GenesisOnlyParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.GenesisOnlyParams 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_GenesisOnlyParams) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.GenesisOnlyParams.total_supply":
+ x.TotalSupply = value.Int()
+ case "inference.inference.GenesisOnlyParams.originator_supply":
+ x.OriginatorSupply = value.Int()
+ case "inference.inference.GenesisOnlyParams.top_reward_amount":
+ x.TopRewardAmount = value.Int()
+ case "inference.inference.GenesisOnlyParams.standard_reward_amount":
+ x.StandardRewardAmount = value.Int()
+ case "inference.inference.GenesisOnlyParams.pre_programmed_sale_amount":
+ x.PreProgrammedSaleAmount = value.Int()
+ case "inference.inference.GenesisOnlyParams.top_rewards":
+ x.TopRewards = int32(value.Int())
+ case "inference.inference.GenesisOnlyParams.supply_denom":
+ x.SupplyDenom = value.Interface().(string)
+ case "inference.inference.GenesisOnlyParams.top_reward_period":
+ x.TopRewardPeriod = value.Int()
+ case "inference.inference.GenesisOnlyParams.top_reward_payouts":
+ x.TopRewardPayouts = value.Int()
+ case "inference.inference.GenesisOnlyParams.top_reward_payouts_per_miner":
+ x.TopRewardPayoutsPerMiner = value.Int()
+ case "inference.inference.GenesisOnlyParams.top_reward_max_duration":
+ x.TopRewardMaxDuration = value.Int()
+ case "inference.inference.GenesisOnlyParams.max_individual_power_percentage":
+ x.MaxIndividualPowerPercentage = value.Message().Interface().(*Decimal)
+ case "inference.inference.GenesisOnlyParams.genesis_guardian_enabled":
+ x.GenesisGuardianEnabled = value.Bool()
+ case "inference.inference.GenesisOnlyParams.genesis_guardian_network_maturity_threshold":
+ x.GenesisGuardianNetworkMaturityThreshold = value.Int()
+ case "inference.inference.GenesisOnlyParams.genesis_guardian_multiplier":
+ x.GenesisGuardianMultiplier = value.Message().Interface().(*Decimal)
+ case "inference.inference.GenesisOnlyParams.genesis_guardian_addresses":
+ lv := value.List()
+ clv := lv.(*_GenesisOnlyParams_16_list)
+ x.GenesisGuardianAddresses = *clv.list
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GenesisOnlyParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.GenesisOnlyParams 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_GenesisOnlyParams) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.GenesisOnlyParams.max_individual_power_percentage":
+ if x.MaxIndividualPowerPercentage == nil {
+ x.MaxIndividualPowerPercentage = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.MaxIndividualPowerPercentage.ProtoReflect())
+ case "inference.inference.GenesisOnlyParams.genesis_guardian_multiplier":
+ if x.GenesisGuardianMultiplier == nil {
+ x.GenesisGuardianMultiplier = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.GenesisGuardianMultiplier.ProtoReflect())
+ case "inference.inference.GenesisOnlyParams.genesis_guardian_addresses":
+ if x.GenesisGuardianAddresses == nil {
+ x.GenesisGuardianAddresses = []string{}
+ }
+ value := &_GenesisOnlyParams_16_list{list: &x.GenesisGuardianAddresses}
+ return protoreflect.ValueOfList(value)
+ case "inference.inference.GenesisOnlyParams.total_supply":
+ panic(fmt.Errorf("field total_supply of message inference.inference.GenesisOnlyParams is not mutable"))
+ case "inference.inference.GenesisOnlyParams.originator_supply":
+ panic(fmt.Errorf("field originator_supply of message inference.inference.GenesisOnlyParams is not mutable"))
+ case "inference.inference.GenesisOnlyParams.top_reward_amount":
+ panic(fmt.Errorf("field top_reward_amount of message inference.inference.GenesisOnlyParams is not mutable"))
+ case "inference.inference.GenesisOnlyParams.standard_reward_amount":
+ panic(fmt.Errorf("field standard_reward_amount of message inference.inference.GenesisOnlyParams is not mutable"))
+ case "inference.inference.GenesisOnlyParams.pre_programmed_sale_amount":
+ panic(fmt.Errorf("field pre_programmed_sale_amount of message inference.inference.GenesisOnlyParams is not mutable"))
+ case "inference.inference.GenesisOnlyParams.top_rewards":
+ panic(fmt.Errorf("field top_rewards of message inference.inference.GenesisOnlyParams is not mutable"))
+ case "inference.inference.GenesisOnlyParams.supply_denom":
+ panic(fmt.Errorf("field supply_denom of message inference.inference.GenesisOnlyParams is not mutable"))
+ case "inference.inference.GenesisOnlyParams.top_reward_period":
+ panic(fmt.Errorf("field top_reward_period of message inference.inference.GenesisOnlyParams is not mutable"))
+ case "inference.inference.GenesisOnlyParams.top_reward_payouts":
+ panic(fmt.Errorf("field top_reward_payouts of message inference.inference.GenesisOnlyParams is not mutable"))
+ case "inference.inference.GenesisOnlyParams.top_reward_payouts_per_miner":
+ panic(fmt.Errorf("field top_reward_payouts_per_miner of message inference.inference.GenesisOnlyParams is not mutable"))
+ case "inference.inference.GenesisOnlyParams.top_reward_max_duration":
+ panic(fmt.Errorf("field top_reward_max_duration of message inference.inference.GenesisOnlyParams is not mutable"))
+ case "inference.inference.GenesisOnlyParams.genesis_guardian_enabled":
+ panic(fmt.Errorf("field genesis_guardian_enabled of message inference.inference.GenesisOnlyParams is not mutable"))
+ case "inference.inference.GenesisOnlyParams.genesis_guardian_network_maturity_threshold":
+ panic(fmt.Errorf("field genesis_guardian_network_maturity_threshold of message inference.inference.GenesisOnlyParams is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GenesisOnlyParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.GenesisOnlyParams 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_GenesisOnlyParams) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.GenesisOnlyParams.total_supply":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.GenesisOnlyParams.originator_supply":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.GenesisOnlyParams.top_reward_amount":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.GenesisOnlyParams.standard_reward_amount":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.GenesisOnlyParams.pre_programmed_sale_amount":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.GenesisOnlyParams.top_rewards":
+ return protoreflect.ValueOfInt32(int32(0))
+ case "inference.inference.GenesisOnlyParams.supply_denom":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.GenesisOnlyParams.top_reward_period":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.GenesisOnlyParams.top_reward_payouts":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.GenesisOnlyParams.top_reward_payouts_per_miner":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.GenesisOnlyParams.top_reward_max_duration":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.GenesisOnlyParams.max_individual_power_percentage":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.GenesisOnlyParams.genesis_guardian_enabled":
+ return protoreflect.ValueOfBool(false)
+ case "inference.inference.GenesisOnlyParams.genesis_guardian_network_maturity_threshold":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.GenesisOnlyParams.genesis_guardian_multiplier":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.GenesisOnlyParams.genesis_guardian_addresses":
+ list := []string{}
+ return protoreflect.ValueOfList(&_GenesisOnlyParams_16_list{list: &list})
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.GenesisOnlyParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.GenesisOnlyParams 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_GenesisOnlyParams) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.GenesisOnlyParams", 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_GenesisOnlyParams) 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_GenesisOnlyParams) 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_GenesisOnlyParams) 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_GenesisOnlyParams) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*GenesisOnlyParams)
+ 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.TotalSupply != 0 {
+ n += 1 + runtime.Sov(uint64(x.TotalSupply))
+ }
+ if x.OriginatorSupply != 0 {
+ n += 1 + runtime.Sov(uint64(x.OriginatorSupply))
+ }
+ if x.TopRewardAmount != 0 {
+ n += 1 + runtime.Sov(uint64(x.TopRewardAmount))
+ }
+ if x.StandardRewardAmount != 0 {
+ n += 1 + runtime.Sov(uint64(x.StandardRewardAmount))
+ }
+ if x.PreProgrammedSaleAmount != 0 {
+ n += 1 + runtime.Sov(uint64(x.PreProgrammedSaleAmount))
+ }
+ if x.TopRewards != 0 {
+ n += 1 + runtime.Sov(uint64(x.TopRewards))
+ }
+ l = len(x.SupplyDenom)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.TopRewardPeriod != 0 {
+ n += 1 + runtime.Sov(uint64(x.TopRewardPeriod))
+ }
+ if x.TopRewardPayouts != 0 {
+ n += 1 + runtime.Sov(uint64(x.TopRewardPayouts))
+ }
+ if x.TopRewardPayoutsPerMiner != 0 {
+ n += 1 + runtime.Sov(uint64(x.TopRewardPayoutsPerMiner))
+ }
+ if x.TopRewardMaxDuration != 0 {
+ n += 1 + runtime.Sov(uint64(x.TopRewardMaxDuration))
+ }
+ if x.MaxIndividualPowerPercentage != nil {
+ l = options.Size(x.MaxIndividualPowerPercentage)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.GenesisGuardianEnabled {
+ n += 2
+ }
+ if x.GenesisGuardianNetworkMaturityThreshold != 0 {
+ n += 1 + runtime.Sov(uint64(x.GenesisGuardianNetworkMaturityThreshold))
+ }
+ if x.GenesisGuardianMultiplier != nil {
+ l = options.Size(x.GenesisGuardianMultiplier)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if len(x.GenesisGuardianAddresses) > 0 {
+ for _, s := range x.GenesisGuardianAddresses {
+ l = len(s)
+ n += 2 + 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().(*GenesisOnlyParams)
+ 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.GenesisGuardianAddresses) > 0 {
+ for iNdEx := len(x.GenesisGuardianAddresses) - 1; iNdEx >= 0; iNdEx-- {
+ i -= len(x.GenesisGuardianAddresses[iNdEx])
+ copy(dAtA[i:], x.GenesisGuardianAddresses[iNdEx])
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.GenesisGuardianAddresses[iNdEx])))
+ i--
+ dAtA[i] = 0x1
+ i--
+ dAtA[i] = 0x82
+ }
+ }
+ if x.GenesisGuardianMultiplier != nil {
+ encoded, err := options.Marshal(x.GenesisGuardianMultiplier)
+ 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] = 0x7a
+ }
+ if x.GenesisGuardianNetworkMaturityThreshold != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.GenesisGuardianNetworkMaturityThreshold))
+ i--
+ dAtA[i] = 0x70
+ }
+ if x.GenesisGuardianEnabled {
+ i--
+ if x.GenesisGuardianEnabled {
+ dAtA[i] = 1
+ } else {
+ dAtA[i] = 0
+ }
+ i--
+ dAtA[i] = 0x68
+ }
+ if x.MaxIndividualPowerPercentage != nil {
+ encoded, err := options.Marshal(x.MaxIndividualPowerPercentage)
+ 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] = 0x62
+ }
+ if x.TopRewardMaxDuration != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.TopRewardMaxDuration))
+ i--
+ dAtA[i] = 0x58
+ }
+ if x.TopRewardPayoutsPerMiner != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.TopRewardPayoutsPerMiner))
+ i--
+ dAtA[i] = 0x50
+ }
+ if x.TopRewardPayouts != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.TopRewardPayouts))
+ i--
+ dAtA[i] = 0x48
+ }
+ if x.TopRewardPeriod != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.TopRewardPeriod))
+ i--
+ dAtA[i] = 0x40
+ }
+ if len(x.SupplyDenom) > 0 {
+ i -= len(x.SupplyDenom)
+ copy(dAtA[i:], x.SupplyDenom)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.SupplyDenom)))
+ i--
+ dAtA[i] = 0x3a
+ }
+ if x.TopRewards != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.TopRewards))
+ i--
+ dAtA[i] = 0x30
+ }
+ if x.PreProgrammedSaleAmount != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.PreProgrammedSaleAmount))
+ i--
+ dAtA[i] = 0x28
+ }
+ if x.StandardRewardAmount != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.StandardRewardAmount))
+ i--
+ dAtA[i] = 0x20
+ }
+ if x.TopRewardAmount != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.TopRewardAmount))
+ i--
+ dAtA[i] = 0x18
+ }
+ if x.OriginatorSupply != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.OriginatorSupply))
+ i--
+ dAtA[i] = 0x10
+ }
+ if x.TotalSupply != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.TotalSupply))
+ 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().(*GenesisOnlyParams)
+ 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: GenesisOnlyParams: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: GenesisOnlyParams: 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 TotalSupply", wireType)
+ }
+ x.TotalSupply = 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.TotalSupply |= 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 OriginatorSupply", wireType)
+ }
+ x.OriginatorSupply = 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.OriginatorSupply |= 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 TopRewardAmount", wireType)
+ }
+ x.TopRewardAmount = 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.TopRewardAmount |= 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 StandardRewardAmount", wireType)
+ }
+ x.StandardRewardAmount = 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.StandardRewardAmount |= int64(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 PreProgrammedSaleAmount", wireType)
+ }
+ x.PreProgrammedSaleAmount = 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.PreProgrammedSaleAmount |= int64(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 TopRewards", wireType)
+ }
+ x.TopRewards = 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.TopRewards |= int32(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 SupplyDenom", 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.SupplyDenom = 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 TopRewardPeriod", wireType)
+ }
+ x.TopRewardPeriod = 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.TopRewardPeriod |= int64(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 TopRewardPayouts", wireType)
+ }
+ x.TopRewardPayouts = 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.TopRewardPayouts |= int64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 10:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TopRewardPayoutsPerMiner", wireType)
+ }
+ x.TopRewardPayoutsPerMiner = 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.TopRewardPayoutsPerMiner |= int64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 11:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TopRewardMaxDuration", wireType)
+ }
+ x.TopRewardMaxDuration = 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.TopRewardMaxDuration |= int64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 12:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MaxIndividualPowerPercentage", 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.MaxIndividualPowerPercentage == nil {
+ x.MaxIndividualPowerPercentage = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.MaxIndividualPowerPercentage); err != nil {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+ }
+ iNdEx = postIndex
+ case 13:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field GenesisGuardianEnabled", 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.GenesisGuardianEnabled = bool(v != 0)
+ case 14:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field GenesisGuardianNetworkMaturityThreshold", wireType)
+ }
+ x.GenesisGuardianNetworkMaturityThreshold = 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.GenesisGuardianNetworkMaturityThreshold |= int64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 15:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field GenesisGuardianMultiplier", 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.GenesisGuardianMultiplier == nil {
+ x.GenesisGuardianMultiplier = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.GenesisGuardianMultiplier); 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 GenesisGuardianAddresses", 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.GenesisGuardianAddresses = append(x.GenesisGuardianAddresses, 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_TokenomicsParams protoreflect.MessageDescriptor
+ fd_TokenomicsParams_subsidy_reduction_interval protoreflect.FieldDescriptor
+ fd_TokenomicsParams_subsidy_reduction_amount protoreflect.FieldDescriptor
+ fd_TokenomicsParams_current_subsidy_percentage protoreflect.FieldDescriptor
+ fd_TokenomicsParams_top_reward_allowed_failure protoreflect.FieldDescriptor
+ fd_TokenomicsParams_top_miner_poc_qualification protoreflect.FieldDescriptor
+ fd_TokenomicsParams_work_vesting_period protoreflect.FieldDescriptor
+ fd_TokenomicsParams_reward_vesting_period protoreflect.FieldDescriptor
+ fd_TokenomicsParams_top_miner_vesting_period protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_params_proto_init()
+ md_TokenomicsParams = File_inference_inference_params_proto.Messages().ByName("TokenomicsParams")
+ fd_TokenomicsParams_subsidy_reduction_interval = md_TokenomicsParams.Fields().ByName("subsidy_reduction_interval")
+ fd_TokenomicsParams_subsidy_reduction_amount = md_TokenomicsParams.Fields().ByName("subsidy_reduction_amount")
+ fd_TokenomicsParams_current_subsidy_percentage = md_TokenomicsParams.Fields().ByName("current_subsidy_percentage")
+ fd_TokenomicsParams_top_reward_allowed_failure = md_TokenomicsParams.Fields().ByName("top_reward_allowed_failure")
+ fd_TokenomicsParams_top_miner_poc_qualification = md_TokenomicsParams.Fields().ByName("top_miner_poc_qualification")
+ fd_TokenomicsParams_work_vesting_period = md_TokenomicsParams.Fields().ByName("work_vesting_period")
+ fd_TokenomicsParams_reward_vesting_period = md_TokenomicsParams.Fields().ByName("reward_vesting_period")
+ fd_TokenomicsParams_top_miner_vesting_period = md_TokenomicsParams.Fields().ByName("top_miner_vesting_period")
+}
+
+var _ protoreflect.Message = (*fastReflection_TokenomicsParams)(nil)
+
+type fastReflection_TokenomicsParams TokenomicsParams
+
+func (x *TokenomicsParams) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_TokenomicsParams)(x)
+}
+
+func (x *TokenomicsParams) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_params_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_TokenomicsParams_messageType fastReflection_TokenomicsParams_messageType
+var _ protoreflect.MessageType = fastReflection_TokenomicsParams_messageType{}
+
+type fastReflection_TokenomicsParams_messageType struct{}
+
+func (x fastReflection_TokenomicsParams_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_TokenomicsParams)(nil)
+}
+func (x fastReflection_TokenomicsParams_messageType) New() protoreflect.Message {
+ return new(fastReflection_TokenomicsParams)
+}
+func (x fastReflection_TokenomicsParams_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_TokenomicsParams
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_TokenomicsParams) Descriptor() protoreflect.MessageDescriptor {
+ return md_TokenomicsParams
+}
+
+// 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_TokenomicsParams) Type() protoreflect.MessageType {
+ return _fastReflection_TokenomicsParams_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_TokenomicsParams) New() protoreflect.Message {
+ return new(fastReflection_TokenomicsParams)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_TokenomicsParams) Interface() protoreflect.ProtoMessage {
+ return (*TokenomicsParams)(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_TokenomicsParams) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.SubsidyReductionInterval != nil {
+ value := protoreflect.ValueOfMessage(x.SubsidyReductionInterval.ProtoReflect())
+ if !f(fd_TokenomicsParams_subsidy_reduction_interval, value) {
+ return
+ }
+ }
+ if x.SubsidyReductionAmount != nil {
+ value := protoreflect.ValueOfMessage(x.SubsidyReductionAmount.ProtoReflect())
+ if !f(fd_TokenomicsParams_subsidy_reduction_amount, value) {
+ return
+ }
+ }
+ if x.CurrentSubsidyPercentage != nil {
+ value := protoreflect.ValueOfMessage(x.CurrentSubsidyPercentage.ProtoReflect())
+ if !f(fd_TokenomicsParams_current_subsidy_percentage, value) {
+ return
+ }
+ }
+ if x.TopRewardAllowedFailure != nil {
+ value := protoreflect.ValueOfMessage(x.TopRewardAllowedFailure.ProtoReflect())
+ if !f(fd_TokenomicsParams_top_reward_allowed_failure, value) {
+ return
+ }
+ }
+ if x.TopMinerPocQualification != int64(0) {
+ value := protoreflect.ValueOfInt64(x.TopMinerPocQualification)
+ if !f(fd_TokenomicsParams_top_miner_poc_qualification, value) {
+ return
+ }
+ }
+ if x.WorkVestingPeriod != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.WorkVestingPeriod)
+ if !f(fd_TokenomicsParams_work_vesting_period, value) {
+ return
+ }
+ }
+ if x.RewardVestingPeriod != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.RewardVestingPeriod)
+ if !f(fd_TokenomicsParams_reward_vesting_period, value) {
+ return
+ }
+ }
+ if x.TopMinerVestingPeriod != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.TopMinerVestingPeriod)
+ if !f(fd_TokenomicsParams_top_miner_vesting_period, 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_TokenomicsParams) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.TokenomicsParams.subsidy_reduction_interval":
+ return x.SubsidyReductionInterval != nil
+ case "inference.inference.TokenomicsParams.subsidy_reduction_amount":
+ return x.SubsidyReductionAmount != nil
+ case "inference.inference.TokenomicsParams.current_subsidy_percentage":
+ return x.CurrentSubsidyPercentage != nil
+ case "inference.inference.TokenomicsParams.top_reward_allowed_failure":
+ return x.TopRewardAllowedFailure != nil
+ case "inference.inference.TokenomicsParams.top_miner_poc_qualification":
+ return x.TopMinerPocQualification != int64(0)
+ case "inference.inference.TokenomicsParams.work_vesting_period":
+ return x.WorkVestingPeriod != uint64(0)
+ case "inference.inference.TokenomicsParams.reward_vesting_period":
+ return x.RewardVestingPeriod != uint64(0)
+ case "inference.inference.TokenomicsParams.top_miner_vesting_period":
+ return x.TopMinerVestingPeriod != uint64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.TokenomicsParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.TokenomicsParams 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_TokenomicsParams) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.TokenomicsParams.subsidy_reduction_interval":
+ x.SubsidyReductionInterval = nil
+ case "inference.inference.TokenomicsParams.subsidy_reduction_amount":
+ x.SubsidyReductionAmount = nil
+ case "inference.inference.TokenomicsParams.current_subsidy_percentage":
+ x.CurrentSubsidyPercentage = nil
+ case "inference.inference.TokenomicsParams.top_reward_allowed_failure":
+ x.TopRewardAllowedFailure = nil
+ case "inference.inference.TokenomicsParams.top_miner_poc_qualification":
+ x.TopMinerPocQualification = int64(0)
+ case "inference.inference.TokenomicsParams.work_vesting_period":
+ x.WorkVestingPeriod = uint64(0)
+ case "inference.inference.TokenomicsParams.reward_vesting_period":
+ x.RewardVestingPeriod = uint64(0)
+ case "inference.inference.TokenomicsParams.top_miner_vesting_period":
+ x.TopMinerVestingPeriod = uint64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.TokenomicsParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.TokenomicsParams 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_TokenomicsParams) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.TokenomicsParams.subsidy_reduction_interval":
+ value := x.SubsidyReductionInterval
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.TokenomicsParams.subsidy_reduction_amount":
+ value := x.SubsidyReductionAmount
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.TokenomicsParams.current_subsidy_percentage":
+ value := x.CurrentSubsidyPercentage
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.TokenomicsParams.top_reward_allowed_failure":
+ value := x.TopRewardAllowedFailure
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.TokenomicsParams.top_miner_poc_qualification":
+ value := x.TopMinerPocQualification
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.TokenomicsParams.work_vesting_period":
+ value := x.WorkVestingPeriod
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.TokenomicsParams.reward_vesting_period":
+ value := x.RewardVestingPeriod
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.TokenomicsParams.top_miner_vesting_period":
+ value := x.TopMinerVestingPeriod
+ return protoreflect.ValueOfUint64(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.TokenomicsParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.TokenomicsParams 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_TokenomicsParams) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.TokenomicsParams.subsidy_reduction_interval":
+ x.SubsidyReductionInterval = value.Message().Interface().(*Decimal)
+ case "inference.inference.TokenomicsParams.subsidy_reduction_amount":
+ x.SubsidyReductionAmount = value.Message().Interface().(*Decimal)
+ case "inference.inference.TokenomicsParams.current_subsidy_percentage":
+ x.CurrentSubsidyPercentage = value.Message().Interface().(*Decimal)
+ case "inference.inference.TokenomicsParams.top_reward_allowed_failure":
+ x.TopRewardAllowedFailure = value.Message().Interface().(*Decimal)
+ case "inference.inference.TokenomicsParams.top_miner_poc_qualification":
+ x.TopMinerPocQualification = value.Int()
+ case "inference.inference.TokenomicsParams.work_vesting_period":
+ x.WorkVestingPeriod = value.Uint()
+ case "inference.inference.TokenomicsParams.reward_vesting_period":
+ x.RewardVestingPeriod = value.Uint()
+ case "inference.inference.TokenomicsParams.top_miner_vesting_period":
+ x.TopMinerVestingPeriod = value.Uint()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.TokenomicsParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.TokenomicsParams 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_TokenomicsParams) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.TokenomicsParams.subsidy_reduction_interval":
+ if x.SubsidyReductionInterval == nil {
+ x.SubsidyReductionInterval = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.SubsidyReductionInterval.ProtoReflect())
+ case "inference.inference.TokenomicsParams.subsidy_reduction_amount":
+ if x.SubsidyReductionAmount == nil {
+ x.SubsidyReductionAmount = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.SubsidyReductionAmount.ProtoReflect())
+ case "inference.inference.TokenomicsParams.current_subsidy_percentage":
+ if x.CurrentSubsidyPercentage == nil {
+ x.CurrentSubsidyPercentage = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.CurrentSubsidyPercentage.ProtoReflect())
+ case "inference.inference.TokenomicsParams.top_reward_allowed_failure":
+ if x.TopRewardAllowedFailure == nil {
+ x.TopRewardAllowedFailure = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.TopRewardAllowedFailure.ProtoReflect())
+ case "inference.inference.TokenomicsParams.top_miner_poc_qualification":
+ panic(fmt.Errorf("field top_miner_poc_qualification of message inference.inference.TokenomicsParams is not mutable"))
+ case "inference.inference.TokenomicsParams.work_vesting_period":
+ panic(fmt.Errorf("field work_vesting_period of message inference.inference.TokenomicsParams is not mutable"))
+ case "inference.inference.TokenomicsParams.reward_vesting_period":
+ panic(fmt.Errorf("field reward_vesting_period of message inference.inference.TokenomicsParams is not mutable"))
+ case "inference.inference.TokenomicsParams.top_miner_vesting_period":
+ panic(fmt.Errorf("field top_miner_vesting_period of message inference.inference.TokenomicsParams is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.TokenomicsParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.TokenomicsParams 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_TokenomicsParams) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.TokenomicsParams.subsidy_reduction_interval":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.TokenomicsParams.subsidy_reduction_amount":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.TokenomicsParams.current_subsidy_percentage":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.TokenomicsParams.top_reward_allowed_failure":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.TokenomicsParams.top_miner_poc_qualification":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.TokenomicsParams.work_vesting_period":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.TokenomicsParams.reward_vesting_period":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.TokenomicsParams.top_miner_vesting_period":
+ return protoreflect.ValueOfUint64(uint64(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.TokenomicsParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.TokenomicsParams 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_TokenomicsParams) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.TokenomicsParams", 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_TokenomicsParams) 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_TokenomicsParams) 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_TokenomicsParams) 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_TokenomicsParams) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*TokenomicsParams)
+ 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.SubsidyReductionInterval != nil {
+ l = options.Size(x.SubsidyReductionInterval)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.SubsidyReductionAmount != nil {
+ l = options.Size(x.SubsidyReductionAmount)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.CurrentSubsidyPercentage != nil {
+ l = options.Size(x.CurrentSubsidyPercentage)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.TopRewardAllowedFailure != nil {
+ l = options.Size(x.TopRewardAllowedFailure)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.TopMinerPocQualification != 0 {
+ n += 1 + runtime.Sov(uint64(x.TopMinerPocQualification))
+ }
+ if x.WorkVestingPeriod != 0 {
+ n += 1 + runtime.Sov(uint64(x.WorkVestingPeriod))
+ }
+ if x.RewardVestingPeriod != 0 {
+ n += 1 + runtime.Sov(uint64(x.RewardVestingPeriod))
+ }
+ if x.TopMinerVestingPeriod != 0 {
+ n += 1 + runtime.Sov(uint64(x.TopMinerVestingPeriod))
+ }
+ 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().(*TokenomicsParams)
+ 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.TopMinerVestingPeriod != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.TopMinerVestingPeriod))
+ i--
+ dAtA[i] = 0x40
+ }
+ if x.RewardVestingPeriod != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.RewardVestingPeriod))
+ i--
+ dAtA[i] = 0x38
+ }
+ if x.WorkVestingPeriod != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.WorkVestingPeriod))
+ i--
+ dAtA[i] = 0x30
+ }
+ if x.TopMinerPocQualification != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.TopMinerPocQualification))
+ i--
+ dAtA[i] = 0x28
+ }
+ if x.TopRewardAllowedFailure != nil {
+ encoded, err := options.Marshal(x.TopRewardAllowedFailure)
+ 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.CurrentSubsidyPercentage != nil {
+ encoded, err := options.Marshal(x.CurrentSubsidyPercentage)
+ 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.SubsidyReductionAmount != nil {
+ encoded, err := options.Marshal(x.SubsidyReductionAmount)
+ 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.SubsidyReductionInterval != nil {
+ encoded, err := options.Marshal(x.SubsidyReductionInterval)
+ 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().(*TokenomicsParams)
+ 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: TokenomicsParams: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TokenomicsParams: 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 SubsidyReductionInterval", 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.SubsidyReductionInterval == nil {
+ x.SubsidyReductionInterval = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.SubsidyReductionInterval); 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 SubsidyReductionAmount", 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.SubsidyReductionAmount == nil {
+ x.SubsidyReductionAmount = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.SubsidyReductionAmount); 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 CurrentSubsidyPercentage", 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.CurrentSubsidyPercentage == nil {
+ x.CurrentSubsidyPercentage = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.CurrentSubsidyPercentage); 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 TopRewardAllowedFailure", 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.TopRewardAllowedFailure == nil {
+ x.TopRewardAllowedFailure = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.TopRewardAllowedFailure); err != nil {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+ }
+ iNdEx = postIndex
+ case 5:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TopMinerPocQualification", wireType)
+ }
+ x.TopMinerPocQualification = 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.TopMinerPocQualification |= int64(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 WorkVestingPeriod", wireType)
+ }
+ x.WorkVestingPeriod = 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.WorkVestingPeriod |= 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 RewardVestingPeriod", wireType)
+ }
+ x.RewardVestingPeriod = 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.RewardVestingPeriod |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 8:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TopMinerVestingPeriod", wireType)
+ }
+ x.TopMinerVestingPeriod = 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.TopMinerVestingPeriod |= 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_EpochParams protoreflect.MessageDescriptor
+ fd_EpochParams_epoch_length protoreflect.FieldDescriptor
+ fd_EpochParams_epoch_multiplier protoreflect.FieldDescriptor
+ fd_EpochParams_epoch_shift protoreflect.FieldDescriptor
+ fd_EpochParams_default_unit_of_compute_price protoreflect.FieldDescriptor
+ fd_EpochParams_poc_stage_duration protoreflect.FieldDescriptor
+ fd_EpochParams_poc_exchange_duration protoreflect.FieldDescriptor
+ fd_EpochParams_poc_validation_delay protoreflect.FieldDescriptor
+ fd_EpochParams_poc_validation_duration protoreflect.FieldDescriptor
+ fd_EpochParams_set_new_validators_delay protoreflect.FieldDescriptor
+ fd_EpochParams_inference_validation_cutoff protoreflect.FieldDescriptor
+ fd_EpochParams_inference_pruning_epoch_threshold protoreflect.FieldDescriptor
+ fd_EpochParams_inference_pruning_max protoreflect.FieldDescriptor
+ fd_EpochParams_poc_pruning_max protoreflect.FieldDescriptor
+ fd_EpochParams_poc_slot_allocation protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_params_proto_init()
+ md_EpochParams = File_inference_inference_params_proto.Messages().ByName("EpochParams")
+ fd_EpochParams_epoch_length = md_EpochParams.Fields().ByName("epoch_length")
+ fd_EpochParams_epoch_multiplier = md_EpochParams.Fields().ByName("epoch_multiplier")
+ fd_EpochParams_epoch_shift = md_EpochParams.Fields().ByName("epoch_shift")
+ fd_EpochParams_default_unit_of_compute_price = md_EpochParams.Fields().ByName("default_unit_of_compute_price")
+ fd_EpochParams_poc_stage_duration = md_EpochParams.Fields().ByName("poc_stage_duration")
+ fd_EpochParams_poc_exchange_duration = md_EpochParams.Fields().ByName("poc_exchange_duration")
+ fd_EpochParams_poc_validation_delay = md_EpochParams.Fields().ByName("poc_validation_delay")
+ fd_EpochParams_poc_validation_duration = md_EpochParams.Fields().ByName("poc_validation_duration")
+ fd_EpochParams_set_new_validators_delay = md_EpochParams.Fields().ByName("set_new_validators_delay")
+ fd_EpochParams_inference_validation_cutoff = md_EpochParams.Fields().ByName("inference_validation_cutoff")
+ fd_EpochParams_inference_pruning_epoch_threshold = md_EpochParams.Fields().ByName("inference_pruning_epoch_threshold")
+ fd_EpochParams_inference_pruning_max = md_EpochParams.Fields().ByName("inference_pruning_max")
+ fd_EpochParams_poc_pruning_max = md_EpochParams.Fields().ByName("poc_pruning_max")
+ fd_EpochParams_poc_slot_allocation = md_EpochParams.Fields().ByName("poc_slot_allocation")
+}
+
+var _ protoreflect.Message = (*fastReflection_EpochParams)(nil)
+
+type fastReflection_EpochParams EpochParams
+
+func (x *EpochParams) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_EpochParams)(x)
+}
+
+func (x *EpochParams) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_params_proto_msgTypes[3]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_EpochParams_messageType fastReflection_EpochParams_messageType
+var _ protoreflect.MessageType = fastReflection_EpochParams_messageType{}
+
+type fastReflection_EpochParams_messageType struct{}
+
+func (x fastReflection_EpochParams_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_EpochParams)(nil)
+}
+func (x fastReflection_EpochParams_messageType) New() protoreflect.Message {
+ return new(fastReflection_EpochParams)
+}
+func (x fastReflection_EpochParams_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_EpochParams
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_EpochParams) Descriptor() protoreflect.MessageDescriptor {
+ return md_EpochParams
+}
+
+// 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_EpochParams) Type() protoreflect.MessageType {
+ return _fastReflection_EpochParams_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_EpochParams) New() protoreflect.Message {
+ return new(fastReflection_EpochParams)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_EpochParams) Interface() protoreflect.ProtoMessage {
+ return (*EpochParams)(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_EpochParams) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.EpochLength != int64(0) {
+ value := protoreflect.ValueOfInt64(x.EpochLength)
+ if !f(fd_EpochParams_epoch_length, value) {
+ return
+ }
+ }
+ if x.EpochMultiplier != int64(0) {
+ value := protoreflect.ValueOfInt64(x.EpochMultiplier)
+ if !f(fd_EpochParams_epoch_multiplier, value) {
+ return
+ }
+ }
+ if x.EpochShift != int64(0) {
+ value := protoreflect.ValueOfInt64(x.EpochShift)
+ if !f(fd_EpochParams_epoch_shift, value) {
+ return
+ }
+ }
+ if x.DefaultUnitOfComputePrice != int64(0) {
+ value := protoreflect.ValueOfInt64(x.DefaultUnitOfComputePrice)
+ if !f(fd_EpochParams_default_unit_of_compute_price, value) {
+ return
+ }
+ }
+ if x.PocStageDuration != int64(0) {
+ value := protoreflect.ValueOfInt64(x.PocStageDuration)
+ if !f(fd_EpochParams_poc_stage_duration, value) {
+ return
+ }
+ }
+ if x.PocExchangeDuration != int64(0) {
+ value := protoreflect.ValueOfInt64(x.PocExchangeDuration)
+ if !f(fd_EpochParams_poc_exchange_duration, value) {
+ return
+ }
+ }
+ if x.PocValidationDelay != int64(0) {
+ value := protoreflect.ValueOfInt64(x.PocValidationDelay)
+ if !f(fd_EpochParams_poc_validation_delay, value) {
+ return
+ }
+ }
+ if x.PocValidationDuration != int64(0) {
+ value := protoreflect.ValueOfInt64(x.PocValidationDuration)
+ if !f(fd_EpochParams_poc_validation_duration, value) {
+ return
+ }
+ }
+ if x.SetNewValidatorsDelay != int64(0) {
+ value := protoreflect.ValueOfInt64(x.SetNewValidatorsDelay)
+ if !f(fd_EpochParams_set_new_validators_delay, value) {
+ return
+ }
+ }
+ if x.InferenceValidationCutoff != int64(0) {
+ value := protoreflect.ValueOfInt64(x.InferenceValidationCutoff)
+ if !f(fd_EpochParams_inference_validation_cutoff, value) {
+ return
+ }
+ }
+ if x.InferencePruningEpochThreshold != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.InferencePruningEpochThreshold)
+ if !f(fd_EpochParams_inference_pruning_epoch_threshold, value) {
+ return
+ }
+ }
+ if x.InferencePruningMax != int64(0) {
+ value := protoreflect.ValueOfInt64(x.InferencePruningMax)
+ if !f(fd_EpochParams_inference_pruning_max, value) {
+ return
+ }
+ }
+ if x.PocPruningMax != int64(0) {
+ value := protoreflect.ValueOfInt64(x.PocPruningMax)
+ if !f(fd_EpochParams_poc_pruning_max, value) {
+ return
+ }
+ }
+ if x.PocSlotAllocation != nil {
+ value := protoreflect.ValueOfMessage(x.PocSlotAllocation.ProtoReflect())
+ if !f(fd_EpochParams_poc_slot_allocation, 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_EpochParams) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.EpochParams.epoch_length":
+ return x.EpochLength != int64(0)
+ case "inference.inference.EpochParams.epoch_multiplier":
+ return x.EpochMultiplier != int64(0)
+ case "inference.inference.EpochParams.epoch_shift":
+ return x.EpochShift != int64(0)
+ case "inference.inference.EpochParams.default_unit_of_compute_price":
+ return x.DefaultUnitOfComputePrice != int64(0)
+ case "inference.inference.EpochParams.poc_stage_duration":
+ return x.PocStageDuration != int64(0)
+ case "inference.inference.EpochParams.poc_exchange_duration":
+ return x.PocExchangeDuration != int64(0)
+ case "inference.inference.EpochParams.poc_validation_delay":
+ return x.PocValidationDelay != int64(0)
+ case "inference.inference.EpochParams.poc_validation_duration":
+ return x.PocValidationDuration != int64(0)
+ case "inference.inference.EpochParams.set_new_validators_delay":
+ return x.SetNewValidatorsDelay != int64(0)
+ case "inference.inference.EpochParams.inference_validation_cutoff":
+ return x.InferenceValidationCutoff != int64(0)
+ case "inference.inference.EpochParams.inference_pruning_epoch_threshold":
+ return x.InferencePruningEpochThreshold != uint64(0)
+ case "inference.inference.EpochParams.inference_pruning_max":
+ return x.InferencePruningMax != int64(0)
+ case "inference.inference.EpochParams.poc_pruning_max":
+ return x.PocPruningMax != int64(0)
+ case "inference.inference.EpochParams.poc_slot_allocation":
+ return x.PocSlotAllocation != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.EpochParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.EpochParams 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_EpochParams) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.EpochParams.epoch_length":
+ x.EpochLength = int64(0)
+ case "inference.inference.EpochParams.epoch_multiplier":
+ x.EpochMultiplier = int64(0)
+ case "inference.inference.EpochParams.epoch_shift":
+ x.EpochShift = int64(0)
+ case "inference.inference.EpochParams.default_unit_of_compute_price":
+ x.DefaultUnitOfComputePrice = int64(0)
+ case "inference.inference.EpochParams.poc_stage_duration":
+ x.PocStageDuration = int64(0)
+ case "inference.inference.EpochParams.poc_exchange_duration":
+ x.PocExchangeDuration = int64(0)
+ case "inference.inference.EpochParams.poc_validation_delay":
+ x.PocValidationDelay = int64(0)
+ case "inference.inference.EpochParams.poc_validation_duration":
+ x.PocValidationDuration = int64(0)
+ case "inference.inference.EpochParams.set_new_validators_delay":
+ x.SetNewValidatorsDelay = int64(0)
+ case "inference.inference.EpochParams.inference_validation_cutoff":
+ x.InferenceValidationCutoff = int64(0)
+ case "inference.inference.EpochParams.inference_pruning_epoch_threshold":
+ x.InferencePruningEpochThreshold = uint64(0)
+ case "inference.inference.EpochParams.inference_pruning_max":
+ x.InferencePruningMax = int64(0)
+ case "inference.inference.EpochParams.poc_pruning_max":
+ x.PocPruningMax = int64(0)
+ case "inference.inference.EpochParams.poc_slot_allocation":
+ x.PocSlotAllocation = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.EpochParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.EpochParams 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_EpochParams) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.EpochParams.epoch_length":
+ value := x.EpochLength
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.EpochParams.epoch_multiplier":
+ value := x.EpochMultiplier
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.EpochParams.epoch_shift":
+ value := x.EpochShift
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.EpochParams.default_unit_of_compute_price":
+ value := x.DefaultUnitOfComputePrice
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.EpochParams.poc_stage_duration":
+ value := x.PocStageDuration
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.EpochParams.poc_exchange_duration":
+ value := x.PocExchangeDuration
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.EpochParams.poc_validation_delay":
+ value := x.PocValidationDelay
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.EpochParams.poc_validation_duration":
+ value := x.PocValidationDuration
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.EpochParams.set_new_validators_delay":
+ value := x.SetNewValidatorsDelay
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.EpochParams.inference_validation_cutoff":
+ value := x.InferenceValidationCutoff
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.EpochParams.inference_pruning_epoch_threshold":
+ value := x.InferencePruningEpochThreshold
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.EpochParams.inference_pruning_max":
+ value := x.InferencePruningMax
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.EpochParams.poc_pruning_max":
+ value := x.PocPruningMax
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.EpochParams.poc_slot_allocation":
+ value := x.PocSlotAllocation
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.EpochParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.EpochParams 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_EpochParams) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.EpochParams.epoch_length":
+ x.EpochLength = value.Int()
+ case "inference.inference.EpochParams.epoch_multiplier":
+ x.EpochMultiplier = value.Int()
+ case "inference.inference.EpochParams.epoch_shift":
+ x.EpochShift = value.Int()
+ case "inference.inference.EpochParams.default_unit_of_compute_price":
+ x.DefaultUnitOfComputePrice = value.Int()
+ case "inference.inference.EpochParams.poc_stage_duration":
+ x.PocStageDuration = value.Int()
+ case "inference.inference.EpochParams.poc_exchange_duration":
+ x.PocExchangeDuration = value.Int()
+ case "inference.inference.EpochParams.poc_validation_delay":
+ x.PocValidationDelay = value.Int()
+ case "inference.inference.EpochParams.poc_validation_duration":
+ x.PocValidationDuration = value.Int()
+ case "inference.inference.EpochParams.set_new_validators_delay":
+ x.SetNewValidatorsDelay = value.Int()
+ case "inference.inference.EpochParams.inference_validation_cutoff":
+ x.InferenceValidationCutoff = value.Int()
+ case "inference.inference.EpochParams.inference_pruning_epoch_threshold":
+ x.InferencePruningEpochThreshold = value.Uint()
+ case "inference.inference.EpochParams.inference_pruning_max":
+ x.InferencePruningMax = value.Int()
+ case "inference.inference.EpochParams.poc_pruning_max":
+ x.PocPruningMax = value.Int()
+ case "inference.inference.EpochParams.poc_slot_allocation":
+ x.PocSlotAllocation = value.Message().Interface().(*Decimal)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.EpochParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.EpochParams 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_EpochParams) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.EpochParams.poc_slot_allocation":
+ if x.PocSlotAllocation == nil {
+ x.PocSlotAllocation = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.PocSlotAllocation.ProtoReflect())
+ case "inference.inference.EpochParams.epoch_length":
+ panic(fmt.Errorf("field epoch_length of message inference.inference.EpochParams is not mutable"))
+ case "inference.inference.EpochParams.epoch_multiplier":
+ panic(fmt.Errorf("field epoch_multiplier of message inference.inference.EpochParams is not mutable"))
+ case "inference.inference.EpochParams.epoch_shift":
+ panic(fmt.Errorf("field epoch_shift of message inference.inference.EpochParams is not mutable"))
+ case "inference.inference.EpochParams.default_unit_of_compute_price":
+ panic(fmt.Errorf("field default_unit_of_compute_price of message inference.inference.EpochParams is not mutable"))
+ case "inference.inference.EpochParams.poc_stage_duration":
+ panic(fmt.Errorf("field poc_stage_duration of message inference.inference.EpochParams is not mutable"))
+ case "inference.inference.EpochParams.poc_exchange_duration":
+ panic(fmt.Errorf("field poc_exchange_duration of message inference.inference.EpochParams is not mutable"))
+ case "inference.inference.EpochParams.poc_validation_delay":
+ panic(fmt.Errorf("field poc_validation_delay of message inference.inference.EpochParams is not mutable"))
+ case "inference.inference.EpochParams.poc_validation_duration":
+ panic(fmt.Errorf("field poc_validation_duration of message inference.inference.EpochParams is not mutable"))
+ case "inference.inference.EpochParams.set_new_validators_delay":
+ panic(fmt.Errorf("field set_new_validators_delay of message inference.inference.EpochParams is not mutable"))
+ case "inference.inference.EpochParams.inference_validation_cutoff":
+ panic(fmt.Errorf("field inference_validation_cutoff of message inference.inference.EpochParams is not mutable"))
+ case "inference.inference.EpochParams.inference_pruning_epoch_threshold":
+ panic(fmt.Errorf("field inference_pruning_epoch_threshold of message inference.inference.EpochParams is not mutable"))
+ case "inference.inference.EpochParams.inference_pruning_max":
+ panic(fmt.Errorf("field inference_pruning_max of message inference.inference.EpochParams is not mutable"))
+ case "inference.inference.EpochParams.poc_pruning_max":
+ panic(fmt.Errorf("field poc_pruning_max of message inference.inference.EpochParams is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.EpochParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.EpochParams 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_EpochParams) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.EpochParams.epoch_length":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.EpochParams.epoch_multiplier":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.EpochParams.epoch_shift":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.EpochParams.default_unit_of_compute_price":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.EpochParams.poc_stage_duration":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.EpochParams.poc_exchange_duration":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.EpochParams.poc_validation_delay":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.EpochParams.poc_validation_duration":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.EpochParams.set_new_validators_delay":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.EpochParams.inference_validation_cutoff":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.EpochParams.inference_pruning_epoch_threshold":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.EpochParams.inference_pruning_max":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.EpochParams.poc_pruning_max":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.EpochParams.poc_slot_allocation":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.EpochParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.EpochParams 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_EpochParams) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.EpochParams", 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_EpochParams) 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_EpochParams) 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_EpochParams) 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_EpochParams) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*EpochParams)
+ 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.EpochLength != 0 {
+ n += 1 + runtime.Sov(uint64(x.EpochLength))
+ }
+ if x.EpochMultiplier != 0 {
+ n += 1 + runtime.Sov(uint64(x.EpochMultiplier))
+ }
+ if x.EpochShift != 0 {
+ n += 1 + runtime.Sov(uint64(x.EpochShift))
+ }
+ if x.DefaultUnitOfComputePrice != 0 {
+ n += 1 + runtime.Sov(uint64(x.DefaultUnitOfComputePrice))
+ }
+ if x.PocStageDuration != 0 {
+ n += 1 + runtime.Sov(uint64(x.PocStageDuration))
+ }
+ if x.PocExchangeDuration != 0 {
+ n += 1 + runtime.Sov(uint64(x.PocExchangeDuration))
+ }
+ if x.PocValidationDelay != 0 {
+ n += 1 + runtime.Sov(uint64(x.PocValidationDelay))
+ }
+ if x.PocValidationDuration != 0 {
+ n += 1 + runtime.Sov(uint64(x.PocValidationDuration))
+ }
+ if x.SetNewValidatorsDelay != 0 {
+ n += 1 + runtime.Sov(uint64(x.SetNewValidatorsDelay))
+ }
+ if x.InferenceValidationCutoff != 0 {
+ n += 1 + runtime.Sov(uint64(x.InferenceValidationCutoff))
+ }
+ if x.InferencePruningEpochThreshold != 0 {
+ n += 1 + runtime.Sov(uint64(x.InferencePruningEpochThreshold))
+ }
+ if x.InferencePruningMax != 0 {
+ n += 1 + runtime.Sov(uint64(x.InferencePruningMax))
+ }
+ if x.PocPruningMax != 0 {
+ n += 1 + runtime.Sov(uint64(x.PocPruningMax))
+ }
+ if x.PocSlotAllocation != nil {
+ l = options.Size(x.PocSlotAllocation)
+ 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().(*EpochParams)
+ 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.PocSlotAllocation != nil {
+ encoded, err := options.Marshal(x.PocSlotAllocation)
+ 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] = 0x72
+ }
+ if x.PocPruningMax != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.PocPruningMax))
+ i--
+ dAtA[i] = 0x68
+ }
+ if x.InferencePruningMax != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.InferencePruningMax))
+ i--
+ dAtA[i] = 0x60
+ }
+ if x.InferencePruningEpochThreshold != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.InferencePruningEpochThreshold))
+ i--
+ dAtA[i] = 0x58
+ }
+ if x.InferenceValidationCutoff != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.InferenceValidationCutoff))
+ i--
+ dAtA[i] = 0x50
+ }
+ if x.SetNewValidatorsDelay != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.SetNewValidatorsDelay))
+ i--
+ dAtA[i] = 0x48
+ }
+ if x.PocValidationDuration != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.PocValidationDuration))
+ i--
+ dAtA[i] = 0x40
+ }
+ if x.PocValidationDelay != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.PocValidationDelay))
+ i--
+ dAtA[i] = 0x38
+ }
+ if x.PocExchangeDuration != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.PocExchangeDuration))
+ i--
+ dAtA[i] = 0x30
+ }
+ if x.PocStageDuration != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.PocStageDuration))
+ i--
+ dAtA[i] = 0x28
+ }
+ if x.DefaultUnitOfComputePrice != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.DefaultUnitOfComputePrice))
+ i--
+ dAtA[i] = 0x20
+ }
+ if x.EpochShift != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochShift))
+ i--
+ dAtA[i] = 0x18
+ }
+ if x.EpochMultiplier != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochMultiplier))
+ i--
+ dAtA[i] = 0x10
+ }
+ if x.EpochLength != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochLength))
+ 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().(*EpochParams)
+ 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: EpochParams: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: EpochParams: 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 EpochLength", wireType)
+ }
+ x.EpochLength = 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.EpochLength |= 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 EpochMultiplier", wireType)
+ }
+ x.EpochMultiplier = 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.EpochMultiplier |= 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 EpochShift", wireType)
+ }
+ x.EpochShift = 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.EpochShift |= 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 DefaultUnitOfComputePrice", wireType)
+ }
+ x.DefaultUnitOfComputePrice = 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.DefaultUnitOfComputePrice |= int64(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 PocStageDuration", wireType)
+ }
+ x.PocStageDuration = 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.PocStageDuration |= int64(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 PocExchangeDuration", wireType)
+ }
+ x.PocExchangeDuration = 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.PocExchangeDuration |= int64(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 PocValidationDelay", wireType)
+ }
+ x.PocValidationDelay = 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.PocValidationDelay |= int64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 8:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PocValidationDuration", wireType)
+ }
+ x.PocValidationDuration = 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.PocValidationDuration |= int64(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 SetNewValidatorsDelay", wireType)
+ }
+ x.SetNewValidatorsDelay = 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.SetNewValidatorsDelay |= int64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 10:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field InferenceValidationCutoff", wireType)
+ }
+ x.InferenceValidationCutoff = 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.InferenceValidationCutoff |= int64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 11:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field InferencePruningEpochThreshold", wireType)
+ }
+ x.InferencePruningEpochThreshold = 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.InferencePruningEpochThreshold |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 12:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field InferencePruningMax", wireType)
+ }
+ x.InferencePruningMax = 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.InferencePruningMax |= int64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 13:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PocPruningMax", wireType)
+ }
+ x.PocPruningMax = 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.PocPruningMax |= int64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 14:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PocSlotAllocation", 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.PocSlotAllocation == nil {
+ x.PocSlotAllocation = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.PocSlotAllocation); 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_ValidationParams protoreflect.MessageDescriptor
+ fd_ValidationParams_false_positive_rate protoreflect.FieldDescriptor
+ fd_ValidationParams_min_ramp_up_measurements protoreflect.FieldDescriptor
+ fd_ValidationParams_pass_value protoreflect.FieldDescriptor
+ fd_ValidationParams_min_validation_average protoreflect.FieldDescriptor
+ fd_ValidationParams_max_validation_average protoreflect.FieldDescriptor
+ fd_ValidationParams_expiration_blocks protoreflect.FieldDescriptor
+ fd_ValidationParams_epochs_to_max protoreflect.FieldDescriptor
+ fd_ValidationParams_full_validation_traffic_cutoff protoreflect.FieldDescriptor
+ fd_ValidationParams_min_validation_halfway protoreflect.FieldDescriptor
+ fd_ValidationParams_min_validation_traffic_cutoff protoreflect.FieldDescriptor
+ fd_ValidationParams_miss_percentage_cutoff protoreflect.FieldDescriptor
+ fd_ValidationParams_miss_requests_penalty protoreflect.FieldDescriptor
+ fd_ValidationParams_timestamp_expiration protoreflect.FieldDescriptor
+ fd_ValidationParams_timestamp_advance protoreflect.FieldDescriptor
+ fd_ValidationParams_estimated_limits_per_block_kb protoreflect.FieldDescriptor
+ fd_ValidationParams_invalid_reputation_preserve protoreflect.FieldDescriptor
+ fd_ValidationParams_bad_participant_invalidation_rate protoreflect.FieldDescriptor
+ fd_ValidationParams_invalidation_h_threshold protoreflect.FieldDescriptor
+ fd_ValidationParams_downtime_good_percentage protoreflect.FieldDescriptor
+ fd_ValidationParams_downtime_bad_percentage protoreflect.FieldDescriptor
+ fd_ValidationParams_downtime_h_threshold protoreflect.FieldDescriptor
+ fd_ValidationParams_downtime_reputation_preserve protoreflect.FieldDescriptor
+ fd_ValidationParams_quick_failure_threshold protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_params_proto_init()
+ md_ValidationParams = File_inference_inference_params_proto.Messages().ByName("ValidationParams")
+ fd_ValidationParams_false_positive_rate = md_ValidationParams.Fields().ByName("false_positive_rate")
+ fd_ValidationParams_min_ramp_up_measurements = md_ValidationParams.Fields().ByName("min_ramp_up_measurements")
+ fd_ValidationParams_pass_value = md_ValidationParams.Fields().ByName("pass_value")
+ fd_ValidationParams_min_validation_average = md_ValidationParams.Fields().ByName("min_validation_average")
+ fd_ValidationParams_max_validation_average = md_ValidationParams.Fields().ByName("max_validation_average")
+ fd_ValidationParams_expiration_blocks = md_ValidationParams.Fields().ByName("expiration_blocks")
+ fd_ValidationParams_epochs_to_max = md_ValidationParams.Fields().ByName("epochs_to_max")
+ fd_ValidationParams_full_validation_traffic_cutoff = md_ValidationParams.Fields().ByName("full_validation_traffic_cutoff")
+ fd_ValidationParams_min_validation_halfway = md_ValidationParams.Fields().ByName("min_validation_halfway")
+ fd_ValidationParams_min_validation_traffic_cutoff = md_ValidationParams.Fields().ByName("min_validation_traffic_cutoff")
+ fd_ValidationParams_miss_percentage_cutoff = md_ValidationParams.Fields().ByName("miss_percentage_cutoff")
+ fd_ValidationParams_miss_requests_penalty = md_ValidationParams.Fields().ByName("miss_requests_penalty")
+ fd_ValidationParams_timestamp_expiration = md_ValidationParams.Fields().ByName("timestamp_expiration")
+ fd_ValidationParams_timestamp_advance = md_ValidationParams.Fields().ByName("timestamp_advance")
+ fd_ValidationParams_estimated_limits_per_block_kb = md_ValidationParams.Fields().ByName("estimated_limits_per_block_kb")
+ fd_ValidationParams_invalid_reputation_preserve = md_ValidationParams.Fields().ByName("invalid_reputation_preserve")
+ fd_ValidationParams_bad_participant_invalidation_rate = md_ValidationParams.Fields().ByName("bad_participant_invalidation_rate")
+ fd_ValidationParams_invalidation_h_threshold = md_ValidationParams.Fields().ByName("invalidation_h_threshold")
+ fd_ValidationParams_downtime_good_percentage = md_ValidationParams.Fields().ByName("downtime_good_percentage")
+ fd_ValidationParams_downtime_bad_percentage = md_ValidationParams.Fields().ByName("downtime_bad_percentage")
+ fd_ValidationParams_downtime_h_threshold = md_ValidationParams.Fields().ByName("downtime_h_threshold")
+ fd_ValidationParams_downtime_reputation_preserve = md_ValidationParams.Fields().ByName("downtime_reputation_preserve")
+ fd_ValidationParams_quick_failure_threshold = md_ValidationParams.Fields().ByName("quick_failure_threshold")
+}
+
+var _ protoreflect.Message = (*fastReflection_ValidationParams)(nil)
+
+type fastReflection_ValidationParams ValidationParams
+
+func (x *ValidationParams) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_ValidationParams)(x)
+}
+
+func (x *ValidationParams) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_params_proto_msgTypes[4]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_ValidationParams_messageType fastReflection_ValidationParams_messageType
+var _ protoreflect.MessageType = fastReflection_ValidationParams_messageType{}
+
+type fastReflection_ValidationParams_messageType struct{}
+
+func (x fastReflection_ValidationParams_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_ValidationParams)(nil)
+}
+func (x fastReflection_ValidationParams_messageType) New() protoreflect.Message {
+ return new(fastReflection_ValidationParams)
+}
+func (x fastReflection_ValidationParams_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_ValidationParams
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_ValidationParams) Descriptor() protoreflect.MessageDescriptor {
+ return md_ValidationParams
+}
+
+// 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_ValidationParams) Type() protoreflect.MessageType {
+ return _fastReflection_ValidationParams_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_ValidationParams) New() protoreflect.Message {
+ return new(fastReflection_ValidationParams)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_ValidationParams) Interface() protoreflect.ProtoMessage {
+ return (*ValidationParams)(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_ValidationParams) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.FalsePositiveRate != nil {
+ value := protoreflect.ValueOfMessage(x.FalsePositiveRate.ProtoReflect())
+ if !f(fd_ValidationParams_false_positive_rate, value) {
+ return
+ }
+ }
+ if x.MinRampUpMeasurements != int32(0) {
+ value := protoreflect.ValueOfInt32(x.MinRampUpMeasurements)
+ if !f(fd_ValidationParams_min_ramp_up_measurements, value) {
+ return
+ }
+ }
+ if x.PassValue != nil {
+ value := protoreflect.ValueOfMessage(x.PassValue.ProtoReflect())
+ if !f(fd_ValidationParams_pass_value, value) {
+ return
+ }
+ }
+ if x.MinValidationAverage != nil {
+ value := protoreflect.ValueOfMessage(x.MinValidationAverage.ProtoReflect())
+ if !f(fd_ValidationParams_min_validation_average, value) {
+ return
+ }
+ }
+ if x.MaxValidationAverage != nil {
+ value := protoreflect.ValueOfMessage(x.MaxValidationAverage.ProtoReflect())
+ if !f(fd_ValidationParams_max_validation_average, value) {
+ return
+ }
+ }
+ if x.ExpirationBlocks != int64(0) {
+ value := protoreflect.ValueOfInt64(x.ExpirationBlocks)
+ if !f(fd_ValidationParams_expiration_blocks, value) {
+ return
+ }
+ }
+ if x.EpochsToMax != int64(0) {
+ value := protoreflect.ValueOfInt64(x.EpochsToMax)
+ if !f(fd_ValidationParams_epochs_to_max, value) {
+ return
+ }
+ }
+ if x.FullValidationTrafficCutoff != int64(0) {
+ value := protoreflect.ValueOfInt64(x.FullValidationTrafficCutoff)
+ if !f(fd_ValidationParams_full_validation_traffic_cutoff, value) {
+ return
+ }
+ }
+ if x.MinValidationHalfway != nil {
+ value := protoreflect.ValueOfMessage(x.MinValidationHalfway.ProtoReflect())
+ if !f(fd_ValidationParams_min_validation_halfway, value) {
+ return
+ }
+ }
+ if x.MinValidationTrafficCutoff != int64(0) {
+ value := protoreflect.ValueOfInt64(x.MinValidationTrafficCutoff)
+ if !f(fd_ValidationParams_min_validation_traffic_cutoff, value) {
+ return
+ }
+ }
+ if x.MissPercentageCutoff != nil {
+ value := protoreflect.ValueOfMessage(x.MissPercentageCutoff.ProtoReflect())
+ if !f(fd_ValidationParams_miss_percentage_cutoff, value) {
+ return
+ }
+ }
+ if x.MissRequestsPenalty != nil {
+ value := protoreflect.ValueOfMessage(x.MissRequestsPenalty.ProtoReflect())
+ if !f(fd_ValidationParams_miss_requests_penalty, value) {
+ return
+ }
+ }
+ if x.TimestampExpiration != int64(0) {
+ value := protoreflect.ValueOfInt64(x.TimestampExpiration)
+ if !f(fd_ValidationParams_timestamp_expiration, value) {
+ return
+ }
+ }
+ if x.TimestampAdvance != int64(0) {
+ value := protoreflect.ValueOfInt64(x.TimestampAdvance)
+ if !f(fd_ValidationParams_timestamp_advance, value) {
+ return
+ }
+ }
+ if x.EstimatedLimitsPerBlockKb != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.EstimatedLimitsPerBlockKb)
+ if !f(fd_ValidationParams_estimated_limits_per_block_kb, value) {
+ return
+ }
+ }
+ if x.InvalidReputationPreserve != nil {
+ value := protoreflect.ValueOfMessage(x.InvalidReputationPreserve.ProtoReflect())
+ if !f(fd_ValidationParams_invalid_reputation_preserve, value) {
+ return
+ }
+ }
+ if x.BadParticipantInvalidationRate != nil {
+ value := protoreflect.ValueOfMessage(x.BadParticipantInvalidationRate.ProtoReflect())
+ if !f(fd_ValidationParams_bad_participant_invalidation_rate, value) {
+ return
+ }
+ }
+ if x.InvalidationHThreshold != nil {
+ value := protoreflect.ValueOfMessage(x.InvalidationHThreshold.ProtoReflect())
+ if !f(fd_ValidationParams_invalidation_h_threshold, value) {
+ return
+ }
+ }
+ if x.DowntimeGoodPercentage != nil {
+ value := protoreflect.ValueOfMessage(x.DowntimeGoodPercentage.ProtoReflect())
+ if !f(fd_ValidationParams_downtime_good_percentage, value) {
+ return
+ }
+ }
+ if x.DowntimeBadPercentage != nil {
+ value := protoreflect.ValueOfMessage(x.DowntimeBadPercentage.ProtoReflect())
+ if !f(fd_ValidationParams_downtime_bad_percentage, value) {
+ return
+ }
+ }
+ if x.DowntimeHThreshold != nil {
+ value := protoreflect.ValueOfMessage(x.DowntimeHThreshold.ProtoReflect())
+ if !f(fd_ValidationParams_downtime_h_threshold, value) {
+ return
+ }
+ }
+ if x.DowntimeReputationPreserve != nil {
+ value := protoreflect.ValueOfMessage(x.DowntimeReputationPreserve.ProtoReflect())
+ if !f(fd_ValidationParams_downtime_reputation_preserve, value) {
+ return
+ }
+ }
+ if x.QuickFailureThreshold != nil {
+ value := protoreflect.ValueOfMessage(x.QuickFailureThreshold.ProtoReflect())
+ if !f(fd_ValidationParams_quick_failure_threshold, 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_ValidationParams) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.ValidationParams.false_positive_rate":
+ return x.FalsePositiveRate != nil
+ case "inference.inference.ValidationParams.min_ramp_up_measurements":
+ return x.MinRampUpMeasurements != int32(0)
+ case "inference.inference.ValidationParams.pass_value":
+ return x.PassValue != nil
+ case "inference.inference.ValidationParams.min_validation_average":
+ return x.MinValidationAverage != nil
+ case "inference.inference.ValidationParams.max_validation_average":
+ return x.MaxValidationAverage != nil
+ case "inference.inference.ValidationParams.expiration_blocks":
+ return x.ExpirationBlocks != int64(0)
+ case "inference.inference.ValidationParams.epochs_to_max":
+ return x.EpochsToMax != int64(0)
+ case "inference.inference.ValidationParams.full_validation_traffic_cutoff":
+ return x.FullValidationTrafficCutoff != int64(0)
+ case "inference.inference.ValidationParams.min_validation_halfway":
+ return x.MinValidationHalfway != nil
+ case "inference.inference.ValidationParams.min_validation_traffic_cutoff":
+ return x.MinValidationTrafficCutoff != int64(0)
+ case "inference.inference.ValidationParams.miss_percentage_cutoff":
+ return x.MissPercentageCutoff != nil
+ case "inference.inference.ValidationParams.miss_requests_penalty":
+ return x.MissRequestsPenalty != nil
+ case "inference.inference.ValidationParams.timestamp_expiration":
+ return x.TimestampExpiration != int64(0)
+ case "inference.inference.ValidationParams.timestamp_advance":
+ return x.TimestampAdvance != int64(0)
+ case "inference.inference.ValidationParams.estimated_limits_per_block_kb":
+ return x.EstimatedLimitsPerBlockKb != uint64(0)
+ case "inference.inference.ValidationParams.invalid_reputation_preserve":
+ return x.InvalidReputationPreserve != nil
+ case "inference.inference.ValidationParams.bad_participant_invalidation_rate":
+ return x.BadParticipantInvalidationRate != nil
+ case "inference.inference.ValidationParams.invalidation_h_threshold":
+ return x.InvalidationHThreshold != nil
+ case "inference.inference.ValidationParams.downtime_good_percentage":
+ return x.DowntimeGoodPercentage != nil
+ case "inference.inference.ValidationParams.downtime_bad_percentage":
+ return x.DowntimeBadPercentage != nil
+ case "inference.inference.ValidationParams.downtime_h_threshold":
+ return x.DowntimeHThreshold != nil
+ case "inference.inference.ValidationParams.downtime_reputation_preserve":
+ return x.DowntimeReputationPreserve != nil
+ case "inference.inference.ValidationParams.quick_failure_threshold":
+ return x.QuickFailureThreshold != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ValidationParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.ValidationParams 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_ValidationParams) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.ValidationParams.false_positive_rate":
+ x.FalsePositiveRate = nil
+ case "inference.inference.ValidationParams.min_ramp_up_measurements":
+ x.MinRampUpMeasurements = int32(0)
+ case "inference.inference.ValidationParams.pass_value":
+ x.PassValue = nil
+ case "inference.inference.ValidationParams.min_validation_average":
+ x.MinValidationAverage = nil
+ case "inference.inference.ValidationParams.max_validation_average":
+ x.MaxValidationAverage = nil
+ case "inference.inference.ValidationParams.expiration_blocks":
+ x.ExpirationBlocks = int64(0)
+ case "inference.inference.ValidationParams.epochs_to_max":
+ x.EpochsToMax = int64(0)
+ case "inference.inference.ValidationParams.full_validation_traffic_cutoff":
+ x.FullValidationTrafficCutoff = int64(0)
+ case "inference.inference.ValidationParams.min_validation_halfway":
+ x.MinValidationHalfway = nil
+ case "inference.inference.ValidationParams.min_validation_traffic_cutoff":
+ x.MinValidationTrafficCutoff = int64(0)
+ case "inference.inference.ValidationParams.miss_percentage_cutoff":
+ x.MissPercentageCutoff = nil
+ case "inference.inference.ValidationParams.miss_requests_penalty":
+ x.MissRequestsPenalty = nil
+ case "inference.inference.ValidationParams.timestamp_expiration":
+ x.TimestampExpiration = int64(0)
+ case "inference.inference.ValidationParams.timestamp_advance":
+ x.TimestampAdvance = int64(0)
+ case "inference.inference.ValidationParams.estimated_limits_per_block_kb":
+ x.EstimatedLimitsPerBlockKb = uint64(0)
+ case "inference.inference.ValidationParams.invalid_reputation_preserve":
+ x.InvalidReputationPreserve = nil
+ case "inference.inference.ValidationParams.bad_participant_invalidation_rate":
+ x.BadParticipantInvalidationRate = nil
+ case "inference.inference.ValidationParams.invalidation_h_threshold":
+ x.InvalidationHThreshold = nil
+ case "inference.inference.ValidationParams.downtime_good_percentage":
+ x.DowntimeGoodPercentage = nil
+ case "inference.inference.ValidationParams.downtime_bad_percentage":
+ x.DowntimeBadPercentage = nil
+ case "inference.inference.ValidationParams.downtime_h_threshold":
+ x.DowntimeHThreshold = nil
+ case "inference.inference.ValidationParams.downtime_reputation_preserve":
+ x.DowntimeReputationPreserve = nil
+ case "inference.inference.ValidationParams.quick_failure_threshold":
+ x.QuickFailureThreshold = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ValidationParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.ValidationParams 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_ValidationParams) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.ValidationParams.false_positive_rate":
+ value := x.FalsePositiveRate
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.ValidationParams.min_ramp_up_measurements":
+ value := x.MinRampUpMeasurements
+ return protoreflect.ValueOfInt32(value)
+ case "inference.inference.ValidationParams.pass_value":
+ value := x.PassValue
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.ValidationParams.min_validation_average":
+ value := x.MinValidationAverage
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.ValidationParams.max_validation_average":
+ value := x.MaxValidationAverage
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.ValidationParams.expiration_blocks":
+ value := x.ExpirationBlocks
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.ValidationParams.epochs_to_max":
+ value := x.EpochsToMax
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.ValidationParams.full_validation_traffic_cutoff":
+ value := x.FullValidationTrafficCutoff
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.ValidationParams.min_validation_halfway":
+ value := x.MinValidationHalfway
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.ValidationParams.min_validation_traffic_cutoff":
+ value := x.MinValidationTrafficCutoff
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.ValidationParams.miss_percentage_cutoff":
+ value := x.MissPercentageCutoff
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.ValidationParams.miss_requests_penalty":
+ value := x.MissRequestsPenalty
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.ValidationParams.timestamp_expiration":
+ value := x.TimestampExpiration
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.ValidationParams.timestamp_advance":
+ value := x.TimestampAdvance
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.ValidationParams.estimated_limits_per_block_kb":
+ value := x.EstimatedLimitsPerBlockKb
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.ValidationParams.invalid_reputation_preserve":
+ value := x.InvalidReputationPreserve
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.ValidationParams.bad_participant_invalidation_rate":
+ value := x.BadParticipantInvalidationRate
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.ValidationParams.invalidation_h_threshold":
+ value := x.InvalidationHThreshold
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.ValidationParams.downtime_good_percentage":
+ value := x.DowntimeGoodPercentage
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.ValidationParams.downtime_bad_percentage":
+ value := x.DowntimeBadPercentage
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.ValidationParams.downtime_h_threshold":
+ value := x.DowntimeHThreshold
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.ValidationParams.downtime_reputation_preserve":
+ value := x.DowntimeReputationPreserve
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.ValidationParams.quick_failure_threshold":
+ value := x.QuickFailureThreshold
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ValidationParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.ValidationParams 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_ValidationParams) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.ValidationParams.false_positive_rate":
+ x.FalsePositiveRate = value.Message().Interface().(*Decimal)
+ case "inference.inference.ValidationParams.min_ramp_up_measurements":
+ x.MinRampUpMeasurements = int32(value.Int())
+ case "inference.inference.ValidationParams.pass_value":
+ x.PassValue = value.Message().Interface().(*Decimal)
+ case "inference.inference.ValidationParams.min_validation_average":
+ x.MinValidationAverage = value.Message().Interface().(*Decimal)
+ case "inference.inference.ValidationParams.max_validation_average":
+ x.MaxValidationAverage = value.Message().Interface().(*Decimal)
+ case "inference.inference.ValidationParams.expiration_blocks":
+ x.ExpirationBlocks = value.Int()
+ case "inference.inference.ValidationParams.epochs_to_max":
+ x.EpochsToMax = value.Int()
+ case "inference.inference.ValidationParams.full_validation_traffic_cutoff":
+ x.FullValidationTrafficCutoff = value.Int()
+ case "inference.inference.ValidationParams.min_validation_halfway":
+ x.MinValidationHalfway = value.Message().Interface().(*Decimal)
+ case "inference.inference.ValidationParams.min_validation_traffic_cutoff":
+ x.MinValidationTrafficCutoff = value.Int()
+ case "inference.inference.ValidationParams.miss_percentage_cutoff":
+ x.MissPercentageCutoff = value.Message().Interface().(*Decimal)
+ case "inference.inference.ValidationParams.miss_requests_penalty":
+ x.MissRequestsPenalty = value.Message().Interface().(*Decimal)
+ case "inference.inference.ValidationParams.timestamp_expiration":
+ x.TimestampExpiration = value.Int()
+ case "inference.inference.ValidationParams.timestamp_advance":
+ x.TimestampAdvance = value.Int()
+ case "inference.inference.ValidationParams.estimated_limits_per_block_kb":
+ x.EstimatedLimitsPerBlockKb = value.Uint()
+ case "inference.inference.ValidationParams.invalid_reputation_preserve":
+ x.InvalidReputationPreserve = value.Message().Interface().(*Decimal)
+ case "inference.inference.ValidationParams.bad_participant_invalidation_rate":
+ x.BadParticipantInvalidationRate = value.Message().Interface().(*Decimal)
+ case "inference.inference.ValidationParams.invalidation_h_threshold":
+ x.InvalidationHThreshold = value.Message().Interface().(*Decimal)
+ case "inference.inference.ValidationParams.downtime_good_percentage":
+ x.DowntimeGoodPercentage = value.Message().Interface().(*Decimal)
+ case "inference.inference.ValidationParams.downtime_bad_percentage":
+ x.DowntimeBadPercentage = value.Message().Interface().(*Decimal)
+ case "inference.inference.ValidationParams.downtime_h_threshold":
+ x.DowntimeHThreshold = value.Message().Interface().(*Decimal)
+ case "inference.inference.ValidationParams.downtime_reputation_preserve":
+ x.DowntimeReputationPreserve = value.Message().Interface().(*Decimal)
+ case "inference.inference.ValidationParams.quick_failure_threshold":
+ x.QuickFailureThreshold = value.Message().Interface().(*Decimal)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ValidationParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.ValidationParams 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_ValidationParams) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.ValidationParams.false_positive_rate":
+ if x.FalsePositiveRate == nil {
+ x.FalsePositiveRate = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.FalsePositiveRate.ProtoReflect())
+ case "inference.inference.ValidationParams.pass_value":
+ if x.PassValue == nil {
+ x.PassValue = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.PassValue.ProtoReflect())
+ case "inference.inference.ValidationParams.min_validation_average":
+ if x.MinValidationAverage == nil {
+ x.MinValidationAverage = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.MinValidationAverage.ProtoReflect())
+ case "inference.inference.ValidationParams.max_validation_average":
+ if x.MaxValidationAverage == nil {
+ x.MaxValidationAverage = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.MaxValidationAverage.ProtoReflect())
+ case "inference.inference.ValidationParams.min_validation_halfway":
+ if x.MinValidationHalfway == nil {
+ x.MinValidationHalfway = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.MinValidationHalfway.ProtoReflect())
+ case "inference.inference.ValidationParams.miss_percentage_cutoff":
+ if x.MissPercentageCutoff == nil {
+ x.MissPercentageCutoff = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.MissPercentageCutoff.ProtoReflect())
+ case "inference.inference.ValidationParams.miss_requests_penalty":
+ if x.MissRequestsPenalty == nil {
+ x.MissRequestsPenalty = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.MissRequestsPenalty.ProtoReflect())
+ case "inference.inference.ValidationParams.invalid_reputation_preserve":
+ if x.InvalidReputationPreserve == nil {
+ x.InvalidReputationPreserve = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.InvalidReputationPreserve.ProtoReflect())
+ case "inference.inference.ValidationParams.bad_participant_invalidation_rate":
+ if x.BadParticipantInvalidationRate == nil {
+ x.BadParticipantInvalidationRate = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.BadParticipantInvalidationRate.ProtoReflect())
+ case "inference.inference.ValidationParams.invalidation_h_threshold":
+ if x.InvalidationHThreshold == nil {
+ x.InvalidationHThreshold = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.InvalidationHThreshold.ProtoReflect())
+ case "inference.inference.ValidationParams.downtime_good_percentage":
+ if x.DowntimeGoodPercentage == nil {
+ x.DowntimeGoodPercentage = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.DowntimeGoodPercentage.ProtoReflect())
+ case "inference.inference.ValidationParams.downtime_bad_percentage":
+ if x.DowntimeBadPercentage == nil {
+ x.DowntimeBadPercentage = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.DowntimeBadPercentage.ProtoReflect())
+ case "inference.inference.ValidationParams.downtime_h_threshold":
+ if x.DowntimeHThreshold == nil {
+ x.DowntimeHThreshold = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.DowntimeHThreshold.ProtoReflect())
+ case "inference.inference.ValidationParams.downtime_reputation_preserve":
+ if x.DowntimeReputationPreserve == nil {
+ x.DowntimeReputationPreserve = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.DowntimeReputationPreserve.ProtoReflect())
+ case "inference.inference.ValidationParams.quick_failure_threshold":
+ if x.QuickFailureThreshold == nil {
+ x.QuickFailureThreshold = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.QuickFailureThreshold.ProtoReflect())
+ case "inference.inference.ValidationParams.min_ramp_up_measurements":
+ panic(fmt.Errorf("field min_ramp_up_measurements of message inference.inference.ValidationParams is not mutable"))
+ case "inference.inference.ValidationParams.expiration_blocks":
+ panic(fmt.Errorf("field expiration_blocks of message inference.inference.ValidationParams is not mutable"))
+ case "inference.inference.ValidationParams.epochs_to_max":
+ panic(fmt.Errorf("field epochs_to_max of message inference.inference.ValidationParams is not mutable"))
+ case "inference.inference.ValidationParams.full_validation_traffic_cutoff":
+ panic(fmt.Errorf("field full_validation_traffic_cutoff of message inference.inference.ValidationParams is not mutable"))
+ case "inference.inference.ValidationParams.min_validation_traffic_cutoff":
+ panic(fmt.Errorf("field min_validation_traffic_cutoff of message inference.inference.ValidationParams is not mutable"))
+ case "inference.inference.ValidationParams.timestamp_expiration":
+ panic(fmt.Errorf("field timestamp_expiration of message inference.inference.ValidationParams is not mutable"))
+ case "inference.inference.ValidationParams.timestamp_advance":
+ panic(fmt.Errorf("field timestamp_advance of message inference.inference.ValidationParams is not mutable"))
+ case "inference.inference.ValidationParams.estimated_limits_per_block_kb":
+ panic(fmt.Errorf("field estimated_limits_per_block_kb of message inference.inference.ValidationParams is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ValidationParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.ValidationParams 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_ValidationParams) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.ValidationParams.false_positive_rate":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.ValidationParams.min_ramp_up_measurements":
+ return protoreflect.ValueOfInt32(int32(0))
+ case "inference.inference.ValidationParams.pass_value":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.ValidationParams.min_validation_average":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.ValidationParams.max_validation_average":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.ValidationParams.expiration_blocks":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.ValidationParams.epochs_to_max":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.ValidationParams.full_validation_traffic_cutoff":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.ValidationParams.min_validation_halfway":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.ValidationParams.min_validation_traffic_cutoff":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.ValidationParams.miss_percentage_cutoff":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.ValidationParams.miss_requests_penalty":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.ValidationParams.timestamp_expiration":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.ValidationParams.timestamp_advance":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.ValidationParams.estimated_limits_per_block_kb":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.ValidationParams.invalid_reputation_preserve":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.ValidationParams.bad_participant_invalidation_rate":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.ValidationParams.invalidation_h_threshold":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.ValidationParams.downtime_good_percentage":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.ValidationParams.downtime_bad_percentage":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.ValidationParams.downtime_h_threshold":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.ValidationParams.downtime_reputation_preserve":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.ValidationParams.quick_failure_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.ValidationParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.ValidationParams 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_ValidationParams) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.ValidationParams", 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_ValidationParams) 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_ValidationParams) 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_ValidationParams) 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_ValidationParams) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*ValidationParams)
+ 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.FalsePositiveRate != nil {
+ l = options.Size(x.FalsePositiveRate)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.MinRampUpMeasurements != 0 {
+ n += 1 + runtime.Sov(uint64(x.MinRampUpMeasurements))
+ }
+ if x.PassValue != nil {
+ l = options.Size(x.PassValue)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.MinValidationAverage != nil {
+ l = options.Size(x.MinValidationAverage)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.MaxValidationAverage != nil {
+ l = options.Size(x.MaxValidationAverage)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.ExpirationBlocks != 0 {
+ n += 1 + runtime.Sov(uint64(x.ExpirationBlocks))
+ }
+ if x.EpochsToMax != 0 {
+ n += 1 + runtime.Sov(uint64(x.EpochsToMax))
+ }
+ if x.FullValidationTrafficCutoff != 0 {
+ n += 1 + runtime.Sov(uint64(x.FullValidationTrafficCutoff))
+ }
+ if x.MinValidationHalfway != nil {
+ l = options.Size(x.MinValidationHalfway)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.MinValidationTrafficCutoff != 0 {
+ n += 1 + runtime.Sov(uint64(x.MinValidationTrafficCutoff))
+ }
+ if x.MissPercentageCutoff != nil {
+ l = options.Size(x.MissPercentageCutoff)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.MissRequestsPenalty != nil {
+ l = options.Size(x.MissRequestsPenalty)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.TimestampExpiration != 0 {
+ n += 1 + runtime.Sov(uint64(x.TimestampExpiration))
+ }
+ if x.TimestampAdvance != 0 {
+ n += 1 + runtime.Sov(uint64(x.TimestampAdvance))
+ }
+ if x.EstimatedLimitsPerBlockKb != 0 {
+ n += 1 + runtime.Sov(uint64(x.EstimatedLimitsPerBlockKb))
+ }
+ if x.InvalidReputationPreserve != nil {
+ l = options.Size(x.InvalidReputationPreserve)
+ n += 2 + l + runtime.Sov(uint64(l))
+ }
+ if x.BadParticipantInvalidationRate != nil {
+ l = options.Size(x.BadParticipantInvalidationRate)
+ n += 2 + l + runtime.Sov(uint64(l))
+ }
+ if x.InvalidationHThreshold != nil {
+ l = options.Size(x.InvalidationHThreshold)
+ n += 2 + l + runtime.Sov(uint64(l))
+ }
+ if x.DowntimeGoodPercentage != nil {
+ l = options.Size(x.DowntimeGoodPercentage)
+ n += 2 + l + runtime.Sov(uint64(l))
+ }
+ if x.DowntimeBadPercentage != nil {
+ l = options.Size(x.DowntimeBadPercentage)
+ n += 2 + l + runtime.Sov(uint64(l))
+ }
+ if x.DowntimeHThreshold != nil {
+ l = options.Size(x.DowntimeHThreshold)
+ n += 2 + l + runtime.Sov(uint64(l))
+ }
+ if x.DowntimeReputationPreserve != nil {
+ l = options.Size(x.DowntimeReputationPreserve)
+ n += 2 + l + runtime.Sov(uint64(l))
+ }
+ if x.QuickFailureThreshold != nil {
+ l = options.Size(x.QuickFailureThreshold)
+ n += 2 + 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().(*ValidationParams)
+ 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.QuickFailureThreshold != nil {
+ encoded, err := options.Marshal(x.QuickFailureThreshold)
+ 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] = 0xba
+ }
+ if x.DowntimeReputationPreserve != nil {
+ encoded, err := options.Marshal(x.DowntimeReputationPreserve)
+ 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] = 0xb2
+ }
+ if x.DowntimeHThreshold != nil {
+ encoded, err := options.Marshal(x.DowntimeHThreshold)
+ 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] = 0xaa
+ }
+ if x.DowntimeBadPercentage != nil {
+ encoded, err := options.Marshal(x.DowntimeBadPercentage)
+ 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] = 0xa2
+ }
+ if x.DowntimeGoodPercentage != nil {
+ encoded, err := options.Marshal(x.DowntimeGoodPercentage)
+ 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] = 0x9a
+ }
+ if x.InvalidationHThreshold != nil {
+ encoded, err := options.Marshal(x.InvalidationHThreshold)
+ 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] = 0x92
+ }
+ if x.BadParticipantInvalidationRate != nil {
+ encoded, err := options.Marshal(x.BadParticipantInvalidationRate)
+ 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.InvalidReputationPreserve != nil {
+ encoded, err := options.Marshal(x.InvalidReputationPreserve)
+ 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] = 0x82
+ }
+ if x.EstimatedLimitsPerBlockKb != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.EstimatedLimitsPerBlockKb))
+ i--
+ dAtA[i] = 0x78
+ }
+ if x.TimestampAdvance != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.TimestampAdvance))
+ i--
+ dAtA[i] = 0x70
+ }
+ if x.TimestampExpiration != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.TimestampExpiration))
+ i--
+ dAtA[i] = 0x68
+ }
+ if x.MissRequestsPenalty != nil {
+ encoded, err := options.Marshal(x.MissRequestsPenalty)
+ 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] = 0x62
+ }
+ if x.MissPercentageCutoff != nil {
+ encoded, err := options.Marshal(x.MissPercentageCutoff)
+ 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] = 0x5a
+ }
+ if x.MinValidationTrafficCutoff != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.MinValidationTrafficCutoff))
+ i--
+ dAtA[i] = 0x50
+ }
+ if x.MinValidationHalfway != nil {
+ encoded, err := options.Marshal(x.MinValidationHalfway)
+ 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] = 0x4a
+ }
+ if x.FullValidationTrafficCutoff != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.FullValidationTrafficCutoff))
+ i--
+ dAtA[i] = 0x40
+ }
+ if x.EpochsToMax != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochsToMax))
+ i--
+ dAtA[i] = 0x38
+ }
+ if x.ExpirationBlocks != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.ExpirationBlocks))
+ i--
+ dAtA[i] = 0x30
+ }
+ if x.MaxValidationAverage != nil {
+ encoded, err := options.Marshal(x.MaxValidationAverage)
+ 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.MinValidationAverage != nil {
+ encoded, err := options.Marshal(x.MinValidationAverage)
+ 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.PassValue != nil {
+ encoded, err := options.Marshal(x.PassValue)
+ 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.MinRampUpMeasurements != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.MinRampUpMeasurements))
+ i--
+ dAtA[i] = 0x10
+ }
+ if x.FalsePositiveRate != nil {
+ encoded, err := options.Marshal(x.FalsePositiveRate)
+ 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().(*ValidationParams)
+ 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: ValidationParams: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ValidationParams: 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 FalsePositiveRate", 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.FalsePositiveRate == nil {
+ x.FalsePositiveRate = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.FalsePositiveRate); 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 MinRampUpMeasurements", wireType)
+ }
+ x.MinRampUpMeasurements = 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.MinRampUpMeasurements |= int32(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 PassValue", 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.PassValue == nil {
+ x.PassValue = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.PassValue); 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 MinValidationAverage", 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.MinValidationAverage == nil {
+ x.MinValidationAverage = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.MinValidationAverage); 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 MaxValidationAverage", 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.MaxValidationAverage == nil {
+ x.MaxValidationAverage = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.MaxValidationAverage); 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 ExpirationBlocks", wireType)
+ }
+ x.ExpirationBlocks = 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.ExpirationBlocks |= int64(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 EpochsToMax", wireType)
+ }
+ x.EpochsToMax = 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.EpochsToMax |= int64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 8:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field FullValidationTrafficCutoff", wireType)
+ }
+ x.FullValidationTrafficCutoff = 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.FullValidationTrafficCutoff |= int64(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 MinValidationHalfway", 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.MinValidationHalfway == nil {
+ x.MinValidationHalfway = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.MinValidationHalfway); err != nil {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+ }
+ iNdEx = postIndex
+ case 10:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MinValidationTrafficCutoff", wireType)
+ }
+ x.MinValidationTrafficCutoff = 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.MinValidationTrafficCutoff |= int64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 11:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MissPercentageCutoff", 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.MissPercentageCutoff == nil {
+ x.MissPercentageCutoff = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.MissPercentageCutoff); 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 MissRequestsPenalty", 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.MissRequestsPenalty == nil {
+ x.MissRequestsPenalty = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.MissRequestsPenalty); err != nil {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+ }
+ iNdEx = postIndex
+ case 13:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TimestampExpiration", wireType)
+ }
+ x.TimestampExpiration = 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.TimestampExpiration |= int64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 14:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TimestampAdvance", wireType)
+ }
+ x.TimestampAdvance = 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.TimestampAdvance |= int64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 15:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EstimatedLimitsPerBlockKb", wireType)
+ }
+ x.EstimatedLimitsPerBlockKb = 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.EstimatedLimitsPerBlockKb |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 16:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field InvalidReputationPreserve", 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.InvalidReputationPreserve == nil {
+ x.InvalidReputationPreserve = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.InvalidReputationPreserve); 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 BadParticipantInvalidationRate", 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.BadParticipantInvalidationRate == nil {
+ x.BadParticipantInvalidationRate = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.BadParticipantInvalidationRate); err != nil {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+ }
+ iNdEx = postIndex
+ case 18:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field InvalidationHThreshold", 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.InvalidationHThreshold == nil {
+ x.InvalidationHThreshold = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.InvalidationHThreshold); err != nil {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+ }
+ iNdEx = postIndex
+ case 19:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DowntimeGoodPercentage", 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.DowntimeGoodPercentage == nil {
+ x.DowntimeGoodPercentage = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.DowntimeGoodPercentage); err != nil {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+ }
+ iNdEx = postIndex
+ case 20:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DowntimeBadPercentage", 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.DowntimeBadPercentage == nil {
+ x.DowntimeBadPercentage = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.DowntimeBadPercentage); err != nil {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+ }
+ iNdEx = postIndex
+ case 21:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DowntimeHThreshold", 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.DowntimeHThreshold == nil {
+ x.DowntimeHThreshold = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.DowntimeHThreshold); err != nil {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+ }
+ iNdEx = postIndex
+ case 22:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DowntimeReputationPreserve", 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.DowntimeReputationPreserve == nil {
+ x.DowntimeReputationPreserve = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.DowntimeReputationPreserve); err != nil {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+ }
+ iNdEx = postIndex
+ case 23:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field QuickFailureThreshold", 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.QuickFailureThreshold == nil {
+ x.QuickFailureThreshold = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.QuickFailureThreshold); 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_PocParams protoreflect.MessageDescriptor
+ fd_PocParams_default_difficulty protoreflect.FieldDescriptor
+ fd_PocParams_validation_sample_size protoreflect.FieldDescriptor
+ fd_PocParams_poc_data_pruning_epoch_threshold protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_params_proto_init()
+ md_PocParams = File_inference_inference_params_proto.Messages().ByName("PocParams")
+ fd_PocParams_default_difficulty = md_PocParams.Fields().ByName("default_difficulty")
+ fd_PocParams_validation_sample_size = md_PocParams.Fields().ByName("validation_sample_size")
+ fd_PocParams_poc_data_pruning_epoch_threshold = md_PocParams.Fields().ByName("poc_data_pruning_epoch_threshold")
+}
+
+var _ protoreflect.Message = (*fastReflection_PocParams)(nil)
+
+type fastReflection_PocParams PocParams
+
+func (x *PocParams) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_PocParams)(x)
+}
+
+func (x *PocParams) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_params_proto_msgTypes[5]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_PocParams_messageType fastReflection_PocParams_messageType
+var _ protoreflect.MessageType = fastReflection_PocParams_messageType{}
+
+type fastReflection_PocParams_messageType struct{}
+
+func (x fastReflection_PocParams_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_PocParams)(nil)
+}
+func (x fastReflection_PocParams_messageType) New() protoreflect.Message {
+ return new(fastReflection_PocParams)
+}
+func (x fastReflection_PocParams_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_PocParams
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_PocParams) Descriptor() protoreflect.MessageDescriptor {
+ return md_PocParams
+}
+
+// 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_PocParams) Type() protoreflect.MessageType {
+ return _fastReflection_PocParams_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_PocParams) New() protoreflect.Message {
+ return new(fastReflection_PocParams)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_PocParams) Interface() protoreflect.ProtoMessage {
+ return (*PocParams)(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_PocParams) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.DefaultDifficulty != int32(0) {
+ value := protoreflect.ValueOfInt32(x.DefaultDifficulty)
+ if !f(fd_PocParams_default_difficulty, value) {
+ return
+ }
+ }
+ if x.ValidationSampleSize != int32(0) {
+ value := protoreflect.ValueOfInt32(x.ValidationSampleSize)
+ if !f(fd_PocParams_validation_sample_size, value) {
+ return
+ }
+ }
+ if x.PocDataPruningEpochThreshold != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.PocDataPruningEpochThreshold)
+ if !f(fd_PocParams_poc_data_pruning_epoch_threshold, 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_PocParams) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.PocParams.default_difficulty":
+ return x.DefaultDifficulty != int32(0)
+ case "inference.inference.PocParams.validation_sample_size":
+ return x.ValidationSampleSize != int32(0)
+ case "inference.inference.PocParams.poc_data_pruning_epoch_threshold":
+ return x.PocDataPruningEpochThreshold != uint64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PocParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.PocParams 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_PocParams) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.PocParams.default_difficulty":
+ x.DefaultDifficulty = int32(0)
+ case "inference.inference.PocParams.validation_sample_size":
+ x.ValidationSampleSize = int32(0)
+ case "inference.inference.PocParams.poc_data_pruning_epoch_threshold":
+ x.PocDataPruningEpochThreshold = uint64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PocParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.PocParams 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_PocParams) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.PocParams.default_difficulty":
+ value := x.DefaultDifficulty
+ return protoreflect.ValueOfInt32(value)
+ case "inference.inference.PocParams.validation_sample_size":
+ value := x.ValidationSampleSize
+ return protoreflect.ValueOfInt32(value)
+ case "inference.inference.PocParams.poc_data_pruning_epoch_threshold":
+ value := x.PocDataPruningEpochThreshold
+ return protoreflect.ValueOfUint64(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PocParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.PocParams 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_PocParams) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.PocParams.default_difficulty":
+ x.DefaultDifficulty = int32(value.Int())
+ case "inference.inference.PocParams.validation_sample_size":
+ x.ValidationSampleSize = int32(value.Int())
+ case "inference.inference.PocParams.poc_data_pruning_epoch_threshold":
+ x.PocDataPruningEpochThreshold = value.Uint()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PocParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.PocParams 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_PocParams) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.PocParams.default_difficulty":
+ panic(fmt.Errorf("field default_difficulty of message inference.inference.PocParams is not mutable"))
+ case "inference.inference.PocParams.validation_sample_size":
+ panic(fmt.Errorf("field validation_sample_size of message inference.inference.PocParams is not mutable"))
+ case "inference.inference.PocParams.poc_data_pruning_epoch_threshold":
+ panic(fmt.Errorf("field poc_data_pruning_epoch_threshold of message inference.inference.PocParams is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PocParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.PocParams 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_PocParams) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.PocParams.default_difficulty":
+ return protoreflect.ValueOfInt32(int32(0))
+ case "inference.inference.PocParams.validation_sample_size":
+ return protoreflect.ValueOfInt32(int32(0))
+ case "inference.inference.PocParams.poc_data_pruning_epoch_threshold":
+ return protoreflect.ValueOfUint64(uint64(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PocParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.PocParams 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_PocParams) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.PocParams", 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_PocParams) 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_PocParams) 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_PocParams) 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_PocParams) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*PocParams)
+ 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.DefaultDifficulty != 0 {
+ n += 1 + runtime.Sov(uint64(x.DefaultDifficulty))
+ }
+ if x.ValidationSampleSize != 0 {
+ n += 1 + runtime.Sov(uint64(x.ValidationSampleSize))
+ }
+ if x.PocDataPruningEpochThreshold != 0 {
+ n += 1 + runtime.Sov(uint64(x.PocDataPruningEpochThreshold))
+ }
+ 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().(*PocParams)
+ 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.PocDataPruningEpochThreshold != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.PocDataPruningEpochThreshold))
+ i--
+ dAtA[i] = 0x18
+ }
+ if x.ValidationSampleSize != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.ValidationSampleSize))
+ i--
+ dAtA[i] = 0x10
+ }
+ if x.DefaultDifficulty != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.DefaultDifficulty))
+ 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().(*PocParams)
+ 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: PocParams: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: PocParams: 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 DefaultDifficulty", wireType)
+ }
+ x.DefaultDifficulty = 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.DefaultDifficulty |= int32(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 ValidationSampleSize", wireType)
+ }
+ x.ValidationSampleSize = 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.ValidationSampleSize |= int32(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 PocDataPruningEpochThreshold", wireType)
+ }
+ x.PocDataPruningEpochThreshold = 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.PocDataPruningEpochThreshold |= 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_Decimal protoreflect.MessageDescriptor
+ fd_Decimal_value protoreflect.FieldDescriptor
+ fd_Decimal_exponent protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_params_proto_init()
+ md_Decimal = File_inference_inference_params_proto.Messages().ByName("Decimal")
+ fd_Decimal_value = md_Decimal.Fields().ByName("value")
+ fd_Decimal_exponent = md_Decimal.Fields().ByName("exponent")
+}
+
+var _ protoreflect.Message = (*fastReflection_Decimal)(nil)
+
+type fastReflection_Decimal Decimal
+
+func (x *Decimal) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_Decimal)(x)
+}
+
+func (x *Decimal) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_params_proto_msgTypes[6]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_Decimal_messageType fastReflection_Decimal_messageType
+var _ protoreflect.MessageType = fastReflection_Decimal_messageType{}
+
+type fastReflection_Decimal_messageType struct{}
+
+func (x fastReflection_Decimal_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_Decimal)(nil)
+}
+func (x fastReflection_Decimal_messageType) New() protoreflect.Message {
+ return new(fastReflection_Decimal)
+}
+func (x fastReflection_Decimal_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_Decimal
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_Decimal) Descriptor() protoreflect.MessageDescriptor {
+ return md_Decimal
+}
+
+// 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_Decimal) Type() protoreflect.MessageType {
+ return _fastReflection_Decimal_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_Decimal) New() protoreflect.Message {
+ return new(fastReflection_Decimal)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_Decimal) Interface() protoreflect.ProtoMessage {
+ return (*Decimal)(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_Decimal) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Value != int64(0) {
+ value := protoreflect.ValueOfInt64(x.Value)
+ if !f(fd_Decimal_value, value) {
+ return
+ }
+ }
+ if x.Exponent != int32(0) {
+ value := protoreflect.ValueOfInt32(x.Exponent)
+ if !f(fd_Decimal_exponent, 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_Decimal) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.Decimal.value":
+ return x.Value != int64(0)
+ case "inference.inference.Decimal.exponent":
+ return x.Exponent != int32(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Decimal"))
+ }
+ panic(fmt.Errorf("message inference.inference.Decimal 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_Decimal) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.Decimal.value":
+ x.Value = int64(0)
+ case "inference.inference.Decimal.exponent":
+ x.Exponent = int32(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Decimal"))
+ }
+ panic(fmt.Errorf("message inference.inference.Decimal 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_Decimal) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.Decimal.value":
+ value := x.Value
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.Decimal.exponent":
+ value := x.Exponent
+ return protoreflect.ValueOfInt32(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Decimal"))
+ }
+ panic(fmt.Errorf("message inference.inference.Decimal 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_Decimal) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.Decimal.value":
+ x.Value = value.Int()
+ case "inference.inference.Decimal.exponent":
+ x.Exponent = int32(value.Int())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Decimal"))
+ }
+ panic(fmt.Errorf("message inference.inference.Decimal 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_Decimal) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.Decimal.value":
+ panic(fmt.Errorf("field value of message inference.inference.Decimal is not mutable"))
+ case "inference.inference.Decimal.exponent":
+ panic(fmt.Errorf("field exponent of message inference.inference.Decimal is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Decimal"))
+ }
+ panic(fmt.Errorf("message inference.inference.Decimal 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_Decimal) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.Decimal.value":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.Decimal.exponent":
+ return protoreflect.ValueOfInt32(int32(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Decimal"))
+ }
+ panic(fmt.Errorf("message inference.inference.Decimal 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_Decimal) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.Decimal", 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_Decimal) 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_Decimal) 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_Decimal) 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_Decimal) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*Decimal)
+ 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.Value != 0 {
+ n += 1 + runtime.Sov(uint64(x.Value))
+ }
+ if x.Exponent != 0 {
+ n += 1 + runtime.Sov(uint64(x.Exponent))
+ }
+ 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().(*Decimal)
+ 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.Exponent != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.Exponent))
+ i--
+ dAtA[i] = 0x10
+ }
+ if x.Value != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.Value))
+ 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().(*Decimal)
+ 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: Decimal: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Decimal: 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 Value", wireType)
+ }
+ x.Value = 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.Value |= 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 Exponent", wireType)
+ }
+ x.Exponent = 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.Exponent |= 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,
+ Size: size,
+ Marshal: marshal,
+ Unmarshal: unmarshal,
+ Merge: nil,
+ CheckInitialized: nil,
+ }
+}
+
+var (
+ md_CollateralParams protoreflect.MessageDescriptor
+ fd_CollateralParams_slash_fraction_invalid protoreflect.FieldDescriptor
+ fd_CollateralParams_slash_fraction_downtime protoreflect.FieldDescriptor
+ fd_CollateralParams_downtime_missed_percentage_threshold protoreflect.FieldDescriptor
+ fd_CollateralParams_grace_period_end_epoch protoreflect.FieldDescriptor
+ fd_CollateralParams_base_weight_ratio protoreflect.FieldDescriptor
+ fd_CollateralParams_collateral_per_weight_unit protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_params_proto_init()
+ md_CollateralParams = File_inference_inference_params_proto.Messages().ByName("CollateralParams")
+ fd_CollateralParams_slash_fraction_invalid = md_CollateralParams.Fields().ByName("slash_fraction_invalid")
+ fd_CollateralParams_slash_fraction_downtime = md_CollateralParams.Fields().ByName("slash_fraction_downtime")
+ fd_CollateralParams_downtime_missed_percentage_threshold = md_CollateralParams.Fields().ByName("downtime_missed_percentage_threshold")
+ fd_CollateralParams_grace_period_end_epoch = md_CollateralParams.Fields().ByName("grace_period_end_epoch")
+ fd_CollateralParams_base_weight_ratio = md_CollateralParams.Fields().ByName("base_weight_ratio")
+ fd_CollateralParams_collateral_per_weight_unit = md_CollateralParams.Fields().ByName("collateral_per_weight_unit")
+}
+
+var _ protoreflect.Message = (*fastReflection_CollateralParams)(nil)
+
+type fastReflection_CollateralParams CollateralParams
+
+func (x *CollateralParams) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_CollateralParams)(x)
+}
+
+func (x *CollateralParams) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_params_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_CollateralParams_messageType fastReflection_CollateralParams_messageType
+var _ protoreflect.MessageType = fastReflection_CollateralParams_messageType{}
+
+type fastReflection_CollateralParams_messageType struct{}
+
+func (x fastReflection_CollateralParams_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_CollateralParams)(nil)
+}
+func (x fastReflection_CollateralParams_messageType) New() protoreflect.Message {
+ return new(fastReflection_CollateralParams)
+}
+func (x fastReflection_CollateralParams_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_CollateralParams
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_CollateralParams) Descriptor() protoreflect.MessageDescriptor {
+ return md_CollateralParams
+}
+
+// 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_CollateralParams) Type() protoreflect.MessageType {
+ return _fastReflection_CollateralParams_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_CollateralParams) New() protoreflect.Message {
+ return new(fastReflection_CollateralParams)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_CollateralParams) Interface() protoreflect.ProtoMessage {
+ return (*CollateralParams)(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_CollateralParams) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.SlashFractionInvalid != nil {
+ value := protoreflect.ValueOfMessage(x.SlashFractionInvalid.ProtoReflect())
+ if !f(fd_CollateralParams_slash_fraction_invalid, value) {
+ return
+ }
+ }
+ if x.SlashFractionDowntime != nil {
+ value := protoreflect.ValueOfMessage(x.SlashFractionDowntime.ProtoReflect())
+ if !f(fd_CollateralParams_slash_fraction_downtime, value) {
+ return
+ }
+ }
+ if x.DowntimeMissedPercentageThreshold != nil {
+ value := protoreflect.ValueOfMessage(x.DowntimeMissedPercentageThreshold.ProtoReflect())
+ if !f(fd_CollateralParams_downtime_missed_percentage_threshold, value) {
+ return
+ }
+ }
+ if x.GracePeriodEndEpoch != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.GracePeriodEndEpoch)
+ if !f(fd_CollateralParams_grace_period_end_epoch, value) {
+ return
+ }
+ }
+ if x.BaseWeightRatio != nil {
+ value := protoreflect.ValueOfMessage(x.BaseWeightRatio.ProtoReflect())
+ if !f(fd_CollateralParams_base_weight_ratio, value) {
+ return
+ }
+ }
+ if x.CollateralPerWeightUnit != nil {
+ value := protoreflect.ValueOfMessage(x.CollateralPerWeightUnit.ProtoReflect())
+ if !f(fd_CollateralParams_collateral_per_weight_unit, 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_CollateralParams) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.CollateralParams.slash_fraction_invalid":
+ return x.SlashFractionInvalid != nil
+ case "inference.inference.CollateralParams.slash_fraction_downtime":
+ return x.SlashFractionDowntime != nil
+ case "inference.inference.CollateralParams.downtime_missed_percentage_threshold":
+ return x.DowntimeMissedPercentageThreshold != nil
+ case "inference.inference.CollateralParams.grace_period_end_epoch":
+ return x.GracePeriodEndEpoch != uint64(0)
+ case "inference.inference.CollateralParams.base_weight_ratio":
+ return x.BaseWeightRatio != nil
+ case "inference.inference.CollateralParams.collateral_per_weight_unit":
+ return x.CollateralPerWeightUnit != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.CollateralParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.CollateralParams 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_CollateralParams) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.CollateralParams.slash_fraction_invalid":
+ x.SlashFractionInvalid = nil
+ case "inference.inference.CollateralParams.slash_fraction_downtime":
+ x.SlashFractionDowntime = nil
+ case "inference.inference.CollateralParams.downtime_missed_percentage_threshold":
+ x.DowntimeMissedPercentageThreshold = nil
+ case "inference.inference.CollateralParams.grace_period_end_epoch":
+ x.GracePeriodEndEpoch = uint64(0)
+ case "inference.inference.CollateralParams.base_weight_ratio":
+ x.BaseWeightRatio = nil
+ case "inference.inference.CollateralParams.collateral_per_weight_unit":
+ x.CollateralPerWeightUnit = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.CollateralParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.CollateralParams 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_CollateralParams) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.CollateralParams.slash_fraction_invalid":
+ value := x.SlashFractionInvalid
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.CollateralParams.slash_fraction_downtime":
+ value := x.SlashFractionDowntime
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.CollateralParams.downtime_missed_percentage_threshold":
+ value := x.DowntimeMissedPercentageThreshold
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.CollateralParams.grace_period_end_epoch":
+ value := x.GracePeriodEndEpoch
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.CollateralParams.base_weight_ratio":
+ value := x.BaseWeightRatio
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.CollateralParams.collateral_per_weight_unit":
+ value := x.CollateralPerWeightUnit
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.CollateralParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.CollateralParams 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_CollateralParams) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.CollateralParams.slash_fraction_invalid":
+ x.SlashFractionInvalid = value.Message().Interface().(*Decimal)
+ case "inference.inference.CollateralParams.slash_fraction_downtime":
+ x.SlashFractionDowntime = value.Message().Interface().(*Decimal)
+ case "inference.inference.CollateralParams.downtime_missed_percentage_threshold":
+ x.DowntimeMissedPercentageThreshold = value.Message().Interface().(*Decimal)
+ case "inference.inference.CollateralParams.grace_period_end_epoch":
+ x.GracePeriodEndEpoch = value.Uint()
+ case "inference.inference.CollateralParams.base_weight_ratio":
+ x.BaseWeightRatio = value.Message().Interface().(*Decimal)
+ case "inference.inference.CollateralParams.collateral_per_weight_unit":
+ x.CollateralPerWeightUnit = value.Message().Interface().(*Decimal)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.CollateralParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.CollateralParams 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_CollateralParams) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.CollateralParams.slash_fraction_invalid":
+ if x.SlashFractionInvalid == nil {
+ x.SlashFractionInvalid = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.SlashFractionInvalid.ProtoReflect())
+ case "inference.inference.CollateralParams.slash_fraction_downtime":
+ if x.SlashFractionDowntime == nil {
+ x.SlashFractionDowntime = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.SlashFractionDowntime.ProtoReflect())
+ case "inference.inference.CollateralParams.downtime_missed_percentage_threshold":
+ if x.DowntimeMissedPercentageThreshold == nil {
+ x.DowntimeMissedPercentageThreshold = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.DowntimeMissedPercentageThreshold.ProtoReflect())
+ case "inference.inference.CollateralParams.base_weight_ratio":
+ if x.BaseWeightRatio == nil {
+ x.BaseWeightRatio = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.BaseWeightRatio.ProtoReflect())
+ case "inference.inference.CollateralParams.collateral_per_weight_unit":
+ if x.CollateralPerWeightUnit == nil {
+ x.CollateralPerWeightUnit = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.CollateralPerWeightUnit.ProtoReflect())
+ case "inference.inference.CollateralParams.grace_period_end_epoch":
+ panic(fmt.Errorf("field grace_period_end_epoch of message inference.inference.CollateralParams is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.CollateralParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.CollateralParams 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_CollateralParams) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.CollateralParams.slash_fraction_invalid":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.CollateralParams.slash_fraction_downtime":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.CollateralParams.downtime_missed_percentage_threshold":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.CollateralParams.grace_period_end_epoch":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.CollateralParams.base_weight_ratio":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.CollateralParams.collateral_per_weight_unit":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.CollateralParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.CollateralParams 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_CollateralParams) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.CollateralParams", 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_CollateralParams) 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_CollateralParams) 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_CollateralParams) 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_CollateralParams) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*CollateralParams)
+ 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.SlashFractionInvalid != nil {
+ l = options.Size(x.SlashFractionInvalid)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.SlashFractionDowntime != nil {
+ l = options.Size(x.SlashFractionDowntime)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.DowntimeMissedPercentageThreshold != nil {
+ l = options.Size(x.DowntimeMissedPercentageThreshold)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.GracePeriodEndEpoch != 0 {
+ n += 1 + runtime.Sov(uint64(x.GracePeriodEndEpoch))
+ }
+ if x.BaseWeightRatio != nil {
+ l = options.Size(x.BaseWeightRatio)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.CollateralPerWeightUnit != nil {
+ l = options.Size(x.CollateralPerWeightUnit)
+ 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().(*CollateralParams)
+ 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.CollateralPerWeightUnit != nil {
+ encoded, err := options.Marshal(x.CollateralPerWeightUnit)
+ 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 x.BaseWeightRatio != nil {
+ encoded, err := options.Marshal(x.BaseWeightRatio)
+ 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.GracePeriodEndEpoch != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.GracePeriodEndEpoch))
+ i--
+ dAtA[i] = 0x20
+ }
+ if x.DowntimeMissedPercentageThreshold != nil {
+ encoded, err := options.Marshal(x.DowntimeMissedPercentageThreshold)
+ 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.SlashFractionDowntime != nil {
+ encoded, err := options.Marshal(x.SlashFractionDowntime)
+ 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.SlashFractionInvalid != nil {
+ encoded, err := options.Marshal(x.SlashFractionInvalid)
+ 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().(*CollateralParams)
+ 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: CollateralParams: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: CollateralParams: 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 SlashFractionInvalid", 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.SlashFractionInvalid == nil {
+ x.SlashFractionInvalid = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.SlashFractionInvalid); 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 SlashFractionDowntime", 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.SlashFractionDowntime == nil {
+ x.SlashFractionDowntime = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.SlashFractionDowntime); 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 DowntimeMissedPercentageThreshold", 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.DowntimeMissedPercentageThreshold == nil {
+ x.DowntimeMissedPercentageThreshold = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.DowntimeMissedPercentageThreshold); 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 GracePeriodEndEpoch", wireType)
+ }
+ x.GracePeriodEndEpoch = 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.GracePeriodEndEpoch |= 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 BaseWeightRatio", 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.BaseWeightRatio == nil {
+ x.BaseWeightRatio = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.BaseWeightRatio); err != nil {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+ }
+ iNdEx = postIndex
+ case 6:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field CollateralPerWeightUnit", 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.CollateralPerWeightUnit == nil {
+ x.CollateralPerWeightUnit = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.CollateralPerWeightUnit); 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_BitcoinRewardParams protoreflect.MessageDescriptor
+ fd_BitcoinRewardParams_use_bitcoin_rewards protoreflect.FieldDescriptor
+ fd_BitcoinRewardParams_initial_epoch_reward protoreflect.FieldDescriptor
+ fd_BitcoinRewardParams_decay_rate protoreflect.FieldDescriptor
+ fd_BitcoinRewardParams_genesis_epoch protoreflect.FieldDescriptor
+ fd_BitcoinRewardParams_utilization_bonus_factor protoreflect.FieldDescriptor
+ fd_BitcoinRewardParams_full_coverage_bonus_factor protoreflect.FieldDescriptor
+ fd_BitcoinRewardParams_partial_coverage_bonus_factor protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_params_proto_init()
+ md_BitcoinRewardParams = File_inference_inference_params_proto.Messages().ByName("BitcoinRewardParams")
+ fd_BitcoinRewardParams_use_bitcoin_rewards = md_BitcoinRewardParams.Fields().ByName("use_bitcoin_rewards")
+ fd_BitcoinRewardParams_initial_epoch_reward = md_BitcoinRewardParams.Fields().ByName("initial_epoch_reward")
+ fd_BitcoinRewardParams_decay_rate = md_BitcoinRewardParams.Fields().ByName("decay_rate")
+ fd_BitcoinRewardParams_genesis_epoch = md_BitcoinRewardParams.Fields().ByName("genesis_epoch")
+ fd_BitcoinRewardParams_utilization_bonus_factor = md_BitcoinRewardParams.Fields().ByName("utilization_bonus_factor")
+ fd_BitcoinRewardParams_full_coverage_bonus_factor = md_BitcoinRewardParams.Fields().ByName("full_coverage_bonus_factor")
+ fd_BitcoinRewardParams_partial_coverage_bonus_factor = md_BitcoinRewardParams.Fields().ByName("partial_coverage_bonus_factor")
+}
+
+var _ protoreflect.Message = (*fastReflection_BitcoinRewardParams)(nil)
+
+type fastReflection_BitcoinRewardParams BitcoinRewardParams
+
+func (x *BitcoinRewardParams) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_BitcoinRewardParams)(x)
+}
+
+func (x *BitcoinRewardParams) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_params_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_BitcoinRewardParams_messageType fastReflection_BitcoinRewardParams_messageType
+var _ protoreflect.MessageType = fastReflection_BitcoinRewardParams_messageType{}
+
+type fastReflection_BitcoinRewardParams_messageType struct{}
+
+func (x fastReflection_BitcoinRewardParams_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_BitcoinRewardParams)(nil)
+}
+func (x fastReflection_BitcoinRewardParams_messageType) New() protoreflect.Message {
+ return new(fastReflection_BitcoinRewardParams)
+}
+func (x fastReflection_BitcoinRewardParams_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_BitcoinRewardParams
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_BitcoinRewardParams) Descriptor() protoreflect.MessageDescriptor {
+ return md_BitcoinRewardParams
+}
+
+// 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_BitcoinRewardParams) Type() protoreflect.MessageType {
+ return _fastReflection_BitcoinRewardParams_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_BitcoinRewardParams) New() protoreflect.Message {
+ return new(fastReflection_BitcoinRewardParams)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_BitcoinRewardParams) Interface() protoreflect.ProtoMessage {
+ return (*BitcoinRewardParams)(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_BitcoinRewardParams) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.UseBitcoinRewards != false {
+ value := protoreflect.ValueOfBool(x.UseBitcoinRewards)
+ if !f(fd_BitcoinRewardParams_use_bitcoin_rewards, value) {
+ return
+ }
+ }
+ if x.InitialEpochReward != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.InitialEpochReward)
+ if !f(fd_BitcoinRewardParams_initial_epoch_reward, value) {
+ return
+ }
+ }
+ if x.DecayRate != nil {
+ value := protoreflect.ValueOfMessage(x.DecayRate.ProtoReflect())
+ if !f(fd_BitcoinRewardParams_decay_rate, value) {
+ return
+ }
+ }
+ if x.GenesisEpoch != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.GenesisEpoch)
+ if !f(fd_BitcoinRewardParams_genesis_epoch, value) {
+ return
+ }
+ }
+ if x.UtilizationBonusFactor != nil {
+ value := protoreflect.ValueOfMessage(x.UtilizationBonusFactor.ProtoReflect())
+ if !f(fd_BitcoinRewardParams_utilization_bonus_factor, value) {
+ return
+ }
+ }
+ if x.FullCoverageBonusFactor != nil {
+ value := protoreflect.ValueOfMessage(x.FullCoverageBonusFactor.ProtoReflect())
+ if !f(fd_BitcoinRewardParams_full_coverage_bonus_factor, value) {
+ return
+ }
+ }
+ if x.PartialCoverageBonusFactor != nil {
+ value := protoreflect.ValueOfMessage(x.PartialCoverageBonusFactor.ProtoReflect())
+ if !f(fd_BitcoinRewardParams_partial_coverage_bonus_factor, 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_BitcoinRewardParams) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.BitcoinRewardParams.use_bitcoin_rewards":
+ return x.UseBitcoinRewards != false
+ case "inference.inference.BitcoinRewardParams.initial_epoch_reward":
+ return x.InitialEpochReward != uint64(0)
+ case "inference.inference.BitcoinRewardParams.decay_rate":
+ return x.DecayRate != nil
+ case "inference.inference.BitcoinRewardParams.genesis_epoch":
+ return x.GenesisEpoch != uint64(0)
+ case "inference.inference.BitcoinRewardParams.utilization_bonus_factor":
+ return x.UtilizationBonusFactor != nil
+ case "inference.inference.BitcoinRewardParams.full_coverage_bonus_factor":
+ return x.FullCoverageBonusFactor != nil
+ case "inference.inference.BitcoinRewardParams.partial_coverage_bonus_factor":
+ return x.PartialCoverageBonusFactor != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BitcoinRewardParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.BitcoinRewardParams 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_BitcoinRewardParams) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.BitcoinRewardParams.use_bitcoin_rewards":
+ x.UseBitcoinRewards = false
+ case "inference.inference.BitcoinRewardParams.initial_epoch_reward":
+ x.InitialEpochReward = uint64(0)
+ case "inference.inference.BitcoinRewardParams.decay_rate":
+ x.DecayRate = nil
+ case "inference.inference.BitcoinRewardParams.genesis_epoch":
+ x.GenesisEpoch = uint64(0)
+ case "inference.inference.BitcoinRewardParams.utilization_bonus_factor":
+ x.UtilizationBonusFactor = nil
+ case "inference.inference.BitcoinRewardParams.full_coverage_bonus_factor":
+ x.FullCoverageBonusFactor = nil
+ case "inference.inference.BitcoinRewardParams.partial_coverage_bonus_factor":
+ x.PartialCoverageBonusFactor = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BitcoinRewardParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.BitcoinRewardParams 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_BitcoinRewardParams) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.BitcoinRewardParams.use_bitcoin_rewards":
+ value := x.UseBitcoinRewards
+ return protoreflect.ValueOfBool(value)
+ case "inference.inference.BitcoinRewardParams.initial_epoch_reward":
+ value := x.InitialEpochReward
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.BitcoinRewardParams.decay_rate":
+ value := x.DecayRate
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.BitcoinRewardParams.genesis_epoch":
+ value := x.GenesisEpoch
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.BitcoinRewardParams.utilization_bonus_factor":
+ value := x.UtilizationBonusFactor
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.BitcoinRewardParams.full_coverage_bonus_factor":
+ value := x.FullCoverageBonusFactor
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.BitcoinRewardParams.partial_coverage_bonus_factor":
+ value := x.PartialCoverageBonusFactor
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BitcoinRewardParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.BitcoinRewardParams 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_BitcoinRewardParams) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.BitcoinRewardParams.use_bitcoin_rewards":
+ x.UseBitcoinRewards = value.Bool()
+ case "inference.inference.BitcoinRewardParams.initial_epoch_reward":
+ x.InitialEpochReward = value.Uint()
+ case "inference.inference.BitcoinRewardParams.decay_rate":
+ x.DecayRate = value.Message().Interface().(*Decimal)
+ case "inference.inference.BitcoinRewardParams.genesis_epoch":
+ x.GenesisEpoch = value.Uint()
+ case "inference.inference.BitcoinRewardParams.utilization_bonus_factor":
+ x.UtilizationBonusFactor = value.Message().Interface().(*Decimal)
+ case "inference.inference.BitcoinRewardParams.full_coverage_bonus_factor":
+ x.FullCoverageBonusFactor = value.Message().Interface().(*Decimal)
+ case "inference.inference.BitcoinRewardParams.partial_coverage_bonus_factor":
+ x.PartialCoverageBonusFactor = value.Message().Interface().(*Decimal)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BitcoinRewardParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.BitcoinRewardParams 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_BitcoinRewardParams) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.BitcoinRewardParams.decay_rate":
+ if x.DecayRate == nil {
+ x.DecayRate = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.DecayRate.ProtoReflect())
+ case "inference.inference.BitcoinRewardParams.utilization_bonus_factor":
+ if x.UtilizationBonusFactor == nil {
+ x.UtilizationBonusFactor = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.UtilizationBonusFactor.ProtoReflect())
+ case "inference.inference.BitcoinRewardParams.full_coverage_bonus_factor":
+ if x.FullCoverageBonusFactor == nil {
+ x.FullCoverageBonusFactor = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.FullCoverageBonusFactor.ProtoReflect())
+ case "inference.inference.BitcoinRewardParams.partial_coverage_bonus_factor":
+ if x.PartialCoverageBonusFactor == nil {
+ x.PartialCoverageBonusFactor = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.PartialCoverageBonusFactor.ProtoReflect())
+ case "inference.inference.BitcoinRewardParams.use_bitcoin_rewards":
+ panic(fmt.Errorf("field use_bitcoin_rewards of message inference.inference.BitcoinRewardParams is not mutable"))
+ case "inference.inference.BitcoinRewardParams.initial_epoch_reward":
+ panic(fmt.Errorf("field initial_epoch_reward of message inference.inference.BitcoinRewardParams is not mutable"))
+ case "inference.inference.BitcoinRewardParams.genesis_epoch":
+ panic(fmt.Errorf("field genesis_epoch of message inference.inference.BitcoinRewardParams is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BitcoinRewardParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.BitcoinRewardParams 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_BitcoinRewardParams) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.BitcoinRewardParams.use_bitcoin_rewards":
+ return protoreflect.ValueOfBool(false)
+ case "inference.inference.BitcoinRewardParams.initial_epoch_reward":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.BitcoinRewardParams.decay_rate":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.BitcoinRewardParams.genesis_epoch":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.BitcoinRewardParams.utilization_bonus_factor":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.BitcoinRewardParams.full_coverage_bonus_factor":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.BitcoinRewardParams.partial_coverage_bonus_factor":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BitcoinRewardParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.BitcoinRewardParams 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_BitcoinRewardParams) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.BitcoinRewardParams", 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_BitcoinRewardParams) 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_BitcoinRewardParams) 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_BitcoinRewardParams) 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_BitcoinRewardParams) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*BitcoinRewardParams)
+ 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.UseBitcoinRewards {
+ n += 2
+ }
+ if x.InitialEpochReward != 0 {
+ n += 1 + runtime.Sov(uint64(x.InitialEpochReward))
+ }
+ if x.DecayRate != nil {
+ l = options.Size(x.DecayRate)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.GenesisEpoch != 0 {
+ n += 1 + runtime.Sov(uint64(x.GenesisEpoch))
+ }
+ if x.UtilizationBonusFactor != nil {
+ l = options.Size(x.UtilizationBonusFactor)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.FullCoverageBonusFactor != nil {
+ l = options.Size(x.FullCoverageBonusFactor)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.PartialCoverageBonusFactor != nil {
+ l = options.Size(x.PartialCoverageBonusFactor)
+ 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().(*BitcoinRewardParams)
+ 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.PartialCoverageBonusFactor != nil {
+ encoded, err := options.Marshal(x.PartialCoverageBonusFactor)
+ 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 x.FullCoverageBonusFactor != nil {
+ encoded, err := options.Marshal(x.FullCoverageBonusFactor)
+ 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 x.UtilizationBonusFactor != nil {
+ encoded, err := options.Marshal(x.UtilizationBonusFactor)
+ 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.GenesisEpoch != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.GenesisEpoch))
+ i--
+ dAtA[i] = 0x20
+ }
+ if x.DecayRate != nil {
+ encoded, err := options.Marshal(x.DecayRate)
+ 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.InitialEpochReward != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.InitialEpochReward))
+ i--
+ dAtA[i] = 0x10
+ }
+ if x.UseBitcoinRewards {
+ i--
+ if x.UseBitcoinRewards {
+ 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().(*BitcoinRewardParams)
+ 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: BitcoinRewardParams: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: BitcoinRewardParams: 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 UseBitcoinRewards", 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.UseBitcoinRewards = 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 InitialEpochReward", wireType)
+ }
+ x.InitialEpochReward = 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.InitialEpochReward |= 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 DecayRate", 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.DecayRate == nil {
+ x.DecayRate = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.DecayRate); 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 GenesisEpoch", wireType)
+ }
+ x.GenesisEpoch = 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.GenesisEpoch |= 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 UtilizationBonusFactor", 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.UtilizationBonusFactor == nil {
+ x.UtilizationBonusFactor = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.UtilizationBonusFactor); err != nil {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+ }
+ iNdEx = postIndex
+ case 6:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field FullCoverageBonusFactor", 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.FullCoverageBonusFactor == nil {
+ x.FullCoverageBonusFactor = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.FullCoverageBonusFactor); 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 PartialCoverageBonusFactor", 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.PartialCoverageBonusFactor == nil {
+ x.PartialCoverageBonusFactor = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.PartialCoverageBonusFactor); 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_DynamicPricingParams protoreflect.MessageDescriptor
+ fd_DynamicPricingParams_stability_zone_lower_bound protoreflect.FieldDescriptor
+ fd_DynamicPricingParams_stability_zone_upper_bound protoreflect.FieldDescriptor
+ fd_DynamicPricingParams_price_elasticity protoreflect.FieldDescriptor
+ fd_DynamicPricingParams_utilization_window_duration protoreflect.FieldDescriptor
+ fd_DynamicPricingParams_min_per_token_price protoreflect.FieldDescriptor
+ fd_DynamicPricingParams_base_per_token_price protoreflect.FieldDescriptor
+ fd_DynamicPricingParams_grace_period_end_epoch protoreflect.FieldDescriptor
+ fd_DynamicPricingParams_grace_period_per_token_price protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_params_proto_init()
+ md_DynamicPricingParams = File_inference_inference_params_proto.Messages().ByName("DynamicPricingParams")
+ fd_DynamicPricingParams_stability_zone_lower_bound = md_DynamicPricingParams.Fields().ByName("stability_zone_lower_bound")
+ fd_DynamicPricingParams_stability_zone_upper_bound = md_DynamicPricingParams.Fields().ByName("stability_zone_upper_bound")
+ fd_DynamicPricingParams_price_elasticity = md_DynamicPricingParams.Fields().ByName("price_elasticity")
+ fd_DynamicPricingParams_utilization_window_duration = md_DynamicPricingParams.Fields().ByName("utilization_window_duration")
+ fd_DynamicPricingParams_min_per_token_price = md_DynamicPricingParams.Fields().ByName("min_per_token_price")
+ fd_DynamicPricingParams_base_per_token_price = md_DynamicPricingParams.Fields().ByName("base_per_token_price")
+ fd_DynamicPricingParams_grace_period_end_epoch = md_DynamicPricingParams.Fields().ByName("grace_period_end_epoch")
+ fd_DynamicPricingParams_grace_period_per_token_price = md_DynamicPricingParams.Fields().ByName("grace_period_per_token_price")
+}
+
+var _ protoreflect.Message = (*fastReflection_DynamicPricingParams)(nil)
+
+type fastReflection_DynamicPricingParams DynamicPricingParams
+
+func (x *DynamicPricingParams) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_DynamicPricingParams)(x)
+}
+
+func (x *DynamicPricingParams) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_params_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_DynamicPricingParams_messageType fastReflection_DynamicPricingParams_messageType
+var _ protoreflect.MessageType = fastReflection_DynamicPricingParams_messageType{}
+
+type fastReflection_DynamicPricingParams_messageType struct{}
+
+func (x fastReflection_DynamicPricingParams_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_DynamicPricingParams)(nil)
+}
+func (x fastReflection_DynamicPricingParams_messageType) New() protoreflect.Message {
+ return new(fastReflection_DynamicPricingParams)
+}
+func (x fastReflection_DynamicPricingParams_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_DynamicPricingParams
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_DynamicPricingParams) Descriptor() protoreflect.MessageDescriptor {
+ return md_DynamicPricingParams
+}
+
+// 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_DynamicPricingParams) Type() protoreflect.MessageType {
+ return _fastReflection_DynamicPricingParams_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_DynamicPricingParams) New() protoreflect.Message {
+ return new(fastReflection_DynamicPricingParams)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_DynamicPricingParams) Interface() protoreflect.ProtoMessage {
+ return (*DynamicPricingParams)(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_DynamicPricingParams) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.StabilityZoneLowerBound != nil {
+ value := protoreflect.ValueOfMessage(x.StabilityZoneLowerBound.ProtoReflect())
+ if !f(fd_DynamicPricingParams_stability_zone_lower_bound, value) {
+ return
+ }
+ }
+ if x.StabilityZoneUpperBound != nil {
+ value := protoreflect.ValueOfMessage(x.StabilityZoneUpperBound.ProtoReflect())
+ if !f(fd_DynamicPricingParams_stability_zone_upper_bound, value) {
+ return
+ }
+ }
+ if x.PriceElasticity != nil {
+ value := protoreflect.ValueOfMessage(x.PriceElasticity.ProtoReflect())
+ if !f(fd_DynamicPricingParams_price_elasticity, value) {
+ return
+ }
+ }
+ if x.UtilizationWindowDuration != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.UtilizationWindowDuration)
+ if !f(fd_DynamicPricingParams_utilization_window_duration, value) {
+ return
+ }
+ }
+ if x.MinPerTokenPrice != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.MinPerTokenPrice)
+ if !f(fd_DynamicPricingParams_min_per_token_price, value) {
+ return
+ }
+ }
+ if x.BasePerTokenPrice != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.BasePerTokenPrice)
+ if !f(fd_DynamicPricingParams_base_per_token_price, value) {
+ return
+ }
+ }
+ if x.GracePeriodEndEpoch != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.GracePeriodEndEpoch)
+ if !f(fd_DynamicPricingParams_grace_period_end_epoch, value) {
+ return
+ }
+ }
+ if x.GracePeriodPerTokenPrice != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.GracePeriodPerTokenPrice)
+ if !f(fd_DynamicPricingParams_grace_period_per_token_price, 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_DynamicPricingParams) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.DynamicPricingParams.stability_zone_lower_bound":
+ return x.StabilityZoneLowerBound != nil
+ case "inference.inference.DynamicPricingParams.stability_zone_upper_bound":
+ return x.StabilityZoneUpperBound != nil
+ case "inference.inference.DynamicPricingParams.price_elasticity":
+ return x.PriceElasticity != nil
+ case "inference.inference.DynamicPricingParams.utilization_window_duration":
+ return x.UtilizationWindowDuration != uint64(0)
+ case "inference.inference.DynamicPricingParams.min_per_token_price":
+ return x.MinPerTokenPrice != uint64(0)
+ case "inference.inference.DynamicPricingParams.base_per_token_price":
+ return x.BasePerTokenPrice != uint64(0)
+ case "inference.inference.DynamicPricingParams.grace_period_end_epoch":
+ return x.GracePeriodEndEpoch != uint64(0)
+ case "inference.inference.DynamicPricingParams.grace_period_per_token_price":
+ return x.GracePeriodPerTokenPrice != uint64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.DynamicPricingParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.DynamicPricingParams 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_DynamicPricingParams) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.DynamicPricingParams.stability_zone_lower_bound":
+ x.StabilityZoneLowerBound = nil
+ case "inference.inference.DynamicPricingParams.stability_zone_upper_bound":
+ x.StabilityZoneUpperBound = nil
+ case "inference.inference.DynamicPricingParams.price_elasticity":
+ x.PriceElasticity = nil
+ case "inference.inference.DynamicPricingParams.utilization_window_duration":
+ x.UtilizationWindowDuration = uint64(0)
+ case "inference.inference.DynamicPricingParams.min_per_token_price":
+ x.MinPerTokenPrice = uint64(0)
+ case "inference.inference.DynamicPricingParams.base_per_token_price":
+ x.BasePerTokenPrice = uint64(0)
+ case "inference.inference.DynamicPricingParams.grace_period_end_epoch":
+ x.GracePeriodEndEpoch = uint64(0)
+ case "inference.inference.DynamicPricingParams.grace_period_per_token_price":
+ x.GracePeriodPerTokenPrice = uint64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.DynamicPricingParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.DynamicPricingParams 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_DynamicPricingParams) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.DynamicPricingParams.stability_zone_lower_bound":
+ value := x.StabilityZoneLowerBound
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.DynamicPricingParams.stability_zone_upper_bound":
+ value := x.StabilityZoneUpperBound
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.DynamicPricingParams.price_elasticity":
+ value := x.PriceElasticity
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.DynamicPricingParams.utilization_window_duration":
+ value := x.UtilizationWindowDuration
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.DynamicPricingParams.min_per_token_price":
+ value := x.MinPerTokenPrice
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.DynamicPricingParams.base_per_token_price":
+ value := x.BasePerTokenPrice
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.DynamicPricingParams.grace_period_end_epoch":
+ value := x.GracePeriodEndEpoch
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.DynamicPricingParams.grace_period_per_token_price":
+ value := x.GracePeriodPerTokenPrice
+ return protoreflect.ValueOfUint64(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.DynamicPricingParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.DynamicPricingParams 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_DynamicPricingParams) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.DynamicPricingParams.stability_zone_lower_bound":
+ x.StabilityZoneLowerBound = value.Message().Interface().(*Decimal)
+ case "inference.inference.DynamicPricingParams.stability_zone_upper_bound":
+ x.StabilityZoneUpperBound = value.Message().Interface().(*Decimal)
+ case "inference.inference.DynamicPricingParams.price_elasticity":
+ x.PriceElasticity = value.Message().Interface().(*Decimal)
+ case "inference.inference.DynamicPricingParams.utilization_window_duration":
+ x.UtilizationWindowDuration = value.Uint()
+ case "inference.inference.DynamicPricingParams.min_per_token_price":
+ x.MinPerTokenPrice = value.Uint()
+ case "inference.inference.DynamicPricingParams.base_per_token_price":
+ x.BasePerTokenPrice = value.Uint()
+ case "inference.inference.DynamicPricingParams.grace_period_end_epoch":
+ x.GracePeriodEndEpoch = value.Uint()
+ case "inference.inference.DynamicPricingParams.grace_period_per_token_price":
+ x.GracePeriodPerTokenPrice = value.Uint()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.DynamicPricingParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.DynamicPricingParams 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_DynamicPricingParams) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.DynamicPricingParams.stability_zone_lower_bound":
+ if x.StabilityZoneLowerBound == nil {
+ x.StabilityZoneLowerBound = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.StabilityZoneLowerBound.ProtoReflect())
+ case "inference.inference.DynamicPricingParams.stability_zone_upper_bound":
+ if x.StabilityZoneUpperBound == nil {
+ x.StabilityZoneUpperBound = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.StabilityZoneUpperBound.ProtoReflect())
+ case "inference.inference.DynamicPricingParams.price_elasticity":
+ if x.PriceElasticity == nil {
+ x.PriceElasticity = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.PriceElasticity.ProtoReflect())
+ case "inference.inference.DynamicPricingParams.utilization_window_duration":
+ panic(fmt.Errorf("field utilization_window_duration of message inference.inference.DynamicPricingParams is not mutable"))
+ case "inference.inference.DynamicPricingParams.min_per_token_price":
+ panic(fmt.Errorf("field min_per_token_price of message inference.inference.DynamicPricingParams is not mutable"))
+ case "inference.inference.DynamicPricingParams.base_per_token_price":
+ panic(fmt.Errorf("field base_per_token_price of message inference.inference.DynamicPricingParams is not mutable"))
+ case "inference.inference.DynamicPricingParams.grace_period_end_epoch":
+ panic(fmt.Errorf("field grace_period_end_epoch of message inference.inference.DynamicPricingParams is not mutable"))
+ case "inference.inference.DynamicPricingParams.grace_period_per_token_price":
+ panic(fmt.Errorf("field grace_period_per_token_price of message inference.inference.DynamicPricingParams is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.DynamicPricingParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.DynamicPricingParams 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_DynamicPricingParams) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.DynamicPricingParams.stability_zone_lower_bound":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.DynamicPricingParams.stability_zone_upper_bound":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.DynamicPricingParams.price_elasticity":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.DynamicPricingParams.utilization_window_duration":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.DynamicPricingParams.min_per_token_price":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.DynamicPricingParams.base_per_token_price":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.DynamicPricingParams.grace_period_end_epoch":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.DynamicPricingParams.grace_period_per_token_price":
+ return protoreflect.ValueOfUint64(uint64(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.DynamicPricingParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.DynamicPricingParams 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_DynamicPricingParams) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.DynamicPricingParams", 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_DynamicPricingParams) 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_DynamicPricingParams) 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_DynamicPricingParams) 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_DynamicPricingParams) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*DynamicPricingParams)
+ 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.StabilityZoneLowerBound != nil {
+ l = options.Size(x.StabilityZoneLowerBound)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.StabilityZoneUpperBound != nil {
+ l = options.Size(x.StabilityZoneUpperBound)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.PriceElasticity != nil {
+ l = options.Size(x.PriceElasticity)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.UtilizationWindowDuration != 0 {
+ n += 1 + runtime.Sov(uint64(x.UtilizationWindowDuration))
+ }
+ if x.MinPerTokenPrice != 0 {
+ n += 1 + runtime.Sov(uint64(x.MinPerTokenPrice))
+ }
+ if x.BasePerTokenPrice != 0 {
+ n += 1 + runtime.Sov(uint64(x.BasePerTokenPrice))
+ }
+ if x.GracePeriodEndEpoch != 0 {
+ n += 1 + runtime.Sov(uint64(x.GracePeriodEndEpoch))
+ }
+ if x.GracePeriodPerTokenPrice != 0 {
+ n += 1 + runtime.Sov(uint64(x.GracePeriodPerTokenPrice))
+ }
+ 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().(*DynamicPricingParams)
+ 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.GracePeriodPerTokenPrice != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.GracePeriodPerTokenPrice))
+ i--
+ dAtA[i] = 0x40
+ }
+ if x.GracePeriodEndEpoch != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.GracePeriodEndEpoch))
+ i--
+ dAtA[i] = 0x38
+ }
+ if x.BasePerTokenPrice != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.BasePerTokenPrice))
+ i--
+ dAtA[i] = 0x30
+ }
+ if x.MinPerTokenPrice != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.MinPerTokenPrice))
+ i--
+ dAtA[i] = 0x28
+ }
+ if x.UtilizationWindowDuration != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.UtilizationWindowDuration))
+ i--
+ dAtA[i] = 0x20
+ }
+ if x.PriceElasticity != nil {
+ encoded, err := options.Marshal(x.PriceElasticity)
+ 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.StabilityZoneUpperBound != nil {
+ encoded, err := options.Marshal(x.StabilityZoneUpperBound)
+ 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.StabilityZoneLowerBound != nil {
+ encoded, err := options.Marshal(x.StabilityZoneLowerBound)
+ 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().(*DynamicPricingParams)
+ 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: DynamicPricingParams: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: DynamicPricingParams: 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 StabilityZoneLowerBound", 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.StabilityZoneLowerBound == nil {
+ x.StabilityZoneLowerBound = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.StabilityZoneLowerBound); 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 StabilityZoneUpperBound", 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.StabilityZoneUpperBound == nil {
+ x.StabilityZoneUpperBound = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.StabilityZoneUpperBound); 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 PriceElasticity", 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.PriceElasticity == nil {
+ x.PriceElasticity = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.PriceElasticity); 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 UtilizationWindowDuration", wireType)
+ }
+ x.UtilizationWindowDuration = 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.UtilizationWindowDuration |= 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 MinPerTokenPrice", wireType)
+ }
+ x.MinPerTokenPrice = 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.MinPerTokenPrice |= 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 BasePerTokenPrice", wireType)
+ }
+ x.BasePerTokenPrice = 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.BasePerTokenPrice |= 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 GracePeriodEndEpoch", wireType)
+ }
+ x.GracePeriodEndEpoch = 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.GracePeriodEndEpoch |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 8:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field GracePeriodPerTokenPrice", wireType)
+ }
+ x.GracePeriodPerTokenPrice = 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.GracePeriodPerTokenPrice |= 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_BandwidthLimitsParams protoreflect.MessageDescriptor
+ fd_BandwidthLimitsParams_estimated_limits_per_block_kb protoreflect.FieldDescriptor
+ fd_BandwidthLimitsParams_kb_per_input_token protoreflect.FieldDescriptor
+ fd_BandwidthLimitsParams_kb_per_output_token protoreflect.FieldDescriptor
+ fd_BandwidthLimitsParams_invalidations_limit protoreflect.FieldDescriptor
+ fd_BandwidthLimitsParams_invalidations_sample_period protoreflect.FieldDescriptor
+ fd_BandwidthLimitsParams_invalidations_limit_curve protoreflect.FieldDescriptor
+ fd_BandwidthLimitsParams_minimum_concurrent_invalidations protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_params_proto_init()
+ md_BandwidthLimitsParams = File_inference_inference_params_proto.Messages().ByName("BandwidthLimitsParams")
+ fd_BandwidthLimitsParams_estimated_limits_per_block_kb = md_BandwidthLimitsParams.Fields().ByName("estimated_limits_per_block_kb")
+ fd_BandwidthLimitsParams_kb_per_input_token = md_BandwidthLimitsParams.Fields().ByName("kb_per_input_token")
+ fd_BandwidthLimitsParams_kb_per_output_token = md_BandwidthLimitsParams.Fields().ByName("kb_per_output_token")
+ fd_BandwidthLimitsParams_invalidations_limit = md_BandwidthLimitsParams.Fields().ByName("invalidations_limit")
+ fd_BandwidthLimitsParams_invalidations_sample_period = md_BandwidthLimitsParams.Fields().ByName("invalidations_sample_period")
+ fd_BandwidthLimitsParams_invalidations_limit_curve = md_BandwidthLimitsParams.Fields().ByName("invalidations_limit_curve")
+ fd_BandwidthLimitsParams_minimum_concurrent_invalidations = md_BandwidthLimitsParams.Fields().ByName("minimum_concurrent_invalidations")
+}
+
+var _ protoreflect.Message = (*fastReflection_BandwidthLimitsParams)(nil)
+
+type fastReflection_BandwidthLimitsParams BandwidthLimitsParams
+
+func (x *BandwidthLimitsParams) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_BandwidthLimitsParams)(x)
+}
+
+func (x *BandwidthLimitsParams) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_params_proto_msgTypes[10]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_BandwidthLimitsParams_messageType fastReflection_BandwidthLimitsParams_messageType
+var _ protoreflect.MessageType = fastReflection_BandwidthLimitsParams_messageType{}
+
+type fastReflection_BandwidthLimitsParams_messageType struct{}
+
+func (x fastReflection_BandwidthLimitsParams_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_BandwidthLimitsParams)(nil)
+}
+func (x fastReflection_BandwidthLimitsParams_messageType) New() protoreflect.Message {
+ return new(fastReflection_BandwidthLimitsParams)
+}
+func (x fastReflection_BandwidthLimitsParams_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_BandwidthLimitsParams
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_BandwidthLimitsParams) Descriptor() protoreflect.MessageDescriptor {
+ return md_BandwidthLimitsParams
+}
+
+// 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_BandwidthLimitsParams) Type() protoreflect.MessageType {
+ return _fastReflection_BandwidthLimitsParams_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_BandwidthLimitsParams) New() protoreflect.Message {
+ return new(fastReflection_BandwidthLimitsParams)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_BandwidthLimitsParams) Interface() protoreflect.ProtoMessage {
+ return (*BandwidthLimitsParams)(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_BandwidthLimitsParams) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.EstimatedLimitsPerBlockKb != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.EstimatedLimitsPerBlockKb)
+ if !f(fd_BandwidthLimitsParams_estimated_limits_per_block_kb, value) {
+ return
+ }
+ }
+ if x.KbPerInputToken != nil {
+ value := protoreflect.ValueOfMessage(x.KbPerInputToken.ProtoReflect())
+ if !f(fd_BandwidthLimitsParams_kb_per_input_token, value) {
+ return
+ }
+ }
+ if x.KbPerOutputToken != nil {
+ value := protoreflect.ValueOfMessage(x.KbPerOutputToken.ProtoReflect())
+ if !f(fd_BandwidthLimitsParams_kb_per_output_token, value) {
+ return
+ }
+ }
+ if x.InvalidationsLimit != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.InvalidationsLimit)
+ if !f(fd_BandwidthLimitsParams_invalidations_limit, value) {
+ return
+ }
+ }
+ if x.InvalidationsSamplePeriod != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.InvalidationsSamplePeriod)
+ if !f(fd_BandwidthLimitsParams_invalidations_sample_period, value) {
+ return
+ }
+ }
+ if x.InvalidationsLimitCurve != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.InvalidationsLimitCurve)
+ if !f(fd_BandwidthLimitsParams_invalidations_limit_curve, value) {
+ return
+ }
+ }
+ if x.MinimumConcurrentInvalidations != uint32(0) {
+ value := protoreflect.ValueOfUint32(x.MinimumConcurrentInvalidations)
+ if !f(fd_BandwidthLimitsParams_minimum_concurrent_invalidations, 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_BandwidthLimitsParams) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.BandwidthLimitsParams.estimated_limits_per_block_kb":
+ return x.EstimatedLimitsPerBlockKb != uint64(0)
+ case "inference.inference.BandwidthLimitsParams.kb_per_input_token":
+ return x.KbPerInputToken != nil
+ case "inference.inference.BandwidthLimitsParams.kb_per_output_token":
+ return x.KbPerOutputToken != nil
+ case "inference.inference.BandwidthLimitsParams.invalidations_limit":
+ return x.InvalidationsLimit != uint64(0)
+ case "inference.inference.BandwidthLimitsParams.invalidations_sample_period":
+ return x.InvalidationsSamplePeriod != uint64(0)
+ case "inference.inference.BandwidthLimitsParams.invalidations_limit_curve":
+ return x.InvalidationsLimitCurve != uint64(0)
+ case "inference.inference.BandwidthLimitsParams.minimum_concurrent_invalidations":
+ return x.MinimumConcurrentInvalidations != uint32(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BandwidthLimitsParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.BandwidthLimitsParams 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_BandwidthLimitsParams) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.BandwidthLimitsParams.estimated_limits_per_block_kb":
+ x.EstimatedLimitsPerBlockKb = uint64(0)
+ case "inference.inference.BandwidthLimitsParams.kb_per_input_token":
+ x.KbPerInputToken = nil
+ case "inference.inference.BandwidthLimitsParams.kb_per_output_token":
+ x.KbPerOutputToken = nil
+ case "inference.inference.BandwidthLimitsParams.invalidations_limit":
+ x.InvalidationsLimit = uint64(0)
+ case "inference.inference.BandwidthLimitsParams.invalidations_sample_period":
+ x.InvalidationsSamplePeriod = uint64(0)
+ case "inference.inference.BandwidthLimitsParams.invalidations_limit_curve":
+ x.InvalidationsLimitCurve = uint64(0)
+ case "inference.inference.BandwidthLimitsParams.minimum_concurrent_invalidations":
+ x.MinimumConcurrentInvalidations = uint32(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BandwidthLimitsParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.BandwidthLimitsParams 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_BandwidthLimitsParams) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.BandwidthLimitsParams.estimated_limits_per_block_kb":
+ value := x.EstimatedLimitsPerBlockKb
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.BandwidthLimitsParams.kb_per_input_token":
+ value := x.KbPerInputToken
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.BandwidthLimitsParams.kb_per_output_token":
+ value := x.KbPerOutputToken
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.BandwidthLimitsParams.invalidations_limit":
+ value := x.InvalidationsLimit
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.BandwidthLimitsParams.invalidations_sample_period":
+ value := x.InvalidationsSamplePeriod
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.BandwidthLimitsParams.invalidations_limit_curve":
+ value := x.InvalidationsLimitCurve
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.BandwidthLimitsParams.minimum_concurrent_invalidations":
+ value := x.MinimumConcurrentInvalidations
+ return protoreflect.ValueOfUint32(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BandwidthLimitsParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.BandwidthLimitsParams 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_BandwidthLimitsParams) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.BandwidthLimitsParams.estimated_limits_per_block_kb":
+ x.EstimatedLimitsPerBlockKb = value.Uint()
+ case "inference.inference.BandwidthLimitsParams.kb_per_input_token":
+ x.KbPerInputToken = value.Message().Interface().(*Decimal)
+ case "inference.inference.BandwidthLimitsParams.kb_per_output_token":
+ x.KbPerOutputToken = value.Message().Interface().(*Decimal)
+ case "inference.inference.BandwidthLimitsParams.invalidations_limit":
+ x.InvalidationsLimit = value.Uint()
+ case "inference.inference.BandwidthLimitsParams.invalidations_sample_period":
+ x.InvalidationsSamplePeriod = value.Uint()
+ case "inference.inference.BandwidthLimitsParams.invalidations_limit_curve":
+ x.InvalidationsLimitCurve = value.Uint()
+ case "inference.inference.BandwidthLimitsParams.minimum_concurrent_invalidations":
+ x.MinimumConcurrentInvalidations = uint32(value.Uint())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BandwidthLimitsParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.BandwidthLimitsParams 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_BandwidthLimitsParams) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.BandwidthLimitsParams.kb_per_input_token":
+ if x.KbPerInputToken == nil {
+ x.KbPerInputToken = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.KbPerInputToken.ProtoReflect())
+ case "inference.inference.BandwidthLimitsParams.kb_per_output_token":
+ if x.KbPerOutputToken == nil {
+ x.KbPerOutputToken = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.KbPerOutputToken.ProtoReflect())
+ case "inference.inference.BandwidthLimitsParams.estimated_limits_per_block_kb":
+ panic(fmt.Errorf("field estimated_limits_per_block_kb of message inference.inference.BandwidthLimitsParams is not mutable"))
+ case "inference.inference.BandwidthLimitsParams.invalidations_limit":
+ panic(fmt.Errorf("field invalidations_limit of message inference.inference.BandwidthLimitsParams is not mutable"))
+ case "inference.inference.BandwidthLimitsParams.invalidations_sample_period":
+ panic(fmt.Errorf("field invalidations_sample_period of message inference.inference.BandwidthLimitsParams is not mutable"))
+ case "inference.inference.BandwidthLimitsParams.invalidations_limit_curve":
+ panic(fmt.Errorf("field invalidations_limit_curve of message inference.inference.BandwidthLimitsParams is not mutable"))
+ case "inference.inference.BandwidthLimitsParams.minimum_concurrent_invalidations":
+ panic(fmt.Errorf("field minimum_concurrent_invalidations of message inference.inference.BandwidthLimitsParams is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BandwidthLimitsParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.BandwidthLimitsParams 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_BandwidthLimitsParams) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.BandwidthLimitsParams.estimated_limits_per_block_kb":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.BandwidthLimitsParams.kb_per_input_token":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.BandwidthLimitsParams.kb_per_output_token":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.BandwidthLimitsParams.invalidations_limit":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.BandwidthLimitsParams.invalidations_sample_period":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.BandwidthLimitsParams.invalidations_limit_curve":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.BandwidthLimitsParams.minimum_concurrent_invalidations":
+ return protoreflect.ValueOfUint32(uint32(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.BandwidthLimitsParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.BandwidthLimitsParams 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_BandwidthLimitsParams) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.BandwidthLimitsParams", 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_BandwidthLimitsParams) 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_BandwidthLimitsParams) 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_BandwidthLimitsParams) 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_BandwidthLimitsParams) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*BandwidthLimitsParams)
+ 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.EstimatedLimitsPerBlockKb != 0 {
+ n += 1 + runtime.Sov(uint64(x.EstimatedLimitsPerBlockKb))
+ }
+ if x.KbPerInputToken != nil {
+ l = options.Size(x.KbPerInputToken)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.KbPerOutputToken != nil {
+ l = options.Size(x.KbPerOutputToken)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.InvalidationsLimit != 0 {
+ n += 1 + runtime.Sov(uint64(x.InvalidationsLimit))
+ }
+ if x.InvalidationsSamplePeriod != 0 {
+ n += 1 + runtime.Sov(uint64(x.InvalidationsSamplePeriod))
+ }
+ if x.InvalidationsLimitCurve != 0 {
+ n += 1 + runtime.Sov(uint64(x.InvalidationsLimitCurve))
+ }
+ if x.MinimumConcurrentInvalidations != 0 {
+ n += 1 + runtime.Sov(uint64(x.MinimumConcurrentInvalidations))
+ }
+ 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().(*BandwidthLimitsParams)
+ 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.MinimumConcurrentInvalidations != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.MinimumConcurrentInvalidations))
+ i--
+ dAtA[i] = 0x38
+ }
+ if x.InvalidationsLimitCurve != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.InvalidationsLimitCurve))
+ i--
+ dAtA[i] = 0x30
+ }
+ if x.InvalidationsSamplePeriod != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.InvalidationsSamplePeriod))
+ i--
+ dAtA[i] = 0x28
+ }
+ if x.InvalidationsLimit != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.InvalidationsLimit))
+ i--
+ dAtA[i] = 0x20
+ }
+ if x.KbPerOutputToken != nil {
+ encoded, err := options.Marshal(x.KbPerOutputToken)
+ 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.KbPerInputToken != nil {
+ encoded, err := options.Marshal(x.KbPerInputToken)
+ 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.EstimatedLimitsPerBlockKb != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.EstimatedLimitsPerBlockKb))
+ 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().(*BandwidthLimitsParams)
+ 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: BandwidthLimitsParams: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: BandwidthLimitsParams: 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 EstimatedLimitsPerBlockKb", wireType)
+ }
+ x.EstimatedLimitsPerBlockKb = 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.EstimatedLimitsPerBlockKb |= 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 KbPerInputToken", 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.KbPerInputToken == nil {
+ x.KbPerInputToken = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.KbPerInputToken); 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 KbPerOutputToken", 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.KbPerOutputToken == nil {
+ x.KbPerOutputToken = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.KbPerOutputToken); 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 InvalidationsLimit", wireType)
+ }
+ x.InvalidationsLimit = 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.InvalidationsLimit |= 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 InvalidationsSamplePeriod", wireType)
+ }
+ x.InvalidationsSamplePeriod = 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.InvalidationsSamplePeriod |= 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 InvalidationsLimitCurve", wireType)
+ }
+ x.InvalidationsLimitCurve = 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.InvalidationsLimitCurve |= 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 MinimumConcurrentInvalidations", wireType)
+ }
+ x.MinimumConcurrentInvalidations = 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.MinimumConcurrentInvalidations |= 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
+ }
+ }
+
+ 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_ConfirmationPoCParams protoreflect.MessageDescriptor
+ fd_ConfirmationPoCParams_expected_confirmations_per_epoch protoreflect.FieldDescriptor
+ fd_ConfirmationPoCParams_alpha_threshold protoreflect.FieldDescriptor
+ fd_ConfirmationPoCParams_slash_fraction protoreflect.FieldDescriptor
+ fd_ConfirmationPoCParams_upgrade_protection_window protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_params_proto_init()
+ md_ConfirmationPoCParams = File_inference_inference_params_proto.Messages().ByName("ConfirmationPoCParams")
+ fd_ConfirmationPoCParams_expected_confirmations_per_epoch = md_ConfirmationPoCParams.Fields().ByName("expected_confirmations_per_epoch")
+ fd_ConfirmationPoCParams_alpha_threshold = md_ConfirmationPoCParams.Fields().ByName("alpha_threshold")
+ fd_ConfirmationPoCParams_slash_fraction = md_ConfirmationPoCParams.Fields().ByName("slash_fraction")
+ fd_ConfirmationPoCParams_upgrade_protection_window = md_ConfirmationPoCParams.Fields().ByName("upgrade_protection_window")
+}
+
+var _ protoreflect.Message = (*fastReflection_ConfirmationPoCParams)(nil)
+
+type fastReflection_ConfirmationPoCParams ConfirmationPoCParams
+
+func (x *ConfirmationPoCParams) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_ConfirmationPoCParams)(x)
+}
+
+func (x *ConfirmationPoCParams) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_params_proto_msgTypes[11]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_ConfirmationPoCParams_messageType fastReflection_ConfirmationPoCParams_messageType
+var _ protoreflect.MessageType = fastReflection_ConfirmationPoCParams_messageType{}
+
+type fastReflection_ConfirmationPoCParams_messageType struct{}
+
+func (x fastReflection_ConfirmationPoCParams_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_ConfirmationPoCParams)(nil)
+}
+func (x fastReflection_ConfirmationPoCParams_messageType) New() protoreflect.Message {
+ return new(fastReflection_ConfirmationPoCParams)
+}
+func (x fastReflection_ConfirmationPoCParams_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_ConfirmationPoCParams
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_ConfirmationPoCParams) Descriptor() protoreflect.MessageDescriptor {
+ return md_ConfirmationPoCParams
+}
+
+// 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_ConfirmationPoCParams) Type() protoreflect.MessageType {
+ return _fastReflection_ConfirmationPoCParams_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_ConfirmationPoCParams) New() protoreflect.Message {
+ return new(fastReflection_ConfirmationPoCParams)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_ConfirmationPoCParams) Interface() protoreflect.ProtoMessage {
+ return (*ConfirmationPoCParams)(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_ConfirmationPoCParams) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.ExpectedConfirmationsPerEpoch != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.ExpectedConfirmationsPerEpoch)
+ if !f(fd_ConfirmationPoCParams_expected_confirmations_per_epoch, value) {
+ return
+ }
+ }
+ if x.AlphaThreshold != nil {
+ value := protoreflect.ValueOfMessage(x.AlphaThreshold.ProtoReflect())
+ if !f(fd_ConfirmationPoCParams_alpha_threshold, value) {
+ return
+ }
+ }
+ if x.SlashFraction != nil {
+ value := protoreflect.ValueOfMessage(x.SlashFraction.ProtoReflect())
+ if !f(fd_ConfirmationPoCParams_slash_fraction, value) {
+ return
+ }
+ }
+ if x.UpgradeProtectionWindow != int64(0) {
+ value := protoreflect.ValueOfInt64(x.UpgradeProtectionWindow)
+ if !f(fd_ConfirmationPoCParams_upgrade_protection_window, 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_ConfirmationPoCParams) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.ConfirmationPoCParams.expected_confirmations_per_epoch":
+ return x.ExpectedConfirmationsPerEpoch != uint64(0)
+ case "inference.inference.ConfirmationPoCParams.alpha_threshold":
+ return x.AlphaThreshold != nil
+ case "inference.inference.ConfirmationPoCParams.slash_fraction":
+ return x.SlashFraction != nil
+ case "inference.inference.ConfirmationPoCParams.upgrade_protection_window":
+ return x.UpgradeProtectionWindow != int64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ConfirmationPoCParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.ConfirmationPoCParams 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_ConfirmationPoCParams) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.ConfirmationPoCParams.expected_confirmations_per_epoch":
+ x.ExpectedConfirmationsPerEpoch = uint64(0)
+ case "inference.inference.ConfirmationPoCParams.alpha_threshold":
+ x.AlphaThreshold = nil
+ case "inference.inference.ConfirmationPoCParams.slash_fraction":
+ x.SlashFraction = nil
+ case "inference.inference.ConfirmationPoCParams.upgrade_protection_window":
+ x.UpgradeProtectionWindow = int64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ConfirmationPoCParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.ConfirmationPoCParams 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_ConfirmationPoCParams) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.ConfirmationPoCParams.expected_confirmations_per_epoch":
+ value := x.ExpectedConfirmationsPerEpoch
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.ConfirmationPoCParams.alpha_threshold":
+ value := x.AlphaThreshold
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.ConfirmationPoCParams.slash_fraction":
+ value := x.SlashFraction
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.ConfirmationPoCParams.upgrade_protection_window":
+ value := x.UpgradeProtectionWindow
+ return protoreflect.ValueOfInt64(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ConfirmationPoCParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.ConfirmationPoCParams 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_ConfirmationPoCParams) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.ConfirmationPoCParams.expected_confirmations_per_epoch":
+ x.ExpectedConfirmationsPerEpoch = value.Uint()
+ case "inference.inference.ConfirmationPoCParams.alpha_threshold":
+ x.AlphaThreshold = value.Message().Interface().(*Decimal)
+ case "inference.inference.ConfirmationPoCParams.slash_fraction":
+ x.SlashFraction = value.Message().Interface().(*Decimal)
+ case "inference.inference.ConfirmationPoCParams.upgrade_protection_window":
+ x.UpgradeProtectionWindow = value.Int()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ConfirmationPoCParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.ConfirmationPoCParams 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_ConfirmationPoCParams) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.ConfirmationPoCParams.alpha_threshold":
+ if x.AlphaThreshold == nil {
+ x.AlphaThreshold = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.AlphaThreshold.ProtoReflect())
+ case "inference.inference.ConfirmationPoCParams.slash_fraction":
+ if x.SlashFraction == nil {
+ x.SlashFraction = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.SlashFraction.ProtoReflect())
+ case "inference.inference.ConfirmationPoCParams.expected_confirmations_per_epoch":
+ panic(fmt.Errorf("field expected_confirmations_per_epoch of message inference.inference.ConfirmationPoCParams is not mutable"))
+ case "inference.inference.ConfirmationPoCParams.upgrade_protection_window":
+ panic(fmt.Errorf("field upgrade_protection_window of message inference.inference.ConfirmationPoCParams is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ConfirmationPoCParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.ConfirmationPoCParams 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_ConfirmationPoCParams) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.ConfirmationPoCParams.expected_confirmations_per_epoch":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.ConfirmationPoCParams.alpha_threshold":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.ConfirmationPoCParams.slash_fraction":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.ConfirmationPoCParams.upgrade_protection_window":
+ return protoreflect.ValueOfInt64(int64(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ConfirmationPoCParams"))
+ }
+ panic(fmt.Errorf("message inference.inference.ConfirmationPoCParams 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_ConfirmationPoCParams) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.ConfirmationPoCParams", 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_ConfirmationPoCParams) 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_ConfirmationPoCParams) 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_ConfirmationPoCParams) 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_ConfirmationPoCParams) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*ConfirmationPoCParams)
+ 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.ExpectedConfirmationsPerEpoch != 0 {
+ n += 1 + runtime.Sov(uint64(x.ExpectedConfirmationsPerEpoch))
+ }
+ if x.AlphaThreshold != nil {
+ l = options.Size(x.AlphaThreshold)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.SlashFraction != nil {
+ l = options.Size(x.SlashFraction)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.UpgradeProtectionWindow != 0 {
+ n += 1 + runtime.Sov(uint64(x.UpgradeProtectionWindow))
+ }
+ 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().(*ConfirmationPoCParams)
+ 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.UpgradeProtectionWindow != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.UpgradeProtectionWindow))
+ i--
+ dAtA[i] = 0x20
+ }
+ if x.SlashFraction != nil {
+ encoded, err := options.Marshal(x.SlashFraction)
+ 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.AlphaThreshold != nil {
+ encoded, err := options.Marshal(x.AlphaThreshold)
+ 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.ExpectedConfirmationsPerEpoch != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.ExpectedConfirmationsPerEpoch))
+ 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().(*ConfirmationPoCParams)
+ 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: ConfirmationPoCParams: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ConfirmationPoCParams: 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 ExpectedConfirmationsPerEpoch", wireType)
+ }
+ x.ExpectedConfirmationsPerEpoch = 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.ExpectedConfirmationsPerEpoch |= 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 AlphaThreshold", 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.AlphaThreshold == nil {
+ x.AlphaThreshold = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.AlphaThreshold); 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 SlashFraction", 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.SlashFraction == nil {
+ x.SlashFraction = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.SlashFraction); 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 UpgradeProtectionWindow", wireType)
+ }
+ x.UpgradeProtectionWindow = 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.UpgradeProtectionWindow |= 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,
+ }
+}
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// protoc-gen-go v1.27.0
+// protoc (unknown)
+// source: inference/inference/params.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)
+)
+
+// Params defines the parameters for the module.
+type Params struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ EpochParams *EpochParams `protobuf:"bytes,1,opt,name=epoch_params,json=epochParams,proto3" json:"epoch_params,omitempty"`
+ ValidationParams *ValidationParams `protobuf:"bytes,2,opt,name=validation_params,json=validationParams,proto3" json:"validation_params,omitempty"`
+ PocParams *PocParams `protobuf:"bytes,3,opt,name=poc_params,json=pocParams,proto3" json:"poc_params,omitempty"`
+ TokenomicsParams *TokenomicsParams `protobuf:"bytes,4,opt,name=tokenomics_params,json=tokenomicsParams,proto3" json:"tokenomics_params,omitempty"`
+ CollateralParams *CollateralParams `protobuf:"bytes,5,opt,name=collateral_params,json=collateralParams,proto3" json:"collateral_params,omitempty"`
+ BitcoinRewardParams *BitcoinRewardParams `protobuf:"bytes,6,opt,name=bitcoin_reward_params,json=bitcoinRewardParams,proto3" json:"bitcoin_reward_params,omitempty"`
+ DynamicPricingParams *DynamicPricingParams `protobuf:"bytes,7,opt,name=dynamic_pricing_params,json=dynamicPricingParams,proto3" json:"dynamic_pricing_params,omitempty"`
+ BandwidthLimitsParams *BandwidthLimitsParams `protobuf:"bytes,8,opt,name=bandwidth_limits_params,json=bandwidthLimitsParams,proto3" json:"bandwidth_limits_params,omitempty"`
+ ConfirmationPocParams *ConfirmationPoCParams `protobuf:"bytes,9,opt,name=confirmation_poc_params,json=confirmationPocParams,proto3" json:"confirmation_poc_params,omitempty"`
+}
+
+func (x *Params) Reset() {
+ *x = Params{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_params_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *Params) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Params) ProtoMessage() {}
+
+// Deprecated: Use Params.ProtoReflect.Descriptor instead.
+func (*Params) Descriptor() ([]byte, []int) {
+ return file_inference_inference_params_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Params) GetEpochParams() *EpochParams {
+ if x != nil {
+ return x.EpochParams
+ }
+ return nil
+}
+
+func (x *Params) GetValidationParams() *ValidationParams {
+ if x != nil {
+ return x.ValidationParams
+ }
+ return nil
+}
+
+func (x *Params) GetPocParams() *PocParams {
+ if x != nil {
+ return x.PocParams
+ }
+ return nil
+}
+
+func (x *Params) GetTokenomicsParams() *TokenomicsParams {
+ if x != nil {
+ return x.TokenomicsParams
+ }
+ return nil
+}
+
+func (x *Params) GetCollateralParams() *CollateralParams {
+ if x != nil {
+ return x.CollateralParams
+ }
+ return nil
+}
+
+func (x *Params) GetBitcoinRewardParams() *BitcoinRewardParams {
+ if x != nil {
+ return x.BitcoinRewardParams
+ }
+ return nil
+}
+
+func (x *Params) GetDynamicPricingParams() *DynamicPricingParams {
+ if x != nil {
+ return x.DynamicPricingParams
+ }
+ return nil
+}
+
+func (x *Params) GetBandwidthLimitsParams() *BandwidthLimitsParams {
+ if x != nil {
+ return x.BandwidthLimitsParams
+ }
+ return nil
+}
+
+func (x *Params) GetConfirmationPocParams() *ConfirmationPoCParams {
+ if x != nil {
+ return x.ConfirmationPocParams
+ }
+ return nil
+}
+
+type GenesisOnlyParams struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ 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"`
+ TopRewardAmount int64 `protobuf:"varint,3,opt,name=top_reward_amount,json=topRewardAmount,proto3" json:"top_reward_amount,omitempty"`
+ StandardRewardAmount int64 `protobuf:"varint,4,opt,name=standard_reward_amount,json=standardRewardAmount,proto3" json:"standard_reward_amount,omitempty"`
+ PreProgrammedSaleAmount int64 `protobuf:"varint,5,opt,name=pre_programmed_sale_amount,json=preProgrammedSaleAmount,proto3" json:"pre_programmed_sale_amount,omitempty"`
+ TopRewards int32 `protobuf:"varint,6,opt,name=top_rewards,json=topRewards,proto3" json:"top_rewards,omitempty"`
+ SupplyDenom string `protobuf:"bytes,7,opt,name=supply_denom,json=supplyDenom,proto3" json:"supply_denom,omitempty"`
+ TopRewardPeriod int64 `protobuf:"varint,8,opt,name=top_reward_period,json=topRewardPeriod,proto3" json:"top_reward_period,omitempty"`
+ TopRewardPayouts int64 `protobuf:"varint,9,opt,name=top_reward_payouts,json=topRewardPayouts,proto3" json:"top_reward_payouts,omitempty"`
+ TopRewardPayoutsPerMiner int64 `protobuf:"varint,10,opt,name=top_reward_payouts_per_miner,json=topRewardPayoutsPerMiner,proto3" json:"top_reward_payouts_per_miner,omitempty"`
+ TopRewardMaxDuration int64 `protobuf:"varint,11,opt,name=top_reward_max_duration,json=topRewardMaxDuration,proto3" json:"top_reward_max_duration,omitempty"`
+ MaxIndividualPowerPercentage *Decimal `protobuf:"bytes,12,opt,name=max_individual_power_percentage,json=maxIndividualPowerPercentage,proto3" json:"max_individual_power_percentage,omitempty"`
+ GenesisGuardianEnabled bool `protobuf:"varint,13,opt,name=genesis_guardian_enabled,json=genesisGuardianEnabled,proto3" json:"genesis_guardian_enabled,omitempty"`
+ GenesisGuardianNetworkMaturityThreshold int64 `protobuf:"varint,14,opt,name=genesis_guardian_network_maturity_threshold,json=genesisGuardianNetworkMaturityThreshold,proto3" json:"genesis_guardian_network_maturity_threshold,omitempty"`
+ GenesisGuardianMultiplier *Decimal `protobuf:"bytes,15,opt,name=genesis_guardian_multiplier,json=genesisGuardianMultiplier,proto3" json:"genesis_guardian_multiplier,omitempty"`
+ GenesisGuardianAddresses []string `protobuf:"bytes,16,rep,name=genesis_guardian_addresses,json=genesisGuardianAddresses,proto3" json:"genesis_guardian_addresses,omitempty"`
+}
+
+func (x *GenesisOnlyParams) Reset() {
+ *x = GenesisOnlyParams{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_params_proto_msgTypes[1]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *GenesisOnlyParams) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GenesisOnlyParams) ProtoMessage() {}
+
+// Deprecated: Use GenesisOnlyParams.ProtoReflect.Descriptor instead.
+func (*GenesisOnlyParams) Descriptor() ([]byte, []int) {
+ return file_inference_inference_params_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *GenesisOnlyParams) GetTotalSupply() int64 {
+ if x != nil {
+ return x.TotalSupply
+ }
+ return 0
+}
+
+func (x *GenesisOnlyParams) GetOriginatorSupply() int64 {
+ if x != nil {
+ return x.OriginatorSupply
+ }
+ return 0
+}
+
+func (x *GenesisOnlyParams) GetTopRewardAmount() int64 {
+ if x != nil {
+ return x.TopRewardAmount
+ }
+ return 0
+}
+
+func (x *GenesisOnlyParams) GetStandardRewardAmount() int64 {
+ if x != nil {
+ return x.StandardRewardAmount
+ }
+ return 0
+}
+
+func (x *GenesisOnlyParams) GetPreProgrammedSaleAmount() int64 {
+ if x != nil {
+ return x.PreProgrammedSaleAmount
+ }
+ return 0
+}
+
+func (x *GenesisOnlyParams) GetTopRewards() int32 {
+ if x != nil {
+ return x.TopRewards
+ }
+ return 0
+}
+
+func (x *GenesisOnlyParams) GetSupplyDenom() string {
+ if x != nil {
+ return x.SupplyDenom
+ }
+ return ""
+}
+
+func (x *GenesisOnlyParams) GetTopRewardPeriod() int64 {
+ if x != nil {
+ return x.TopRewardPeriod
+ }
+ return 0
+}
+
+func (x *GenesisOnlyParams) GetTopRewardPayouts() int64 {
+ if x != nil {
+ return x.TopRewardPayouts
+ }
+ return 0
+}
+
+func (x *GenesisOnlyParams) GetTopRewardPayoutsPerMiner() int64 {
+ if x != nil {
+ return x.TopRewardPayoutsPerMiner
+ }
+ return 0
+}
+
+func (x *GenesisOnlyParams) GetTopRewardMaxDuration() int64 {
+ if x != nil {
+ return x.TopRewardMaxDuration
+ }
+ return 0
+}
+
+func (x *GenesisOnlyParams) GetMaxIndividualPowerPercentage() *Decimal {
+ if x != nil {
+ return x.MaxIndividualPowerPercentage
+ }
+ return nil
+}
+
+func (x *GenesisOnlyParams) GetGenesisGuardianEnabled() bool {
+ if x != nil {
+ return x.GenesisGuardianEnabled
+ }
+ return false
+}
+
+func (x *GenesisOnlyParams) GetGenesisGuardianNetworkMaturityThreshold() int64 {
+ if x != nil {
+ return x.GenesisGuardianNetworkMaturityThreshold
+ }
+ return 0
+}
+
+func (x *GenesisOnlyParams) GetGenesisGuardianMultiplier() *Decimal {
+ if x != nil {
+ return x.GenesisGuardianMultiplier
+ }
+ return nil
+}
+
+func (x *GenesisOnlyParams) GetGenesisGuardianAddresses() []string {
+ if x != nil {
+ return x.GenesisGuardianAddresses
+ }
+ return nil
+}
+
+type TokenomicsParams struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ SubsidyReductionInterval *Decimal `protobuf:"bytes,1,opt,name=subsidy_reduction_interval,json=subsidyReductionInterval,proto3" json:"subsidy_reduction_interval,omitempty"`
+ SubsidyReductionAmount *Decimal `protobuf:"bytes,2,opt,name=subsidy_reduction_amount,json=subsidyReductionAmount,proto3" json:"subsidy_reduction_amount,omitempty"`
+ CurrentSubsidyPercentage *Decimal `protobuf:"bytes,3,opt,name=current_subsidy_percentage,json=currentSubsidyPercentage,proto3" json:"current_subsidy_percentage,omitempty"`
+ TopRewardAllowedFailure *Decimal `protobuf:"bytes,4,opt,name=top_reward_allowed_failure,json=topRewardAllowedFailure,proto3" json:"top_reward_allowed_failure,omitempty"`
+ TopMinerPocQualification int64 `protobuf:"varint,5,opt,name=top_miner_poc_qualification,json=topMinerPocQualification,proto3" json:"top_miner_poc_qualification,omitempty"`
+ WorkVestingPeriod uint64 `protobuf:"varint,6,opt,name=work_vesting_period,json=workVestingPeriod,proto3" json:"work_vesting_period,omitempty"`
+ RewardVestingPeriod uint64 `protobuf:"varint,7,opt,name=reward_vesting_period,json=rewardVestingPeriod,proto3" json:"reward_vesting_period,omitempty"`
+ TopMinerVestingPeriod uint64 `protobuf:"varint,8,opt,name=top_miner_vesting_period,json=topMinerVestingPeriod,proto3" json:"top_miner_vesting_period,omitempty"`
+}
+
+func (x *TokenomicsParams) Reset() {
+ *x = TokenomicsParams{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_params_proto_msgTypes[2]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *TokenomicsParams) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TokenomicsParams) ProtoMessage() {}
+
+// Deprecated: Use TokenomicsParams.ProtoReflect.Descriptor instead.
+func (*TokenomicsParams) Descriptor() ([]byte, []int) {
+ return file_inference_inference_params_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *TokenomicsParams) GetSubsidyReductionInterval() *Decimal {
+ if x != nil {
+ return x.SubsidyReductionInterval
+ }
+ return nil
+}
+
+func (x *TokenomicsParams) GetSubsidyReductionAmount() *Decimal {
+ if x != nil {
+ return x.SubsidyReductionAmount
+ }
+ return nil
+}
+
+func (x *TokenomicsParams) GetCurrentSubsidyPercentage() *Decimal {
+ if x != nil {
+ return x.CurrentSubsidyPercentage
+ }
+ return nil
+}
+
+func (x *TokenomicsParams) GetTopRewardAllowedFailure() *Decimal {
+ if x != nil {
+ return x.TopRewardAllowedFailure
+ }
+ return nil
+}
+
+func (x *TokenomicsParams) GetTopMinerPocQualification() int64 {
+ if x != nil {
+ return x.TopMinerPocQualification
+ }
+ return 0
+}
+
+func (x *TokenomicsParams) GetWorkVestingPeriod() uint64 {
+ if x != nil {
+ return x.WorkVestingPeriod
+ }
+ return 0
+}
+
+func (x *TokenomicsParams) GetRewardVestingPeriod() uint64 {
+ if x != nil {
+ return x.RewardVestingPeriod
+ }
+ return 0
+}
+
+func (x *TokenomicsParams) GetTopMinerVestingPeriod() uint64 {
+ if x != nil {
+ return x.TopMinerVestingPeriod
+ }
+ return 0
+}
+
+type EpochParams struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ EpochLength int64 `protobuf:"varint,1,opt,name=epoch_length,json=epochLength,proto3" json:"epoch_length,omitempty"`
+ EpochMultiplier int64 `protobuf:"varint,2,opt,name=epoch_multiplier,json=epochMultiplier,proto3" json:"epoch_multiplier,omitempty"`
+ EpochShift int64 `protobuf:"varint,3,opt,name=epoch_shift,json=epochShift,proto3" json:"epoch_shift,omitempty"`
+ DefaultUnitOfComputePrice int64 `protobuf:"varint,4,opt,name=default_unit_of_compute_price,json=defaultUnitOfComputePrice,proto3" json:"default_unit_of_compute_price,omitempty"`
+ PocStageDuration int64 `protobuf:"varint,5,opt,name=poc_stage_duration,json=pocStageDuration,proto3" json:"poc_stage_duration,omitempty"`
+ PocExchangeDuration int64 `protobuf:"varint,6,opt,name=poc_exchange_duration,json=pocExchangeDuration,proto3" json:"poc_exchange_duration,omitempty"`
+ PocValidationDelay int64 `protobuf:"varint,7,opt,name=poc_validation_delay,json=pocValidationDelay,proto3" json:"poc_validation_delay,omitempty"`
+ PocValidationDuration int64 `protobuf:"varint,8,opt,name=poc_validation_duration,json=pocValidationDuration,proto3" json:"poc_validation_duration,omitempty"`
+ SetNewValidatorsDelay int64 `protobuf:"varint,9,opt,name=set_new_validators_delay,json=setNewValidatorsDelay,proto3" json:"set_new_validators_delay,omitempty"`
+ InferenceValidationCutoff int64 `protobuf:"varint,10,opt,name=inference_validation_cutoff,json=inferenceValidationCutoff,proto3" json:"inference_validation_cutoff,omitempty"`
+ InferencePruningEpochThreshold uint64 `protobuf:"varint,11,opt,name=inference_pruning_epoch_threshold,json=inferencePruningEpochThreshold,proto3" json:"inference_pruning_epoch_threshold,omitempty"`
+ InferencePruningMax int64 `protobuf:"varint,12,opt,name=inference_pruning_max,json=inferencePruningMax,proto3" json:"inference_pruning_max,omitempty"`
+ PocPruningMax int64 `protobuf:"varint,13,opt,name=poc_pruning_max,json=pocPruningMax,proto3" json:"poc_pruning_max,omitempty"`
+ PocSlotAllocation *Decimal `protobuf:"bytes,14,opt,name=poc_slot_allocation,json=pocSlotAllocation,proto3" json:"poc_slot_allocation,omitempty"` // Fraction of slots allocated to PoC (0.0 to 1.0, default 0.5)
+}
+
+func (x *EpochParams) Reset() {
+ *x = EpochParams{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_params_proto_msgTypes[3]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *EpochParams) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*EpochParams) ProtoMessage() {}
+
+// Deprecated: Use EpochParams.ProtoReflect.Descriptor instead.
+func (*EpochParams) Descriptor() ([]byte, []int) {
+ return file_inference_inference_params_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *EpochParams) GetEpochLength() int64 {
+ if x != nil {
+ return x.EpochLength
+ }
+ return 0
+}
+
+func (x *EpochParams) GetEpochMultiplier() int64 {
+ if x != nil {
+ return x.EpochMultiplier
+ }
+ return 0
+}
+
+func (x *EpochParams) GetEpochShift() int64 {
+ if x != nil {
+ return x.EpochShift
+ }
+ return 0
+}
+
+func (x *EpochParams) GetDefaultUnitOfComputePrice() int64 {
+ if x != nil {
+ return x.DefaultUnitOfComputePrice
+ }
+ return 0
+}
+
+func (x *EpochParams) GetPocStageDuration() int64 {
+ if x != nil {
+ return x.PocStageDuration
+ }
+ return 0
+}
+
+func (x *EpochParams) GetPocExchangeDuration() int64 {
+ if x != nil {
+ return x.PocExchangeDuration
+ }
+ return 0
+}
+
+func (x *EpochParams) GetPocValidationDelay() int64 {
+ if x != nil {
+ return x.PocValidationDelay
+ }
+ return 0
+}
+
+func (x *EpochParams) GetPocValidationDuration() int64 {
+ if x != nil {
+ return x.PocValidationDuration
+ }
+ return 0
+}
+
+func (x *EpochParams) GetSetNewValidatorsDelay() int64 {
+ if x != nil {
+ return x.SetNewValidatorsDelay
+ }
+ return 0
+}
+
+func (x *EpochParams) GetInferenceValidationCutoff() int64 {
+ if x != nil {
+ return x.InferenceValidationCutoff
+ }
+ return 0
+}
+
+func (x *EpochParams) GetInferencePruningEpochThreshold() uint64 {
+ if x != nil {
+ return x.InferencePruningEpochThreshold
+ }
+ return 0
+}
+
+func (x *EpochParams) GetInferencePruningMax() int64 {
+ if x != nil {
+ return x.InferencePruningMax
+ }
+ return 0
+}
+
+func (x *EpochParams) GetPocPruningMax() int64 {
+ if x != nil {
+ return x.PocPruningMax
+ }
+ return 0
+}
+
+func (x *EpochParams) GetPocSlotAllocation() *Decimal {
+ if x != nil {
+ return x.PocSlotAllocation
+ }
+ return nil
+}
+
+type ValidationParams struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ FalsePositiveRate *Decimal `protobuf:"bytes,1,opt,name=false_positive_rate,json=falsePositiveRate,proto3" json:"false_positive_rate,omitempty"`
+ MinRampUpMeasurements int32 `protobuf:"varint,2,opt,name=min_ramp_up_measurements,json=minRampUpMeasurements,proto3" json:"min_ramp_up_measurements,omitempty"`
+ PassValue *Decimal `protobuf:"bytes,3,opt,name=pass_value,json=passValue,proto3" json:"pass_value,omitempty"`
+ MinValidationAverage *Decimal `protobuf:"bytes,4,opt,name=min_validation_average,json=minValidationAverage,proto3" json:"min_validation_average,omitempty"`
+ MaxValidationAverage *Decimal `protobuf:"bytes,5,opt,name=max_validation_average,json=maxValidationAverage,proto3" json:"max_validation_average,omitempty"`
+ ExpirationBlocks int64 `protobuf:"varint,6,opt,name=expiration_blocks,json=expirationBlocks,proto3" json:"expiration_blocks,omitempty"`
+ EpochsToMax int64 `protobuf:"varint,7,opt,name=epochs_to_max,json=epochsToMax,proto3" json:"epochs_to_max,omitempty"`
+ FullValidationTrafficCutoff int64 `protobuf:"varint,8,opt,name=full_validation_traffic_cutoff,json=fullValidationTrafficCutoff,proto3" json:"full_validation_traffic_cutoff,omitempty"`
+ MinValidationHalfway *Decimal `protobuf:"bytes,9,opt,name=min_validation_halfway,json=minValidationHalfway,proto3" json:"min_validation_halfway,omitempty"`
+ MinValidationTrafficCutoff int64 `protobuf:"varint,10,opt,name=min_validation_traffic_cutoff,json=minValidationTrafficCutoff,proto3" json:"min_validation_traffic_cutoff,omitempty"`
+ MissPercentageCutoff *Decimal `protobuf:"bytes,11,opt,name=miss_percentage_cutoff,json=missPercentageCutoff,proto3" json:"miss_percentage_cutoff,omitempty"`
+ MissRequestsPenalty *Decimal `protobuf:"bytes,12,opt,name=miss_requests_penalty,json=missRequestsPenalty,proto3" json:"miss_requests_penalty,omitempty"`
+ TimestampExpiration int64 `protobuf:"varint,13,opt,name=timestamp_expiration,json=timestampExpiration,proto3" json:"timestamp_expiration,omitempty"` // Max time in seconds until timestamps are "too old"
+ TimestampAdvance int64 `protobuf:"varint,14,opt,name=timestamp_advance,json=timestampAdvance,proto3" json:"timestamp_advance,omitempty"` // Max time in seconds until timestamps are "in the future"
+ EstimatedLimitsPerBlockKb uint64 `protobuf:"varint,15,opt,name=estimated_limits_per_block_kb,json=estimatedLimitsPerBlockKb,proto3" json:"estimated_limits_per_block_kb,omitempty"` // Max estimated KB per block per Transfer Agent
+ InvalidReputationPreserve *Decimal `protobuf:"bytes,16,opt,name=invalid_reputation_preserve,json=invalidReputationPreserve,proto3" json:"invalid_reputation_preserve,omitempty"` // How much reputation to keep after an invalidation hit (defaults to 0)
+ BadParticipantInvalidationRate *Decimal `protobuf:"bytes,17,opt,name=bad_participant_invalidation_rate,json=badParticipantInvalidationRate,proto3" json:"bad_participant_invalidation_rate,omitempty"`
+ InvalidationHThreshold *Decimal `protobuf:"bytes,18,opt,name=invalidation_h_threshold,json=invalidationHThreshold,proto3" json:"invalidation_h_threshold,omitempty"` // The H value for the SPRT algorithm for invalid inferences
+ DowntimeGoodPercentage *Decimal `protobuf:"bytes,19,opt,name=downtime_good_percentage,json=downtimeGoodPercentage,proto3" json:"downtime_good_percentage,omitempty"`
+ DowntimeBadPercentage *Decimal `protobuf:"bytes,20,opt,name=downtime_bad_percentage,json=downtimeBadPercentage,proto3" json:"downtime_bad_percentage,omitempty"`
+ DowntimeHThreshold *Decimal `protobuf:"bytes,21,opt,name=downtime_h_threshold,json=downtimeHThreshold,proto3" json:"downtime_h_threshold,omitempty"`
+ DowntimeReputationPreserve *Decimal `protobuf:"bytes,22,opt,name=downtime_reputation_preserve,json=downtimeReputationPreserve,proto3" json:"downtime_reputation_preserve,omitempty"` // How much reputation to keep after a downtime him (defaults to 0)
+ QuickFailureThreshold *Decimal `protobuf:"bytes,23,opt,name=quick_failure_threshold,json=quickFailureThreshold,proto3" json:"quick_failure_threshold,omitempty"` // The threshold of probabilty of consecutive failures to cause a quick invalidation
+}
+
+func (x *ValidationParams) Reset() {
+ *x = ValidationParams{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_params_proto_msgTypes[4]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *ValidationParams) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ValidationParams) ProtoMessage() {}
+
+// Deprecated: Use ValidationParams.ProtoReflect.Descriptor instead.
+func (*ValidationParams) Descriptor() ([]byte, []int) {
+ return file_inference_inference_params_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *ValidationParams) GetFalsePositiveRate() *Decimal {
+ if x != nil {
+ return x.FalsePositiveRate
+ }
+ return nil
+}
+
+func (x *ValidationParams) GetMinRampUpMeasurements() int32 {
+ if x != nil {
+ return x.MinRampUpMeasurements
+ }
+ return 0
+}
+
+func (x *ValidationParams) GetPassValue() *Decimal {
+ if x != nil {
+ return x.PassValue
+ }
+ return nil
+}
+
+func (x *ValidationParams) GetMinValidationAverage() *Decimal {
+ if x != nil {
+ return x.MinValidationAverage
+ }
+ return nil
+}
+
+func (x *ValidationParams) GetMaxValidationAverage() *Decimal {
+ if x != nil {
+ return x.MaxValidationAverage
+ }
+ return nil
+}
+
+func (x *ValidationParams) GetExpirationBlocks() int64 {
+ if x != nil {
+ return x.ExpirationBlocks
+ }
+ return 0
+}
+
+func (x *ValidationParams) GetEpochsToMax() int64 {
+ if x != nil {
+ return x.EpochsToMax
+ }
+ return 0
+}
+
+func (x *ValidationParams) GetFullValidationTrafficCutoff() int64 {
+ if x != nil {
+ return x.FullValidationTrafficCutoff
+ }
+ return 0
+}
+
+func (x *ValidationParams) GetMinValidationHalfway() *Decimal {
+ if x != nil {
+ return x.MinValidationHalfway
+ }
+ return nil
+}
+
+func (x *ValidationParams) GetMinValidationTrafficCutoff() int64 {
+ if x != nil {
+ return x.MinValidationTrafficCutoff
+ }
+ return 0
+}
+
+func (x *ValidationParams) GetMissPercentageCutoff() *Decimal {
+ if x != nil {
+ return x.MissPercentageCutoff
+ }
+ return nil
+}
+
+func (x *ValidationParams) GetMissRequestsPenalty() *Decimal {
+ if x != nil {
+ return x.MissRequestsPenalty
+ }
+ return nil
+}
+
+func (x *ValidationParams) GetTimestampExpiration() int64 {
+ if x != nil {
+ return x.TimestampExpiration
+ }
+ return 0
+}
+
+func (x *ValidationParams) GetTimestampAdvance() int64 {
+ if x != nil {
+ return x.TimestampAdvance
+ }
+ return 0
+}
+
+func (x *ValidationParams) GetEstimatedLimitsPerBlockKb() uint64 {
+ if x != nil {
+ return x.EstimatedLimitsPerBlockKb
+ }
+ return 0
+}
+
+func (x *ValidationParams) GetInvalidReputationPreserve() *Decimal {
+ if x != nil {
+ return x.InvalidReputationPreserve
+ }
+ return nil
+}
+
+func (x *ValidationParams) GetBadParticipantInvalidationRate() *Decimal {
+ if x != nil {
+ return x.BadParticipantInvalidationRate
+ }
+ return nil
+}
+
+func (x *ValidationParams) GetInvalidationHThreshold() *Decimal {
+ if x != nil {
+ return x.InvalidationHThreshold
+ }
+ return nil
+}
+
+func (x *ValidationParams) GetDowntimeGoodPercentage() *Decimal {
+ if x != nil {
+ return x.DowntimeGoodPercentage
+ }
+ return nil
+}
+
+func (x *ValidationParams) GetDowntimeBadPercentage() *Decimal {
+ if x != nil {
+ return x.DowntimeBadPercentage
+ }
+ return nil
+}
+
+func (x *ValidationParams) GetDowntimeHThreshold() *Decimal {
+ if x != nil {
+ return x.DowntimeHThreshold
+ }
+ return nil
+}
+
+func (x *ValidationParams) GetDowntimeReputationPreserve() *Decimal {
+ if x != nil {
+ return x.DowntimeReputationPreserve
+ }
+ return nil
+}
+
+func (x *ValidationParams) GetQuickFailureThreshold() *Decimal {
+ if x != nil {
+ return x.QuickFailureThreshold
+ }
+ return nil
+}
+
+type PocParams struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ DefaultDifficulty int32 `protobuf:"varint,1,opt,name=default_difficulty,json=defaultDifficulty,proto3" json:"default_difficulty,omitempty"`
+ ValidationSampleSize int32 `protobuf:"varint,2,opt,name=validation_sample_size,json=validationSampleSize,proto3" json:"validation_sample_size,omitempty"`
+ PocDataPruningEpochThreshold uint64 `protobuf:"varint,3,opt,name=poc_data_pruning_epoch_threshold,json=pocDataPruningEpochThreshold,proto3" json:"poc_data_pruning_epoch_threshold,omitempty"`
+}
+
+func (x *PocParams) Reset() {
+ *x = PocParams{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_params_proto_msgTypes[5]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *PocParams) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*PocParams) ProtoMessage() {}
+
+// Deprecated: Use PocParams.ProtoReflect.Descriptor instead.
+func (*PocParams) Descriptor() ([]byte, []int) {
+ return file_inference_inference_params_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *PocParams) GetDefaultDifficulty() int32 {
+ if x != nil {
+ return x.DefaultDifficulty
+ }
+ return 0
+}
+
+func (x *PocParams) GetValidationSampleSize() int32 {
+ if x != nil {
+ return x.ValidationSampleSize
+ }
+ return 0
+}
+
+func (x *PocParams) GetPocDataPruningEpochThreshold() uint64 {
+ if x != nil {
+ return x.PocDataPruningEpochThreshold
+ }
+ return 0
+}
+
+type Decimal struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Value int64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
+ Exponent int32 `protobuf:"varint,2,opt,name=exponent,proto3" json:"exponent,omitempty"`
+}
+
+func (x *Decimal) Reset() {
+ *x = Decimal{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_params_proto_msgTypes[6]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *Decimal) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Decimal) ProtoMessage() {}
+
+// Deprecated: Use Decimal.ProtoReflect.Descriptor instead.
+func (*Decimal) Descriptor() ([]byte, []int) {
+ return file_inference_inference_params_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *Decimal) GetValue() int64 {
+ if x != nil {
+ return x.Value
+ }
+ return 0
+}
+
+func (x *Decimal) GetExponent() int32 {
+ if x != nil {
+ return x.Exponent
+ }
+ return 0
+}
+
+// CollateralParams defines the parameters for collateral slashing.
+type CollateralParams struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // slash_fraction_invalid is the percentage of collateral to slash when a participant is marked INVALID.
+ SlashFractionInvalid *Decimal `protobuf:"bytes,1,opt,name=slash_fraction_invalid,json=slashFractionInvalid,proto3" json:"slash_fraction_invalid,omitempty"`
+ // slash_fraction_downtime is the percentage of collateral to slash for downtime.
+ SlashFractionDowntime *Decimal `protobuf:"bytes,2,opt,name=slash_fraction_downtime,json=slashFractionDowntime,proto3" json:"slash_fraction_downtime,omitempty"`
+ // downtime_missed_percentage_threshold is the missed request percentage that triggers a downtime slash.
+ DowntimeMissedPercentageThreshold *Decimal `protobuf:"bytes,3,opt,name=downtime_missed_percentage_threshold,json=downtimeMissedPercentageThreshold,proto3" json:"downtime_missed_percentage_threshold,omitempty"`
+ GracePeriodEndEpoch uint64 `protobuf:"varint,4,opt,name=grace_period_end_epoch,json=gracePeriodEndEpoch,proto3" json:"grace_period_end_epoch,omitempty"`
+ // BaseWeightRatio is the portion of potential weight granted unconditionally (0-1)
+ BaseWeightRatio *Decimal `protobuf:"bytes,5,opt,name=base_weight_ratio,json=baseWeightRatio,proto3" json:"base_weight_ratio,omitempty"`
+ // CollateralPerWeightUnit is the amount of collateral required per unit of weight
+ CollateralPerWeightUnit *Decimal `protobuf:"bytes,6,opt,name=collateral_per_weight_unit,json=collateralPerWeightUnit,proto3" json:"collateral_per_weight_unit,omitempty"`
+}
+
+func (x *CollateralParams) Reset() {
+ *x = CollateralParams{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_params_proto_msgTypes[7]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *CollateralParams) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*CollateralParams) ProtoMessage() {}
+
+// Deprecated: Use CollateralParams.ProtoReflect.Descriptor instead.
+func (*CollateralParams) Descriptor() ([]byte, []int) {
+ return file_inference_inference_params_proto_rawDescGZIP(), []int{7}
+}
+
+func (x *CollateralParams) GetSlashFractionInvalid() *Decimal {
+ if x != nil {
+ return x.SlashFractionInvalid
+ }
+ return nil
+}
+
+func (x *CollateralParams) GetSlashFractionDowntime() *Decimal {
+ if x != nil {
+ return x.SlashFractionDowntime
+ }
+ return nil
+}
+
+func (x *CollateralParams) GetDowntimeMissedPercentageThreshold() *Decimal {
+ if x != nil {
+ return x.DowntimeMissedPercentageThreshold
+ }
+ return nil
+}
+
+func (x *CollateralParams) GetGracePeriodEndEpoch() uint64 {
+ if x != nil {
+ return x.GracePeriodEndEpoch
+ }
+ return 0
+}
+
+func (x *CollateralParams) GetBaseWeightRatio() *Decimal {
+ if x != nil {
+ return x.BaseWeightRatio
+ }
+ return nil
+}
+
+func (x *CollateralParams) GetCollateralPerWeightUnit() *Decimal {
+ if x != nil {
+ return x.CollateralPerWeightUnit
+ }
+ return nil
+}
+
+// BitcoinRewardParams defines the parameters for Bitcoin-style reward system.
+type BitcoinRewardParams struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // use_bitcoin_rewards enables/disables the Bitcoin-style reward system (default: true for production, false for safe deployment)
+ UseBitcoinRewards bool `protobuf:"varint,1,opt,name=use_bitcoin_rewards,json=useBitcoinRewards,proto3" json:"use_bitcoin_rewards,omitempty"`
+ // initial_epoch_reward is the base reward amount per epoch (in native tokens)
+ InitialEpochReward uint64 `protobuf:"varint,2,opt,name=initial_epoch_reward,json=initialEpochReward,proto3" json:"initial_epoch_reward,omitempty"`
+ // decay_rate is the exponential decay rate per epoch for reward halving
+ DecayRate *Decimal `protobuf:"bytes,3,opt,name=decay_rate,json=decayRate,proto3" json:"decay_rate,omitempty"`
+ // genesis_epoch is the starting epoch for Bitcoin-style calculations
+ GenesisEpoch uint64 `protobuf:"varint,4,opt,name=genesis_epoch,json=genesisEpoch,proto3" json:"genesis_epoch,omitempty"`
+ // utilization_bonus_factor controls bonus multipliers for high-demand models (Phase 2)
+ UtilizationBonusFactor *Decimal `protobuf:"bytes,5,opt,name=utilization_bonus_factor,json=utilizationBonusFactor,proto3" json:"utilization_bonus_factor,omitempty"`
+ // full_coverage_bonus_factor is the multiplier for participants supporting all governance models (Phase 2)
+ FullCoverageBonusFactor *Decimal `protobuf:"bytes,6,opt,name=full_coverage_bonus_factor,json=fullCoverageBonusFactor,proto3" json:"full_coverage_bonus_factor,omitempty"`
+ // partial_coverage_bonus_factor is the scaling factor for partial model coverage (Phase 2)
+ PartialCoverageBonusFactor *Decimal `protobuf:"bytes,7,opt,name=partial_coverage_bonus_factor,json=partialCoverageBonusFactor,proto3" json:"partial_coverage_bonus_factor,omitempty"`
+}
+
+func (x *BitcoinRewardParams) Reset() {
+ *x = BitcoinRewardParams{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_params_proto_msgTypes[8]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *BitcoinRewardParams) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BitcoinRewardParams) ProtoMessage() {}
+
+// Deprecated: Use BitcoinRewardParams.ProtoReflect.Descriptor instead.
+func (*BitcoinRewardParams) Descriptor() ([]byte, []int) {
+ return file_inference_inference_params_proto_rawDescGZIP(), []int{8}
+}
+
+func (x *BitcoinRewardParams) GetUseBitcoinRewards() bool {
+ if x != nil {
+ return x.UseBitcoinRewards
+ }
+ return false
+}
+
+func (x *BitcoinRewardParams) GetInitialEpochReward() uint64 {
+ if x != nil {
+ return x.InitialEpochReward
+ }
+ return 0
+}
+
+func (x *BitcoinRewardParams) GetDecayRate() *Decimal {
+ if x != nil {
+ return x.DecayRate
+ }
+ return nil
+}
+
+func (x *BitcoinRewardParams) GetGenesisEpoch() uint64 {
+ if x != nil {
+ return x.GenesisEpoch
+ }
+ return 0
+}
+
+func (x *BitcoinRewardParams) GetUtilizationBonusFactor() *Decimal {
+ if x != nil {
+ return x.UtilizationBonusFactor
+ }
+ return nil
+}
+
+func (x *BitcoinRewardParams) GetFullCoverageBonusFactor() *Decimal {
+ if x != nil {
+ return x.FullCoverageBonusFactor
+ }
+ return nil
+}
+
+func (x *BitcoinRewardParams) GetPartialCoverageBonusFactor() *Decimal {
+ if x != nil {
+ return x.PartialCoverageBonusFactor
+ }
+ return nil
+}
+
+// DynamicPricingParams defines the parameters for the dynamic pricing system.
+type DynamicPricingParams struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // stability_zone_lower_bound is the lower bound of the stability zone where price doesn't change (0-1)
+ StabilityZoneLowerBound *Decimal `protobuf:"bytes,1,opt,name=stability_zone_lower_bound,json=stabilityZoneLowerBound,proto3" json:"stability_zone_lower_bound,omitempty"`
+ // stability_zone_upper_bound is the upper bound of the stability zone where price doesn't change (0-1)
+ StabilityZoneUpperBound *Decimal `protobuf:"bytes,2,opt,name=stability_zone_upper_bound,json=stabilityZoneUpperBound,proto3" json:"stability_zone_upper_bound,omitempty"`
+ // price_elasticity controls price adjustment magnitude - determines maximum change at maximum utilization deviation (0-1)
+ PriceElasticity *Decimal `protobuf:"bytes,3,opt,name=price_elasticity,json=priceElasticity,proto3" json:"price_elasticity,omitempty"`
+ // utilization_window_duration is the time window in seconds for utilization calculation
+ UtilizationWindowDuration uint64 `protobuf:"varint,4,opt,name=utilization_window_duration,json=utilizationWindowDuration,proto3" json:"utilization_window_duration,omitempty"`
+ // min_per_token_price is the minimum per-token price floor to prevent zero pricing (in native token units)
+ MinPerTokenPrice uint64 `protobuf:"varint,5,opt,name=min_per_token_price,json=minPerTokenPrice,proto3" json:"min_per_token_price,omitempty"`
+ // base_per_token_price is the initial per-token price after grace period (in native token units)
+ BasePerTokenPrice uint64 `protobuf:"varint,6,opt,name=base_per_token_price,json=basePerTokenPrice,proto3" json:"base_per_token_price,omitempty"`
+ // grace_period_end_epoch is the epoch when free inference period ends
+ GracePeriodEndEpoch uint64 `protobuf:"varint,7,opt,name=grace_period_end_epoch,json=gracePeriodEndEpoch,proto3" json:"grace_period_end_epoch,omitempty"`
+ // grace_period_per_token_price is the per-token price during grace period (default 0 for free)
+ GracePeriodPerTokenPrice uint64 `protobuf:"varint,8,opt,name=grace_period_per_token_price,json=gracePeriodPerTokenPrice,proto3" json:"grace_period_per_token_price,omitempty"`
+}
+
+func (x *DynamicPricingParams) Reset() {
+ *x = DynamicPricingParams{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_params_proto_msgTypes[9]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *DynamicPricingParams) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DynamicPricingParams) ProtoMessage() {}
+
+// Deprecated: Use DynamicPricingParams.ProtoReflect.Descriptor instead.
+func (*DynamicPricingParams) Descriptor() ([]byte, []int) {
+ return file_inference_inference_params_proto_rawDescGZIP(), []int{9}
+}
+
+func (x *DynamicPricingParams) GetStabilityZoneLowerBound() *Decimal {
+ if x != nil {
+ return x.StabilityZoneLowerBound
+ }
+ return nil
+}
+
+func (x *DynamicPricingParams) GetStabilityZoneUpperBound() *Decimal {
+ if x != nil {
+ return x.StabilityZoneUpperBound
+ }
+ return nil
+}
+
+func (x *DynamicPricingParams) GetPriceElasticity() *Decimal {
+ if x != nil {
+ return x.PriceElasticity
+ }
+ return nil
+}
+
+func (x *DynamicPricingParams) GetUtilizationWindowDuration() uint64 {
+ if x != nil {
+ return x.UtilizationWindowDuration
+ }
+ return 0
+}
+
+func (x *DynamicPricingParams) GetMinPerTokenPrice() uint64 {
+ if x != nil {
+ return x.MinPerTokenPrice
+ }
+ return 0
+}
+
+func (x *DynamicPricingParams) GetBasePerTokenPrice() uint64 {
+ if x != nil {
+ return x.BasePerTokenPrice
+ }
+ return 0
+}
+
+func (x *DynamicPricingParams) GetGracePeriodEndEpoch() uint64 {
+ if x != nil {
+ return x.GracePeriodEndEpoch
+ }
+ return 0
+}
+
+func (x *DynamicPricingParams) GetGracePeriodPerTokenPrice() uint64 {
+ if x != nil {
+ return x.GracePeriodPerTokenPrice
+ }
+ return 0
+}
+
+// BandwidthLimitsParams defines the parameters for request bandwidth limitations.
+type BandwidthLimitsParams struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // estimated_limits_per_block_kb is the maximum KB per block that can be consumed
+ EstimatedLimitsPerBlockKb uint64 `protobuf:"varint,1,opt,name=estimated_limits_per_block_kb,json=estimatedLimitsPerBlockKb,proto3" json:"estimated_limits_per_block_kb,omitempty"`
+ // kb_per_input_token is the estimated KB per input token
+ KbPerInputToken *Decimal `protobuf:"bytes,2,opt,name=kb_per_input_token,json=kbPerInputToken,proto3" json:"kb_per_input_token,omitempty"`
+ // kb_per_output_token is the estimated KB per output token
+ KbPerOutputToken *Decimal `protobuf:"bytes,3,opt,name=kb_per_output_token,json=kbPerOutputToken,proto3" json:"kb_per_output_token,omitempty"`
+ // The total max simultaneous invalidations across the chain
+ InvalidationsLimit uint64 `protobuf:"varint,4,opt,name=invalidations_limit,json=invalidationsLimit,proto3" json:"invalidations_limit,omitempty"`
+ // The seconds to look back to determine inference rate for invalidations
+ InvalidationsSamplePeriod uint64 `protobuf:"varint,5,opt,name=invalidations_sample_period,json=invalidationsSamplePeriod,proto3" json:"invalidations_sample_period,omitempty"`
+ // The curve for the tanh function for determining how quickly traffic expands the
+ // max invalidations allowed
+ InvalidationsLimitCurve uint64 `protobuf:"varint,6,opt,name=invalidations_limit_curve,json=invalidationsLimitCurve,proto3" json:"invalidations_limit_curve,omitempty"`
+ // The least amount of concurrent invalidations
+ MinimumConcurrentInvalidations uint32 `protobuf:"varint,7,opt,name=minimum_concurrent_invalidations,json=minimumConcurrentInvalidations,proto3" json:"minimum_concurrent_invalidations,omitempty"`
+}
+
+func (x *BandwidthLimitsParams) Reset() {
+ *x = BandwidthLimitsParams{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_params_proto_msgTypes[10]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *BandwidthLimitsParams) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BandwidthLimitsParams) ProtoMessage() {}
+
+// Deprecated: Use BandwidthLimitsParams.ProtoReflect.Descriptor instead.
+func (*BandwidthLimitsParams) Descriptor() ([]byte, []int) {
+ return file_inference_inference_params_proto_rawDescGZIP(), []int{10}
+}
+
+func (x *BandwidthLimitsParams) GetEstimatedLimitsPerBlockKb() uint64 {
+ if x != nil {
+ return x.EstimatedLimitsPerBlockKb
+ }
+ return 0
+}
+
+func (x *BandwidthLimitsParams) GetKbPerInputToken() *Decimal {
+ if x != nil {
+ return x.KbPerInputToken
+ }
+ return nil
+}
+
+func (x *BandwidthLimitsParams) GetKbPerOutputToken() *Decimal {
+ if x != nil {
+ return x.KbPerOutputToken
+ }
+ return nil
+}
+
+func (x *BandwidthLimitsParams) GetInvalidationsLimit() uint64 {
+ if x != nil {
+ return x.InvalidationsLimit
+ }
+ return 0
+}
+
+func (x *BandwidthLimitsParams) GetInvalidationsSamplePeriod() uint64 {
+ if x != nil {
+ return x.InvalidationsSamplePeriod
+ }
+ return 0
+}
+
+func (x *BandwidthLimitsParams) GetInvalidationsLimitCurve() uint64 {
+ if x != nil {
+ return x.InvalidationsLimitCurve
+ }
+ return 0
+}
+
+func (x *BandwidthLimitsParams) GetMinimumConcurrentInvalidations() uint32 {
+ if x != nil {
+ return x.MinimumConcurrentInvalidations
+ }
+ return 0
+}
+
+// ConfirmationPoCParams defines the parameters for confirmation PoC feature.
+type ConfirmationPoCParams struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // expected_confirmations_per_epoch is N in the trigger probability formula (e.g., 1)
+ ExpectedConfirmationsPerEpoch uint64 `protobuf:"varint,1,opt,name=expected_confirmations_per_epoch,json=expectedConfirmationsPerEpoch,proto3" json:"expected_confirmations_per_epoch,omitempty"`
+ // alpha_threshold is the minimum confirmed weight ratio (e.g., "0.70")
+ AlphaThreshold *Decimal `protobuf:"bytes,2,opt,name=alpha_threshold,json=alphaThreshold,proto3" json:"alpha_threshold,omitempty"`
+ // slash_fraction is the collateral slashed for failure (e.g., "0.10")
+ SlashFraction *Decimal `protobuf:"bytes,3,opt,name=slash_fraction,json=slashFraction,proto3" json:"slash_fraction,omitempty"`
+ // upgrade_protection_window is blocks before/after upgrade to skip confirmation PoC (default: 500)
+ UpgradeProtectionWindow int64 `protobuf:"varint,4,opt,name=upgrade_protection_window,json=upgradeProtectionWindow,proto3" json:"upgrade_protection_window,omitempty"`
+}
+
+func (x *ConfirmationPoCParams) Reset() {
+ *x = ConfirmationPoCParams{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_params_proto_msgTypes[11]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *ConfirmationPoCParams) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ConfirmationPoCParams) ProtoMessage() {}
+
+// Deprecated: Use ConfirmationPoCParams.ProtoReflect.Descriptor instead.
+func (*ConfirmationPoCParams) Descriptor() ([]byte, []int) {
+ return file_inference_inference_params_proto_rawDescGZIP(), []int{11}
+}
+
+func (x *ConfirmationPoCParams) GetExpectedConfirmationsPerEpoch() uint64 {
+ if x != nil {
+ return x.ExpectedConfirmationsPerEpoch
+ }
+ return 0
+}
+
+func (x *ConfirmationPoCParams) GetAlphaThreshold() *Decimal {
+ if x != nil {
+ return x.AlphaThreshold
+ }
+ return nil
+}
+
+func (x *ConfirmationPoCParams) GetSlashFraction() *Decimal {
+ if x != nil {
+ return x.SlashFraction
+ }
+ return nil
+}
+
+func (x *ConfirmationPoCParams) GetUpgradeProtectionWindow() int64 {
+ if x != nil {
+ return x.UpgradeProtectionWindow
+ }
+ return 0
+}
+
+var File_inference_inference_params_proto protoreflect.FileDescriptor
+
+var file_inference_inference_params_proto_rawDesc = []byte{
+ 0x0a, 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, 0x12, 0x13, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
+ 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x1a, 0x11, 0x61, 0x6d, 0x69, 0x6e, 0x6f, 0x2f, 0x61,
+ 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, 0xb6, 0x06, 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,
+ 0x63, 0x65, 0x2e, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x0b,
+ 0x65, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x52, 0x0a, 0x11, 0x76,
+ 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73,
+ 0x18, 0x02, 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, 0x10, 0x76,
+ 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12,
+ 0x3d, 0x0a, 0x0a, 0x70, 0x6f, 0x63, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x03, 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, 0x50, 0x6f, 0x63, 0x50, 0x61, 0x72,
+ 0x61, 0x6d, 0x73, 0x52, 0x09, 0x70, 0x6f, 0x63, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x52,
+ 0x0a, 0x11, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x6f, 0x6d, 0x69, 0x63, 0x73, 0x5f, 0x70, 0x61, 0x72,
+ 0x61, 0x6d, 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,
+ 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x6f, 0x6d, 0x69, 0x63, 0x73, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73,
+ 0x52, 0x10, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x6f, 0x6d, 0x69, 0x63, 0x73, 0x50, 0x61, 0x72, 0x61,
+ 0x6d, 0x73, 0x12, 0x52, 0x0a, 0x11, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c,
+ 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x05, 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, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x50, 0x61,
+ 0x72, 0x61, 0x6d, 0x73, 0x52, 0x10, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c,
+ 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x5c, 0x0a, 0x15, 0x62, 0x69, 0x74, 0x63, 0x6f, 0x69,
+ 0x6e, 0x5f, 0x72, 0x65, 0x77, 0x61, 0x72, 0x64, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18,
+ 0x06, 0x20, 0x01, 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, 0x42, 0x69, 0x74, 0x63,
+ 0x6f, 0x69, 0x6e, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52,
+ 0x13, 0x62, 0x69, 0x74, 0x63, 0x6f, 0x69, 0x6e, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x50, 0x61,
+ 0x72, 0x61, 0x6d, 0x73, 0x12, 0x5f, 0x0a, 0x16, 0x64, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x5f,
+ 0x70, 0x72, 0x69, 0x63, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x07,
+ 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, 0x44, 0x79, 0x6e, 0x61, 0x6d,
+ 0x69, 0x63, 0x50, 0x72, 0x69, 0x63, 0x69, 0x6e, 0x67, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52,
+ 0x14, 0x64, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x50, 0x72, 0x69, 0x63, 0x69, 0x6e, 0x67, 0x50,
+ 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x62, 0x0a, 0x17, 0x62, 0x61, 0x6e, 0x64, 0x77, 0x69, 0x64,
+ 0x74, 0x68, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73,
+ 0x18, 0x08, 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, 0x42, 0x61, 0x6e,
+ 0x64, 0x77, 0x69, 0x64, 0x74, 0x68, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x50, 0x61, 0x72, 0x61,
+ 0x6d, 0x73, 0x52, 0x15, 0x62, 0x61, 0x6e, 0x64, 0x77, 0x69, 0x64, 0x74, 0x68, 0x4c, 0x69, 0x6d,
+ 0x69, 0x74, 0x73, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x62, 0x0a, 0x17, 0x63, 0x6f, 0x6e,
+ 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x6f, 0x63, 0x5f, 0x70, 0x61,
+ 0x72, 0x61, 0x6d, 0x73, 0x18, 0x09, 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, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x43,
+ 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x15, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61,
+ 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x63, 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, 0x22, 0xb0, 0x07, 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, 0x2a, 0x0a, 0x11, 0x74, 0x6f,
+ 0x70, 0x5f, 0x72, 0x65, 0x77, 0x61, 0x72, 0x64, 0x5f, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18,
+ 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0f, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64,
+ 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 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, 0x1f, 0x0a, 0x0b, 0x74, 0x6f, 0x70,
+ 0x5f, 0x72, 0x65, 0x77, 0x61, 0x72, 0x64, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a,
+ 0x74, 0x6f, 0x70, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x73, 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, 0x2a, 0x0a,
+ 0x11, 0x74, 0x6f, 0x70, 0x5f, 0x72, 0x65, 0x77, 0x61, 0x72, 0x64, 0x5f, 0x70, 0x65, 0x72, 0x69,
+ 0x6f, 0x64, 0x18, 0x08, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0f, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x77,
+ 0x61, 0x72, 0x64, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x12, 0x2c, 0x0a, 0x12, 0x74, 0x6f, 0x70,
+ 0x5f, 0x72, 0x65, 0x77, 0x61, 0x72, 0x64, 0x5f, 0x70, 0x61, 0x79, 0x6f, 0x75, 0x74, 0x73, 0x18,
+ 0x09, 0x20, 0x01, 0x28, 0x03, 0x52, 0x10, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64,
+ 0x50, 0x61, 0x79, 0x6f, 0x75, 0x74, 0x73, 0x12, 0x3e, 0x0a, 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, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x03, 0x52, 0x18, 0x74,
+ 0x6f, 0x70, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x50, 0x61, 0x79, 0x6f, 0x75, 0x74, 0x73, 0x50,
+ 0x65, 0x72, 0x4d, 0x69, 0x6e, 0x65, 0x72, 0x12, 0x35, 0x0a, 0x17, 0x74, 0x6f, 0x70, 0x5f, 0x72,
+ 0x65, 0x77, 0x61, 0x72, 0x64, 0x5f, 0x6d, 0x61, 0x78, 0x5f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69,
+ 0x6f, 0x6e, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x03, 0x52, 0x14, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x77,
+ 0x61, 0x72, 0x64, 0x4d, 0x61, 0x78, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 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, 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, 0x22, 0xdf, 0x04, 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, 0x59, 0x0a, 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, 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, 0x17,
+ 0x74, 0x6f, 0x70, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64,
+ 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x12, 0x3d, 0x0a, 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, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x18, 0x74, 0x6f,
+ 0x70, 0x4d, 0x69, 0x6e, 0x65, 0x72, 0x50, 0x6f, 0x63, 0x51, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69,
+ 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 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, 0x12, 0x37, 0x0a, 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, 0x18, 0x08, 0x20, 0x01, 0x28, 0x04, 0x52, 0x15, 0x74, 0x6f,
+ 0x70, 0x4d, 0x69, 0x6e, 0x65, 0x72, 0x56, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x50, 0x65, 0x72,
+ 0x69, 0x6f, 0x64, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0xfe, 0x05, 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, 0x32, 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, 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, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0xcc, 0x0d, 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, 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, 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, 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, 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, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0xbe, 0x01, 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, 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, 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, 0xee, 0x03, 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, 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, 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, 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 (
+ file_inference_inference_params_proto_rawDescOnce sync.Once
+ file_inference_inference_params_proto_rawDescData = file_inference_inference_params_proto_rawDesc
+)
+
+func file_inference_inference_params_proto_rawDescGZIP() []byte {
+ file_inference_inference_params_proto_rawDescOnce.Do(func() {
+ file_inference_inference_params_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_inference_params_proto_rawDescData)
+ })
+ return file_inference_inference_params_proto_rawDescData
+}
+
+var file_inference_inference_params_proto_msgTypes = make([]protoimpl.MessageInfo, 12)
+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
+ (*PocParams)(nil), // 5: inference.inference.PocParams
+ (*Decimal)(nil), // 6: inference.inference.Decimal
+ (*CollateralParams)(nil), // 7: inference.inference.CollateralParams
+ (*BitcoinRewardParams)(nil), // 8: inference.inference.BitcoinRewardParams
+ (*DynamicPricingParams)(nil), // 9: inference.inference.DynamicPricingParams
+ (*BandwidthLimitsParams)(nil), // 10: inference.inference.BandwidthLimitsParams
+ (*ConfirmationPoCParams)(nil), // 11: inference.inference.ConfirmationPoCParams
+}
+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
+ 5, // 2: inference.inference.Params.poc_params:type_name -> inference.inference.PocParams
+ 2, // 3: inference.inference.Params.tokenomics_params:type_name -> inference.inference.TokenomicsParams
+ 7, // 4: inference.inference.Params.collateral_params:type_name -> inference.inference.CollateralParams
+ 8, // 5: inference.inference.Params.bitcoin_reward_params:type_name -> inference.inference.BitcoinRewardParams
+ 9, // 6: inference.inference.Params.dynamic_pricing_params:type_name -> inference.inference.DynamicPricingParams
+ 10, // 7: inference.inference.Params.bandwidth_limits_params:type_name -> inference.inference.BandwidthLimitsParams
+ 11, // 8: inference.inference.Params.confirmation_poc_params:type_name -> inference.inference.ConfirmationPoCParams
+ 6, // 9: inference.inference.GenesisOnlyParams.max_individual_power_percentage:type_name -> inference.inference.Decimal
+ 6, // 10: inference.inference.GenesisOnlyParams.genesis_guardian_multiplier:type_name -> inference.inference.Decimal
+ 6, // 11: inference.inference.TokenomicsParams.subsidy_reduction_interval:type_name -> inference.inference.Decimal
+ 6, // 12: inference.inference.TokenomicsParams.subsidy_reduction_amount:type_name -> inference.inference.Decimal
+ 6, // 13: inference.inference.TokenomicsParams.current_subsidy_percentage:type_name -> inference.inference.Decimal
+ 6, // 14: inference.inference.TokenomicsParams.top_reward_allowed_failure:type_name -> inference.inference.Decimal
+ 6, // 15: inference.inference.EpochParams.poc_slot_allocation:type_name -> inference.inference.Decimal
+ 6, // 16: inference.inference.ValidationParams.false_positive_rate:type_name -> inference.inference.Decimal
+ 6, // 17: inference.inference.ValidationParams.pass_value:type_name -> inference.inference.Decimal
+ 6, // 18: inference.inference.ValidationParams.min_validation_average:type_name -> inference.inference.Decimal
+ 6, // 19: inference.inference.ValidationParams.max_validation_average:type_name -> inference.inference.Decimal
+ 6, // 20: inference.inference.ValidationParams.min_validation_halfway:type_name -> inference.inference.Decimal
+ 6, // 21: inference.inference.ValidationParams.miss_percentage_cutoff:type_name -> inference.inference.Decimal
+ 6, // 22: inference.inference.ValidationParams.miss_requests_penalty:type_name -> inference.inference.Decimal
+ 6, // 23: inference.inference.ValidationParams.invalid_reputation_preserve:type_name -> inference.inference.Decimal
+ 6, // 24: inference.inference.ValidationParams.bad_participant_invalidation_rate:type_name -> inference.inference.Decimal
+ 6, // 25: inference.inference.ValidationParams.invalidation_h_threshold:type_name -> inference.inference.Decimal
+ 6, // 26: inference.inference.ValidationParams.downtime_good_percentage:type_name -> inference.inference.Decimal
+ 6, // 27: inference.inference.ValidationParams.downtime_bad_percentage:type_name -> inference.inference.Decimal
+ 6, // 28: inference.inference.ValidationParams.downtime_h_threshold:type_name -> inference.inference.Decimal
+ 6, // 29: inference.inference.ValidationParams.downtime_reputation_preserve:type_name -> inference.inference.Decimal
+ 6, // 30: inference.inference.ValidationParams.quick_failure_threshold:type_name -> inference.inference.Decimal
+ 6, // 31: inference.inference.CollateralParams.slash_fraction_invalid:type_name -> inference.inference.Decimal
+ 6, // 32: inference.inference.CollateralParams.slash_fraction_downtime:type_name -> inference.inference.Decimal
+ 6, // 33: inference.inference.CollateralParams.downtime_missed_percentage_threshold:type_name -> inference.inference.Decimal
+ 6, // 34: inference.inference.CollateralParams.base_weight_ratio:type_name -> inference.inference.Decimal
+ 6, // 35: inference.inference.CollateralParams.collateral_per_weight_unit:type_name -> inference.inference.Decimal
+ 6, // 36: inference.inference.BitcoinRewardParams.decay_rate:type_name -> inference.inference.Decimal
+ 6, // 37: inference.inference.BitcoinRewardParams.utilization_bonus_factor:type_name -> inference.inference.Decimal
+ 6, // 38: inference.inference.BitcoinRewardParams.full_coverage_bonus_factor:type_name -> inference.inference.Decimal
+ 6, // 39: inference.inference.BitcoinRewardParams.partial_coverage_bonus_factor:type_name -> inference.inference.Decimal
+ 6, // 40: inference.inference.DynamicPricingParams.stability_zone_lower_bound:type_name -> inference.inference.Decimal
+ 6, // 41: inference.inference.DynamicPricingParams.stability_zone_upper_bound:type_name -> inference.inference.Decimal
+ 6, // 42: inference.inference.DynamicPricingParams.price_elasticity:type_name -> inference.inference.Decimal
+ 6, // 43: inference.inference.BandwidthLimitsParams.kb_per_input_token:type_name -> inference.inference.Decimal
+ 6, // 44: inference.inference.BandwidthLimitsParams.kb_per_output_token:type_name -> inference.inference.Decimal
+ 6, // 45: inference.inference.ConfirmationPoCParams.alpha_threshold:type_name -> inference.inference.Decimal
+ 6, // 46: inference.inference.ConfirmationPoCParams.slash_fraction:type_name -> inference.inference.Decimal
+ 47, // [47:47] is the sub-list for method output_type
+ 47, // [47:47] is the sub-list for method input_type
+ 47, // [47:47] is the sub-list for extension type_name
+ 47, // [47:47] is the sub-list for extension extendee
+ 0, // [0:47] is the sub-list for field type_name
+}
+
+func init() { file_inference_inference_params_proto_init() }
+func file_inference_inference_params_proto_init() {
+ if File_inference_inference_params_proto != nil {
+ return
+ }
+ if !protoimpl.UnsafeEnabled {
+ file_inference_inference_params_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*Params); 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[1].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*GenesisOnlyParams); 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[2].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*TokenomicsParams); 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[3].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*EpochParams); 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[4].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*ValidationParams); 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[5].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*PocParams); 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[6].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*Decimal); 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[7].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*CollateralParams); 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[8].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*BitcoinRewardParams); 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[9].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*DynamicPricingParams); 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[10].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*BandwidthLimitsParams); 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[11].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*ConfirmationPoCParams); 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_params_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 12,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_inference_params_proto_goTypes,
+ DependencyIndexes: file_inference_inference_params_proto_depIdxs,
+ MessageInfos: file_inference_inference_params_proto_msgTypes,
+ }.Build()
+ File_inference_inference_params_proto = out.File
+ file_inference_inference_params_proto_rawDesc = nil
+ file_inference_inference_params_proto_goTypes = nil
+ file_inference_inference_params_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/inference/paramsv1.pulsar.go b/inference-chain/api/inference/inference/paramsv1.pulsar.go
new file mode 100644
index 000000000..3911c4535
--- /dev/null
+++ b/inference-chain/api/inference/inference/paramsv1.pulsar.go
@@ -0,0 +1,3992 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package inference
+
+import (
+ _ "cosmossdk.io/api/amino"
+ binary "encoding/binary"
+ fmt "fmt"
+ _ "github.com/cosmos/cosmos-proto"
+ runtime "github.com/cosmos/cosmos-proto/runtime"
+ _ "github.com/cosmos/gogoproto/gogoproto"
+ protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+ protoiface "google.golang.org/protobuf/runtime/protoiface"
+ protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+ io "io"
+ math "math"
+ reflect "reflect"
+ sync "sync"
+)
+
+var (
+ md_ParamsV1 protoreflect.MessageDescriptor
+ fd_ParamsV1_epoch_params protoreflect.FieldDescriptor
+ fd_ParamsV1_validation_params protoreflect.FieldDescriptor
+ fd_ParamsV1_poc_params protoreflect.FieldDescriptor
+ fd_ParamsV1_tokenomics_params protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_paramsv1_proto_init()
+ md_ParamsV1 = File_inference_inference_paramsv1_proto.Messages().ByName("ParamsV1")
+ fd_ParamsV1_epoch_params = md_ParamsV1.Fields().ByName("epoch_params")
+ fd_ParamsV1_validation_params = md_ParamsV1.Fields().ByName("validation_params")
+ fd_ParamsV1_poc_params = md_ParamsV1.Fields().ByName("poc_params")
+ fd_ParamsV1_tokenomics_params = md_ParamsV1.Fields().ByName("tokenomics_params")
+}
+
+var _ protoreflect.Message = (*fastReflection_ParamsV1)(nil)
+
+type fastReflection_ParamsV1 ParamsV1
+
+func (x *ParamsV1) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_ParamsV1)(x)
+}
+
+func (x *ParamsV1) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_paramsv1_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_ParamsV1_messageType fastReflection_ParamsV1_messageType
+var _ protoreflect.MessageType = fastReflection_ParamsV1_messageType{}
+
+type fastReflection_ParamsV1_messageType struct{}
+
+func (x fastReflection_ParamsV1_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_ParamsV1)(nil)
+}
+func (x fastReflection_ParamsV1_messageType) New() protoreflect.Message {
+ return new(fastReflection_ParamsV1)
+}
+func (x fastReflection_ParamsV1_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_ParamsV1
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_ParamsV1) Descriptor() protoreflect.MessageDescriptor {
+ return md_ParamsV1
+}
+
+// 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_ParamsV1) Type() protoreflect.MessageType {
+ return _fastReflection_ParamsV1_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_ParamsV1) New() protoreflect.Message {
+ return new(fastReflection_ParamsV1)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_ParamsV1) Interface() protoreflect.ProtoMessage {
+ return (*ParamsV1)(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_ParamsV1) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.EpochParams != nil {
+ value := protoreflect.ValueOfMessage(x.EpochParams.ProtoReflect())
+ if !f(fd_ParamsV1_epoch_params, value) {
+ return
+ }
+ }
+ if x.ValidationParams != nil {
+ value := protoreflect.ValueOfMessage(x.ValidationParams.ProtoReflect())
+ if !f(fd_ParamsV1_validation_params, value) {
+ return
+ }
+ }
+ if x.PocParams != nil {
+ value := protoreflect.ValueOfMessage(x.PocParams.ProtoReflect())
+ if !f(fd_ParamsV1_poc_params, value) {
+ return
+ }
+ }
+ if x.TokenomicsParams != nil {
+ value := protoreflect.ValueOfMessage(x.TokenomicsParams.ProtoReflect())
+ if !f(fd_ParamsV1_tokenomics_params, 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_ParamsV1) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.ParamsV1.epoch_params":
+ return x.EpochParams != nil
+ case "inference.inference.ParamsV1.validation_params":
+ return x.ValidationParams != nil
+ case "inference.inference.ParamsV1.poc_params":
+ return x.PocParams != nil
+ case "inference.inference.ParamsV1.tokenomics_params":
+ return x.TokenomicsParams != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParamsV1"))
+ }
+ panic(fmt.Errorf("message inference.inference.ParamsV1 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_ParamsV1) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.ParamsV1.epoch_params":
+ x.EpochParams = nil
+ case "inference.inference.ParamsV1.validation_params":
+ x.ValidationParams = nil
+ case "inference.inference.ParamsV1.poc_params":
+ x.PocParams = nil
+ case "inference.inference.ParamsV1.tokenomics_params":
+ x.TokenomicsParams = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParamsV1"))
+ }
+ panic(fmt.Errorf("message inference.inference.ParamsV1 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_ParamsV1) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.ParamsV1.epoch_params":
+ value := x.EpochParams
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.ParamsV1.validation_params":
+ value := x.ValidationParams
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.ParamsV1.poc_params":
+ value := x.PocParams
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.ParamsV1.tokenomics_params":
+ value := x.TokenomicsParams
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParamsV1"))
+ }
+ panic(fmt.Errorf("message inference.inference.ParamsV1 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_ParamsV1) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.ParamsV1.epoch_params":
+ x.EpochParams = value.Message().Interface().(*EpochParamsV1)
+ case "inference.inference.ParamsV1.validation_params":
+ x.ValidationParams = value.Message().Interface().(*ValidationParamsV1)
+ case "inference.inference.ParamsV1.poc_params":
+ x.PocParams = value.Message().Interface().(*PocParamsV1)
+ case "inference.inference.ParamsV1.tokenomics_params":
+ x.TokenomicsParams = value.Message().Interface().(*TokenomicsParamsV1)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParamsV1"))
+ }
+ panic(fmt.Errorf("message inference.inference.ParamsV1 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_ParamsV1) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.ParamsV1.epoch_params":
+ if x.EpochParams == nil {
+ x.EpochParams = new(EpochParamsV1)
+ }
+ return protoreflect.ValueOfMessage(x.EpochParams.ProtoReflect())
+ case "inference.inference.ParamsV1.validation_params":
+ if x.ValidationParams == nil {
+ x.ValidationParams = new(ValidationParamsV1)
+ }
+ return protoreflect.ValueOfMessage(x.ValidationParams.ProtoReflect())
+ case "inference.inference.ParamsV1.poc_params":
+ if x.PocParams == nil {
+ x.PocParams = new(PocParamsV1)
+ }
+ return protoreflect.ValueOfMessage(x.PocParams.ProtoReflect())
+ case "inference.inference.ParamsV1.tokenomics_params":
+ if x.TokenomicsParams == nil {
+ x.TokenomicsParams = new(TokenomicsParamsV1)
+ }
+ return protoreflect.ValueOfMessage(x.TokenomicsParams.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParamsV1"))
+ }
+ panic(fmt.Errorf("message inference.inference.ParamsV1 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_ParamsV1) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.ParamsV1.epoch_params":
+ m := new(EpochParamsV1)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.ParamsV1.validation_params":
+ m := new(ValidationParamsV1)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.ParamsV1.poc_params":
+ m := new(PocParamsV1)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.ParamsV1.tokenomics_params":
+ m := new(TokenomicsParamsV1)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParamsV1"))
+ }
+ panic(fmt.Errorf("message inference.inference.ParamsV1 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_ParamsV1) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.ParamsV1", 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_ParamsV1) 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_ParamsV1) 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_ParamsV1) 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_ParamsV1) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*ParamsV1)
+ 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.EpochParams != nil {
+ l = options.Size(x.EpochParams)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.ValidationParams != nil {
+ l = options.Size(x.ValidationParams)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.PocParams != nil {
+ l = options.Size(x.PocParams)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.TokenomicsParams != nil {
+ l = options.Size(x.TokenomicsParams)
+ 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().(*ParamsV1)
+ 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.TokenomicsParams != nil {
+ encoded, err := options.Marshal(x.TokenomicsParams)
+ 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.PocParams != nil {
+ encoded, err := options.Marshal(x.PocParams)
+ 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.ValidationParams != nil {
+ encoded, err := options.Marshal(x.ValidationParams)
+ 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.EpochParams != nil {
+ encoded, err := options.Marshal(x.EpochParams)
+ 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().(*ParamsV1)
+ 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: ParamsV1: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ParamsV1: 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 EpochParams", 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.EpochParams == nil {
+ x.EpochParams = &EpochParamsV1{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.EpochParams); 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 ValidationParams", 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.ValidationParams == nil {
+ x.ValidationParams = &ValidationParamsV1{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ValidationParams); 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 PocParams", 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.PocParams == nil {
+ x.PocParams = &PocParamsV1{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.PocParams); 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 TokenomicsParams", 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.TokenomicsParams == nil {
+ x.TokenomicsParams = &TokenomicsParamsV1{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.TokenomicsParams); 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_TokenomicsParamsV1 protoreflect.MessageDescriptor
+ fd_TokenomicsParamsV1_subsidy_reduction_interval protoreflect.FieldDescriptor
+ fd_TokenomicsParamsV1_subsidy_reduction_amount protoreflect.FieldDescriptor
+ fd_TokenomicsParamsV1_current_subsidy_percentage protoreflect.FieldDescriptor
+ fd_TokenomicsParamsV1_top_reward_allowed_failure protoreflect.FieldDescriptor
+ fd_TokenomicsParamsV1_top_miner_poc_qualification protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_paramsv1_proto_init()
+ md_TokenomicsParamsV1 = File_inference_inference_paramsv1_proto.Messages().ByName("TokenomicsParamsV1")
+ fd_TokenomicsParamsV1_subsidy_reduction_interval = md_TokenomicsParamsV1.Fields().ByName("subsidy_reduction_interval")
+ fd_TokenomicsParamsV1_subsidy_reduction_amount = md_TokenomicsParamsV1.Fields().ByName("subsidy_reduction_amount")
+ fd_TokenomicsParamsV1_current_subsidy_percentage = md_TokenomicsParamsV1.Fields().ByName("current_subsidy_percentage")
+ fd_TokenomicsParamsV1_top_reward_allowed_failure = md_TokenomicsParamsV1.Fields().ByName("top_reward_allowed_failure")
+ fd_TokenomicsParamsV1_top_miner_poc_qualification = md_TokenomicsParamsV1.Fields().ByName("top_miner_poc_qualification")
+}
+
+var _ protoreflect.Message = (*fastReflection_TokenomicsParamsV1)(nil)
+
+type fastReflection_TokenomicsParamsV1 TokenomicsParamsV1
+
+func (x *TokenomicsParamsV1) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_TokenomicsParamsV1)(x)
+}
+
+func (x *TokenomicsParamsV1) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_paramsv1_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_TokenomicsParamsV1_messageType fastReflection_TokenomicsParamsV1_messageType
+var _ protoreflect.MessageType = fastReflection_TokenomicsParamsV1_messageType{}
+
+type fastReflection_TokenomicsParamsV1_messageType struct{}
+
+func (x fastReflection_TokenomicsParamsV1_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_TokenomicsParamsV1)(nil)
+}
+func (x fastReflection_TokenomicsParamsV1_messageType) New() protoreflect.Message {
+ return new(fastReflection_TokenomicsParamsV1)
+}
+func (x fastReflection_TokenomicsParamsV1_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_TokenomicsParamsV1
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_TokenomicsParamsV1) Descriptor() protoreflect.MessageDescriptor {
+ return md_TokenomicsParamsV1
+}
+
+// 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_TokenomicsParamsV1) Type() protoreflect.MessageType {
+ return _fastReflection_TokenomicsParamsV1_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_TokenomicsParamsV1) New() protoreflect.Message {
+ return new(fastReflection_TokenomicsParamsV1)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_TokenomicsParamsV1) Interface() protoreflect.ProtoMessage {
+ return (*TokenomicsParamsV1)(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_TokenomicsParamsV1) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.SubsidyReductionInterval != float64(0) || math.Signbit(x.SubsidyReductionInterval) {
+ value := protoreflect.ValueOfFloat64(x.SubsidyReductionInterval)
+ if !f(fd_TokenomicsParamsV1_subsidy_reduction_interval, value) {
+ return
+ }
+ }
+ if x.SubsidyReductionAmount != float32(0) || math.Signbit(float64(x.SubsidyReductionAmount)) {
+ value := protoreflect.ValueOfFloat32(x.SubsidyReductionAmount)
+ if !f(fd_TokenomicsParamsV1_subsidy_reduction_amount, value) {
+ return
+ }
+ }
+ if x.CurrentSubsidyPercentage != float32(0) || math.Signbit(float64(x.CurrentSubsidyPercentage)) {
+ value := protoreflect.ValueOfFloat32(x.CurrentSubsidyPercentage)
+ if !f(fd_TokenomicsParamsV1_current_subsidy_percentage, value) {
+ return
+ }
+ }
+ if x.TopRewardAllowedFailure != float32(0) || math.Signbit(float64(x.TopRewardAllowedFailure)) {
+ value := protoreflect.ValueOfFloat32(x.TopRewardAllowedFailure)
+ if !f(fd_TokenomicsParamsV1_top_reward_allowed_failure, value) {
+ return
+ }
+ }
+ if x.TopMinerPocQualification != int64(0) {
+ value := protoreflect.ValueOfInt64(x.TopMinerPocQualification)
+ if !f(fd_TokenomicsParamsV1_top_miner_poc_qualification, 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_TokenomicsParamsV1) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.TokenomicsParamsV1.subsidy_reduction_interval":
+ return x.SubsidyReductionInterval != float64(0) || math.Signbit(x.SubsidyReductionInterval)
+ case "inference.inference.TokenomicsParamsV1.subsidy_reduction_amount":
+ return x.SubsidyReductionAmount != float32(0) || math.Signbit(float64(x.SubsidyReductionAmount))
+ case "inference.inference.TokenomicsParamsV1.current_subsidy_percentage":
+ return x.CurrentSubsidyPercentage != float32(0) || math.Signbit(float64(x.CurrentSubsidyPercentage))
+ case "inference.inference.TokenomicsParamsV1.top_reward_allowed_failure":
+ return x.TopRewardAllowedFailure != float32(0) || math.Signbit(float64(x.TopRewardAllowedFailure))
+ case "inference.inference.TokenomicsParamsV1.top_miner_poc_qualification":
+ return x.TopMinerPocQualification != int64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.TokenomicsParamsV1"))
+ }
+ panic(fmt.Errorf("message inference.inference.TokenomicsParamsV1 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_TokenomicsParamsV1) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.TokenomicsParamsV1.subsidy_reduction_interval":
+ x.SubsidyReductionInterval = float64(0)
+ case "inference.inference.TokenomicsParamsV1.subsidy_reduction_amount":
+ x.SubsidyReductionAmount = float32(0)
+ case "inference.inference.TokenomicsParamsV1.current_subsidy_percentage":
+ x.CurrentSubsidyPercentage = float32(0)
+ case "inference.inference.TokenomicsParamsV1.top_reward_allowed_failure":
+ x.TopRewardAllowedFailure = float32(0)
+ case "inference.inference.TokenomicsParamsV1.top_miner_poc_qualification":
+ x.TopMinerPocQualification = int64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.TokenomicsParamsV1"))
+ }
+ panic(fmt.Errorf("message inference.inference.TokenomicsParamsV1 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_TokenomicsParamsV1) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.TokenomicsParamsV1.subsidy_reduction_interval":
+ value := x.SubsidyReductionInterval
+ return protoreflect.ValueOfFloat64(value)
+ case "inference.inference.TokenomicsParamsV1.subsidy_reduction_amount":
+ value := x.SubsidyReductionAmount
+ return protoreflect.ValueOfFloat32(value)
+ case "inference.inference.TokenomicsParamsV1.current_subsidy_percentage":
+ value := x.CurrentSubsidyPercentage
+ return protoreflect.ValueOfFloat32(value)
+ case "inference.inference.TokenomicsParamsV1.top_reward_allowed_failure":
+ value := x.TopRewardAllowedFailure
+ return protoreflect.ValueOfFloat32(value)
+ case "inference.inference.TokenomicsParamsV1.top_miner_poc_qualification":
+ value := x.TopMinerPocQualification
+ return protoreflect.ValueOfInt64(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.TokenomicsParamsV1"))
+ }
+ panic(fmt.Errorf("message inference.inference.TokenomicsParamsV1 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_TokenomicsParamsV1) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.TokenomicsParamsV1.subsidy_reduction_interval":
+ x.SubsidyReductionInterval = value.Float()
+ case "inference.inference.TokenomicsParamsV1.subsidy_reduction_amount":
+ x.SubsidyReductionAmount = float32(value.Float())
+ case "inference.inference.TokenomicsParamsV1.current_subsidy_percentage":
+ x.CurrentSubsidyPercentage = float32(value.Float())
+ case "inference.inference.TokenomicsParamsV1.top_reward_allowed_failure":
+ x.TopRewardAllowedFailure = float32(value.Float())
+ case "inference.inference.TokenomicsParamsV1.top_miner_poc_qualification":
+ x.TopMinerPocQualification = value.Int()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.TokenomicsParamsV1"))
+ }
+ panic(fmt.Errorf("message inference.inference.TokenomicsParamsV1 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_TokenomicsParamsV1) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.TokenomicsParamsV1.subsidy_reduction_interval":
+ panic(fmt.Errorf("field subsidy_reduction_interval of message inference.inference.TokenomicsParamsV1 is not mutable"))
+ case "inference.inference.TokenomicsParamsV1.subsidy_reduction_amount":
+ panic(fmt.Errorf("field subsidy_reduction_amount of message inference.inference.TokenomicsParamsV1 is not mutable"))
+ case "inference.inference.TokenomicsParamsV1.current_subsidy_percentage":
+ panic(fmt.Errorf("field current_subsidy_percentage of message inference.inference.TokenomicsParamsV1 is not mutable"))
+ case "inference.inference.TokenomicsParamsV1.top_reward_allowed_failure":
+ panic(fmt.Errorf("field top_reward_allowed_failure of message inference.inference.TokenomicsParamsV1 is not mutable"))
+ case "inference.inference.TokenomicsParamsV1.top_miner_poc_qualification":
+ panic(fmt.Errorf("field top_miner_poc_qualification of message inference.inference.TokenomicsParamsV1 is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.TokenomicsParamsV1"))
+ }
+ panic(fmt.Errorf("message inference.inference.TokenomicsParamsV1 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_TokenomicsParamsV1) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.TokenomicsParamsV1.subsidy_reduction_interval":
+ return protoreflect.ValueOfFloat64(float64(0))
+ case "inference.inference.TokenomicsParamsV1.subsidy_reduction_amount":
+ return protoreflect.ValueOfFloat32(float32(0))
+ case "inference.inference.TokenomicsParamsV1.current_subsidy_percentage":
+ return protoreflect.ValueOfFloat32(float32(0))
+ case "inference.inference.TokenomicsParamsV1.top_reward_allowed_failure":
+ return protoreflect.ValueOfFloat32(float32(0))
+ case "inference.inference.TokenomicsParamsV1.top_miner_poc_qualification":
+ return protoreflect.ValueOfInt64(int64(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.TokenomicsParamsV1"))
+ }
+ panic(fmt.Errorf("message inference.inference.TokenomicsParamsV1 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_TokenomicsParamsV1) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.TokenomicsParamsV1", 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_TokenomicsParamsV1) 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_TokenomicsParamsV1) 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_TokenomicsParamsV1) 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_TokenomicsParamsV1) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*TokenomicsParamsV1)
+ 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.SubsidyReductionInterval != 0 || math.Signbit(x.SubsidyReductionInterval) {
+ n += 9
+ }
+ if x.SubsidyReductionAmount != 0 || math.Signbit(float64(x.SubsidyReductionAmount)) {
+ n += 5
+ }
+ if x.CurrentSubsidyPercentage != 0 || math.Signbit(float64(x.CurrentSubsidyPercentage)) {
+ n += 5
+ }
+ if x.TopRewardAllowedFailure != 0 || math.Signbit(float64(x.TopRewardAllowedFailure)) {
+ n += 5
+ }
+ if x.TopMinerPocQualification != 0 {
+ n += 1 + runtime.Sov(uint64(x.TopMinerPocQualification))
+ }
+ 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().(*TokenomicsParamsV1)
+ 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.TopMinerPocQualification != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.TopMinerPocQualification))
+ i--
+ dAtA[i] = 0x28
+ }
+ if x.TopRewardAllowedFailure != 0 || math.Signbit(float64(x.TopRewardAllowedFailure)) {
+ i -= 4
+ binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(x.TopRewardAllowedFailure))))
+ i--
+ dAtA[i] = 0x25
+ }
+ if x.CurrentSubsidyPercentage != 0 || math.Signbit(float64(x.CurrentSubsidyPercentage)) {
+ i -= 4
+ binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(x.CurrentSubsidyPercentage))))
+ i--
+ dAtA[i] = 0x1d
+ }
+ if x.SubsidyReductionAmount != 0 || math.Signbit(float64(x.SubsidyReductionAmount)) {
+ i -= 4
+ binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(x.SubsidyReductionAmount))))
+ i--
+ dAtA[i] = 0x15
+ }
+ if x.SubsidyReductionInterval != 0 || math.Signbit(x.SubsidyReductionInterval) {
+ i -= 8
+ binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(x.SubsidyReductionInterval))))
+ i--
+ dAtA[i] = 0x9
+ }
+ 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().(*TokenomicsParamsV1)
+ 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: TokenomicsParamsV1: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TokenomicsParamsV1: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 1 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field SubsidyReductionInterval", wireType)
+ }
+ 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
+ x.SubsidyReductionInterval = float64(math.Float64frombits(v))
+ case 2:
+ if wireType != 5 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field SubsidyReductionAmount", wireType)
+ }
+ var v uint32
+ if (iNdEx + 4) > l {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+ }
+ v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
+ iNdEx += 4
+ x.SubsidyReductionAmount = float32(math.Float32frombits(v))
+ case 3:
+ if wireType != 5 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field CurrentSubsidyPercentage", wireType)
+ }
+ var v uint32
+ if (iNdEx + 4) > l {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+ }
+ v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
+ iNdEx += 4
+ x.CurrentSubsidyPercentage = float32(math.Float32frombits(v))
+ case 4:
+ if wireType != 5 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TopRewardAllowedFailure", wireType)
+ }
+ var v uint32
+ if (iNdEx + 4) > l {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+ }
+ v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
+ iNdEx += 4
+ x.TopRewardAllowedFailure = float32(math.Float32frombits(v))
+ case 5:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TopMinerPocQualification", wireType)
+ }
+ x.TopMinerPocQualification = 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.TopMinerPocQualification |= 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_EpochParamsV1 protoreflect.MessageDescriptor
+ fd_EpochParamsV1_epoch_length protoreflect.FieldDescriptor
+ fd_EpochParamsV1_epoch_multiplier protoreflect.FieldDescriptor
+ fd_EpochParamsV1_epoch_shift protoreflect.FieldDescriptor
+ fd_EpochParamsV1_default_unit_of_compute_price protoreflect.FieldDescriptor
+ fd_EpochParamsV1_poc_stage_duration protoreflect.FieldDescriptor
+ fd_EpochParamsV1_poc_exchange_duration protoreflect.FieldDescriptor
+ fd_EpochParamsV1_poc_validation_delay protoreflect.FieldDescriptor
+ fd_EpochParamsV1_poc_validation_duration protoreflect.FieldDescriptor
+ fd_EpochParamsV1_set_new_validators_delay protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_paramsv1_proto_init()
+ md_EpochParamsV1 = File_inference_inference_paramsv1_proto.Messages().ByName("EpochParamsV1")
+ fd_EpochParamsV1_epoch_length = md_EpochParamsV1.Fields().ByName("epoch_length")
+ fd_EpochParamsV1_epoch_multiplier = md_EpochParamsV1.Fields().ByName("epoch_multiplier")
+ fd_EpochParamsV1_epoch_shift = md_EpochParamsV1.Fields().ByName("epoch_shift")
+ fd_EpochParamsV1_default_unit_of_compute_price = md_EpochParamsV1.Fields().ByName("default_unit_of_compute_price")
+ fd_EpochParamsV1_poc_stage_duration = md_EpochParamsV1.Fields().ByName("poc_stage_duration")
+ fd_EpochParamsV1_poc_exchange_duration = md_EpochParamsV1.Fields().ByName("poc_exchange_duration")
+ fd_EpochParamsV1_poc_validation_delay = md_EpochParamsV1.Fields().ByName("poc_validation_delay")
+ fd_EpochParamsV1_poc_validation_duration = md_EpochParamsV1.Fields().ByName("poc_validation_duration")
+ fd_EpochParamsV1_set_new_validators_delay = md_EpochParamsV1.Fields().ByName("set_new_validators_delay")
+}
+
+var _ protoreflect.Message = (*fastReflection_EpochParamsV1)(nil)
+
+type fastReflection_EpochParamsV1 EpochParamsV1
+
+func (x *EpochParamsV1) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_EpochParamsV1)(x)
+}
+
+func (x *EpochParamsV1) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_paramsv1_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_EpochParamsV1_messageType fastReflection_EpochParamsV1_messageType
+var _ protoreflect.MessageType = fastReflection_EpochParamsV1_messageType{}
+
+type fastReflection_EpochParamsV1_messageType struct{}
+
+func (x fastReflection_EpochParamsV1_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_EpochParamsV1)(nil)
+}
+func (x fastReflection_EpochParamsV1_messageType) New() protoreflect.Message {
+ return new(fastReflection_EpochParamsV1)
+}
+func (x fastReflection_EpochParamsV1_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_EpochParamsV1
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_EpochParamsV1) Descriptor() protoreflect.MessageDescriptor {
+ return md_EpochParamsV1
+}
+
+// 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_EpochParamsV1) Type() protoreflect.MessageType {
+ return _fastReflection_EpochParamsV1_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_EpochParamsV1) New() protoreflect.Message {
+ return new(fastReflection_EpochParamsV1)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_EpochParamsV1) Interface() protoreflect.ProtoMessage {
+ return (*EpochParamsV1)(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_EpochParamsV1) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.EpochLength != int64(0) {
+ value := protoreflect.ValueOfInt64(x.EpochLength)
+ if !f(fd_EpochParamsV1_epoch_length, value) {
+ return
+ }
+ }
+ if x.EpochMultiplier != int64(0) {
+ value := protoreflect.ValueOfInt64(x.EpochMultiplier)
+ if !f(fd_EpochParamsV1_epoch_multiplier, value) {
+ return
+ }
+ }
+ if x.EpochShift != int64(0) {
+ value := protoreflect.ValueOfInt64(x.EpochShift)
+ if !f(fd_EpochParamsV1_epoch_shift, value) {
+ return
+ }
+ }
+ if x.DefaultUnitOfComputePrice != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.DefaultUnitOfComputePrice)
+ if !f(fd_EpochParamsV1_default_unit_of_compute_price, value) {
+ return
+ }
+ }
+ if x.PocStageDuration != int64(0) {
+ value := protoreflect.ValueOfInt64(x.PocStageDuration)
+ if !f(fd_EpochParamsV1_poc_stage_duration, value) {
+ return
+ }
+ }
+ if x.PocExchangeDuration != int64(0) {
+ value := protoreflect.ValueOfInt64(x.PocExchangeDuration)
+ if !f(fd_EpochParamsV1_poc_exchange_duration, value) {
+ return
+ }
+ }
+ if x.PocValidationDelay != int64(0) {
+ value := protoreflect.ValueOfInt64(x.PocValidationDelay)
+ if !f(fd_EpochParamsV1_poc_validation_delay, value) {
+ return
+ }
+ }
+ if x.PocValidationDuration != int64(0) {
+ value := protoreflect.ValueOfInt64(x.PocValidationDuration)
+ if !f(fd_EpochParamsV1_poc_validation_duration, value) {
+ return
+ }
+ }
+ if x.SetNewValidatorsDelay != int64(0) {
+ value := protoreflect.ValueOfInt64(x.SetNewValidatorsDelay)
+ if !f(fd_EpochParamsV1_set_new_validators_delay, 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_EpochParamsV1) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.EpochParamsV1.epoch_length":
+ return x.EpochLength != int64(0)
+ case "inference.inference.EpochParamsV1.epoch_multiplier":
+ return x.EpochMultiplier != int64(0)
+ case "inference.inference.EpochParamsV1.epoch_shift":
+ return x.EpochShift != int64(0)
+ case "inference.inference.EpochParamsV1.default_unit_of_compute_price":
+ return x.DefaultUnitOfComputePrice != uint64(0)
+ case "inference.inference.EpochParamsV1.poc_stage_duration":
+ return x.PocStageDuration != int64(0)
+ case "inference.inference.EpochParamsV1.poc_exchange_duration":
+ return x.PocExchangeDuration != int64(0)
+ case "inference.inference.EpochParamsV1.poc_validation_delay":
+ return x.PocValidationDelay != int64(0)
+ case "inference.inference.EpochParamsV1.poc_validation_duration":
+ return x.PocValidationDuration != int64(0)
+ case "inference.inference.EpochParamsV1.set_new_validators_delay":
+ return x.SetNewValidatorsDelay != int64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.EpochParamsV1"))
+ }
+ panic(fmt.Errorf("message inference.inference.EpochParamsV1 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_EpochParamsV1) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.EpochParamsV1.epoch_length":
+ x.EpochLength = int64(0)
+ case "inference.inference.EpochParamsV1.epoch_multiplier":
+ x.EpochMultiplier = int64(0)
+ case "inference.inference.EpochParamsV1.epoch_shift":
+ x.EpochShift = int64(0)
+ case "inference.inference.EpochParamsV1.default_unit_of_compute_price":
+ x.DefaultUnitOfComputePrice = uint64(0)
+ case "inference.inference.EpochParamsV1.poc_stage_duration":
+ x.PocStageDuration = int64(0)
+ case "inference.inference.EpochParamsV1.poc_exchange_duration":
+ x.PocExchangeDuration = int64(0)
+ case "inference.inference.EpochParamsV1.poc_validation_delay":
+ x.PocValidationDelay = int64(0)
+ case "inference.inference.EpochParamsV1.poc_validation_duration":
+ x.PocValidationDuration = int64(0)
+ case "inference.inference.EpochParamsV1.set_new_validators_delay":
+ x.SetNewValidatorsDelay = int64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.EpochParamsV1"))
+ }
+ panic(fmt.Errorf("message inference.inference.EpochParamsV1 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_EpochParamsV1) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.EpochParamsV1.epoch_length":
+ value := x.EpochLength
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.EpochParamsV1.epoch_multiplier":
+ value := x.EpochMultiplier
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.EpochParamsV1.epoch_shift":
+ value := x.EpochShift
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.EpochParamsV1.default_unit_of_compute_price":
+ value := x.DefaultUnitOfComputePrice
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.EpochParamsV1.poc_stage_duration":
+ value := x.PocStageDuration
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.EpochParamsV1.poc_exchange_duration":
+ value := x.PocExchangeDuration
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.EpochParamsV1.poc_validation_delay":
+ value := x.PocValidationDelay
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.EpochParamsV1.poc_validation_duration":
+ value := x.PocValidationDuration
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.EpochParamsV1.set_new_validators_delay":
+ value := x.SetNewValidatorsDelay
+ return protoreflect.ValueOfInt64(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.EpochParamsV1"))
+ }
+ panic(fmt.Errorf("message inference.inference.EpochParamsV1 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_EpochParamsV1) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.EpochParamsV1.epoch_length":
+ x.EpochLength = value.Int()
+ case "inference.inference.EpochParamsV1.epoch_multiplier":
+ x.EpochMultiplier = value.Int()
+ case "inference.inference.EpochParamsV1.epoch_shift":
+ x.EpochShift = value.Int()
+ case "inference.inference.EpochParamsV1.default_unit_of_compute_price":
+ x.DefaultUnitOfComputePrice = value.Uint()
+ case "inference.inference.EpochParamsV1.poc_stage_duration":
+ x.PocStageDuration = value.Int()
+ case "inference.inference.EpochParamsV1.poc_exchange_duration":
+ x.PocExchangeDuration = value.Int()
+ case "inference.inference.EpochParamsV1.poc_validation_delay":
+ x.PocValidationDelay = value.Int()
+ case "inference.inference.EpochParamsV1.poc_validation_duration":
+ x.PocValidationDuration = value.Int()
+ case "inference.inference.EpochParamsV1.set_new_validators_delay":
+ x.SetNewValidatorsDelay = value.Int()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.EpochParamsV1"))
+ }
+ panic(fmt.Errorf("message inference.inference.EpochParamsV1 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_EpochParamsV1) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.EpochParamsV1.epoch_length":
+ panic(fmt.Errorf("field epoch_length of message inference.inference.EpochParamsV1 is not mutable"))
+ case "inference.inference.EpochParamsV1.epoch_multiplier":
+ panic(fmt.Errorf("field epoch_multiplier of message inference.inference.EpochParamsV1 is not mutable"))
+ case "inference.inference.EpochParamsV1.epoch_shift":
+ panic(fmt.Errorf("field epoch_shift of message inference.inference.EpochParamsV1 is not mutable"))
+ case "inference.inference.EpochParamsV1.default_unit_of_compute_price":
+ panic(fmt.Errorf("field default_unit_of_compute_price of message inference.inference.EpochParamsV1 is not mutable"))
+ case "inference.inference.EpochParamsV1.poc_stage_duration":
+ panic(fmt.Errorf("field poc_stage_duration of message inference.inference.EpochParamsV1 is not mutable"))
+ case "inference.inference.EpochParamsV1.poc_exchange_duration":
+ panic(fmt.Errorf("field poc_exchange_duration of message inference.inference.EpochParamsV1 is not mutable"))
+ case "inference.inference.EpochParamsV1.poc_validation_delay":
+ panic(fmt.Errorf("field poc_validation_delay of message inference.inference.EpochParamsV1 is not mutable"))
+ case "inference.inference.EpochParamsV1.poc_validation_duration":
+ panic(fmt.Errorf("field poc_validation_duration of message inference.inference.EpochParamsV1 is not mutable"))
+ case "inference.inference.EpochParamsV1.set_new_validators_delay":
+ panic(fmt.Errorf("field set_new_validators_delay of message inference.inference.EpochParamsV1 is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.EpochParamsV1"))
+ }
+ panic(fmt.Errorf("message inference.inference.EpochParamsV1 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_EpochParamsV1) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.EpochParamsV1.epoch_length":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.EpochParamsV1.epoch_multiplier":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.EpochParamsV1.epoch_shift":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.EpochParamsV1.default_unit_of_compute_price":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.EpochParamsV1.poc_stage_duration":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.EpochParamsV1.poc_exchange_duration":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.EpochParamsV1.poc_validation_delay":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.EpochParamsV1.poc_validation_duration":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.EpochParamsV1.set_new_validators_delay":
+ return protoreflect.ValueOfInt64(int64(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.EpochParamsV1"))
+ }
+ panic(fmt.Errorf("message inference.inference.EpochParamsV1 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_EpochParamsV1) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.EpochParamsV1", 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_EpochParamsV1) 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_EpochParamsV1) 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_EpochParamsV1) 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_EpochParamsV1) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*EpochParamsV1)
+ 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.EpochLength != 0 {
+ n += 1 + runtime.Sov(uint64(x.EpochLength))
+ }
+ if x.EpochMultiplier != 0 {
+ n += 1 + runtime.Sov(uint64(x.EpochMultiplier))
+ }
+ if x.EpochShift != 0 {
+ n += 1 + runtime.Sov(uint64(x.EpochShift))
+ }
+ if x.DefaultUnitOfComputePrice != 0 {
+ n += 1 + runtime.Sov(uint64(x.DefaultUnitOfComputePrice))
+ }
+ if x.PocStageDuration != 0 {
+ n += 1 + runtime.Sov(uint64(x.PocStageDuration))
+ }
+ if x.PocExchangeDuration != 0 {
+ n += 1 + runtime.Sov(uint64(x.PocExchangeDuration))
+ }
+ if x.PocValidationDelay != 0 {
+ n += 1 + runtime.Sov(uint64(x.PocValidationDelay))
+ }
+ if x.PocValidationDuration != 0 {
+ n += 1 + runtime.Sov(uint64(x.PocValidationDuration))
+ }
+ if x.SetNewValidatorsDelay != 0 {
+ n += 1 + runtime.Sov(uint64(x.SetNewValidatorsDelay))
+ }
+ 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().(*EpochParamsV1)
+ 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.SetNewValidatorsDelay != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.SetNewValidatorsDelay))
+ i--
+ dAtA[i] = 0x48
+ }
+ if x.PocValidationDuration != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.PocValidationDuration))
+ i--
+ dAtA[i] = 0x40
+ }
+ if x.PocValidationDelay != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.PocValidationDelay))
+ i--
+ dAtA[i] = 0x38
+ }
+ if x.PocExchangeDuration != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.PocExchangeDuration))
+ i--
+ dAtA[i] = 0x30
+ }
+ if x.PocStageDuration != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.PocStageDuration))
+ i--
+ dAtA[i] = 0x28
+ }
+ if x.DefaultUnitOfComputePrice != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.DefaultUnitOfComputePrice))
+ i--
+ dAtA[i] = 0x20
+ }
+ if x.EpochShift != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochShift))
+ i--
+ dAtA[i] = 0x18
+ }
+ if x.EpochMultiplier != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochMultiplier))
+ i--
+ dAtA[i] = 0x10
+ }
+ if x.EpochLength != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochLength))
+ 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().(*EpochParamsV1)
+ 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: EpochParamsV1: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: EpochParamsV1: 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 EpochLength", wireType)
+ }
+ x.EpochLength = 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.EpochLength |= 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 EpochMultiplier", wireType)
+ }
+ x.EpochMultiplier = 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.EpochMultiplier |= 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 EpochShift", wireType)
+ }
+ x.EpochShift = 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.EpochShift |= 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 DefaultUnitOfComputePrice", wireType)
+ }
+ x.DefaultUnitOfComputePrice = 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.DefaultUnitOfComputePrice |= 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 PocStageDuration", wireType)
+ }
+ x.PocStageDuration = 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.PocStageDuration |= int64(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 PocExchangeDuration", wireType)
+ }
+ x.PocExchangeDuration = 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.PocExchangeDuration |= int64(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 PocValidationDelay", wireType)
+ }
+ x.PocValidationDelay = 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.PocValidationDelay |= int64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 8:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PocValidationDuration", wireType)
+ }
+ x.PocValidationDuration = 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.PocValidationDuration |= int64(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 SetNewValidatorsDelay", wireType)
+ }
+ x.SetNewValidatorsDelay = 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.SetNewValidatorsDelay |= 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_ValidationParamsV1 protoreflect.MessageDescriptor
+ fd_ValidationParamsV1_false_positive_rate protoreflect.FieldDescriptor
+ fd_ValidationParamsV1_min_ramp_up_measurements protoreflect.FieldDescriptor
+ fd_ValidationParamsV1_pass_value protoreflect.FieldDescriptor
+ fd_ValidationParamsV1_min_validation_average protoreflect.FieldDescriptor
+ fd_ValidationParamsV1_max_validation_average protoreflect.FieldDescriptor
+ fd_ValidationParamsV1_expiration_blocks protoreflect.FieldDescriptor
+ fd_ValidationParamsV1_epochs_to_max protoreflect.FieldDescriptor
+ fd_ValidationParamsV1_full_validation_traffic_cutoff protoreflect.FieldDescriptor
+ fd_ValidationParamsV1_min_validation_halfway protoreflect.FieldDescriptor
+ fd_ValidationParamsV1_min_validation_traffic_cutoff protoreflect.FieldDescriptor
+ fd_ValidationParamsV1_miss_percentage_cutoff protoreflect.FieldDescriptor
+ fd_ValidationParamsV1_miss_requests_penalty protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_paramsv1_proto_init()
+ md_ValidationParamsV1 = File_inference_inference_paramsv1_proto.Messages().ByName("ValidationParamsV1")
+ fd_ValidationParamsV1_false_positive_rate = md_ValidationParamsV1.Fields().ByName("false_positive_rate")
+ fd_ValidationParamsV1_min_ramp_up_measurements = md_ValidationParamsV1.Fields().ByName("min_ramp_up_measurements")
+ fd_ValidationParamsV1_pass_value = md_ValidationParamsV1.Fields().ByName("pass_value")
+ fd_ValidationParamsV1_min_validation_average = md_ValidationParamsV1.Fields().ByName("min_validation_average")
+ fd_ValidationParamsV1_max_validation_average = md_ValidationParamsV1.Fields().ByName("max_validation_average")
+ fd_ValidationParamsV1_expiration_blocks = md_ValidationParamsV1.Fields().ByName("expiration_blocks")
+ fd_ValidationParamsV1_epochs_to_max = md_ValidationParamsV1.Fields().ByName("epochs_to_max")
+ fd_ValidationParamsV1_full_validation_traffic_cutoff = md_ValidationParamsV1.Fields().ByName("full_validation_traffic_cutoff")
+ fd_ValidationParamsV1_min_validation_halfway = md_ValidationParamsV1.Fields().ByName("min_validation_halfway")
+ fd_ValidationParamsV1_min_validation_traffic_cutoff = md_ValidationParamsV1.Fields().ByName("min_validation_traffic_cutoff")
+ fd_ValidationParamsV1_miss_percentage_cutoff = md_ValidationParamsV1.Fields().ByName("miss_percentage_cutoff")
+ fd_ValidationParamsV1_miss_requests_penalty = md_ValidationParamsV1.Fields().ByName("miss_requests_penalty")
+}
+
+var _ protoreflect.Message = (*fastReflection_ValidationParamsV1)(nil)
+
+type fastReflection_ValidationParamsV1 ValidationParamsV1
+
+func (x *ValidationParamsV1) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_ValidationParamsV1)(x)
+}
+
+func (x *ValidationParamsV1) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_paramsv1_proto_msgTypes[3]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_ValidationParamsV1_messageType fastReflection_ValidationParamsV1_messageType
+var _ protoreflect.MessageType = fastReflection_ValidationParamsV1_messageType{}
+
+type fastReflection_ValidationParamsV1_messageType struct{}
+
+func (x fastReflection_ValidationParamsV1_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_ValidationParamsV1)(nil)
+}
+func (x fastReflection_ValidationParamsV1_messageType) New() protoreflect.Message {
+ return new(fastReflection_ValidationParamsV1)
+}
+func (x fastReflection_ValidationParamsV1_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_ValidationParamsV1
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_ValidationParamsV1) Descriptor() protoreflect.MessageDescriptor {
+ return md_ValidationParamsV1
+}
+
+// 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_ValidationParamsV1) Type() protoreflect.MessageType {
+ return _fastReflection_ValidationParamsV1_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_ValidationParamsV1) New() protoreflect.Message {
+ return new(fastReflection_ValidationParamsV1)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_ValidationParamsV1) Interface() protoreflect.ProtoMessage {
+ return (*ValidationParamsV1)(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_ValidationParamsV1) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.FalsePositiveRate != float64(0) || math.Signbit(x.FalsePositiveRate) {
+ value := protoreflect.ValueOfFloat64(x.FalsePositiveRate)
+ if !f(fd_ValidationParamsV1_false_positive_rate, value) {
+ return
+ }
+ }
+ if x.MinRampUpMeasurements != uint32(0) {
+ value := protoreflect.ValueOfUint32(x.MinRampUpMeasurements)
+ if !f(fd_ValidationParamsV1_min_ramp_up_measurements, value) {
+ return
+ }
+ }
+ if x.PassValue != float64(0) || math.Signbit(x.PassValue) {
+ value := protoreflect.ValueOfFloat64(x.PassValue)
+ if !f(fd_ValidationParamsV1_pass_value, value) {
+ return
+ }
+ }
+ if x.MinValidationAverage != float64(0) || math.Signbit(x.MinValidationAverage) {
+ value := protoreflect.ValueOfFloat64(x.MinValidationAverage)
+ if !f(fd_ValidationParamsV1_min_validation_average, value) {
+ return
+ }
+ }
+ if x.MaxValidationAverage != float64(0) || math.Signbit(x.MaxValidationAverage) {
+ value := protoreflect.ValueOfFloat64(x.MaxValidationAverage)
+ if !f(fd_ValidationParamsV1_max_validation_average, value) {
+ return
+ }
+ }
+ if x.ExpirationBlocks != int64(0) {
+ value := protoreflect.ValueOfInt64(x.ExpirationBlocks)
+ if !f(fd_ValidationParamsV1_expiration_blocks, value) {
+ return
+ }
+ }
+ if x.EpochsToMax != int64(0) {
+ value := protoreflect.ValueOfInt64(x.EpochsToMax)
+ if !f(fd_ValidationParamsV1_epochs_to_max, value) {
+ return
+ }
+ }
+ if x.FullValidationTrafficCutoff != int64(0) {
+ value := protoreflect.ValueOfInt64(x.FullValidationTrafficCutoff)
+ if !f(fd_ValidationParamsV1_full_validation_traffic_cutoff, value) {
+ return
+ }
+ }
+ if x.MinValidationHalfway != float64(0) || math.Signbit(x.MinValidationHalfway) {
+ value := protoreflect.ValueOfFloat64(x.MinValidationHalfway)
+ if !f(fd_ValidationParamsV1_min_validation_halfway, value) {
+ return
+ }
+ }
+ if x.MinValidationTrafficCutoff != int64(0) {
+ value := protoreflect.ValueOfInt64(x.MinValidationTrafficCutoff)
+ if !f(fd_ValidationParamsV1_min_validation_traffic_cutoff, value) {
+ return
+ }
+ }
+ if x.MissPercentageCutoff != float64(0) || math.Signbit(x.MissPercentageCutoff) {
+ value := protoreflect.ValueOfFloat64(x.MissPercentageCutoff)
+ if !f(fd_ValidationParamsV1_miss_percentage_cutoff, value) {
+ return
+ }
+ }
+ if x.MissRequestsPenalty != float64(0) || math.Signbit(x.MissRequestsPenalty) {
+ value := protoreflect.ValueOfFloat64(x.MissRequestsPenalty)
+ if !f(fd_ValidationParamsV1_miss_requests_penalty, 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_ValidationParamsV1) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.ValidationParamsV1.false_positive_rate":
+ return x.FalsePositiveRate != float64(0) || math.Signbit(x.FalsePositiveRate)
+ case "inference.inference.ValidationParamsV1.min_ramp_up_measurements":
+ return x.MinRampUpMeasurements != uint32(0)
+ case "inference.inference.ValidationParamsV1.pass_value":
+ return x.PassValue != float64(0) || math.Signbit(x.PassValue)
+ case "inference.inference.ValidationParamsV1.min_validation_average":
+ return x.MinValidationAverage != float64(0) || math.Signbit(x.MinValidationAverage)
+ case "inference.inference.ValidationParamsV1.max_validation_average":
+ return x.MaxValidationAverage != float64(0) || math.Signbit(x.MaxValidationAverage)
+ case "inference.inference.ValidationParamsV1.expiration_blocks":
+ return x.ExpirationBlocks != int64(0)
+ case "inference.inference.ValidationParamsV1.epochs_to_max":
+ return x.EpochsToMax != int64(0)
+ case "inference.inference.ValidationParamsV1.full_validation_traffic_cutoff":
+ return x.FullValidationTrafficCutoff != int64(0)
+ case "inference.inference.ValidationParamsV1.min_validation_halfway":
+ return x.MinValidationHalfway != float64(0) || math.Signbit(x.MinValidationHalfway)
+ case "inference.inference.ValidationParamsV1.min_validation_traffic_cutoff":
+ return x.MinValidationTrafficCutoff != int64(0)
+ case "inference.inference.ValidationParamsV1.miss_percentage_cutoff":
+ return x.MissPercentageCutoff != float64(0) || math.Signbit(x.MissPercentageCutoff)
+ case "inference.inference.ValidationParamsV1.miss_requests_penalty":
+ return x.MissRequestsPenalty != float64(0) || math.Signbit(x.MissRequestsPenalty)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ValidationParamsV1"))
+ }
+ panic(fmt.Errorf("message inference.inference.ValidationParamsV1 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_ValidationParamsV1) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.ValidationParamsV1.false_positive_rate":
+ x.FalsePositiveRate = float64(0)
+ case "inference.inference.ValidationParamsV1.min_ramp_up_measurements":
+ x.MinRampUpMeasurements = uint32(0)
+ case "inference.inference.ValidationParamsV1.pass_value":
+ x.PassValue = float64(0)
+ case "inference.inference.ValidationParamsV1.min_validation_average":
+ x.MinValidationAverage = float64(0)
+ case "inference.inference.ValidationParamsV1.max_validation_average":
+ x.MaxValidationAverage = float64(0)
+ case "inference.inference.ValidationParamsV1.expiration_blocks":
+ x.ExpirationBlocks = int64(0)
+ case "inference.inference.ValidationParamsV1.epochs_to_max":
+ x.EpochsToMax = int64(0)
+ case "inference.inference.ValidationParamsV1.full_validation_traffic_cutoff":
+ x.FullValidationTrafficCutoff = int64(0)
+ case "inference.inference.ValidationParamsV1.min_validation_halfway":
+ x.MinValidationHalfway = float64(0)
+ case "inference.inference.ValidationParamsV1.min_validation_traffic_cutoff":
+ x.MinValidationTrafficCutoff = int64(0)
+ case "inference.inference.ValidationParamsV1.miss_percentage_cutoff":
+ x.MissPercentageCutoff = float64(0)
+ case "inference.inference.ValidationParamsV1.miss_requests_penalty":
+ x.MissRequestsPenalty = float64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ValidationParamsV1"))
+ }
+ panic(fmt.Errorf("message inference.inference.ValidationParamsV1 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_ValidationParamsV1) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.ValidationParamsV1.false_positive_rate":
+ value := x.FalsePositiveRate
+ return protoreflect.ValueOfFloat64(value)
+ case "inference.inference.ValidationParamsV1.min_ramp_up_measurements":
+ value := x.MinRampUpMeasurements
+ return protoreflect.ValueOfUint32(value)
+ case "inference.inference.ValidationParamsV1.pass_value":
+ value := x.PassValue
+ return protoreflect.ValueOfFloat64(value)
+ case "inference.inference.ValidationParamsV1.min_validation_average":
+ value := x.MinValidationAverage
+ return protoreflect.ValueOfFloat64(value)
+ case "inference.inference.ValidationParamsV1.max_validation_average":
+ value := x.MaxValidationAverage
+ return protoreflect.ValueOfFloat64(value)
+ case "inference.inference.ValidationParamsV1.expiration_blocks":
+ value := x.ExpirationBlocks
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.ValidationParamsV1.epochs_to_max":
+ value := x.EpochsToMax
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.ValidationParamsV1.full_validation_traffic_cutoff":
+ value := x.FullValidationTrafficCutoff
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.ValidationParamsV1.min_validation_halfway":
+ value := x.MinValidationHalfway
+ return protoreflect.ValueOfFloat64(value)
+ case "inference.inference.ValidationParamsV1.min_validation_traffic_cutoff":
+ value := x.MinValidationTrafficCutoff
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.ValidationParamsV1.miss_percentage_cutoff":
+ value := x.MissPercentageCutoff
+ return protoreflect.ValueOfFloat64(value)
+ case "inference.inference.ValidationParamsV1.miss_requests_penalty":
+ value := x.MissRequestsPenalty
+ return protoreflect.ValueOfFloat64(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ValidationParamsV1"))
+ }
+ panic(fmt.Errorf("message inference.inference.ValidationParamsV1 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_ValidationParamsV1) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.ValidationParamsV1.false_positive_rate":
+ x.FalsePositiveRate = value.Float()
+ case "inference.inference.ValidationParamsV1.min_ramp_up_measurements":
+ x.MinRampUpMeasurements = uint32(value.Uint())
+ case "inference.inference.ValidationParamsV1.pass_value":
+ x.PassValue = value.Float()
+ case "inference.inference.ValidationParamsV1.min_validation_average":
+ x.MinValidationAverage = value.Float()
+ case "inference.inference.ValidationParamsV1.max_validation_average":
+ x.MaxValidationAverage = value.Float()
+ case "inference.inference.ValidationParamsV1.expiration_blocks":
+ x.ExpirationBlocks = value.Int()
+ case "inference.inference.ValidationParamsV1.epochs_to_max":
+ x.EpochsToMax = value.Int()
+ case "inference.inference.ValidationParamsV1.full_validation_traffic_cutoff":
+ x.FullValidationTrafficCutoff = value.Int()
+ case "inference.inference.ValidationParamsV1.min_validation_halfway":
+ x.MinValidationHalfway = value.Float()
+ case "inference.inference.ValidationParamsV1.min_validation_traffic_cutoff":
+ x.MinValidationTrafficCutoff = value.Int()
+ case "inference.inference.ValidationParamsV1.miss_percentage_cutoff":
+ x.MissPercentageCutoff = value.Float()
+ case "inference.inference.ValidationParamsV1.miss_requests_penalty":
+ x.MissRequestsPenalty = value.Float()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ValidationParamsV1"))
+ }
+ panic(fmt.Errorf("message inference.inference.ValidationParamsV1 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_ValidationParamsV1) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.ValidationParamsV1.false_positive_rate":
+ panic(fmt.Errorf("field false_positive_rate of message inference.inference.ValidationParamsV1 is not mutable"))
+ case "inference.inference.ValidationParamsV1.min_ramp_up_measurements":
+ panic(fmt.Errorf("field min_ramp_up_measurements of message inference.inference.ValidationParamsV1 is not mutable"))
+ case "inference.inference.ValidationParamsV1.pass_value":
+ panic(fmt.Errorf("field pass_value of message inference.inference.ValidationParamsV1 is not mutable"))
+ case "inference.inference.ValidationParamsV1.min_validation_average":
+ panic(fmt.Errorf("field min_validation_average of message inference.inference.ValidationParamsV1 is not mutable"))
+ case "inference.inference.ValidationParamsV1.max_validation_average":
+ panic(fmt.Errorf("field max_validation_average of message inference.inference.ValidationParamsV1 is not mutable"))
+ case "inference.inference.ValidationParamsV1.expiration_blocks":
+ panic(fmt.Errorf("field expiration_blocks of message inference.inference.ValidationParamsV1 is not mutable"))
+ case "inference.inference.ValidationParamsV1.epochs_to_max":
+ panic(fmt.Errorf("field epochs_to_max of message inference.inference.ValidationParamsV1 is not mutable"))
+ case "inference.inference.ValidationParamsV1.full_validation_traffic_cutoff":
+ panic(fmt.Errorf("field full_validation_traffic_cutoff of message inference.inference.ValidationParamsV1 is not mutable"))
+ case "inference.inference.ValidationParamsV1.min_validation_halfway":
+ panic(fmt.Errorf("field min_validation_halfway of message inference.inference.ValidationParamsV1 is not mutable"))
+ case "inference.inference.ValidationParamsV1.min_validation_traffic_cutoff":
+ panic(fmt.Errorf("field min_validation_traffic_cutoff of message inference.inference.ValidationParamsV1 is not mutable"))
+ case "inference.inference.ValidationParamsV1.miss_percentage_cutoff":
+ panic(fmt.Errorf("field miss_percentage_cutoff of message inference.inference.ValidationParamsV1 is not mutable"))
+ case "inference.inference.ValidationParamsV1.miss_requests_penalty":
+ panic(fmt.Errorf("field miss_requests_penalty of message inference.inference.ValidationParamsV1 is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ValidationParamsV1"))
+ }
+ panic(fmt.Errorf("message inference.inference.ValidationParamsV1 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_ValidationParamsV1) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.ValidationParamsV1.false_positive_rate":
+ return protoreflect.ValueOfFloat64(float64(0))
+ case "inference.inference.ValidationParamsV1.min_ramp_up_measurements":
+ return protoreflect.ValueOfUint32(uint32(0))
+ case "inference.inference.ValidationParamsV1.pass_value":
+ return protoreflect.ValueOfFloat64(float64(0))
+ case "inference.inference.ValidationParamsV1.min_validation_average":
+ return protoreflect.ValueOfFloat64(float64(0))
+ case "inference.inference.ValidationParamsV1.max_validation_average":
+ return protoreflect.ValueOfFloat64(float64(0))
+ case "inference.inference.ValidationParamsV1.expiration_blocks":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.ValidationParamsV1.epochs_to_max":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.ValidationParamsV1.full_validation_traffic_cutoff":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.ValidationParamsV1.min_validation_halfway":
+ return protoreflect.ValueOfFloat64(float64(0))
+ case "inference.inference.ValidationParamsV1.min_validation_traffic_cutoff":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.ValidationParamsV1.miss_percentage_cutoff":
+ return protoreflect.ValueOfFloat64(float64(0))
+ case "inference.inference.ValidationParamsV1.miss_requests_penalty":
+ return protoreflect.ValueOfFloat64(float64(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ValidationParamsV1"))
+ }
+ panic(fmt.Errorf("message inference.inference.ValidationParamsV1 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_ValidationParamsV1) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.ValidationParamsV1", 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_ValidationParamsV1) 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_ValidationParamsV1) 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_ValidationParamsV1) 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_ValidationParamsV1) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*ValidationParamsV1)
+ 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.FalsePositiveRate != 0 || math.Signbit(x.FalsePositiveRate) {
+ n += 9
+ }
+ if x.MinRampUpMeasurements != 0 {
+ n += 1 + runtime.Sov(uint64(x.MinRampUpMeasurements))
+ }
+ if x.PassValue != 0 || math.Signbit(x.PassValue) {
+ n += 9
+ }
+ if x.MinValidationAverage != 0 || math.Signbit(x.MinValidationAverage) {
+ n += 9
+ }
+ if x.MaxValidationAverage != 0 || math.Signbit(x.MaxValidationAverage) {
+ n += 9
+ }
+ if x.ExpirationBlocks != 0 {
+ n += 1 + runtime.Sov(uint64(x.ExpirationBlocks))
+ }
+ if x.EpochsToMax != 0 {
+ n += 1 + runtime.Sov(uint64(x.EpochsToMax))
+ }
+ if x.FullValidationTrafficCutoff != 0 {
+ n += 1 + runtime.Sov(uint64(x.FullValidationTrafficCutoff))
+ }
+ if x.MinValidationHalfway != 0 || math.Signbit(x.MinValidationHalfway) {
+ n += 9
+ }
+ if x.MinValidationTrafficCutoff != 0 {
+ n += 1 + runtime.Sov(uint64(x.MinValidationTrafficCutoff))
+ }
+ if x.MissPercentageCutoff != 0 || math.Signbit(x.MissPercentageCutoff) {
+ n += 9
+ }
+ if x.MissRequestsPenalty != 0 || math.Signbit(x.MissRequestsPenalty) {
+ n += 9
+ }
+ 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().(*ValidationParamsV1)
+ 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.MissRequestsPenalty != 0 || math.Signbit(x.MissRequestsPenalty) {
+ i -= 8
+ binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(x.MissRequestsPenalty))))
+ i--
+ dAtA[i] = 0x61
+ }
+ if x.MissPercentageCutoff != 0 || math.Signbit(x.MissPercentageCutoff) {
+ i -= 8
+ binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(x.MissPercentageCutoff))))
+ i--
+ dAtA[i] = 0x59
+ }
+ if x.MinValidationTrafficCutoff != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.MinValidationTrafficCutoff))
+ i--
+ dAtA[i] = 0x50
+ }
+ if x.MinValidationHalfway != 0 || math.Signbit(x.MinValidationHalfway) {
+ i -= 8
+ binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(x.MinValidationHalfway))))
+ i--
+ dAtA[i] = 0x49
+ }
+ if x.FullValidationTrafficCutoff != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.FullValidationTrafficCutoff))
+ i--
+ dAtA[i] = 0x40
+ }
+ if x.EpochsToMax != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochsToMax))
+ i--
+ dAtA[i] = 0x38
+ }
+ if x.ExpirationBlocks != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.ExpirationBlocks))
+ i--
+ dAtA[i] = 0x30
+ }
+ if x.MaxValidationAverage != 0 || math.Signbit(x.MaxValidationAverage) {
+ i -= 8
+ binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(x.MaxValidationAverage))))
+ i--
+ dAtA[i] = 0x29
+ }
+ if x.MinValidationAverage != 0 || math.Signbit(x.MinValidationAverage) {
+ i -= 8
+ binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(x.MinValidationAverage))))
+ i--
+ dAtA[i] = 0x21
+ }
+ if x.PassValue != 0 || math.Signbit(x.PassValue) {
+ i -= 8
+ binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(x.PassValue))))
+ i--
+ dAtA[i] = 0x19
+ }
+ if x.MinRampUpMeasurements != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.MinRampUpMeasurements))
+ i--
+ dAtA[i] = 0x10
+ }
+ if x.FalsePositiveRate != 0 || math.Signbit(x.FalsePositiveRate) {
+ i -= 8
+ binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(x.FalsePositiveRate))))
+ i--
+ dAtA[i] = 0x9
+ }
+ 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().(*ValidationParamsV1)
+ 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: ValidationParamsV1: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ValidationParamsV1: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 1 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field FalsePositiveRate", wireType)
+ }
+ 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
+ x.FalsePositiveRate = float64(math.Float64frombits(v))
+ case 2:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MinRampUpMeasurements", wireType)
+ }
+ x.MinRampUpMeasurements = 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.MinRampUpMeasurements |= uint32(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 3:
+ if wireType != 1 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PassValue", wireType)
+ }
+ 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
+ x.PassValue = float64(math.Float64frombits(v))
+ case 4:
+ if wireType != 1 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MinValidationAverage", wireType)
+ }
+ 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
+ x.MinValidationAverage = float64(math.Float64frombits(v))
+ case 5:
+ if wireType != 1 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MaxValidationAverage", wireType)
+ }
+ 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
+ x.MaxValidationAverage = float64(math.Float64frombits(v))
+ case 6:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ExpirationBlocks", wireType)
+ }
+ x.ExpirationBlocks = 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.ExpirationBlocks |= int64(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 EpochsToMax", wireType)
+ }
+ x.EpochsToMax = 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.EpochsToMax |= int64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 8:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field FullValidationTrafficCutoff", wireType)
+ }
+ x.FullValidationTrafficCutoff = 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.FullValidationTrafficCutoff |= int64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 9:
+ if wireType != 1 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MinValidationHalfway", wireType)
+ }
+ 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
+ x.MinValidationHalfway = float64(math.Float64frombits(v))
+ case 10:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MinValidationTrafficCutoff", wireType)
+ }
+ x.MinValidationTrafficCutoff = 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.MinValidationTrafficCutoff |= int64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 11:
+ if wireType != 1 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MissPercentageCutoff", wireType)
+ }
+ 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
+ x.MissPercentageCutoff = float64(math.Float64frombits(v))
+ case 12:
+ if wireType != 1 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MissRequestsPenalty", wireType)
+ }
+ 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
+ x.MissRequestsPenalty = float64(math.Float64frombits(v))
+ 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_PocParamsV1 protoreflect.MessageDescriptor
+ fd_PocParamsV1_default_difficulty protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_paramsv1_proto_init()
+ md_PocParamsV1 = File_inference_inference_paramsv1_proto.Messages().ByName("PocParamsV1")
+ fd_PocParamsV1_default_difficulty = md_PocParamsV1.Fields().ByName("default_difficulty")
+}
+
+var _ protoreflect.Message = (*fastReflection_PocParamsV1)(nil)
+
+type fastReflection_PocParamsV1 PocParamsV1
+
+func (x *PocParamsV1) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_PocParamsV1)(x)
+}
+
+func (x *PocParamsV1) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_paramsv1_proto_msgTypes[4]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_PocParamsV1_messageType fastReflection_PocParamsV1_messageType
+var _ protoreflect.MessageType = fastReflection_PocParamsV1_messageType{}
+
+type fastReflection_PocParamsV1_messageType struct{}
+
+func (x fastReflection_PocParamsV1_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_PocParamsV1)(nil)
+}
+func (x fastReflection_PocParamsV1_messageType) New() protoreflect.Message {
+ return new(fastReflection_PocParamsV1)
+}
+func (x fastReflection_PocParamsV1_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_PocParamsV1
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_PocParamsV1) Descriptor() protoreflect.MessageDescriptor {
+ return md_PocParamsV1
+}
+
+// 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_PocParamsV1) Type() protoreflect.MessageType {
+ return _fastReflection_PocParamsV1_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_PocParamsV1) New() protoreflect.Message {
+ return new(fastReflection_PocParamsV1)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_PocParamsV1) Interface() protoreflect.ProtoMessage {
+ return (*PocParamsV1)(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_PocParamsV1) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.DefaultDifficulty != uint32(0) {
+ value := protoreflect.ValueOfUint32(x.DefaultDifficulty)
+ if !f(fd_PocParamsV1_default_difficulty, 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_PocParamsV1) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.PocParamsV1.default_difficulty":
+ return x.DefaultDifficulty != uint32(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PocParamsV1"))
+ }
+ panic(fmt.Errorf("message inference.inference.PocParamsV1 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_PocParamsV1) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.PocParamsV1.default_difficulty":
+ x.DefaultDifficulty = uint32(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PocParamsV1"))
+ }
+ panic(fmt.Errorf("message inference.inference.PocParamsV1 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_PocParamsV1) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.PocParamsV1.default_difficulty":
+ value := x.DefaultDifficulty
+ return protoreflect.ValueOfUint32(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PocParamsV1"))
+ }
+ panic(fmt.Errorf("message inference.inference.PocParamsV1 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_PocParamsV1) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.PocParamsV1.default_difficulty":
+ x.DefaultDifficulty = uint32(value.Uint())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PocParamsV1"))
+ }
+ panic(fmt.Errorf("message inference.inference.PocParamsV1 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_PocParamsV1) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.PocParamsV1.default_difficulty":
+ panic(fmt.Errorf("field default_difficulty of message inference.inference.PocParamsV1 is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PocParamsV1"))
+ }
+ panic(fmt.Errorf("message inference.inference.PocParamsV1 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_PocParamsV1) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.PocParamsV1.default_difficulty":
+ return protoreflect.ValueOfUint32(uint32(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PocParamsV1"))
+ }
+ panic(fmt.Errorf("message inference.inference.PocParamsV1 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_PocParamsV1) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.PocParamsV1", 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_PocParamsV1) 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_PocParamsV1) 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_PocParamsV1) 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_PocParamsV1) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*PocParamsV1)
+ 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.DefaultDifficulty != 0 {
+ n += 1 + runtime.Sov(uint64(x.DefaultDifficulty))
+ }
+ 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().(*PocParamsV1)
+ 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.DefaultDifficulty != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.DefaultDifficulty))
+ 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().(*PocParamsV1)
+ 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: PocParamsV1: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: PocParamsV1: 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 DefaultDifficulty", wireType)
+ }
+ x.DefaultDifficulty = 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.DefaultDifficulty |= 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
+ }
+ }
+
+ 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/paramsv1.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)
+)
+
+// Params defines the parameters for the module.
+type ParamsV1 struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ EpochParams *EpochParamsV1 `protobuf:"bytes,1,opt,name=epoch_params,json=epochParams,proto3" json:"epoch_params,omitempty"`
+ ValidationParams *ValidationParamsV1 `protobuf:"bytes,2,opt,name=validation_params,json=validationParams,proto3" json:"validation_params,omitempty"`
+ PocParams *PocParamsV1 `protobuf:"bytes,3,opt,name=poc_params,json=pocParams,proto3" json:"poc_params,omitempty"`
+ TokenomicsParams *TokenomicsParamsV1 `protobuf:"bytes,4,opt,name=tokenomics_params,json=tokenomicsParams,proto3" json:"tokenomics_params,omitempty"`
+}
+
+func (x *ParamsV1) Reset() {
+ *x = ParamsV1{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_paramsv1_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *ParamsV1) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ParamsV1) ProtoMessage() {}
+
+// Deprecated: Use ParamsV1.ProtoReflect.Descriptor instead.
+func (*ParamsV1) Descriptor() ([]byte, []int) {
+ return file_inference_inference_paramsv1_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *ParamsV1) GetEpochParams() *EpochParamsV1 {
+ if x != nil {
+ return x.EpochParams
+ }
+ return nil
+}
+
+func (x *ParamsV1) GetValidationParams() *ValidationParamsV1 {
+ if x != nil {
+ return x.ValidationParams
+ }
+ return nil
+}
+
+func (x *ParamsV1) GetPocParams() *PocParamsV1 {
+ if x != nil {
+ return x.PocParams
+ }
+ return nil
+}
+
+func (x *ParamsV1) GetTokenomicsParams() *TokenomicsParamsV1 {
+ if x != nil {
+ return x.TokenomicsParams
+ }
+ return nil
+}
+
+type TokenomicsParamsV1 struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ SubsidyReductionInterval float64 `protobuf:"fixed64,1,opt,name=subsidy_reduction_interval,json=subsidyReductionInterval,proto3" json:"subsidy_reduction_interval,omitempty"`
+ SubsidyReductionAmount float32 `protobuf:"fixed32,2,opt,name=subsidy_reduction_amount,json=subsidyReductionAmount,proto3" json:"subsidy_reduction_amount,omitempty"`
+ CurrentSubsidyPercentage float32 `protobuf:"fixed32,3,opt,name=current_subsidy_percentage,json=currentSubsidyPercentage,proto3" json:"current_subsidy_percentage,omitempty"`
+ TopRewardAllowedFailure float32 `protobuf:"fixed32,4,opt,name=top_reward_allowed_failure,json=topRewardAllowedFailure,proto3" json:"top_reward_allowed_failure,omitempty"`
+ TopMinerPocQualification int64 `protobuf:"varint,5,opt,name=top_miner_poc_qualification,json=topMinerPocQualification,proto3" json:"top_miner_poc_qualification,omitempty"`
+}
+
+func (x *TokenomicsParamsV1) Reset() {
+ *x = TokenomicsParamsV1{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_paramsv1_proto_msgTypes[1]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *TokenomicsParamsV1) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TokenomicsParamsV1) ProtoMessage() {}
+
+// Deprecated: Use TokenomicsParamsV1.ProtoReflect.Descriptor instead.
+func (*TokenomicsParamsV1) Descriptor() ([]byte, []int) {
+ return file_inference_inference_paramsv1_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *TokenomicsParamsV1) GetSubsidyReductionInterval() float64 {
+ if x != nil {
+ return x.SubsidyReductionInterval
+ }
+ return 0
+}
+
+func (x *TokenomicsParamsV1) GetSubsidyReductionAmount() float32 {
+ if x != nil {
+ return x.SubsidyReductionAmount
+ }
+ return 0
+}
+
+func (x *TokenomicsParamsV1) GetCurrentSubsidyPercentage() float32 {
+ if x != nil {
+ return x.CurrentSubsidyPercentage
+ }
+ return 0
+}
+
+func (x *TokenomicsParamsV1) GetTopRewardAllowedFailure() float32 {
+ if x != nil {
+ return x.TopRewardAllowedFailure
+ }
+ return 0
+}
+
+func (x *TokenomicsParamsV1) GetTopMinerPocQualification() int64 {
+ if x != nil {
+ return x.TopMinerPocQualification
+ }
+ return 0
+}
+
+type EpochParamsV1 struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ EpochLength int64 `protobuf:"varint,1,opt,name=epoch_length,json=epochLength,proto3" json:"epoch_length,omitempty"`
+ EpochMultiplier int64 `protobuf:"varint,2,opt,name=epoch_multiplier,json=epochMultiplier,proto3" json:"epoch_multiplier,omitempty"`
+ EpochShift int64 `protobuf:"varint,3,opt,name=epoch_shift,json=epochShift,proto3" json:"epoch_shift,omitempty"`
+ DefaultUnitOfComputePrice uint64 `protobuf:"varint,4,opt,name=default_unit_of_compute_price,json=defaultUnitOfComputePrice,proto3" json:"default_unit_of_compute_price,omitempty"`
+ PocStageDuration int64 `protobuf:"varint,5,opt,name=poc_stage_duration,json=pocStageDuration,proto3" json:"poc_stage_duration,omitempty"`
+ PocExchangeDuration int64 `protobuf:"varint,6,opt,name=poc_exchange_duration,json=pocExchangeDuration,proto3" json:"poc_exchange_duration,omitempty"`
+ PocValidationDelay int64 `protobuf:"varint,7,opt,name=poc_validation_delay,json=pocValidationDelay,proto3" json:"poc_validation_delay,omitempty"`
+ PocValidationDuration int64 `protobuf:"varint,8,opt,name=poc_validation_duration,json=pocValidationDuration,proto3" json:"poc_validation_duration,omitempty"`
+ SetNewValidatorsDelay int64 `protobuf:"varint,9,opt,name=set_new_validators_delay,json=setNewValidatorsDelay,proto3" json:"set_new_validators_delay,omitempty"`
+}
+
+func (x *EpochParamsV1) Reset() {
+ *x = EpochParamsV1{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_paramsv1_proto_msgTypes[2]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *EpochParamsV1) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*EpochParamsV1) ProtoMessage() {}
+
+// Deprecated: Use EpochParamsV1.ProtoReflect.Descriptor instead.
+func (*EpochParamsV1) Descriptor() ([]byte, []int) {
+ return file_inference_inference_paramsv1_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *EpochParamsV1) GetEpochLength() int64 {
+ if x != nil {
+ return x.EpochLength
+ }
+ return 0
+}
+
+func (x *EpochParamsV1) GetEpochMultiplier() int64 {
+ if x != nil {
+ return x.EpochMultiplier
+ }
+ return 0
+}
+
+func (x *EpochParamsV1) GetEpochShift() int64 {
+ if x != nil {
+ return x.EpochShift
+ }
+ return 0
+}
+
+func (x *EpochParamsV1) GetDefaultUnitOfComputePrice() uint64 {
+ if x != nil {
+ return x.DefaultUnitOfComputePrice
+ }
+ return 0
+}
+
+func (x *EpochParamsV1) GetPocStageDuration() int64 {
+ if x != nil {
+ return x.PocStageDuration
+ }
+ return 0
+}
+
+func (x *EpochParamsV1) GetPocExchangeDuration() int64 {
+ if x != nil {
+ return x.PocExchangeDuration
+ }
+ return 0
+}
+
+func (x *EpochParamsV1) GetPocValidationDelay() int64 {
+ if x != nil {
+ return x.PocValidationDelay
+ }
+ return 0
+}
+
+func (x *EpochParamsV1) GetPocValidationDuration() int64 {
+ if x != nil {
+ return x.PocValidationDuration
+ }
+ return 0
+}
+
+func (x *EpochParamsV1) GetSetNewValidatorsDelay() int64 {
+ if x != nil {
+ return x.SetNewValidatorsDelay
+ }
+ return 0
+}
+
+type ValidationParamsV1 struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ FalsePositiveRate float64 `protobuf:"fixed64,1,opt,name=false_positive_rate,json=falsePositiveRate,proto3" json:"false_positive_rate,omitempty"`
+ MinRampUpMeasurements uint32 `protobuf:"varint,2,opt,name=min_ramp_up_measurements,json=minRampUpMeasurements,proto3" json:"min_ramp_up_measurements,omitempty"`
+ PassValue float64 `protobuf:"fixed64,3,opt,name=pass_value,json=passValue,proto3" json:"pass_value,omitempty"`
+ MinValidationAverage float64 `protobuf:"fixed64,4,opt,name=min_validation_average,json=minValidationAverage,proto3" json:"min_validation_average,omitempty"`
+ MaxValidationAverage float64 `protobuf:"fixed64,5,opt,name=max_validation_average,json=maxValidationAverage,proto3" json:"max_validation_average,omitempty"`
+ ExpirationBlocks int64 `protobuf:"varint,6,opt,name=expiration_blocks,json=expirationBlocks,proto3" json:"expiration_blocks,omitempty"`
+ EpochsToMax int64 `protobuf:"varint,7,opt,name=epochs_to_max,json=epochsToMax,proto3" json:"epochs_to_max,omitempty"`
+ FullValidationTrafficCutoff int64 `protobuf:"varint,8,opt,name=full_validation_traffic_cutoff,json=fullValidationTrafficCutoff,proto3" json:"full_validation_traffic_cutoff,omitempty"`
+ MinValidationHalfway float64 `protobuf:"fixed64,9,opt,name=min_validation_halfway,json=minValidationHalfway,proto3" json:"min_validation_halfway,omitempty"`
+ MinValidationTrafficCutoff int64 `protobuf:"varint,10,opt,name=min_validation_traffic_cutoff,json=minValidationTrafficCutoff,proto3" json:"min_validation_traffic_cutoff,omitempty"`
+ MissPercentageCutoff float64 `protobuf:"fixed64,11,opt,name=miss_percentage_cutoff,json=missPercentageCutoff,proto3" json:"miss_percentage_cutoff,omitempty"`
+ MissRequestsPenalty float64 `protobuf:"fixed64,12,opt,name=miss_requests_penalty,json=missRequestsPenalty,proto3" json:"miss_requests_penalty,omitempty"`
+}
+
+func (x *ValidationParamsV1) Reset() {
+ *x = ValidationParamsV1{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_paramsv1_proto_msgTypes[3]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *ValidationParamsV1) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ValidationParamsV1) ProtoMessage() {}
+
+// Deprecated: Use ValidationParamsV1.ProtoReflect.Descriptor instead.
+func (*ValidationParamsV1) Descriptor() ([]byte, []int) {
+ return file_inference_inference_paramsv1_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *ValidationParamsV1) GetFalsePositiveRate() float64 {
+ if x != nil {
+ return x.FalsePositiveRate
+ }
+ return 0
+}
+
+func (x *ValidationParamsV1) GetMinRampUpMeasurements() uint32 {
+ if x != nil {
+ return x.MinRampUpMeasurements
+ }
+ return 0
+}
+
+func (x *ValidationParamsV1) GetPassValue() float64 {
+ if x != nil {
+ return x.PassValue
+ }
+ return 0
+}
+
+func (x *ValidationParamsV1) GetMinValidationAverage() float64 {
+ if x != nil {
+ return x.MinValidationAverage
+ }
+ return 0
+}
+
+func (x *ValidationParamsV1) GetMaxValidationAverage() float64 {
+ if x != nil {
+ return x.MaxValidationAverage
+ }
+ return 0
+}
+
+func (x *ValidationParamsV1) GetExpirationBlocks() int64 {
+ if x != nil {
+ return x.ExpirationBlocks
+ }
+ return 0
+}
+
+func (x *ValidationParamsV1) GetEpochsToMax() int64 {
+ if x != nil {
+ return x.EpochsToMax
+ }
+ return 0
+}
+
+func (x *ValidationParamsV1) GetFullValidationTrafficCutoff() int64 {
+ if x != nil {
+ return x.FullValidationTrafficCutoff
+ }
+ return 0
+}
+
+func (x *ValidationParamsV1) GetMinValidationHalfway() float64 {
+ if x != nil {
+ return x.MinValidationHalfway
+ }
+ return 0
+}
+
+func (x *ValidationParamsV1) GetMinValidationTrafficCutoff() int64 {
+ if x != nil {
+ return x.MinValidationTrafficCutoff
+ }
+ return 0
+}
+
+func (x *ValidationParamsV1) GetMissPercentageCutoff() float64 {
+ if x != nil {
+ return x.MissPercentageCutoff
+ }
+ return 0
+}
+
+func (x *ValidationParamsV1) GetMissRequestsPenalty() float64 {
+ if x != nil {
+ return x.MissRequestsPenalty
+ }
+ return 0
+}
+
+type PocParamsV1 struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ DefaultDifficulty uint32 `protobuf:"varint,1,opt,name=default_difficulty,json=defaultDifficulty,proto3" json:"default_difficulty,omitempty"`
+}
+
+func (x *PocParamsV1) Reset() {
+ *x = PocParamsV1{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_paramsv1_proto_msgTypes[4]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *PocParamsV1) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*PocParamsV1) ProtoMessage() {}
+
+// Deprecated: Use PocParamsV1.ProtoReflect.Descriptor instead.
+func (*PocParamsV1) Descriptor() ([]byte, []int) {
+ return file_inference_inference_paramsv1_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *PocParamsV1) GetDefaultDifficulty() uint32 {
+ if x != nil {
+ return x.DefaultDifficulty
+ }
+ return 0
+}
+
+var File_inference_inference_paramsv1_proto protoreflect.FileDescriptor
+
+var file_inference_inference_paramsv1_proto_rawDesc = []byte{
+ 0x0a, 0x22, 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, 0x76, 0x31, 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, 0x1a, 0x11, 0x61, 0x6d, 0x69, 0x6e, 0x6f,
+ 0x2f, 0x61, 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, 0xe5, 0x02,
+ 0x0a, 0x08, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x56, 0x31, 0x12, 0x45, 0x0a, 0x0c, 0x65, 0x70,
+ 0x6f, 0x63, 0x68, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 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, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x61, 0x72, 0x61,
+ 0x6d, 0x73, 0x56, 0x31, 0x52, 0x0b, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x61, 0x72, 0x61, 0x6d,
+ 0x73, 0x12, 0x54, 0x0a, 0x11, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f,
+ 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 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, 0x56, 0x31, 0x52, 0x10, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f,
+ 0x6e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x3f, 0x0a, 0x0a, 0x70, 0x6f, 0x63, 0x5f, 0x70,
+ 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x03, 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, 0x6f, 0x63, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x56, 0x31, 0x52, 0x09, 0x70,
+ 0x6f, 0x63, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x54, 0x0a, 0x11, 0x74, 0x6f, 0x6b, 0x65,
+ 0x6e, 0x6f, 0x6d, 0x69, 0x63, 0x73, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x04, 0x20,
+ 0x01, 0x28, 0x0b, 0x32, 0x27, 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, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x56, 0x31, 0x52, 0x10, 0x74, 0x6f,
+ 0x6b, 0x65, 0x6e, 0x6f, 0x6d, 0x69, 0x63, 0x73, 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, 0x22, 0xcc, 0x02, 0x0a, 0x12, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x6f,
+ 0x6d, 0x69, 0x63, 0x73, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x56, 0x31, 0x12, 0x3c, 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, 0x01,
+ 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, 0x38, 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, 0x02, 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, 0x3c, 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, 0x02, 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, 0x3b, 0x0a, 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,
+ 0x18, 0x04, 0x20, 0x01, 0x28, 0x02, 0x52, 0x17, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x77, 0x61, 0x72,
+ 0x64, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x12,
+ 0x3d, 0x0a, 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, 0x18, 0x05,
+ 0x20, 0x01, 0x28, 0x03, 0x52, 0x18, 0x74, 0x6f, 0x70, 0x4d, 0x69, 0x6e, 0x65, 0x72, 0x50, 0x6f,
+ 0x63, 0x51, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3a, 0x04,
+ 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0xcb, 0x03, 0x0a, 0x0d, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x61,
+ 0x72, 0x61, 0x6d, 0x73, 0x56, 0x31, 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, 0x04, 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, 0x32, 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, 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, 0x3a, 0x04, 0xe8, 0xa0,
+ 0x1f, 0x01, 0x22, 0x87, 0x05, 0x0a, 0x12, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f,
+ 0x6e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x56, 0x31, 0x12, 0x2e, 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, 0x01, 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, 0x0d, 0x52, 0x15, 0x6d, 0x69, 0x6e,
+ 0x52, 0x61, 0x6d, 0x70, 0x55, 0x70, 0x4d, 0x65, 0x61, 0x73, 0x75, 0x72, 0x65, 0x6d, 0x65, 0x6e,
+ 0x74, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x70, 0x61, 0x73, 0x73, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65,
+ 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, 0x52, 0x09, 0x70, 0x61, 0x73, 0x73, 0x56, 0x61, 0x6c, 0x75,
+ 0x65, 0x12, 0x34, 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,
+ 0x01, 0x52, 0x14, 0x6d, 0x69, 0x6e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+ 0x41, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x12, 0x34, 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, 0x01, 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, 0x34, 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, 0x01, 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, 0x34, 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, 0x01, 0x52, 0x14, 0x6d, 0x69,
+ 0x73, 0x73, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x43, 0x75, 0x74, 0x6f,
+ 0x66, 0x66, 0x12, 0x32, 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,
+ 0x01, 0x52, 0x13, 0x6d, 0x69, 0x73, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x50,
+ 0x65, 0x6e, 0x61, 0x6c, 0x74, 0x79, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0x42, 0x0a, 0x0b,
+ 0x50, 0x6f, 0x63, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x56, 0x31, 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, 0x0d, 0x52, 0x11, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74,
+ 0x44, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01,
+ 0x42, 0xbb, 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, 0x0d, 0x50, 0x61,
+ 0x72, 0x61, 0x6d, 0x73, 0x76, 0x31, 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_paramsv1_proto_rawDescOnce sync.Once
+ file_inference_inference_paramsv1_proto_rawDescData = file_inference_inference_paramsv1_proto_rawDesc
+)
+
+func file_inference_inference_paramsv1_proto_rawDescGZIP() []byte {
+ file_inference_inference_paramsv1_proto_rawDescOnce.Do(func() {
+ file_inference_inference_paramsv1_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_inference_paramsv1_proto_rawDescData)
+ })
+ return file_inference_inference_paramsv1_proto_rawDescData
+}
+
+var file_inference_inference_paramsv1_proto_msgTypes = make([]protoimpl.MessageInfo, 5)
+var file_inference_inference_paramsv1_proto_goTypes = []interface{}{
+ (*ParamsV1)(nil), // 0: inference.inference.ParamsV1
+ (*TokenomicsParamsV1)(nil), // 1: inference.inference.TokenomicsParamsV1
+ (*EpochParamsV1)(nil), // 2: inference.inference.EpochParamsV1
+ (*ValidationParamsV1)(nil), // 3: inference.inference.ValidationParamsV1
+ (*PocParamsV1)(nil), // 4: inference.inference.PocParamsV1
+}
+var file_inference_inference_paramsv1_proto_depIdxs = []int32{
+ 2, // 0: inference.inference.ParamsV1.epoch_params:type_name -> inference.inference.EpochParamsV1
+ 3, // 1: inference.inference.ParamsV1.validation_params:type_name -> inference.inference.ValidationParamsV1
+ 4, // 2: inference.inference.ParamsV1.poc_params:type_name -> inference.inference.PocParamsV1
+ 1, // 3: inference.inference.ParamsV1.tokenomics_params:type_name -> inference.inference.TokenomicsParamsV1
+ 4, // [4:4] is the sub-list for method output_type
+ 4, // [4:4] is the sub-list for method input_type
+ 4, // [4:4] is the sub-list for extension type_name
+ 4, // [4:4] is the sub-list for extension extendee
+ 0, // [0:4] is the sub-list for field type_name
+}
+
+func init() { file_inference_inference_paramsv1_proto_init() }
+func file_inference_inference_paramsv1_proto_init() {
+ if File_inference_inference_paramsv1_proto != nil {
+ return
+ }
+ if !protoimpl.UnsafeEnabled {
+ file_inference_inference_paramsv1_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*ParamsV1); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_inference_paramsv1_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*TokenomicsParamsV1); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_inference_paramsv1_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*EpochParamsV1); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_inference_paramsv1_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*ValidationParamsV1); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_inference_paramsv1_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*PocParamsV1); 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_paramsv1_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 5,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_inference_paramsv1_proto_goTypes,
+ DependencyIndexes: file_inference_inference_paramsv1_proto_depIdxs,
+ MessageInfos: file_inference_inference_paramsv1_proto_msgTypes,
+ }.Build()
+ File_inference_inference_paramsv1_proto = out.File
+ file_inference_inference_paramsv1_proto_rawDesc = nil
+ file_inference_inference_paramsv1_proto_goTypes = nil
+ file_inference_inference_paramsv1_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/inference/partial_upgrade.pulsar.go b/inference-chain/api/inference/inference/partial_upgrade.pulsar.go
new file mode 100644
index 000000000..0f211c275
--- /dev/null
+++ b/inference-chain/api/inference/inference/partial_upgrade.pulsar.go
@@ -0,0 +1,775 @@
+// 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_PartialUpgrade protoreflect.MessageDescriptor
+ fd_PartialUpgrade_height protoreflect.FieldDescriptor
+ fd_PartialUpgrade_node_version protoreflect.FieldDescriptor
+ fd_PartialUpgrade_api_binaries_json protoreflect.FieldDescriptor
+ fd_PartialUpgrade_name protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_partial_upgrade_proto_init()
+ md_PartialUpgrade = File_inference_inference_partial_upgrade_proto.Messages().ByName("PartialUpgrade")
+ fd_PartialUpgrade_height = md_PartialUpgrade.Fields().ByName("height")
+ fd_PartialUpgrade_node_version = md_PartialUpgrade.Fields().ByName("node_version")
+ fd_PartialUpgrade_api_binaries_json = md_PartialUpgrade.Fields().ByName("api_binaries_json")
+ fd_PartialUpgrade_name = md_PartialUpgrade.Fields().ByName("name")
+}
+
+var _ protoreflect.Message = (*fastReflection_PartialUpgrade)(nil)
+
+type fastReflection_PartialUpgrade PartialUpgrade
+
+func (x *PartialUpgrade) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_PartialUpgrade)(x)
+}
+
+func (x *PartialUpgrade) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_partial_upgrade_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_PartialUpgrade_messageType fastReflection_PartialUpgrade_messageType
+var _ protoreflect.MessageType = fastReflection_PartialUpgrade_messageType{}
+
+type fastReflection_PartialUpgrade_messageType struct{}
+
+func (x fastReflection_PartialUpgrade_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_PartialUpgrade)(nil)
+}
+func (x fastReflection_PartialUpgrade_messageType) New() protoreflect.Message {
+ return new(fastReflection_PartialUpgrade)
+}
+func (x fastReflection_PartialUpgrade_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_PartialUpgrade
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_PartialUpgrade) Descriptor() protoreflect.MessageDescriptor {
+ return md_PartialUpgrade
+}
+
+// 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_PartialUpgrade) Type() protoreflect.MessageType {
+ return _fastReflection_PartialUpgrade_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_PartialUpgrade) New() protoreflect.Message {
+ return new(fastReflection_PartialUpgrade)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_PartialUpgrade) Interface() protoreflect.ProtoMessage {
+ return (*PartialUpgrade)(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_PartialUpgrade) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Height != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.Height)
+ if !f(fd_PartialUpgrade_height, value) {
+ return
+ }
+ }
+ if x.NodeVersion != "" {
+ value := protoreflect.ValueOfString(x.NodeVersion)
+ if !f(fd_PartialUpgrade_node_version, value) {
+ return
+ }
+ }
+ if x.ApiBinariesJson != "" {
+ value := protoreflect.ValueOfString(x.ApiBinariesJson)
+ if !f(fd_PartialUpgrade_api_binaries_json, value) {
+ return
+ }
+ }
+ if x.Name != "" {
+ value := protoreflect.ValueOfString(x.Name)
+ if !f(fd_PartialUpgrade_name, 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_PartialUpgrade) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.PartialUpgrade.height":
+ return x.Height != uint64(0)
+ case "inference.inference.PartialUpgrade.node_version":
+ return x.NodeVersion != ""
+ case "inference.inference.PartialUpgrade.api_binaries_json":
+ return x.ApiBinariesJson != ""
+ case "inference.inference.PartialUpgrade.name":
+ return x.Name != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PartialUpgrade"))
+ }
+ panic(fmt.Errorf("message inference.inference.PartialUpgrade 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_PartialUpgrade) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.PartialUpgrade.height":
+ x.Height = uint64(0)
+ case "inference.inference.PartialUpgrade.node_version":
+ x.NodeVersion = ""
+ case "inference.inference.PartialUpgrade.api_binaries_json":
+ x.ApiBinariesJson = ""
+ case "inference.inference.PartialUpgrade.name":
+ x.Name = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PartialUpgrade"))
+ }
+ panic(fmt.Errorf("message inference.inference.PartialUpgrade 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_PartialUpgrade) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.PartialUpgrade.height":
+ value := x.Height
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.PartialUpgrade.node_version":
+ value := x.NodeVersion
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.PartialUpgrade.api_binaries_json":
+ value := x.ApiBinariesJson
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.PartialUpgrade.name":
+ value := x.Name
+ return protoreflect.ValueOfString(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PartialUpgrade"))
+ }
+ panic(fmt.Errorf("message inference.inference.PartialUpgrade 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_PartialUpgrade) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.PartialUpgrade.height":
+ x.Height = value.Uint()
+ case "inference.inference.PartialUpgrade.node_version":
+ x.NodeVersion = value.Interface().(string)
+ case "inference.inference.PartialUpgrade.api_binaries_json":
+ x.ApiBinariesJson = value.Interface().(string)
+ case "inference.inference.PartialUpgrade.name":
+ x.Name = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PartialUpgrade"))
+ }
+ panic(fmt.Errorf("message inference.inference.PartialUpgrade 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_PartialUpgrade) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.PartialUpgrade.height":
+ panic(fmt.Errorf("field height of message inference.inference.PartialUpgrade is not mutable"))
+ case "inference.inference.PartialUpgrade.node_version":
+ panic(fmt.Errorf("field node_version of message inference.inference.PartialUpgrade is not mutable"))
+ case "inference.inference.PartialUpgrade.api_binaries_json":
+ panic(fmt.Errorf("field api_binaries_json of message inference.inference.PartialUpgrade is not mutable"))
+ case "inference.inference.PartialUpgrade.name":
+ panic(fmt.Errorf("field name of message inference.inference.PartialUpgrade is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PartialUpgrade"))
+ }
+ panic(fmt.Errorf("message inference.inference.PartialUpgrade 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_PartialUpgrade) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.PartialUpgrade.height":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.PartialUpgrade.node_version":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.PartialUpgrade.api_binaries_json":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.PartialUpgrade.name":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PartialUpgrade"))
+ }
+ panic(fmt.Errorf("message inference.inference.PartialUpgrade 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_PartialUpgrade) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.PartialUpgrade", 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_PartialUpgrade) 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_PartialUpgrade) 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_PartialUpgrade) 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_PartialUpgrade) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*PartialUpgrade)
+ 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))
+ }
+ l = len(x.NodeVersion)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ l = len(x.ApiBinariesJson)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ l = len(x.Name)
+ 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().(*PartialUpgrade)
+ 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.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.ApiBinariesJson) > 0 {
+ i -= len(x.ApiBinariesJson)
+ copy(dAtA[i:], x.ApiBinariesJson)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ApiBinariesJson)))
+ i--
+ dAtA[i] = 0x1a
+ }
+ 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] = 0x12
+ }
+ 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().(*PartialUpgrade)
+ 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: PartialUpgrade: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: PartialUpgrade: 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
+ }
+ }
+ case 2:
+ if wireType != 2 {
+ 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 {
+ if shift >= 64 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.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.NodeVersion = 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 ApiBinariesJson", 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.ApiBinariesJson = 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
+ 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/partial_upgrade.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)
+)
+
+type PartialUpgrade struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Height uint64 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
+ NodeVersion string `protobuf:"bytes,2,opt,name=node_version,json=nodeVersion,proto3" json:"node_version,omitempty"`
+ ApiBinariesJson string `protobuf:"bytes,3,opt,name=api_binaries_json,json=apiBinariesJson,proto3" json:"api_binaries_json,omitempty"`
+ Name string `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"`
+}
+
+func (x *PartialUpgrade) Reset() {
+ *x = PartialUpgrade{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_partial_upgrade_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *PartialUpgrade) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*PartialUpgrade) ProtoMessage() {}
+
+// Deprecated: Use PartialUpgrade.ProtoReflect.Descriptor instead.
+func (*PartialUpgrade) Descriptor() ([]byte, []int) {
+ return file_inference_inference_partial_upgrade_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *PartialUpgrade) GetHeight() uint64 {
+ if x != nil {
+ return x.Height
+ }
+ return 0
+}
+
+func (x *PartialUpgrade) GetNodeVersion() string {
+ if x != nil {
+ return x.NodeVersion
+ }
+ return ""
+}
+
+func (x *PartialUpgrade) GetApiBinariesJson() string {
+ if x != nil {
+ return x.ApiBinariesJson
+ }
+ return ""
+}
+
+func (x *PartialUpgrade) GetName() string {
+ if x != nil {
+ return x.Name
+ }
+ return ""
+}
+
+var File_inference_inference_partial_upgrade_proto protoreflect.FileDescriptor
+
+var file_inference_inference_partial_upgrade_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, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x5f, 0x75, 0x70,
+ 0x67, 0x72, 0x61, 0x64, 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, 0x8b, 0x01, 0x0a, 0x0e, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x55, 0x70, 0x67, 0x72,
+ 0x61, 0x64, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x01, 0x20,
+ 0x01, 0x28, 0x04, 0x52, 0x06, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x6e,
+ 0x6f, 0x64, 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28,
+ 0x09, 0x52, 0x0b, 0x6e, 0x6f, 0x64, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x2a,
+ 0x0a, 0x11, 0x61, 0x70, 0x69, 0x5f, 0x62, 0x69, 0x6e, 0x61, 0x72, 0x69, 0x65, 0x73, 0x5f, 0x6a,
+ 0x73, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x61, 0x70, 0x69, 0x42, 0x69,
+ 0x6e, 0x61, 0x72, 0x69, 0x65, 0x73, 0x4a, 0x73, 0x6f, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61,
+ 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 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, 0x50, 0x61, 0x72, 0x74,
+ 0x69, 0x61, 0x6c, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64, 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_partial_upgrade_proto_rawDescOnce sync.Once
+ file_inference_inference_partial_upgrade_proto_rawDescData = file_inference_inference_partial_upgrade_proto_rawDesc
+)
+
+func file_inference_inference_partial_upgrade_proto_rawDescGZIP() []byte {
+ file_inference_inference_partial_upgrade_proto_rawDescOnce.Do(func() {
+ file_inference_inference_partial_upgrade_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_inference_partial_upgrade_proto_rawDescData)
+ })
+ return file_inference_inference_partial_upgrade_proto_rawDescData
+}
+
+var file_inference_inference_partial_upgrade_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_inference_inference_partial_upgrade_proto_goTypes = []interface{}{
+ (*PartialUpgrade)(nil), // 0: inference.inference.PartialUpgrade
+}
+var file_inference_inference_partial_upgrade_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_partial_upgrade_proto_init() }
+func file_inference_inference_partial_upgrade_proto_init() {
+ if File_inference_inference_partial_upgrade_proto != nil {
+ return
+ }
+ if !protoimpl.UnsafeEnabled {
+ file_inference_inference_partial_upgrade_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*PartialUpgrade); 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_partial_upgrade_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 1,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_inference_partial_upgrade_proto_goTypes,
+ DependencyIndexes: file_inference_inference_partial_upgrade_proto_depIdxs,
+ MessageInfos: file_inference_inference_partial_upgrade_proto_msgTypes,
+ }.Build()
+ File_inference_inference_partial_upgrade_proto = out.File
+ file_inference_inference_partial_upgrade_proto_rawDesc = nil
+ file_inference_inference_partial_upgrade_proto_goTypes = nil
+ file_inference_inference_partial_upgrade_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/inference/participant.pulsar.go b/inference-chain/api/inference/inference/participant.pulsar.go
new file mode 100644
index 000000000..c5a19b851
--- /dev/null
+++ b/inference-chain/api/inference/inference/participant.pulsar.go
@@ -0,0 +1,2587 @@
+// 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_Participant protoreflect.MessageDescriptor
+ fd_Participant_index protoreflect.FieldDescriptor
+ fd_Participant_address protoreflect.FieldDescriptor
+ fd_Participant_weight protoreflect.FieldDescriptor
+ fd_Participant_join_time protoreflect.FieldDescriptor
+ fd_Participant_join_height protoreflect.FieldDescriptor
+ fd_Participant_last_inference_time protoreflect.FieldDescriptor
+ fd_Participant_inference_url protoreflect.FieldDescriptor
+ fd_Participant_status protoreflect.FieldDescriptor
+ fd_Participant_coin_balance protoreflect.FieldDescriptor
+ fd_Participant_validator_key protoreflect.FieldDescriptor
+ fd_Participant_consecutive_invalid_inferences protoreflect.FieldDescriptor
+ fd_Participant_worker_public_key protoreflect.FieldDescriptor
+ fd_Participant_epochs_completed protoreflect.FieldDescriptor
+ fd_Participant_current_epoch_stats protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_participant_proto_init()
+ md_Participant = File_inference_inference_participant_proto.Messages().ByName("Participant")
+ fd_Participant_index = md_Participant.Fields().ByName("index")
+ fd_Participant_address = md_Participant.Fields().ByName("address")
+ fd_Participant_weight = md_Participant.Fields().ByName("weight")
+ fd_Participant_join_time = md_Participant.Fields().ByName("join_time")
+ fd_Participant_join_height = md_Participant.Fields().ByName("join_height")
+ fd_Participant_last_inference_time = md_Participant.Fields().ByName("last_inference_time")
+ fd_Participant_inference_url = md_Participant.Fields().ByName("inference_url")
+ fd_Participant_status = md_Participant.Fields().ByName("status")
+ fd_Participant_coin_balance = md_Participant.Fields().ByName("coin_balance")
+ fd_Participant_validator_key = md_Participant.Fields().ByName("validator_key")
+ fd_Participant_consecutive_invalid_inferences = md_Participant.Fields().ByName("consecutive_invalid_inferences")
+ fd_Participant_worker_public_key = md_Participant.Fields().ByName("worker_public_key")
+ fd_Participant_epochs_completed = md_Participant.Fields().ByName("epochs_completed")
+ fd_Participant_current_epoch_stats = md_Participant.Fields().ByName("current_epoch_stats")
+}
+
+var _ protoreflect.Message = (*fastReflection_Participant)(nil)
+
+type fastReflection_Participant Participant
+
+func (x *Participant) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_Participant)(x)
+}
+
+func (x *Participant) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_participant_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_Participant_messageType fastReflection_Participant_messageType
+var _ protoreflect.MessageType = fastReflection_Participant_messageType{}
+
+type fastReflection_Participant_messageType struct{}
+
+func (x fastReflection_Participant_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_Participant)(nil)
+}
+func (x fastReflection_Participant_messageType) New() protoreflect.Message {
+ return new(fastReflection_Participant)
+}
+func (x fastReflection_Participant_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_Participant
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_Participant) Descriptor() protoreflect.MessageDescriptor {
+ return md_Participant
+}
+
+// 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_Participant) Type() protoreflect.MessageType {
+ return _fastReflection_Participant_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_Participant) New() protoreflect.Message {
+ return new(fastReflection_Participant)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_Participant) Interface() protoreflect.ProtoMessage {
+ return (*Participant)(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_Participant) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Index != "" {
+ value := protoreflect.ValueOfString(x.Index)
+ if !f(fd_Participant_index, value) {
+ return
+ }
+ }
+ if x.Address != "" {
+ value := protoreflect.ValueOfString(x.Address)
+ if !f(fd_Participant_address, value) {
+ return
+ }
+ }
+ if x.Weight != int32(0) {
+ value := protoreflect.ValueOfInt32(x.Weight)
+ if !f(fd_Participant_weight, value) {
+ return
+ }
+ }
+ if x.JoinTime != int64(0) {
+ value := protoreflect.ValueOfInt64(x.JoinTime)
+ if !f(fd_Participant_join_time, value) {
+ return
+ }
+ }
+ if x.JoinHeight != int64(0) {
+ value := protoreflect.ValueOfInt64(x.JoinHeight)
+ if !f(fd_Participant_join_height, value) {
+ return
+ }
+ }
+ if x.LastInferenceTime != int64(0) {
+ value := protoreflect.ValueOfInt64(x.LastInferenceTime)
+ if !f(fd_Participant_last_inference_time, value) {
+ return
+ }
+ }
+ if x.InferenceUrl != "" {
+ value := protoreflect.ValueOfString(x.InferenceUrl)
+ if !f(fd_Participant_inference_url, value) {
+ return
+ }
+ }
+ if x.Status != 0 {
+ value := protoreflect.ValueOfEnum((protoreflect.EnumNumber)(x.Status))
+ if !f(fd_Participant_status, value) {
+ return
+ }
+ }
+ if x.CoinBalance != int64(0) {
+ value := protoreflect.ValueOfInt64(x.CoinBalance)
+ if !f(fd_Participant_coin_balance, value) {
+ return
+ }
+ }
+ if x.ValidatorKey != "" {
+ value := protoreflect.ValueOfString(x.ValidatorKey)
+ if !f(fd_Participant_validator_key, value) {
+ return
+ }
+ }
+ if x.ConsecutiveInvalidInferences != int64(0) {
+ value := protoreflect.ValueOfInt64(x.ConsecutiveInvalidInferences)
+ if !f(fd_Participant_consecutive_invalid_inferences, value) {
+ return
+ }
+ }
+ if x.WorkerPublicKey != "" {
+ value := protoreflect.ValueOfString(x.WorkerPublicKey)
+ if !f(fd_Participant_worker_public_key, value) {
+ return
+ }
+ }
+ if x.EpochsCompleted != uint32(0) {
+ value := protoreflect.ValueOfUint32(x.EpochsCompleted)
+ if !f(fd_Participant_epochs_completed, value) {
+ return
+ }
+ }
+ if x.CurrentEpochStats != nil {
+ value := protoreflect.ValueOfMessage(x.CurrentEpochStats.ProtoReflect())
+ if !f(fd_Participant_current_epoch_stats, 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_Participant) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.Participant.index":
+ return x.Index != ""
+ case "inference.inference.Participant.address":
+ return x.Address != ""
+ case "inference.inference.Participant.weight":
+ return x.Weight != int32(0)
+ case "inference.inference.Participant.join_time":
+ return x.JoinTime != int64(0)
+ case "inference.inference.Participant.join_height":
+ return x.JoinHeight != int64(0)
+ case "inference.inference.Participant.last_inference_time":
+ return x.LastInferenceTime != int64(0)
+ case "inference.inference.Participant.inference_url":
+ return x.InferenceUrl != ""
+ case "inference.inference.Participant.status":
+ return x.Status != 0
+ case "inference.inference.Participant.coin_balance":
+ return x.CoinBalance != int64(0)
+ case "inference.inference.Participant.validator_key":
+ return x.ValidatorKey != ""
+ case "inference.inference.Participant.consecutive_invalid_inferences":
+ return x.ConsecutiveInvalidInferences != int64(0)
+ case "inference.inference.Participant.worker_public_key":
+ return x.WorkerPublicKey != ""
+ case "inference.inference.Participant.epochs_completed":
+ return x.EpochsCompleted != uint32(0)
+ case "inference.inference.Participant.current_epoch_stats":
+ return x.CurrentEpochStats != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Participant"))
+ }
+ panic(fmt.Errorf("message inference.inference.Participant 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_Participant) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.Participant.index":
+ x.Index = ""
+ case "inference.inference.Participant.address":
+ x.Address = ""
+ case "inference.inference.Participant.weight":
+ x.Weight = int32(0)
+ case "inference.inference.Participant.join_time":
+ x.JoinTime = int64(0)
+ case "inference.inference.Participant.join_height":
+ x.JoinHeight = int64(0)
+ case "inference.inference.Participant.last_inference_time":
+ x.LastInferenceTime = int64(0)
+ case "inference.inference.Participant.inference_url":
+ x.InferenceUrl = ""
+ case "inference.inference.Participant.status":
+ x.Status = 0
+ case "inference.inference.Participant.coin_balance":
+ x.CoinBalance = int64(0)
+ case "inference.inference.Participant.validator_key":
+ x.ValidatorKey = ""
+ case "inference.inference.Participant.consecutive_invalid_inferences":
+ x.ConsecutiveInvalidInferences = int64(0)
+ case "inference.inference.Participant.worker_public_key":
+ x.WorkerPublicKey = ""
+ case "inference.inference.Participant.epochs_completed":
+ x.EpochsCompleted = uint32(0)
+ case "inference.inference.Participant.current_epoch_stats":
+ x.CurrentEpochStats = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Participant"))
+ }
+ panic(fmt.Errorf("message inference.inference.Participant 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_Participant) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.Participant.index":
+ value := x.Index
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.Participant.address":
+ value := x.Address
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.Participant.weight":
+ value := x.Weight
+ return protoreflect.ValueOfInt32(value)
+ case "inference.inference.Participant.join_time":
+ value := x.JoinTime
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.Participant.join_height":
+ value := x.JoinHeight
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.Participant.last_inference_time":
+ value := x.LastInferenceTime
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.Participant.inference_url":
+ value := x.InferenceUrl
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.Participant.status":
+ value := x.Status
+ return protoreflect.ValueOfEnum((protoreflect.EnumNumber)(value))
+ case "inference.inference.Participant.coin_balance":
+ value := x.CoinBalance
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.Participant.validator_key":
+ value := x.ValidatorKey
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.Participant.consecutive_invalid_inferences":
+ value := x.ConsecutiveInvalidInferences
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.Participant.worker_public_key":
+ value := x.WorkerPublicKey
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.Participant.epochs_completed":
+ value := x.EpochsCompleted
+ return protoreflect.ValueOfUint32(value)
+ case "inference.inference.Participant.current_epoch_stats":
+ value := x.CurrentEpochStats
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Participant"))
+ }
+ panic(fmt.Errorf("message inference.inference.Participant 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_Participant) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.Participant.index":
+ x.Index = value.Interface().(string)
+ case "inference.inference.Participant.address":
+ x.Address = value.Interface().(string)
+ case "inference.inference.Participant.weight":
+ x.Weight = int32(value.Int())
+ case "inference.inference.Participant.join_time":
+ x.JoinTime = value.Int()
+ case "inference.inference.Participant.join_height":
+ x.JoinHeight = value.Int()
+ case "inference.inference.Participant.last_inference_time":
+ x.LastInferenceTime = value.Int()
+ case "inference.inference.Participant.inference_url":
+ x.InferenceUrl = value.Interface().(string)
+ case "inference.inference.Participant.status":
+ x.Status = (ParticipantStatus)(value.Enum())
+ case "inference.inference.Participant.coin_balance":
+ x.CoinBalance = value.Int()
+ case "inference.inference.Participant.validator_key":
+ x.ValidatorKey = value.Interface().(string)
+ case "inference.inference.Participant.consecutive_invalid_inferences":
+ x.ConsecutiveInvalidInferences = value.Int()
+ case "inference.inference.Participant.worker_public_key":
+ x.WorkerPublicKey = value.Interface().(string)
+ case "inference.inference.Participant.epochs_completed":
+ x.EpochsCompleted = uint32(value.Uint())
+ case "inference.inference.Participant.current_epoch_stats":
+ x.CurrentEpochStats = value.Message().Interface().(*CurrentEpochStats)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Participant"))
+ }
+ panic(fmt.Errorf("message inference.inference.Participant 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_Participant) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.Participant.current_epoch_stats":
+ if x.CurrentEpochStats == nil {
+ x.CurrentEpochStats = new(CurrentEpochStats)
+ }
+ return protoreflect.ValueOfMessage(x.CurrentEpochStats.ProtoReflect())
+ case "inference.inference.Participant.index":
+ panic(fmt.Errorf("field index of message inference.inference.Participant is not mutable"))
+ case "inference.inference.Participant.address":
+ panic(fmt.Errorf("field address of message inference.inference.Participant is not mutable"))
+ case "inference.inference.Participant.weight":
+ panic(fmt.Errorf("field weight of message inference.inference.Participant is not mutable"))
+ case "inference.inference.Participant.join_time":
+ panic(fmt.Errorf("field join_time of message inference.inference.Participant is not mutable"))
+ case "inference.inference.Participant.join_height":
+ panic(fmt.Errorf("field join_height of message inference.inference.Participant is not mutable"))
+ case "inference.inference.Participant.last_inference_time":
+ panic(fmt.Errorf("field last_inference_time of message inference.inference.Participant is not mutable"))
+ case "inference.inference.Participant.inference_url":
+ panic(fmt.Errorf("field inference_url of message inference.inference.Participant is not mutable"))
+ case "inference.inference.Participant.status":
+ panic(fmt.Errorf("field status of message inference.inference.Participant is not mutable"))
+ case "inference.inference.Participant.coin_balance":
+ panic(fmt.Errorf("field coin_balance of message inference.inference.Participant is not mutable"))
+ case "inference.inference.Participant.validator_key":
+ panic(fmt.Errorf("field validator_key of message inference.inference.Participant is not mutable"))
+ case "inference.inference.Participant.consecutive_invalid_inferences":
+ panic(fmt.Errorf("field consecutive_invalid_inferences of message inference.inference.Participant is not mutable"))
+ case "inference.inference.Participant.worker_public_key":
+ panic(fmt.Errorf("field worker_public_key of message inference.inference.Participant is not mutable"))
+ case "inference.inference.Participant.epochs_completed":
+ panic(fmt.Errorf("field epochs_completed of message inference.inference.Participant is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Participant"))
+ }
+ panic(fmt.Errorf("message inference.inference.Participant 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_Participant) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.Participant.index":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.Participant.address":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.Participant.weight":
+ return protoreflect.ValueOfInt32(int32(0))
+ case "inference.inference.Participant.join_time":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.Participant.join_height":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.Participant.last_inference_time":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.Participant.inference_url":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.Participant.status":
+ return protoreflect.ValueOfEnum(0)
+ case "inference.inference.Participant.coin_balance":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.Participant.validator_key":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.Participant.consecutive_invalid_inferences":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.Participant.worker_public_key":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.Participant.epochs_completed":
+ return protoreflect.ValueOfUint32(uint32(0))
+ case "inference.inference.Participant.current_epoch_stats":
+ m := new(CurrentEpochStats)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Participant"))
+ }
+ panic(fmt.Errorf("message inference.inference.Participant 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_Participant) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.Participant", 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_Participant) 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_Participant) 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_Participant) 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_Participant) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*Participant)
+ 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.Index)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ l = len(x.Address)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.Weight != 0 {
+ n += 1 + runtime.Sov(uint64(x.Weight))
+ }
+ if x.JoinTime != 0 {
+ n += 1 + runtime.Sov(uint64(x.JoinTime))
+ }
+ if x.JoinHeight != 0 {
+ n += 1 + runtime.Sov(uint64(x.JoinHeight))
+ }
+ if x.LastInferenceTime != 0 {
+ n += 1 + runtime.Sov(uint64(x.LastInferenceTime))
+ }
+ l = len(x.InferenceUrl)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.Status != 0 {
+ n += 1 + runtime.Sov(uint64(x.Status))
+ }
+ if x.CoinBalance != 0 {
+ n += 1 + runtime.Sov(uint64(x.CoinBalance))
+ }
+ l = len(x.ValidatorKey)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.ConsecutiveInvalidInferences != 0 {
+ n += 1 + runtime.Sov(uint64(x.ConsecutiveInvalidInferences))
+ }
+ l = len(x.WorkerPublicKey)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.EpochsCompleted != 0 {
+ n += 1 + runtime.Sov(uint64(x.EpochsCompleted))
+ }
+ if x.CurrentEpochStats != nil {
+ l = options.Size(x.CurrentEpochStats)
+ 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().(*Participant)
+ 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.CurrentEpochStats != nil {
+ encoded, err := options.Marshal(x.CurrentEpochStats)
+ 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] = 0x72
+ }
+ if x.EpochsCompleted != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochsCompleted))
+ i--
+ dAtA[i] = 0x68
+ }
+ if len(x.WorkerPublicKey) > 0 {
+ i -= len(x.WorkerPublicKey)
+ copy(dAtA[i:], x.WorkerPublicKey)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.WorkerPublicKey)))
+ i--
+ dAtA[i] = 0x62
+ }
+ if x.ConsecutiveInvalidInferences != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.ConsecutiveInvalidInferences))
+ i--
+ dAtA[i] = 0x58
+ }
+ if len(x.ValidatorKey) > 0 {
+ i -= len(x.ValidatorKey)
+ copy(dAtA[i:], x.ValidatorKey)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ValidatorKey)))
+ i--
+ dAtA[i] = 0x52
+ }
+ if x.CoinBalance != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.CoinBalance))
+ i--
+ dAtA[i] = 0x48
+ }
+ if x.Status != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.Status))
+ i--
+ dAtA[i] = 0x40
+ }
+ if len(x.InferenceUrl) > 0 {
+ i -= len(x.InferenceUrl)
+ copy(dAtA[i:], x.InferenceUrl)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.InferenceUrl)))
+ i--
+ dAtA[i] = 0x3a
+ }
+ if x.LastInferenceTime != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.LastInferenceTime))
+ i--
+ dAtA[i] = 0x30
+ }
+ if x.JoinHeight != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.JoinHeight))
+ i--
+ dAtA[i] = 0x28
+ }
+ if x.JoinTime != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.JoinTime))
+ i--
+ dAtA[i] = 0x20
+ }
+ if x.Weight != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.Weight))
+ i--
+ dAtA[i] = 0x18
+ }
+ 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] = 0x12
+ }
+ if len(x.Index) > 0 {
+ i -= len(x.Index)
+ copy(dAtA[i:], x.Index)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Index)))
+ 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().(*Participant)
+ 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: Participant: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Participant: 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 Index", 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.Index = 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 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 3:
+ 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 |= 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 JoinTime", wireType)
+ }
+ x.JoinTime = 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.JoinTime |= int64(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 JoinHeight", wireType)
+ }
+ x.JoinHeight = 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.JoinHeight |= int64(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 LastInferenceTime", wireType)
+ }
+ x.LastInferenceTime = 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.LastInferenceTime |= int64(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 InferenceUrl", 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.InferenceUrl = 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 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 |= ParticipantStatus(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 CoinBalance", wireType)
+ }
+ x.CoinBalance = 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.CoinBalance |= int64(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 ValidatorKey", 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.ValidatorKey = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 11:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ConsecutiveInvalidInferences", wireType)
+ }
+ x.ConsecutiveInvalidInferences = 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.ConsecutiveInvalidInferences |= int64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 12:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field WorkerPublicKey", 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.WorkerPublicKey = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 13:
+ 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
+ }
+ }
+ case 14:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field CurrentEpochStats", 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.CurrentEpochStats == nil {
+ x.CurrentEpochStats = &CurrentEpochStats{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.CurrentEpochStats); 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_CurrentEpochStats protoreflect.MessageDescriptor
+ fd_CurrentEpochStats_inference_count protoreflect.FieldDescriptor
+ fd_CurrentEpochStats_missed_requests protoreflect.FieldDescriptor
+ fd_CurrentEpochStats_earned_coins protoreflect.FieldDescriptor
+ fd_CurrentEpochStats_rewarded_coins protoreflect.FieldDescriptor
+ fd_CurrentEpochStats_burned_coins protoreflect.FieldDescriptor
+ fd_CurrentEpochStats_validated_inferences protoreflect.FieldDescriptor
+ fd_CurrentEpochStats_invalidated_inferences protoreflect.FieldDescriptor
+ fd_CurrentEpochStats_invalidLLR protoreflect.FieldDescriptor
+ fd_CurrentEpochStats_inactiveLLR protoreflect.FieldDescriptor
+ fd_CurrentEpochStats_confirmationPoCRatio protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_participant_proto_init()
+ md_CurrentEpochStats = File_inference_inference_participant_proto.Messages().ByName("CurrentEpochStats")
+ fd_CurrentEpochStats_inference_count = md_CurrentEpochStats.Fields().ByName("inference_count")
+ fd_CurrentEpochStats_missed_requests = md_CurrentEpochStats.Fields().ByName("missed_requests")
+ fd_CurrentEpochStats_earned_coins = md_CurrentEpochStats.Fields().ByName("earned_coins")
+ fd_CurrentEpochStats_rewarded_coins = md_CurrentEpochStats.Fields().ByName("rewarded_coins")
+ fd_CurrentEpochStats_burned_coins = md_CurrentEpochStats.Fields().ByName("burned_coins")
+ fd_CurrentEpochStats_validated_inferences = md_CurrentEpochStats.Fields().ByName("validated_inferences")
+ fd_CurrentEpochStats_invalidated_inferences = md_CurrentEpochStats.Fields().ByName("invalidated_inferences")
+ fd_CurrentEpochStats_invalidLLR = md_CurrentEpochStats.Fields().ByName("invalidLLR")
+ fd_CurrentEpochStats_inactiveLLR = md_CurrentEpochStats.Fields().ByName("inactiveLLR")
+ fd_CurrentEpochStats_confirmationPoCRatio = md_CurrentEpochStats.Fields().ByName("confirmationPoCRatio")
+}
+
+var _ protoreflect.Message = (*fastReflection_CurrentEpochStats)(nil)
+
+type fastReflection_CurrentEpochStats CurrentEpochStats
+
+func (x *CurrentEpochStats) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_CurrentEpochStats)(x)
+}
+
+func (x *CurrentEpochStats) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_participant_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_CurrentEpochStats_messageType fastReflection_CurrentEpochStats_messageType
+var _ protoreflect.MessageType = fastReflection_CurrentEpochStats_messageType{}
+
+type fastReflection_CurrentEpochStats_messageType struct{}
+
+func (x fastReflection_CurrentEpochStats_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_CurrentEpochStats)(nil)
+}
+func (x fastReflection_CurrentEpochStats_messageType) New() protoreflect.Message {
+ return new(fastReflection_CurrentEpochStats)
+}
+func (x fastReflection_CurrentEpochStats_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_CurrentEpochStats
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_CurrentEpochStats) Descriptor() protoreflect.MessageDescriptor {
+ return md_CurrentEpochStats
+}
+
+// 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_CurrentEpochStats) Type() protoreflect.MessageType {
+ return _fastReflection_CurrentEpochStats_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_CurrentEpochStats) New() protoreflect.Message {
+ return new(fastReflection_CurrentEpochStats)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_CurrentEpochStats) Interface() protoreflect.ProtoMessage {
+ return (*CurrentEpochStats)(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_CurrentEpochStats) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.InferenceCount != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.InferenceCount)
+ if !f(fd_CurrentEpochStats_inference_count, value) {
+ return
+ }
+ }
+ if x.MissedRequests != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.MissedRequests)
+ if !f(fd_CurrentEpochStats_missed_requests, value) {
+ return
+ }
+ }
+ if x.EarnedCoins != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.EarnedCoins)
+ if !f(fd_CurrentEpochStats_earned_coins, value) {
+ return
+ }
+ }
+ if x.RewardedCoins != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.RewardedCoins)
+ if !f(fd_CurrentEpochStats_rewarded_coins, value) {
+ return
+ }
+ }
+ if x.BurnedCoins != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.BurnedCoins)
+ if !f(fd_CurrentEpochStats_burned_coins, value) {
+ return
+ }
+ }
+ if x.ValidatedInferences != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.ValidatedInferences)
+ if !f(fd_CurrentEpochStats_validated_inferences, value) {
+ return
+ }
+ }
+ if x.InvalidatedInferences != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.InvalidatedInferences)
+ if !f(fd_CurrentEpochStats_invalidated_inferences, value) {
+ return
+ }
+ }
+ if x.InvalidLLR != nil {
+ value := protoreflect.ValueOfMessage(x.InvalidLLR.ProtoReflect())
+ if !f(fd_CurrentEpochStats_invalidLLR, value) {
+ return
+ }
+ }
+ if x.InactiveLLR != nil {
+ value := protoreflect.ValueOfMessage(x.InactiveLLR.ProtoReflect())
+ if !f(fd_CurrentEpochStats_inactiveLLR, value) {
+ return
+ }
+ }
+ if x.ConfirmationPoCRatio != nil {
+ value := protoreflect.ValueOfMessage(x.ConfirmationPoCRatio.ProtoReflect())
+ if !f(fd_CurrentEpochStats_confirmationPoCRatio, 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_CurrentEpochStats) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.CurrentEpochStats.inference_count":
+ return x.InferenceCount != uint64(0)
+ case "inference.inference.CurrentEpochStats.missed_requests":
+ return x.MissedRequests != uint64(0)
+ case "inference.inference.CurrentEpochStats.earned_coins":
+ return x.EarnedCoins != uint64(0)
+ case "inference.inference.CurrentEpochStats.rewarded_coins":
+ return x.RewardedCoins != uint64(0)
+ case "inference.inference.CurrentEpochStats.burned_coins":
+ return x.BurnedCoins != uint64(0)
+ case "inference.inference.CurrentEpochStats.validated_inferences":
+ return x.ValidatedInferences != uint64(0)
+ case "inference.inference.CurrentEpochStats.invalidated_inferences":
+ return x.InvalidatedInferences != uint64(0)
+ case "inference.inference.CurrentEpochStats.invalidLLR":
+ return x.InvalidLLR != nil
+ case "inference.inference.CurrentEpochStats.inactiveLLR":
+ return x.InactiveLLR != nil
+ case "inference.inference.CurrentEpochStats.confirmationPoCRatio":
+ return x.ConfirmationPoCRatio != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.CurrentEpochStats"))
+ }
+ panic(fmt.Errorf("message inference.inference.CurrentEpochStats 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_CurrentEpochStats) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.CurrentEpochStats.inference_count":
+ x.InferenceCount = uint64(0)
+ case "inference.inference.CurrentEpochStats.missed_requests":
+ x.MissedRequests = uint64(0)
+ case "inference.inference.CurrentEpochStats.earned_coins":
+ x.EarnedCoins = uint64(0)
+ case "inference.inference.CurrentEpochStats.rewarded_coins":
+ x.RewardedCoins = uint64(0)
+ case "inference.inference.CurrentEpochStats.burned_coins":
+ x.BurnedCoins = uint64(0)
+ case "inference.inference.CurrentEpochStats.validated_inferences":
+ x.ValidatedInferences = uint64(0)
+ case "inference.inference.CurrentEpochStats.invalidated_inferences":
+ x.InvalidatedInferences = uint64(0)
+ case "inference.inference.CurrentEpochStats.invalidLLR":
+ x.InvalidLLR = nil
+ case "inference.inference.CurrentEpochStats.inactiveLLR":
+ x.InactiveLLR = nil
+ case "inference.inference.CurrentEpochStats.confirmationPoCRatio":
+ x.ConfirmationPoCRatio = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.CurrentEpochStats"))
+ }
+ panic(fmt.Errorf("message inference.inference.CurrentEpochStats 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_CurrentEpochStats) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.CurrentEpochStats.inference_count":
+ value := x.InferenceCount
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.CurrentEpochStats.missed_requests":
+ value := x.MissedRequests
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.CurrentEpochStats.earned_coins":
+ value := x.EarnedCoins
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.CurrentEpochStats.rewarded_coins":
+ value := x.RewardedCoins
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.CurrentEpochStats.burned_coins":
+ value := x.BurnedCoins
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.CurrentEpochStats.validated_inferences":
+ value := x.ValidatedInferences
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.CurrentEpochStats.invalidated_inferences":
+ value := x.InvalidatedInferences
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.CurrentEpochStats.invalidLLR":
+ value := x.InvalidLLR
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.CurrentEpochStats.inactiveLLR":
+ value := x.InactiveLLR
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.CurrentEpochStats.confirmationPoCRatio":
+ value := x.ConfirmationPoCRatio
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.CurrentEpochStats"))
+ }
+ panic(fmt.Errorf("message inference.inference.CurrentEpochStats 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_CurrentEpochStats) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.CurrentEpochStats.inference_count":
+ x.InferenceCount = value.Uint()
+ case "inference.inference.CurrentEpochStats.missed_requests":
+ x.MissedRequests = value.Uint()
+ case "inference.inference.CurrentEpochStats.earned_coins":
+ x.EarnedCoins = value.Uint()
+ case "inference.inference.CurrentEpochStats.rewarded_coins":
+ x.RewardedCoins = value.Uint()
+ case "inference.inference.CurrentEpochStats.burned_coins":
+ x.BurnedCoins = value.Uint()
+ case "inference.inference.CurrentEpochStats.validated_inferences":
+ x.ValidatedInferences = value.Uint()
+ case "inference.inference.CurrentEpochStats.invalidated_inferences":
+ x.InvalidatedInferences = value.Uint()
+ case "inference.inference.CurrentEpochStats.invalidLLR":
+ x.InvalidLLR = value.Message().Interface().(*Decimal)
+ case "inference.inference.CurrentEpochStats.inactiveLLR":
+ x.InactiveLLR = value.Message().Interface().(*Decimal)
+ case "inference.inference.CurrentEpochStats.confirmationPoCRatio":
+ x.ConfirmationPoCRatio = value.Message().Interface().(*Decimal)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.CurrentEpochStats"))
+ }
+ panic(fmt.Errorf("message inference.inference.CurrentEpochStats 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_CurrentEpochStats) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.CurrentEpochStats.invalidLLR":
+ if x.InvalidLLR == nil {
+ x.InvalidLLR = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.InvalidLLR.ProtoReflect())
+ case "inference.inference.CurrentEpochStats.inactiveLLR":
+ if x.InactiveLLR == nil {
+ x.InactiveLLR = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.InactiveLLR.ProtoReflect())
+ case "inference.inference.CurrentEpochStats.confirmationPoCRatio":
+ if x.ConfirmationPoCRatio == nil {
+ x.ConfirmationPoCRatio = new(Decimal)
+ }
+ return protoreflect.ValueOfMessage(x.ConfirmationPoCRatio.ProtoReflect())
+ case "inference.inference.CurrentEpochStats.inference_count":
+ panic(fmt.Errorf("field inference_count of message inference.inference.CurrentEpochStats is not mutable"))
+ case "inference.inference.CurrentEpochStats.missed_requests":
+ panic(fmt.Errorf("field missed_requests of message inference.inference.CurrentEpochStats is not mutable"))
+ case "inference.inference.CurrentEpochStats.earned_coins":
+ panic(fmt.Errorf("field earned_coins of message inference.inference.CurrentEpochStats is not mutable"))
+ case "inference.inference.CurrentEpochStats.rewarded_coins":
+ panic(fmt.Errorf("field rewarded_coins of message inference.inference.CurrentEpochStats is not mutable"))
+ case "inference.inference.CurrentEpochStats.burned_coins":
+ panic(fmt.Errorf("field burned_coins of message inference.inference.CurrentEpochStats is not mutable"))
+ case "inference.inference.CurrentEpochStats.validated_inferences":
+ panic(fmt.Errorf("field validated_inferences of message inference.inference.CurrentEpochStats is not mutable"))
+ case "inference.inference.CurrentEpochStats.invalidated_inferences":
+ panic(fmt.Errorf("field invalidated_inferences of message inference.inference.CurrentEpochStats is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.CurrentEpochStats"))
+ }
+ panic(fmt.Errorf("message inference.inference.CurrentEpochStats 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_CurrentEpochStats) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.CurrentEpochStats.inference_count":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.CurrentEpochStats.missed_requests":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.CurrentEpochStats.earned_coins":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.CurrentEpochStats.rewarded_coins":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.CurrentEpochStats.burned_coins":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.CurrentEpochStats.validated_inferences":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.CurrentEpochStats.invalidated_inferences":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.CurrentEpochStats.invalidLLR":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.CurrentEpochStats.inactiveLLR":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.CurrentEpochStats.confirmationPoCRatio":
+ m := new(Decimal)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.CurrentEpochStats"))
+ }
+ panic(fmt.Errorf("message inference.inference.CurrentEpochStats 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_CurrentEpochStats) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.CurrentEpochStats", 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_CurrentEpochStats) 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_CurrentEpochStats) 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_CurrentEpochStats) 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_CurrentEpochStats) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*CurrentEpochStats)
+ 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.InferenceCount != 0 {
+ n += 1 + runtime.Sov(uint64(x.InferenceCount))
+ }
+ if x.MissedRequests != 0 {
+ n += 1 + runtime.Sov(uint64(x.MissedRequests))
+ }
+ if x.EarnedCoins != 0 {
+ n += 1 + runtime.Sov(uint64(x.EarnedCoins))
+ }
+ if x.RewardedCoins != 0 {
+ n += 1 + runtime.Sov(uint64(x.RewardedCoins))
+ }
+ if x.BurnedCoins != 0 {
+ n += 1 + runtime.Sov(uint64(x.BurnedCoins))
+ }
+ if x.ValidatedInferences != 0 {
+ n += 1 + runtime.Sov(uint64(x.ValidatedInferences))
+ }
+ if x.InvalidatedInferences != 0 {
+ n += 1 + runtime.Sov(uint64(x.InvalidatedInferences))
+ }
+ if x.InvalidLLR != nil {
+ l = options.Size(x.InvalidLLR)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.InactiveLLR != nil {
+ l = options.Size(x.InactiveLLR)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.ConfirmationPoCRatio != nil {
+ l = options.Size(x.ConfirmationPoCRatio)
+ 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().(*CurrentEpochStats)
+ 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.ConfirmationPoCRatio != nil {
+ encoded, err := options.Marshal(x.ConfirmationPoCRatio)
+ 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.InactiveLLR != nil {
+ encoded, err := options.Marshal(x.InactiveLLR)
+ 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] = 0x4a
+ }
+ if x.InvalidLLR != nil {
+ encoded, err := options.Marshal(x.InvalidLLR)
+ 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] = 0x42
+ }
+ if x.InvalidatedInferences != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.InvalidatedInferences))
+ i--
+ dAtA[i] = 0x38
+ }
+ if x.ValidatedInferences != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.ValidatedInferences))
+ i--
+ dAtA[i] = 0x30
+ }
+ if x.BurnedCoins != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.BurnedCoins))
+ i--
+ dAtA[i] = 0x28
+ }
+ if x.RewardedCoins != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.RewardedCoins))
+ i--
+ dAtA[i] = 0x20
+ }
+ if x.EarnedCoins != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.EarnedCoins))
+ i--
+ dAtA[i] = 0x18
+ }
+ if x.MissedRequests != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.MissedRequests))
+ i--
+ dAtA[i] = 0x10
+ }
+ if x.InferenceCount != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.InferenceCount))
+ 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().(*CurrentEpochStats)
+ 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: CurrentEpochStats: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: CurrentEpochStats: 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 InferenceCount", wireType)
+ }
+ x.InferenceCount = 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.InferenceCount |= 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 MissedRequests", wireType)
+ }
+ x.MissedRequests = 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.MissedRequests |= 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 EarnedCoins", wireType)
+ }
+ x.EarnedCoins = 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.EarnedCoins |= 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 RewardedCoins", wireType)
+ }
+ x.RewardedCoins = 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.RewardedCoins |= 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 BurnedCoins", wireType)
+ }
+ x.BurnedCoins = 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.BurnedCoins |= 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 ValidatedInferences", wireType)
+ }
+ x.ValidatedInferences = 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.ValidatedInferences |= 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 InvalidatedInferences", wireType)
+ }
+ x.InvalidatedInferences = 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.InvalidatedInferences |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 8:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field InvalidLLR", 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.InvalidLLR == nil {
+ x.InvalidLLR = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.InvalidLLR); err != nil {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+ }
+ iNdEx = postIndex
+ case 9:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field InactiveLLR", 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.InactiveLLR == nil {
+ x.InactiveLLR = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.InactiveLLR); err != nil {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+ }
+ iNdEx = postIndex
+ case 10:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ConfirmationPoCRatio", 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.ConfirmationPoCRatio == nil {
+ x.ConfirmationPoCRatio = &Decimal{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ConfirmationPoCRatio); 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/participant.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)
+)
+
+type ParticipantStatus int32
+
+const (
+ ParticipantStatus_UNSPECIFIED ParticipantStatus = 0
+ ParticipantStatus_ACTIVE ParticipantStatus = 1
+ ParticipantStatus_INACTIVE ParticipantStatus = 2
+ ParticipantStatus_INVALID ParticipantStatus = 3
+ // Deprecated: Do not use.
+ ParticipantStatus_RAMPING ParticipantStatus = 4
+ ParticipantStatus_UNCONFIRMED ParticipantStatus = 5
+)
+
+// Enum value maps for ParticipantStatus.
+var (
+ ParticipantStatus_name = map[int32]string{
+ 0: "UNSPECIFIED",
+ 1: "ACTIVE",
+ 2: "INACTIVE",
+ 3: "INVALID",
+ 4: "RAMPING",
+ 5: "UNCONFIRMED",
+ }
+ ParticipantStatus_value = map[string]int32{
+ "UNSPECIFIED": 0,
+ "ACTIVE": 1,
+ "INACTIVE": 2,
+ "INVALID": 3,
+ "RAMPING": 4,
+ "UNCONFIRMED": 5,
+ }
+)
+
+func (x ParticipantStatus) Enum() *ParticipantStatus {
+ p := new(ParticipantStatus)
+ *p = x
+ return p
+}
+
+func (x ParticipantStatus) String() string {
+ return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (ParticipantStatus) Descriptor() protoreflect.EnumDescriptor {
+ return file_inference_inference_participant_proto_enumTypes[0].Descriptor()
+}
+
+func (ParticipantStatus) Type() protoreflect.EnumType {
+ return &file_inference_inference_participant_proto_enumTypes[0]
+}
+
+func (x ParticipantStatus) Number() protoreflect.EnumNumber {
+ return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use ParticipantStatus.Descriptor instead.
+func (ParticipantStatus) EnumDescriptor() ([]byte, []int) {
+ return file_inference_inference_participant_proto_rawDescGZIP(), []int{0}
+}
+
+type Participant struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Index string `protobuf:"bytes,1,opt,name=index,proto3" json:"index,omitempty"`
+ Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
+ Weight int32 `protobuf:"varint,3,opt,name=weight,proto3" json:"weight,omitempty"`
+ JoinTime int64 `protobuf:"varint,4,opt,name=join_time,json=joinTime,proto3" json:"join_time,omitempty"`
+ JoinHeight int64 `protobuf:"varint,5,opt,name=join_height,json=joinHeight,proto3" json:"join_height,omitempty"`
+ LastInferenceTime int64 `protobuf:"varint,6,opt,name=last_inference_time,json=lastInferenceTime,proto3" json:"last_inference_time,omitempty"`
+ InferenceUrl string `protobuf:"bytes,7,opt,name=inference_url,json=inferenceUrl,proto3" json:"inference_url,omitempty"`
+ Status ParticipantStatus `protobuf:"varint,8,opt,name=status,proto3,enum=inference.inference.ParticipantStatus" json:"status,omitempty"`
+ CoinBalance int64 `protobuf:"varint,9,opt,name=coin_balance,json=coinBalance,proto3" json:"coin_balance,omitempty"`
+ ValidatorKey string `protobuf:"bytes,10,opt,name=validator_key,json=validatorKey,proto3" json:"validator_key,omitempty"`
+ ConsecutiveInvalidInferences int64 `protobuf:"varint,11,opt,name=consecutive_invalid_inferences,json=consecutiveInvalidInferences,proto3" json:"consecutive_invalid_inferences,omitempty"`
+ WorkerPublicKey string `protobuf:"bytes,12,opt,name=worker_public_key,json=workerPublicKey,proto3" json:"worker_public_key,omitempty"`
+ EpochsCompleted uint32 `protobuf:"varint,13,opt,name=epochs_completed,json=epochsCompleted,proto3" json:"epochs_completed,omitempty"`
+ CurrentEpochStats *CurrentEpochStats `protobuf:"bytes,14,opt,name=current_epoch_stats,json=currentEpochStats,proto3" json:"current_epoch_stats,omitempty"`
+}
+
+func (x *Participant) Reset() {
+ *x = Participant{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_participant_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *Participant) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Participant) ProtoMessage() {}
+
+// Deprecated: Use Participant.ProtoReflect.Descriptor instead.
+func (*Participant) Descriptor() ([]byte, []int) {
+ return file_inference_inference_participant_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Participant) GetIndex() string {
+ if x != nil {
+ return x.Index
+ }
+ return ""
+}
+
+func (x *Participant) GetAddress() string {
+ if x != nil {
+ return x.Address
+ }
+ return ""
+}
+
+func (x *Participant) GetWeight() int32 {
+ if x != nil {
+ return x.Weight
+ }
+ return 0
+}
+
+func (x *Participant) GetJoinTime() int64 {
+ if x != nil {
+ return x.JoinTime
+ }
+ return 0
+}
+
+func (x *Participant) GetJoinHeight() int64 {
+ if x != nil {
+ return x.JoinHeight
+ }
+ return 0
+}
+
+func (x *Participant) GetLastInferenceTime() int64 {
+ if x != nil {
+ return x.LastInferenceTime
+ }
+ return 0
+}
+
+func (x *Participant) GetInferenceUrl() string {
+ if x != nil {
+ return x.InferenceUrl
+ }
+ return ""
+}
+
+func (x *Participant) GetStatus() ParticipantStatus {
+ if x != nil {
+ return x.Status
+ }
+ return ParticipantStatus_UNSPECIFIED
+}
+
+func (x *Participant) GetCoinBalance() int64 {
+ if x != nil {
+ return x.CoinBalance
+ }
+ return 0
+}
+
+func (x *Participant) GetValidatorKey() string {
+ if x != nil {
+ return x.ValidatorKey
+ }
+ return ""
+}
+
+func (x *Participant) GetConsecutiveInvalidInferences() int64 {
+ if x != nil {
+ return x.ConsecutiveInvalidInferences
+ }
+ return 0
+}
+
+func (x *Participant) GetWorkerPublicKey() string {
+ if x != nil {
+ return x.WorkerPublicKey
+ }
+ return ""
+}
+
+func (x *Participant) GetEpochsCompleted() uint32 {
+ if x != nil {
+ return x.EpochsCompleted
+ }
+ return 0
+}
+
+func (x *Participant) GetCurrentEpochStats() *CurrentEpochStats {
+ if x != nil {
+ return x.CurrentEpochStats
+ }
+ return nil
+}
+
+type CurrentEpochStats struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ InferenceCount uint64 `protobuf:"varint,1,opt,name=inference_count,json=inferenceCount,proto3" json:"inference_count,omitempty"`
+ MissedRequests uint64 `protobuf:"varint,2,opt,name=missed_requests,json=missedRequests,proto3" json:"missed_requests,omitempty"`
+ EarnedCoins uint64 `protobuf:"varint,3,opt,name=earned_coins,json=earnedCoins,proto3" json:"earned_coins,omitempty"`
+ RewardedCoins uint64 `protobuf:"varint,4,opt,name=rewarded_coins,json=rewardedCoins,proto3" json:"rewarded_coins,omitempty"`
+ BurnedCoins uint64 `protobuf:"varint,5,opt,name=burned_coins,json=burnedCoins,proto3" json:"burned_coins,omitempty"`
+ ValidatedInferences uint64 `protobuf:"varint,6,opt,name=validated_inferences,json=validatedInferences,proto3" json:"validated_inferences,omitempty"`
+ InvalidatedInferences uint64 `protobuf:"varint,7,opt,name=invalidated_inferences,json=invalidatedInferences,proto3" json:"invalidated_inferences,omitempty"`
+ InvalidLLR *Decimal `protobuf:"bytes,8,opt,name=invalidLLR,proto3" json:"invalidLLR,omitempty"`
+ InactiveLLR *Decimal `protobuf:"bytes,9,opt,name=inactiveLLR,proto3" json:"inactiveLLR,omitempty"`
+ ConfirmationPoCRatio *Decimal `protobuf:"bytes,10,opt,name=confirmationPoCRatio,proto3" json:"confirmationPoCRatio,omitempty"`
+}
+
+func (x *CurrentEpochStats) Reset() {
+ *x = CurrentEpochStats{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_participant_proto_msgTypes[1]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *CurrentEpochStats) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*CurrentEpochStats) ProtoMessage() {}
+
+// Deprecated: Use CurrentEpochStats.ProtoReflect.Descriptor instead.
+func (*CurrentEpochStats) Descriptor() ([]byte, []int) {
+ return file_inference_inference_participant_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *CurrentEpochStats) GetInferenceCount() uint64 {
+ if x != nil {
+ return x.InferenceCount
+ }
+ return 0
+}
+
+func (x *CurrentEpochStats) GetMissedRequests() uint64 {
+ if x != nil {
+ return x.MissedRequests
+ }
+ return 0
+}
+
+func (x *CurrentEpochStats) GetEarnedCoins() uint64 {
+ if x != nil {
+ return x.EarnedCoins
+ }
+ return 0
+}
+
+func (x *CurrentEpochStats) GetRewardedCoins() uint64 {
+ if x != nil {
+ return x.RewardedCoins
+ }
+ return 0
+}
+
+func (x *CurrentEpochStats) GetBurnedCoins() uint64 {
+ if x != nil {
+ return x.BurnedCoins
+ }
+ return 0
+}
+
+func (x *CurrentEpochStats) GetValidatedInferences() uint64 {
+ if x != nil {
+ return x.ValidatedInferences
+ }
+ return 0
+}
+
+func (x *CurrentEpochStats) GetInvalidatedInferences() uint64 {
+ if x != nil {
+ return x.InvalidatedInferences
+ }
+ return 0
+}
+
+func (x *CurrentEpochStats) GetInvalidLLR() *Decimal {
+ if x != nil {
+ return x.InvalidLLR
+ }
+ return nil
+}
+
+func (x *CurrentEpochStats) GetInactiveLLR() *Decimal {
+ if x != nil {
+ return x.InactiveLLR
+ }
+ return nil
+}
+
+func (x *CurrentEpochStats) GetConfirmationPoCRatio() *Decimal {
+ if x != nil {
+ return x.ConfirmationPoCRatio
+ }
+ return nil
+}
+
+var File_inference_inference_participant_proto protoreflect.FileDescriptor
+
+var file_inference_inference_participant_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, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 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, 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, 0xe5,
+ 0x04, 0x0a, 0x0b, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x12, 0x14,
+ 0x0a, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x69,
+ 0x6e, 0x64, 0x65, 0x78, 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, 0x16,
+ 0x0a, 0x06, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06,
+ 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x6a, 0x6f, 0x69, 0x6e, 0x5f, 0x74,
+ 0x69, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x6a, 0x6f, 0x69, 0x6e, 0x54,
+ 0x69, 0x6d, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x6a, 0x6f, 0x69, 0x6e, 0x5f, 0x68, 0x65, 0x69, 0x67,
+ 0x68, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x6a, 0x6f, 0x69, 0x6e, 0x48, 0x65,
+ 0x69, 0x67, 0x68, 0x74, 0x12, 0x2e, 0x0a, 0x13, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x69, 0x6e, 0x66,
+ 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28,
+ 0x03, 0x52, 0x11, 0x6c, 0x61, 0x73, 0x74, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+ 0x54, 0x69, 0x6d, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+ 0x65, 0x5f, 0x75, 0x72, 0x6c, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x69, 0x6e, 0x66,
+ 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x55, 0x72, 0x6c, 0x12, 0x3e, 0x0a, 0x06, 0x73, 0x74, 0x61,
+ 0x74, 0x75, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 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, 0x53, 0x74, 0x61, 0x74, 0x75,
+ 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x63, 0x6f, 0x69,
+ 0x6e, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x03, 0x52,
+ 0x0b, 0x63, 0x6f, 0x69, 0x6e, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x23, 0x0a, 0x0d,
+ 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x0a, 0x20,
+ 0x01, 0x28, 0x09, 0x52, 0x0c, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x4b, 0x65,
+ 0x79, 0x12, 0x44, 0x0a, 0x1e, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x63, 0x75, 0x74, 0x69, 0x76, 0x65,
+ 0x5f, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x5f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+ 0x63, 0x65, 0x73, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x03, 0x52, 0x1c, 0x63, 0x6f, 0x6e, 0x73, 0x65,
+ 0x63, 0x75, 0x74, 0x69, 0x76, 0x65, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x49, 0x6e, 0x66,
+ 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x12, 0x2a, 0x0a, 0x11, 0x77, 0x6f, 0x72, 0x6b, 0x65,
+ 0x72, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x0c, 0x20, 0x01,
+ 0x28, 0x09, 0x52, 0x0f, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63,
+ 0x4b, 0x65, 0x79, 0x12, 0x29, 0x0a, 0x10, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x73, 0x5f, 0x63, 0x6f,
+ 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0f, 0x65,
+ 0x70, 0x6f, 0x63, 0x68, 0x73, 0x43, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x12, 0x56,
+ 0x0a, 0x13, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f,
+ 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, 0x0e, 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, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x53, 0x74,
+ 0x61, 0x74, 0x73, 0x52, 0x11, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x45, 0x70, 0x6f, 0x63,
+ 0x68, 0x53, 0x74, 0x61, 0x74, 0x73, 0x22, 0x8c, 0x04, 0x0a, 0x11, 0x43, 0x75, 0x72, 0x72, 0x65,
+ 0x6e, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x27, 0x0a, 0x0f,
+ 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18,
+ 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+ 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x27, 0x0a, 0x0f, 0x6d, 0x69, 0x73, 0x73, 0x65, 0x64, 0x5f,
+ 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0e,
+ 0x6d, 0x69, 0x73, 0x73, 0x65, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x12, 0x21,
+ 0x0a, 0x0c, 0x65, 0x61, 0x72, 0x6e, 0x65, 0x64, 0x5f, 0x63, 0x6f, 0x69, 0x6e, 0x73, 0x18, 0x03,
+ 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x65, 0x61, 0x72, 0x6e, 0x65, 0x64, 0x43, 0x6f, 0x69, 0x6e,
+ 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x77, 0x61, 0x72, 0x64, 0x65, 0x64, 0x5f, 0x63, 0x6f,
+ 0x69, 0x6e, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0d, 0x72, 0x65, 0x77, 0x61, 0x72,
+ 0x64, 0x65, 0x64, 0x43, 0x6f, 0x69, 0x6e, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x62, 0x75, 0x72, 0x6e,
+ 0x65, 0x64, 0x5f, 0x63, 0x6f, 0x69, 0x6e, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b,
+ 0x62, 0x75, 0x72, 0x6e, 0x65, 0x64, 0x43, 0x6f, 0x69, 0x6e, 0x73, 0x12, 0x31, 0x0a, 0x14, 0x76,
+ 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+ 0x63, 0x65, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x04, 0x52, 0x13, 0x76, 0x61, 0x6c, 0x69, 0x64,
+ 0x61, 0x74, 0x65, 0x64, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x12, 0x35,
+ 0x0a, 0x16, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x69, 0x6e,
+ 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x04, 0x52, 0x15,
+ 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x64, 0x49, 0x6e, 0x66, 0x65, 0x72,
+ 0x65, 0x6e, 0x63, 0x65, 0x73, 0x12, 0x3c, 0x0a, 0x0a, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64,
+ 0x4c, 0x4c, 0x52, 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, 0x0a, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64,
+ 0x4c, 0x4c, 0x52, 0x12, 0x3e, 0x0a, 0x0b, 0x69, 0x6e, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x4c,
+ 0x4c, 0x52, 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, 0x0b, 0x69, 0x6e, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65,
+ 0x4c, 0x4c, 0x52, 0x12, 0x50, 0x0a, 0x14, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74,
+ 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x43, 0x52, 0x61, 0x74, 0x69, 0x6f, 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,
+ 0x14, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x43,
+ 0x52, 0x61, 0x74, 0x69, 0x6f, 0x2a, 0x6d, 0x0a, 0x11, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69,
+ 0x70, 0x61, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x0f, 0x0a, 0x0b, 0x55, 0x4e,
+ 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x0a, 0x0a, 0x06, 0x41,
+ 0x43, 0x54, 0x49, 0x56, 0x45, 0x10, 0x01, 0x12, 0x0c, 0x0a, 0x08, 0x49, 0x4e, 0x41, 0x43, 0x54,
+ 0x49, 0x56, 0x45, 0x10, 0x02, 0x12, 0x0b, 0x0a, 0x07, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44,
+ 0x10, 0x03, 0x12, 0x0f, 0x0a, 0x07, 0x52, 0x41, 0x4d, 0x50, 0x49, 0x4e, 0x47, 0x10, 0x04, 0x1a,
+ 0x02, 0x08, 0x01, 0x12, 0x0f, 0x0a, 0x0b, 0x55, 0x4e, 0x43, 0x4f, 0x4e, 0x46, 0x49, 0x52, 0x4d,
+ 0x45, 0x44, 0x10, 0x05, 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, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 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_participant_proto_rawDescOnce sync.Once
+ file_inference_inference_participant_proto_rawDescData = file_inference_inference_participant_proto_rawDesc
+)
+
+func file_inference_inference_participant_proto_rawDescGZIP() []byte {
+ file_inference_inference_participant_proto_rawDescOnce.Do(func() {
+ file_inference_inference_participant_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_inference_participant_proto_rawDescData)
+ })
+ return file_inference_inference_participant_proto_rawDescData
+}
+
+var file_inference_inference_participant_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
+var file_inference_inference_participant_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
+var file_inference_inference_participant_proto_goTypes = []interface{}{
+ (ParticipantStatus)(0), // 0: inference.inference.ParticipantStatus
+ (*Participant)(nil), // 1: inference.inference.Participant
+ (*CurrentEpochStats)(nil), // 2: inference.inference.CurrentEpochStats
+ (*Decimal)(nil), // 3: inference.inference.Decimal
+}
+var file_inference_inference_participant_proto_depIdxs = []int32{
+ 0, // 0: inference.inference.Participant.status:type_name -> inference.inference.ParticipantStatus
+ 2, // 1: inference.inference.Participant.current_epoch_stats:type_name -> inference.inference.CurrentEpochStats
+ 3, // 2: inference.inference.CurrentEpochStats.invalidLLR:type_name -> inference.inference.Decimal
+ 3, // 3: inference.inference.CurrentEpochStats.inactiveLLR:type_name -> inference.inference.Decimal
+ 3, // 4: inference.inference.CurrentEpochStats.confirmationPoCRatio:type_name -> inference.inference.Decimal
+ 5, // [5:5] is the sub-list for method output_type
+ 5, // [5:5] is the sub-list for method input_type
+ 5, // [5:5] is the sub-list for extension type_name
+ 5, // [5:5] is the sub-list for extension extendee
+ 0, // [0:5] is the sub-list for field type_name
+}
+
+func init() { file_inference_inference_participant_proto_init() }
+func file_inference_inference_participant_proto_init() {
+ if File_inference_inference_participant_proto != nil {
+ return
+ }
+ file_inference_inference_params_proto_init()
+ if !protoimpl.UnsafeEnabled {
+ file_inference_inference_participant_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*Participant); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_inference_participant_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*CurrentEpochStats); 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_participant_proto_rawDesc,
+ NumEnums: 1,
+ NumMessages: 2,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_inference_participant_proto_goTypes,
+ DependencyIndexes: file_inference_inference_participant_proto_depIdxs,
+ EnumInfos: file_inference_inference_participant_proto_enumTypes,
+ MessageInfos: file_inference_inference_participant_proto_msgTypes,
+ }.Build()
+ File_inference_inference_participant_proto = out.File
+ file_inference_inference_participant_proto_rawDesc = nil
+ file_inference_inference_participant_proto_goTypes = nil
+ file_inference_inference_participant_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/inference/pocbatch.pulsar.go b/inference-chain/api/inference/inference/pocbatch.pulsar.go
new file mode 100644
index 000000000..01b31def7
--- /dev/null
+++ b/inference-chain/api/inference/inference/pocbatch.pulsar.go
@@ -0,0 +1,2625 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package inference
+
+import (
+ binary "encoding/binary"
+ 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"
+ math "math"
+ reflect "reflect"
+ sync "sync"
+)
+
+var _ protoreflect.List = (*_PoCBatch_4_list)(nil)
+
+type _PoCBatch_4_list struct {
+ list *[]int64
+}
+
+func (x *_PoCBatch_4_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_PoCBatch_4_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfInt64((*x.list)[i])
+}
+
+func (x *_PoCBatch_4_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Int()
+ concreteValue := valueUnwrapped
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_PoCBatch_4_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Int()
+ concreteValue := valueUnwrapped
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_PoCBatch_4_list) AppendMutable() protoreflect.Value {
+ panic(fmt.Errorf("AppendMutable can not be called on message PoCBatch at list field Nonces as it is not of Message kind"))
+}
+
+func (x *_PoCBatch_4_list) Truncate(n int) {
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_PoCBatch_4_list) NewElement() protoreflect.Value {
+ v := int64(0)
+ return protoreflect.ValueOfInt64(v)
+}
+
+func (x *_PoCBatch_4_list) IsValid() bool {
+ return x.list != nil
+}
+
+var _ protoreflect.List = (*_PoCBatch_5_list)(nil)
+
+type _PoCBatch_5_list struct {
+ list *[]float64
+}
+
+func (x *_PoCBatch_5_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_PoCBatch_5_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfFloat64((*x.list)[i])
+}
+
+func (x *_PoCBatch_5_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Float()
+ concreteValue := valueUnwrapped
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_PoCBatch_5_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Float()
+ concreteValue := valueUnwrapped
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_PoCBatch_5_list) AppendMutable() protoreflect.Value {
+ panic(fmt.Errorf("AppendMutable can not be called on message PoCBatch at list field Dist as it is not of Message kind"))
+}
+
+func (x *_PoCBatch_5_list) Truncate(n int) {
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_PoCBatch_5_list) NewElement() protoreflect.Value {
+ v := float64(0)
+ return protoreflect.ValueOfFloat64(v)
+}
+
+func (x *_PoCBatch_5_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_PoCBatch protoreflect.MessageDescriptor
+ fd_PoCBatch_participant_address protoreflect.FieldDescriptor
+ fd_PoCBatch_poc_stage_start_block_height protoreflect.FieldDescriptor
+ fd_PoCBatch_received_at_block_height protoreflect.FieldDescriptor
+ fd_PoCBatch_nonces protoreflect.FieldDescriptor
+ fd_PoCBatch_dist protoreflect.FieldDescriptor
+ fd_PoCBatch_batch_id protoreflect.FieldDescriptor
+ fd_PoCBatch_node_id protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_pocbatch_proto_init()
+ md_PoCBatch = File_inference_inference_pocbatch_proto.Messages().ByName("PoCBatch")
+ fd_PoCBatch_participant_address = md_PoCBatch.Fields().ByName("participant_address")
+ fd_PoCBatch_poc_stage_start_block_height = md_PoCBatch.Fields().ByName("poc_stage_start_block_height")
+ fd_PoCBatch_received_at_block_height = md_PoCBatch.Fields().ByName("received_at_block_height")
+ fd_PoCBatch_nonces = md_PoCBatch.Fields().ByName("nonces")
+ fd_PoCBatch_dist = md_PoCBatch.Fields().ByName("dist")
+ fd_PoCBatch_batch_id = md_PoCBatch.Fields().ByName("batch_id")
+ fd_PoCBatch_node_id = md_PoCBatch.Fields().ByName("node_id")
+}
+
+var _ protoreflect.Message = (*fastReflection_PoCBatch)(nil)
+
+type fastReflection_PoCBatch PoCBatch
+
+func (x *PoCBatch) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_PoCBatch)(x)
+}
+
+func (x *PoCBatch) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_pocbatch_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_PoCBatch_messageType fastReflection_PoCBatch_messageType
+var _ protoreflect.MessageType = fastReflection_PoCBatch_messageType{}
+
+type fastReflection_PoCBatch_messageType struct{}
+
+func (x fastReflection_PoCBatch_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_PoCBatch)(nil)
+}
+func (x fastReflection_PoCBatch_messageType) New() protoreflect.Message {
+ return new(fastReflection_PoCBatch)
+}
+func (x fastReflection_PoCBatch_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_PoCBatch
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_PoCBatch) Descriptor() protoreflect.MessageDescriptor {
+ return md_PoCBatch
+}
+
+// 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_PoCBatch) Type() protoreflect.MessageType {
+ return _fastReflection_PoCBatch_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_PoCBatch) New() protoreflect.Message {
+ return new(fastReflection_PoCBatch)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_PoCBatch) Interface() protoreflect.ProtoMessage {
+ return (*PoCBatch)(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_PoCBatch) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.ParticipantAddress != "" {
+ value := protoreflect.ValueOfString(x.ParticipantAddress)
+ if !f(fd_PoCBatch_participant_address, value) {
+ return
+ }
+ }
+ if x.PocStageStartBlockHeight != int64(0) {
+ value := protoreflect.ValueOfInt64(x.PocStageStartBlockHeight)
+ if !f(fd_PoCBatch_poc_stage_start_block_height, value) {
+ return
+ }
+ }
+ if x.ReceivedAtBlockHeight != int64(0) {
+ value := protoreflect.ValueOfInt64(x.ReceivedAtBlockHeight)
+ if !f(fd_PoCBatch_received_at_block_height, value) {
+ return
+ }
+ }
+ if len(x.Nonces) != 0 {
+ value := protoreflect.ValueOfList(&_PoCBatch_4_list{list: &x.Nonces})
+ if !f(fd_PoCBatch_nonces, value) {
+ return
+ }
+ }
+ if len(x.Dist) != 0 {
+ value := protoreflect.ValueOfList(&_PoCBatch_5_list{list: &x.Dist})
+ if !f(fd_PoCBatch_dist, value) {
+ return
+ }
+ }
+ if x.BatchId != "" {
+ value := protoreflect.ValueOfString(x.BatchId)
+ if !f(fd_PoCBatch_batch_id, value) {
+ return
+ }
+ }
+ if x.NodeId != "" {
+ value := protoreflect.ValueOfString(x.NodeId)
+ if !f(fd_PoCBatch_node_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_PoCBatch) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.PoCBatch.participant_address":
+ return x.ParticipantAddress != ""
+ case "inference.inference.PoCBatch.poc_stage_start_block_height":
+ return x.PocStageStartBlockHeight != int64(0)
+ case "inference.inference.PoCBatch.received_at_block_height":
+ return x.ReceivedAtBlockHeight != int64(0)
+ case "inference.inference.PoCBatch.nonces":
+ return len(x.Nonces) != 0
+ case "inference.inference.PoCBatch.dist":
+ return len(x.Dist) != 0
+ case "inference.inference.PoCBatch.batch_id":
+ return x.BatchId != ""
+ case "inference.inference.PoCBatch.node_id":
+ return x.NodeId != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCBatch"))
+ }
+ panic(fmt.Errorf("message inference.inference.PoCBatch 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_PoCBatch) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.PoCBatch.participant_address":
+ x.ParticipantAddress = ""
+ case "inference.inference.PoCBatch.poc_stage_start_block_height":
+ x.PocStageStartBlockHeight = int64(0)
+ case "inference.inference.PoCBatch.received_at_block_height":
+ x.ReceivedAtBlockHeight = int64(0)
+ case "inference.inference.PoCBatch.nonces":
+ x.Nonces = nil
+ case "inference.inference.PoCBatch.dist":
+ x.Dist = nil
+ case "inference.inference.PoCBatch.batch_id":
+ x.BatchId = ""
+ case "inference.inference.PoCBatch.node_id":
+ x.NodeId = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCBatch"))
+ }
+ panic(fmt.Errorf("message inference.inference.PoCBatch 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_PoCBatch) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.PoCBatch.participant_address":
+ value := x.ParticipantAddress
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.PoCBatch.poc_stage_start_block_height":
+ value := x.PocStageStartBlockHeight
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.PoCBatch.received_at_block_height":
+ value := x.ReceivedAtBlockHeight
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.PoCBatch.nonces":
+ if len(x.Nonces) == 0 {
+ return protoreflect.ValueOfList(&_PoCBatch_4_list{})
+ }
+ listValue := &_PoCBatch_4_list{list: &x.Nonces}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.inference.PoCBatch.dist":
+ if len(x.Dist) == 0 {
+ return protoreflect.ValueOfList(&_PoCBatch_5_list{})
+ }
+ listValue := &_PoCBatch_5_list{list: &x.Dist}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.inference.PoCBatch.batch_id":
+ value := x.BatchId
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.PoCBatch.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.PoCBatch"))
+ }
+ panic(fmt.Errorf("message inference.inference.PoCBatch 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_PoCBatch) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.PoCBatch.participant_address":
+ x.ParticipantAddress = value.Interface().(string)
+ case "inference.inference.PoCBatch.poc_stage_start_block_height":
+ x.PocStageStartBlockHeight = value.Int()
+ case "inference.inference.PoCBatch.received_at_block_height":
+ x.ReceivedAtBlockHeight = value.Int()
+ case "inference.inference.PoCBatch.nonces":
+ lv := value.List()
+ clv := lv.(*_PoCBatch_4_list)
+ x.Nonces = *clv.list
+ case "inference.inference.PoCBatch.dist":
+ lv := value.List()
+ clv := lv.(*_PoCBatch_5_list)
+ x.Dist = *clv.list
+ case "inference.inference.PoCBatch.batch_id":
+ x.BatchId = value.Interface().(string)
+ case "inference.inference.PoCBatch.node_id":
+ x.NodeId = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCBatch"))
+ }
+ panic(fmt.Errorf("message inference.inference.PoCBatch 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_PoCBatch) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.PoCBatch.nonces":
+ if x.Nonces == nil {
+ x.Nonces = []int64{}
+ }
+ value := &_PoCBatch_4_list{list: &x.Nonces}
+ return protoreflect.ValueOfList(value)
+ case "inference.inference.PoCBatch.dist":
+ if x.Dist == nil {
+ x.Dist = []float64{}
+ }
+ value := &_PoCBatch_5_list{list: &x.Dist}
+ return protoreflect.ValueOfList(value)
+ case "inference.inference.PoCBatch.participant_address":
+ panic(fmt.Errorf("field participant_address of message inference.inference.PoCBatch is not mutable"))
+ case "inference.inference.PoCBatch.poc_stage_start_block_height":
+ panic(fmt.Errorf("field poc_stage_start_block_height of message inference.inference.PoCBatch is not mutable"))
+ case "inference.inference.PoCBatch.received_at_block_height":
+ panic(fmt.Errorf("field received_at_block_height of message inference.inference.PoCBatch is not mutable"))
+ case "inference.inference.PoCBatch.batch_id":
+ panic(fmt.Errorf("field batch_id of message inference.inference.PoCBatch is not mutable"))
+ case "inference.inference.PoCBatch.node_id":
+ panic(fmt.Errorf("field node_id of message inference.inference.PoCBatch is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCBatch"))
+ }
+ panic(fmt.Errorf("message inference.inference.PoCBatch 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_PoCBatch) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.PoCBatch.participant_address":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.PoCBatch.poc_stage_start_block_height":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.PoCBatch.received_at_block_height":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.PoCBatch.nonces":
+ list := []int64{}
+ return protoreflect.ValueOfList(&_PoCBatch_4_list{list: &list})
+ case "inference.inference.PoCBatch.dist":
+ list := []float64{}
+ return protoreflect.ValueOfList(&_PoCBatch_5_list{list: &list})
+ case "inference.inference.PoCBatch.batch_id":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.PoCBatch.node_id":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCBatch"))
+ }
+ panic(fmt.Errorf("message inference.inference.PoCBatch 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_PoCBatch) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.PoCBatch", 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_PoCBatch) 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_PoCBatch) 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_PoCBatch) 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_PoCBatch) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*PoCBatch)
+ 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.ParticipantAddress)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.PocStageStartBlockHeight != 0 {
+ n += 1 + runtime.Sov(uint64(x.PocStageStartBlockHeight))
+ }
+ if x.ReceivedAtBlockHeight != 0 {
+ n += 1 + runtime.Sov(uint64(x.ReceivedAtBlockHeight))
+ }
+ 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.BatchId)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ l = len(x.NodeId)
+ 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().(*PoCBatch)
+ 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.NodeId) > 0 {
+ i -= len(x.NodeId)
+ copy(dAtA[i:], x.NodeId)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.NodeId)))
+ i--
+ dAtA[i] = 0x3a
+ }
+ 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] = 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++
+ }
+ dAtA[j2] = uint8(num)
+ j2++
+ }
+ i = runtime.EncodeVarint(dAtA, i, uint64(pksize3))
+ i--
+ dAtA[i] = 0x22
+ }
+ if x.ReceivedAtBlockHeight != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.ReceivedAtBlockHeight))
+ i--
+ dAtA[i] = 0x18
+ }
+ if x.PocStageStartBlockHeight != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.PocStageStartBlockHeight))
+ 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
+ }
+ return protoiface.MarshalOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Buf: input.Buf,
+ }, nil
+ }
+ unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+ x := input.Message.Interface().(*PoCBatch)
+ 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: PoCBatch: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: PoCBatch: 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 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 != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ReceivedAtBlockHeight", wireType)
+ }
+ x.ReceivedAtBlockHeight = 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.ReceivedAtBlockHeight |= int64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ 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 BatchId", 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.BatchId = 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 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 (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 = (*_PoCValidation_5_list)(nil)
+
+type _PoCValidation_5_list struct {
+ list *[]int64
+}
+
+func (x *_PoCValidation_5_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_PoCValidation_5_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfInt64((*x.list)[i])
+}
+
+func (x *_PoCValidation_5_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Int()
+ concreteValue := valueUnwrapped
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_PoCValidation_5_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Int()
+ concreteValue := valueUnwrapped
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_PoCValidation_5_list) AppendMutable() protoreflect.Value {
+ panic(fmt.Errorf("AppendMutable can not be called on message PoCValidation at list field Nonces as it is not of Message kind"))
+}
+
+func (x *_PoCValidation_5_list) Truncate(n int) {
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_PoCValidation_5_list) NewElement() protoreflect.Value {
+ v := int64(0)
+ return protoreflect.ValueOfInt64(v)
+}
+
+func (x *_PoCValidation_5_list) IsValid() bool {
+ return x.list != nil
+}
+
+var _ protoreflect.List = (*_PoCValidation_6_list)(nil)
+
+type _PoCValidation_6_list struct {
+ list *[]float64
+}
+
+func (x *_PoCValidation_6_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_PoCValidation_6_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfFloat64((*x.list)[i])
+}
+
+func (x *_PoCValidation_6_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Float()
+ concreteValue := valueUnwrapped
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_PoCValidation_6_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Float()
+ concreteValue := valueUnwrapped
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_PoCValidation_6_list) AppendMutable() protoreflect.Value {
+ panic(fmt.Errorf("AppendMutable can not be called on message PoCValidation at list field Dist as it is not of Message kind"))
+}
+
+func (x *_PoCValidation_6_list) Truncate(n int) {
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_PoCValidation_6_list) NewElement() protoreflect.Value {
+ v := float64(0)
+ return protoreflect.ValueOfFloat64(v)
+}
+
+func (x *_PoCValidation_6_list) IsValid() bool {
+ return x.list != nil
+}
+
+var _ protoreflect.List = (*_PoCValidation_7_list)(nil)
+
+type _PoCValidation_7_list struct {
+ list *[]float64
+}
+
+func (x *_PoCValidation_7_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_PoCValidation_7_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfFloat64((*x.list)[i])
+}
+
+func (x *_PoCValidation_7_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Float()
+ concreteValue := valueUnwrapped
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_PoCValidation_7_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Float()
+ concreteValue := valueUnwrapped
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_PoCValidation_7_list) AppendMutable() protoreflect.Value {
+ panic(fmt.Errorf("AppendMutable can not be called on message PoCValidation at list field ReceivedDist as it is not of Message kind"))
+}
+
+func (x *_PoCValidation_7_list) Truncate(n int) {
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_PoCValidation_7_list) NewElement() protoreflect.Value {
+ v := float64(0)
+ return protoreflect.ValueOfFloat64(v)
+}
+
+func (x *_PoCValidation_7_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_PoCValidation protoreflect.MessageDescriptor
+ fd_PoCValidation_participant_address protoreflect.FieldDescriptor
+ fd_PoCValidation_validator_participant_address protoreflect.FieldDescriptor
+ fd_PoCValidation_poc_stage_start_block_height protoreflect.FieldDescriptor
+ fd_PoCValidation_validated_at_block_height protoreflect.FieldDescriptor
+ fd_PoCValidation_nonces protoreflect.FieldDescriptor
+ fd_PoCValidation_dist protoreflect.FieldDescriptor
+ fd_PoCValidation_received_dist protoreflect.FieldDescriptor
+ fd_PoCValidation_r_target protoreflect.FieldDescriptor
+ fd_PoCValidation_fraud_threshold protoreflect.FieldDescriptor
+ fd_PoCValidation_n_invalid protoreflect.FieldDescriptor
+ fd_PoCValidation_probability_honest protoreflect.FieldDescriptor
+ fd_PoCValidation_fraud_detected protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_pocbatch_proto_init()
+ md_PoCValidation = File_inference_inference_pocbatch_proto.Messages().ByName("PoCValidation")
+ fd_PoCValidation_participant_address = md_PoCValidation.Fields().ByName("participant_address")
+ fd_PoCValidation_validator_participant_address = md_PoCValidation.Fields().ByName("validator_participant_address")
+ fd_PoCValidation_poc_stage_start_block_height = md_PoCValidation.Fields().ByName("poc_stage_start_block_height")
+ fd_PoCValidation_validated_at_block_height = md_PoCValidation.Fields().ByName("validated_at_block_height")
+ fd_PoCValidation_nonces = md_PoCValidation.Fields().ByName("nonces")
+ fd_PoCValidation_dist = md_PoCValidation.Fields().ByName("dist")
+ fd_PoCValidation_received_dist = md_PoCValidation.Fields().ByName("received_dist")
+ fd_PoCValidation_r_target = md_PoCValidation.Fields().ByName("r_target")
+ fd_PoCValidation_fraud_threshold = md_PoCValidation.Fields().ByName("fraud_threshold")
+ fd_PoCValidation_n_invalid = md_PoCValidation.Fields().ByName("n_invalid")
+ fd_PoCValidation_probability_honest = md_PoCValidation.Fields().ByName("probability_honest")
+ fd_PoCValidation_fraud_detected = md_PoCValidation.Fields().ByName("fraud_detected")
+}
+
+var _ protoreflect.Message = (*fastReflection_PoCValidation)(nil)
+
+type fastReflection_PoCValidation PoCValidation
+
+func (x *PoCValidation) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_PoCValidation)(x)
+}
+
+func (x *PoCValidation) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_pocbatch_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_PoCValidation_messageType fastReflection_PoCValidation_messageType
+var _ protoreflect.MessageType = fastReflection_PoCValidation_messageType{}
+
+type fastReflection_PoCValidation_messageType struct{}
+
+func (x fastReflection_PoCValidation_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_PoCValidation)(nil)
+}
+func (x fastReflection_PoCValidation_messageType) New() protoreflect.Message {
+ return new(fastReflection_PoCValidation)
+}
+func (x fastReflection_PoCValidation_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_PoCValidation
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_PoCValidation) Descriptor() protoreflect.MessageDescriptor {
+ return md_PoCValidation
+}
+
+// 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_PoCValidation) Type() protoreflect.MessageType {
+ return _fastReflection_PoCValidation_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_PoCValidation) New() protoreflect.Message {
+ return new(fastReflection_PoCValidation)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_PoCValidation) Interface() protoreflect.ProtoMessage {
+ return (*PoCValidation)(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_PoCValidation) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.ParticipantAddress != "" {
+ value := protoreflect.ValueOfString(x.ParticipantAddress)
+ if !f(fd_PoCValidation_participant_address, value) {
+ return
+ }
+ }
+ if x.ValidatorParticipantAddress != "" {
+ value := protoreflect.ValueOfString(x.ValidatorParticipantAddress)
+ if !f(fd_PoCValidation_validator_participant_address, value) {
+ return
+ }
+ }
+ if x.PocStageStartBlockHeight != int64(0) {
+ value := protoreflect.ValueOfInt64(x.PocStageStartBlockHeight)
+ if !f(fd_PoCValidation_poc_stage_start_block_height, value) {
+ return
+ }
+ }
+ if x.ValidatedAtBlockHeight != int64(0) {
+ value := protoreflect.ValueOfInt64(x.ValidatedAtBlockHeight)
+ if !f(fd_PoCValidation_validated_at_block_height, value) {
+ return
+ }
+ }
+ if len(x.Nonces) != 0 {
+ value := protoreflect.ValueOfList(&_PoCValidation_5_list{list: &x.Nonces})
+ if !f(fd_PoCValidation_nonces, value) {
+ return
+ }
+ }
+ if len(x.Dist) != 0 {
+ value := protoreflect.ValueOfList(&_PoCValidation_6_list{list: &x.Dist})
+ if !f(fd_PoCValidation_dist, value) {
+ return
+ }
+ }
+ if len(x.ReceivedDist) != 0 {
+ value := protoreflect.ValueOfList(&_PoCValidation_7_list{list: &x.ReceivedDist})
+ if !f(fd_PoCValidation_received_dist, value) {
+ return
+ }
+ }
+ if x.RTarget != float64(0) || math.Signbit(x.RTarget) {
+ value := protoreflect.ValueOfFloat64(x.RTarget)
+ if !f(fd_PoCValidation_r_target, value) {
+ return
+ }
+ }
+ if x.FraudThreshold != float64(0) || math.Signbit(x.FraudThreshold) {
+ value := protoreflect.ValueOfFloat64(x.FraudThreshold)
+ if !f(fd_PoCValidation_fraud_threshold, value) {
+ return
+ }
+ }
+ if x.NInvalid != int64(0) {
+ value := protoreflect.ValueOfInt64(x.NInvalid)
+ if !f(fd_PoCValidation_n_invalid, value) {
+ return
+ }
+ }
+ if x.ProbabilityHonest != float64(0) || math.Signbit(x.ProbabilityHonest) {
+ value := protoreflect.ValueOfFloat64(x.ProbabilityHonest)
+ if !f(fd_PoCValidation_probability_honest, value) {
+ return
+ }
+ }
+ if x.FraudDetected != false {
+ value := protoreflect.ValueOfBool(x.FraudDetected)
+ if !f(fd_PoCValidation_fraud_detected, 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_PoCValidation) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.PoCValidation.participant_address":
+ return x.ParticipantAddress != ""
+ case "inference.inference.PoCValidation.validator_participant_address":
+ return x.ValidatorParticipantAddress != ""
+ case "inference.inference.PoCValidation.poc_stage_start_block_height":
+ return x.PocStageStartBlockHeight != int64(0)
+ case "inference.inference.PoCValidation.validated_at_block_height":
+ return x.ValidatedAtBlockHeight != int64(0)
+ case "inference.inference.PoCValidation.nonces":
+ return len(x.Nonces) != 0
+ case "inference.inference.PoCValidation.dist":
+ return len(x.Dist) != 0
+ case "inference.inference.PoCValidation.received_dist":
+ return len(x.ReceivedDist) != 0
+ case "inference.inference.PoCValidation.r_target":
+ return x.RTarget != float64(0) || math.Signbit(x.RTarget)
+ case "inference.inference.PoCValidation.fraud_threshold":
+ return x.FraudThreshold != float64(0) || math.Signbit(x.FraudThreshold)
+ case "inference.inference.PoCValidation.n_invalid":
+ return x.NInvalid != int64(0)
+ case "inference.inference.PoCValidation.probability_honest":
+ return x.ProbabilityHonest != float64(0) || math.Signbit(x.ProbabilityHonest)
+ case "inference.inference.PoCValidation.fraud_detected":
+ return x.FraudDetected != false
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCValidation"))
+ }
+ panic(fmt.Errorf("message inference.inference.PoCValidation 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_PoCValidation) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.PoCValidation.participant_address":
+ x.ParticipantAddress = ""
+ case "inference.inference.PoCValidation.validator_participant_address":
+ x.ValidatorParticipantAddress = ""
+ case "inference.inference.PoCValidation.poc_stage_start_block_height":
+ x.PocStageStartBlockHeight = int64(0)
+ case "inference.inference.PoCValidation.validated_at_block_height":
+ x.ValidatedAtBlockHeight = int64(0)
+ case "inference.inference.PoCValidation.nonces":
+ x.Nonces = nil
+ case "inference.inference.PoCValidation.dist":
+ x.Dist = nil
+ case "inference.inference.PoCValidation.received_dist":
+ x.ReceivedDist = nil
+ case "inference.inference.PoCValidation.r_target":
+ x.RTarget = float64(0)
+ case "inference.inference.PoCValidation.fraud_threshold":
+ x.FraudThreshold = float64(0)
+ case "inference.inference.PoCValidation.n_invalid":
+ x.NInvalid = int64(0)
+ case "inference.inference.PoCValidation.probability_honest":
+ x.ProbabilityHonest = float64(0)
+ case "inference.inference.PoCValidation.fraud_detected":
+ x.FraudDetected = false
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCValidation"))
+ }
+ panic(fmt.Errorf("message inference.inference.PoCValidation 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_PoCValidation) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.PoCValidation.participant_address":
+ value := x.ParticipantAddress
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.PoCValidation.validator_participant_address":
+ value := x.ValidatorParticipantAddress
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.PoCValidation.poc_stage_start_block_height":
+ value := x.PocStageStartBlockHeight
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.PoCValidation.validated_at_block_height":
+ value := x.ValidatedAtBlockHeight
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.PoCValidation.nonces":
+ if len(x.Nonces) == 0 {
+ return protoreflect.ValueOfList(&_PoCValidation_5_list{})
+ }
+ listValue := &_PoCValidation_5_list{list: &x.Nonces}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.inference.PoCValidation.dist":
+ if len(x.Dist) == 0 {
+ return protoreflect.ValueOfList(&_PoCValidation_6_list{})
+ }
+ listValue := &_PoCValidation_6_list{list: &x.Dist}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.inference.PoCValidation.received_dist":
+ if len(x.ReceivedDist) == 0 {
+ return protoreflect.ValueOfList(&_PoCValidation_7_list{})
+ }
+ listValue := &_PoCValidation_7_list{list: &x.ReceivedDist}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.inference.PoCValidation.r_target":
+ value := x.RTarget
+ return protoreflect.ValueOfFloat64(value)
+ case "inference.inference.PoCValidation.fraud_threshold":
+ value := x.FraudThreshold
+ return protoreflect.ValueOfFloat64(value)
+ case "inference.inference.PoCValidation.n_invalid":
+ value := x.NInvalid
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.PoCValidation.probability_honest":
+ value := x.ProbabilityHonest
+ return protoreflect.ValueOfFloat64(value)
+ case "inference.inference.PoCValidation.fraud_detected":
+ value := x.FraudDetected
+ return protoreflect.ValueOfBool(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCValidation"))
+ }
+ panic(fmt.Errorf("message inference.inference.PoCValidation 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_PoCValidation) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.PoCValidation.participant_address":
+ x.ParticipantAddress = value.Interface().(string)
+ case "inference.inference.PoCValidation.validator_participant_address":
+ x.ValidatorParticipantAddress = value.Interface().(string)
+ case "inference.inference.PoCValidation.poc_stage_start_block_height":
+ x.PocStageStartBlockHeight = value.Int()
+ case "inference.inference.PoCValidation.validated_at_block_height":
+ x.ValidatedAtBlockHeight = value.Int()
+ case "inference.inference.PoCValidation.nonces":
+ lv := value.List()
+ clv := lv.(*_PoCValidation_5_list)
+ x.Nonces = *clv.list
+ case "inference.inference.PoCValidation.dist":
+ lv := value.List()
+ clv := lv.(*_PoCValidation_6_list)
+ x.Dist = *clv.list
+ case "inference.inference.PoCValidation.received_dist":
+ lv := value.List()
+ clv := lv.(*_PoCValidation_7_list)
+ x.ReceivedDist = *clv.list
+ case "inference.inference.PoCValidation.r_target":
+ x.RTarget = value.Float()
+ case "inference.inference.PoCValidation.fraud_threshold":
+ x.FraudThreshold = value.Float()
+ case "inference.inference.PoCValidation.n_invalid":
+ x.NInvalid = value.Int()
+ case "inference.inference.PoCValidation.probability_honest":
+ x.ProbabilityHonest = value.Float()
+ case "inference.inference.PoCValidation.fraud_detected":
+ x.FraudDetected = value.Bool()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCValidation"))
+ }
+ panic(fmt.Errorf("message inference.inference.PoCValidation 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_PoCValidation) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.PoCValidation.nonces":
+ if x.Nonces == nil {
+ x.Nonces = []int64{}
+ }
+ value := &_PoCValidation_5_list{list: &x.Nonces}
+ return protoreflect.ValueOfList(value)
+ case "inference.inference.PoCValidation.dist":
+ if x.Dist == nil {
+ x.Dist = []float64{}
+ }
+ value := &_PoCValidation_6_list{list: &x.Dist}
+ return protoreflect.ValueOfList(value)
+ case "inference.inference.PoCValidation.received_dist":
+ if x.ReceivedDist == nil {
+ x.ReceivedDist = []float64{}
+ }
+ value := &_PoCValidation_7_list{list: &x.ReceivedDist}
+ return protoreflect.ValueOfList(value)
+ case "inference.inference.PoCValidation.participant_address":
+ panic(fmt.Errorf("field participant_address of message inference.inference.PoCValidation is not mutable"))
+ case "inference.inference.PoCValidation.validator_participant_address":
+ panic(fmt.Errorf("field validator_participant_address of message inference.inference.PoCValidation is not mutable"))
+ case "inference.inference.PoCValidation.poc_stage_start_block_height":
+ panic(fmt.Errorf("field poc_stage_start_block_height of message inference.inference.PoCValidation is not mutable"))
+ case "inference.inference.PoCValidation.validated_at_block_height":
+ panic(fmt.Errorf("field validated_at_block_height of message inference.inference.PoCValidation is not mutable"))
+ case "inference.inference.PoCValidation.r_target":
+ panic(fmt.Errorf("field r_target of message inference.inference.PoCValidation is not mutable"))
+ case "inference.inference.PoCValidation.fraud_threshold":
+ panic(fmt.Errorf("field fraud_threshold of message inference.inference.PoCValidation is not mutable"))
+ case "inference.inference.PoCValidation.n_invalid":
+ panic(fmt.Errorf("field n_invalid of message inference.inference.PoCValidation is not mutable"))
+ case "inference.inference.PoCValidation.probability_honest":
+ panic(fmt.Errorf("field probability_honest of message inference.inference.PoCValidation is not mutable"))
+ case "inference.inference.PoCValidation.fraud_detected":
+ panic(fmt.Errorf("field fraud_detected of message inference.inference.PoCValidation is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCValidation"))
+ }
+ panic(fmt.Errorf("message inference.inference.PoCValidation 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_PoCValidation) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.PoCValidation.participant_address":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.PoCValidation.validator_participant_address":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.PoCValidation.poc_stage_start_block_height":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.PoCValidation.validated_at_block_height":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.PoCValidation.nonces":
+ list := []int64{}
+ return protoreflect.ValueOfList(&_PoCValidation_5_list{list: &list})
+ case "inference.inference.PoCValidation.dist":
+ list := []float64{}
+ return protoreflect.ValueOfList(&_PoCValidation_6_list{list: &list})
+ case "inference.inference.PoCValidation.received_dist":
+ list := []float64{}
+ return protoreflect.ValueOfList(&_PoCValidation_7_list{list: &list})
+ case "inference.inference.PoCValidation.r_target":
+ return protoreflect.ValueOfFloat64(float64(0))
+ case "inference.inference.PoCValidation.fraud_threshold":
+ return protoreflect.ValueOfFloat64(float64(0))
+ case "inference.inference.PoCValidation.n_invalid":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.PoCValidation.probability_honest":
+ return protoreflect.ValueOfFloat64(float64(0))
+ case "inference.inference.PoCValidation.fraud_detected":
+ return protoreflect.ValueOfBool(false)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCValidation"))
+ }
+ panic(fmt.Errorf("message inference.inference.PoCValidation 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_PoCValidation) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.PoCValidation", 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_PoCValidation) 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_PoCValidation) 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_PoCValidation) 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_PoCValidation) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*PoCValidation)
+ 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.ParticipantAddress)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ l = len(x.ValidatorParticipantAddress)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.PocStageStartBlockHeight != 0 {
+ n += 1 + runtime.Sov(uint64(x.PocStageStartBlockHeight))
+ }
+ if x.ValidatedAtBlockHeight != 0 {
+ n += 1 + runtime.Sov(uint64(x.ValidatedAtBlockHeight))
+ }
+ 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
+ }
+ if len(x.ReceivedDist) > 0 {
+ n += 1 + runtime.Sov(uint64(len(x.ReceivedDist)*8)) + len(x.ReceivedDist)*8
+ }
+ if x.RTarget != 0 || math.Signbit(x.RTarget) {
+ n += 9
+ }
+ if x.FraudThreshold != 0 || math.Signbit(x.FraudThreshold) {
+ n += 9
+ }
+ if x.NInvalid != 0 {
+ n += 1 + runtime.Sov(uint64(x.NInvalid))
+ }
+ if x.ProbabilityHonest != 0 || math.Signbit(x.ProbabilityHonest) {
+ n += 9
+ }
+ if x.FraudDetected {
+ 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().(*PoCValidation)
+ 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.FraudDetected {
+ i--
+ if x.FraudDetected {
+ dAtA[i] = 1
+ } else {
+ dAtA[i] = 0
+ }
+ i--
+ dAtA[i] = 0x60
+ }
+ if x.ProbabilityHonest != 0 || math.Signbit(x.ProbabilityHonest) {
+ i -= 8
+ binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(x.ProbabilityHonest))))
+ i--
+ dAtA[i] = 0x59
+ }
+ if x.NInvalid != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.NInvalid))
+ i--
+ dAtA[i] = 0x50
+ }
+ if x.FraudThreshold != 0 || math.Signbit(x.FraudThreshold) {
+ i -= 8
+ binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(x.FraudThreshold))))
+ i--
+ dAtA[i] = 0x49
+ }
+ if x.RTarget != 0 || math.Signbit(x.RTarget) {
+ i -= 8
+ binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(x.RTarget))))
+ i--
+ dAtA[i] = 0x41
+ }
+ if len(x.ReceivedDist) > 0 {
+ for iNdEx := len(x.ReceivedDist) - 1; iNdEx >= 0; iNdEx-- {
+ f1 := math.Float64bits(float64(x.ReceivedDist[iNdEx]))
+ i -= 8
+ binary.LittleEndian.PutUint64(dAtA[i:], uint64(f1))
+ }
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ReceivedDist)*8))
+ i--
+ dAtA[i] = 0x3a
+ }
+ if len(x.Dist) > 0 {
+ for iNdEx := len(x.Dist) - 1; iNdEx >= 0; iNdEx-- {
+ f2 := math.Float64bits(float64(x.Dist[iNdEx]))
+ i -= 8
+ binary.LittleEndian.PutUint64(dAtA[i:], uint64(f2))
+ }
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Dist)*8))
+ i--
+ dAtA[i] = 0x32
+ }
+ if len(x.Nonces) > 0 {
+ var pksize4 int
+ for _, num := range x.Nonces {
+ pksize4 += runtime.Sov(uint64(num))
+ }
+ i -= pksize4
+ j3 := i
+ for _, num1 := range x.Nonces {
+ num := uint64(num1)
+ for num >= 1<<7 {
+ dAtA[j3] = uint8(uint64(num)&0x7f | 0x80)
+ num >>= 7
+ j3++
+ }
+ dAtA[j3] = uint8(num)
+ j3++
+ }
+ i = runtime.EncodeVarint(dAtA, i, uint64(pksize4))
+ i--
+ dAtA[i] = 0x2a
+ }
+ if x.ValidatedAtBlockHeight != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.ValidatedAtBlockHeight))
+ i--
+ dAtA[i] = 0x20
+ }
+ if x.PocStageStartBlockHeight != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.PocStageStartBlockHeight))
+ i--
+ dAtA[i] = 0x18
+ }
+ if len(x.ValidatorParticipantAddress) > 0 {
+ i -= len(x.ValidatorParticipantAddress)
+ copy(dAtA[i:], x.ValidatorParticipantAddress)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ValidatorParticipantAddress)))
+ 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...)
+ } 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().(*PoCValidation)
+ 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: PoCValidation: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: PoCValidation: 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 ValidatorParticipantAddress", 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.ValidatorParticipantAddress = 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 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 4:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidatedAtBlockHeight", wireType)
+ }
+ x.ValidatedAtBlockHeight = 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.ValidatedAtBlockHeight |= int64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 5:
+ 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 6:
+ 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 7:
+ 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.ReceivedDist = append(x.ReceivedDist, 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.ReceivedDist) == 0 {
+ x.ReceivedDist = 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.ReceivedDist = append(x.ReceivedDist, v2)
+ }
+ } else {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ReceivedDist", wireType)
+ }
+ case 8:
+ if wireType != 1 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RTarget", wireType)
+ }
+ 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
+ x.RTarget = float64(math.Float64frombits(v))
+ case 9:
+ if wireType != 1 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field FraudThreshold", wireType)
+ }
+ 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
+ x.FraudThreshold = float64(math.Float64frombits(v))
+ case 10:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field NInvalid", wireType)
+ }
+ x.NInvalid = 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.NInvalid |= int64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 11:
+ if wireType != 1 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ProbabilityHonest", wireType)
+ }
+ 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
+ x.ProbabilityHonest = float64(math.Float64frombits(v))
+ case 12:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field FraudDetected", 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.FraudDetected = 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,
+ }
+}
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// protoc-gen-go v1.27.0
+// protoc (unknown)
+// source: inference/inference/pocbatch.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)
+)
+
+type PoCBatch 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"`
+ PocStageStartBlockHeight int64 `protobuf:"varint,2,opt,name=poc_stage_start_block_height,json=pocStageStartBlockHeight,proto3" json:"poc_stage_start_block_height,omitempty"`
+ ReceivedAtBlockHeight int64 `protobuf:"varint,3,opt,name=received_at_block_height,json=receivedAtBlockHeight,proto3" json:"received_at_block_height,omitempty"`
+ Nonces []int64 `protobuf:"varint,4,rep,packed,name=nonces,proto3" json:"nonces,omitempty"`
+ Dist []float64 `protobuf:"fixed64,5,rep,packed,name=dist,proto3" json:"dist,omitempty"`
+ BatchId string `protobuf:"bytes,6,opt,name=batch_id,json=batchId,proto3" json:"batch_id,omitempty"`
+ NodeId string `protobuf:"bytes,7,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
+}
+
+func (x *PoCBatch) Reset() {
+ *x = PoCBatch{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_pocbatch_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *PoCBatch) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*PoCBatch) ProtoMessage() {}
+
+// Deprecated: Use PoCBatch.ProtoReflect.Descriptor instead.
+func (*PoCBatch) Descriptor() ([]byte, []int) {
+ return file_inference_inference_pocbatch_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *PoCBatch) GetParticipantAddress() string {
+ if x != nil {
+ return x.ParticipantAddress
+ }
+ return ""
+}
+
+func (x *PoCBatch) GetPocStageStartBlockHeight() int64 {
+ if x != nil {
+ return x.PocStageStartBlockHeight
+ }
+ return 0
+}
+
+func (x *PoCBatch) GetReceivedAtBlockHeight() int64 {
+ if x != nil {
+ return x.ReceivedAtBlockHeight
+ }
+ return 0
+}
+
+func (x *PoCBatch) GetNonces() []int64 {
+ if x != nil {
+ return x.Nonces
+ }
+ return nil
+}
+
+func (x *PoCBatch) GetDist() []float64 {
+ if x != nil {
+ return x.Dist
+ }
+ return nil
+}
+
+func (x *PoCBatch) GetBatchId() string {
+ if x != nil {
+ return x.BatchId
+ }
+ return ""
+}
+
+func (x *PoCBatch) GetNodeId() string {
+ if x != nil {
+ return x.NodeId
+ }
+ return ""
+}
+
+// ignite scaffold message SubmitPocValidation participant_address poc_stage_start_block_height:int nonces:array.int dist:array.int received_dist:array.int r_target:int fraud_threshold:int n_invalid:int probability_honest:int fraud_detected:bool
+type PoCValidation 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"`
+ ValidatorParticipantAddress string `protobuf:"bytes,2,opt,name=validator_participant_address,json=validatorParticipantAddress,proto3" json:"validator_participant_address,omitempty"`
+ PocStageStartBlockHeight int64 `protobuf:"varint,3,opt,name=poc_stage_start_block_height,json=pocStageStartBlockHeight,proto3" json:"poc_stage_start_block_height,omitempty"`
+ ValidatedAtBlockHeight int64 `protobuf:"varint,4,opt,name=validated_at_block_height,json=validatedAtBlockHeight,proto3" json:"validated_at_block_height,omitempty"`
+ Nonces []int64 `protobuf:"varint,5,rep,packed,name=nonces,proto3" json:"nonces,omitempty"`
+ Dist []float64 `protobuf:"fixed64,6,rep,packed,name=dist,proto3" json:"dist,omitempty"`
+ ReceivedDist []float64 `protobuf:"fixed64,7,rep,packed,name=received_dist,json=receivedDist,proto3" json:"received_dist,omitempty"`
+ RTarget float64 `protobuf:"fixed64,8,opt,name=r_target,json=rTarget,proto3" json:"r_target,omitempty"`
+ FraudThreshold float64 `protobuf:"fixed64,9,opt,name=fraud_threshold,json=fraudThreshold,proto3" json:"fraud_threshold,omitempty"`
+ NInvalid int64 `protobuf:"varint,10,opt,name=n_invalid,json=nInvalid,proto3" json:"n_invalid,omitempty"`
+ ProbabilityHonest float64 `protobuf:"fixed64,11,opt,name=probability_honest,json=probabilityHonest,proto3" json:"probability_honest,omitempty"`
+ FraudDetected bool `protobuf:"varint,12,opt,name=fraud_detected,json=fraudDetected,proto3" json:"fraud_detected,omitempty"`
+}
+
+func (x *PoCValidation) Reset() {
+ *x = PoCValidation{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_pocbatch_proto_msgTypes[1]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *PoCValidation) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*PoCValidation) ProtoMessage() {}
+
+// Deprecated: Use PoCValidation.ProtoReflect.Descriptor instead.
+func (*PoCValidation) Descriptor() ([]byte, []int) {
+ return file_inference_inference_pocbatch_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *PoCValidation) GetParticipantAddress() string {
+ if x != nil {
+ return x.ParticipantAddress
+ }
+ return ""
+}
+
+func (x *PoCValidation) GetValidatorParticipantAddress() string {
+ if x != nil {
+ return x.ValidatorParticipantAddress
+ }
+ return ""
+}
+
+func (x *PoCValidation) GetPocStageStartBlockHeight() int64 {
+ if x != nil {
+ return x.PocStageStartBlockHeight
+ }
+ return 0
+}
+
+func (x *PoCValidation) GetValidatedAtBlockHeight() int64 {
+ if x != nil {
+ return x.ValidatedAtBlockHeight
+ }
+ return 0
+}
+
+func (x *PoCValidation) GetNonces() []int64 {
+ if x != nil {
+ return x.Nonces
+ }
+ return nil
+}
+
+func (x *PoCValidation) GetDist() []float64 {
+ if x != nil {
+ return x.Dist
+ }
+ return nil
+}
+
+func (x *PoCValidation) GetReceivedDist() []float64 {
+ if x != nil {
+ return x.ReceivedDist
+ }
+ return nil
+}
+
+func (x *PoCValidation) GetRTarget() float64 {
+ if x != nil {
+ return x.RTarget
+ }
+ return 0
+}
+
+func (x *PoCValidation) GetFraudThreshold() float64 {
+ if x != nil {
+ return x.FraudThreshold
+ }
+ return 0
+}
+
+func (x *PoCValidation) GetNInvalid() int64 {
+ if x != nil {
+ return x.NInvalid
+ }
+ return 0
+}
+
+func (x *PoCValidation) GetProbabilityHonest() float64 {
+ if x != nil {
+ return x.ProbabilityHonest
+ }
+ return 0
+}
+
+func (x *PoCValidation) GetFraudDetected() bool {
+ if x != nil {
+ return x.FraudDetected
+ }
+ return false
+}
+
+var File_inference_inference_pocbatch_proto protoreflect.FileDescriptor
+
+var file_inference_inference_pocbatch_proto_rawDesc = []byte{
+ 0x0a, 0x22, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65,
+ 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x70, 0x6f, 0x63, 0x62, 0x61, 0x74, 0x63, 0x68, 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, 0x94, 0x02, 0x0a, 0x08, 0x50, 0x6f,
+ 0x43, 0x42, 0x61, 0x74, 0x63, 0x68, 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, 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, 0x37, 0x0a, 0x18, 0x72, 0x65, 0x63, 0x65, 0x69,
+ 0x76, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69,
+ 0x67, 0x68, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x15, 0x72, 0x65, 0x63, 0x65, 0x69,
+ 0x76, 0x65, 0x64, 0x41, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74,
+ 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, 0x19, 0x0a, 0x08,
+ 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x69, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07,
+ 0x62, 0x61, 0x74, 0x63, 0x68, 0x49, 0x64, 0x12, 0x17, 0x0a, 0x07, 0x6e, 0x6f, 0x64, 0x65, 0x5f,
+ 0x69, 0x64, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x64,
+ 0x22, 0x87, 0x04, 0x0a, 0x0d, 0x50, 0x6f, 0x43, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69,
+ 0x6f, 0x6e, 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, 0x42, 0x0a, 0x1d, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72,
+ 0x5f, 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, 0x1b, 0x76, 0x61, 0x6c, 0x69,
+ 0x64, 0x61, 0x74, 0x6f, 0x72, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74,
+ 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 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, 0x03, 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, 0x39, 0x0a, 0x19, 0x76, 0x61, 0x6c, 0x69, 0x64,
+ 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65,
+ 0x69, 0x67, 0x68, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x16, 0x76, 0x61, 0x6c, 0x69,
+ 0x64, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67,
+ 0x68, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x73, 0x18, 0x05, 0x20, 0x03,
+ 0x28, 0x03, 0x52, 0x06, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x69,
+ 0x73, 0x74, 0x18, 0x06, 0x20, 0x03, 0x28, 0x01, 0x52, 0x04, 0x64, 0x69, 0x73, 0x74, 0x12, 0x23,
+ 0x0a, 0x0d, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, 0x5f, 0x64, 0x69, 0x73, 0x74, 0x18,
+ 0x07, 0x20, 0x03, 0x28, 0x01, 0x52, 0x0c, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, 0x44,
+ 0x69, 0x73, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x72, 0x5f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x18,
+ 0x08, 0x20, 0x01, 0x28, 0x01, 0x52, 0x07, 0x72, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x12, 0x27,
+ 0x0a, 0x0f, 0x66, 0x72, 0x61, 0x75, 0x64, 0x5f, 0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c,
+ 0x64, 0x18, 0x09, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0e, 0x66, 0x72, 0x61, 0x75, 0x64, 0x54, 0x68,
+ 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x6e, 0x5f, 0x69, 0x6e, 0x76,
+ 0x61, 0x6c, 0x69, 0x64, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x6e, 0x49, 0x6e, 0x76,
+ 0x61, 0x6c, 0x69, 0x64, 0x12, 0x2d, 0x0a, 0x12, 0x70, 0x72, 0x6f, 0x62, 0x61, 0x62, 0x69, 0x6c,
+ 0x69, 0x74, 0x79, 0x5f, 0x68, 0x6f, 0x6e, 0x65, 0x73, 0x74, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x01,
+ 0x52, 0x11, 0x70, 0x72, 0x6f, 0x62, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x48, 0x6f, 0x6e,
+ 0x65, 0x73, 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x66, 0x72, 0x61, 0x75, 0x64, 0x5f, 0x64, 0x65, 0x74,
+ 0x65, 0x63, 0x74, 0x65, 0x64, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0d, 0x66, 0x72, 0x61,
+ 0x75, 0x64, 0x44, 0x65, 0x74, 0x65, 0x63, 0x74, 0x65, 0x64, 0x42, 0xbb, 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, 0x0d, 0x50, 0x6f, 0x63, 0x62, 0x61, 0x74, 0x63, 0x68,
+ 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_pocbatch_proto_rawDescOnce sync.Once
+ file_inference_inference_pocbatch_proto_rawDescData = file_inference_inference_pocbatch_proto_rawDesc
+)
+
+func file_inference_inference_pocbatch_proto_rawDescGZIP() []byte {
+ file_inference_inference_pocbatch_proto_rawDescOnce.Do(func() {
+ file_inference_inference_pocbatch_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_inference_pocbatch_proto_rawDescData)
+ })
+ return file_inference_inference_pocbatch_proto_rawDescData
+}
+
+var file_inference_inference_pocbatch_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
+var file_inference_inference_pocbatch_proto_goTypes = []interface{}{
+ (*PoCBatch)(nil), // 0: inference.inference.PoCBatch
+ (*PoCValidation)(nil), // 1: inference.inference.PoCValidation
+}
+var file_inference_inference_pocbatch_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_pocbatch_proto_init() }
+func file_inference_inference_pocbatch_proto_init() {
+ if File_inference_inference_pocbatch_proto != nil {
+ return
+ }
+ if !protoimpl.UnsafeEnabled {
+ file_inference_inference_pocbatch_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*PoCBatch); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_inference_inference_pocbatch_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*PoCValidation); 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_pocbatch_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 2,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_inference_pocbatch_proto_goTypes,
+ DependencyIndexes: file_inference_inference_pocbatch_proto_depIdxs,
+ MessageInfos: file_inference_inference_pocbatch_proto_msgTypes,
+ }.Build()
+ File_inference_inference_pocbatch_proto = out.File
+ file_inference_inference_pocbatch_proto_rawDesc = nil
+ file_inference_inference_pocbatch_proto_goTypes = nil
+ file_inference_inference_pocbatch_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/inference/pruning_state.pulsar.go b/inference-chain/api/inference/inference/pruning_state.pulsar.go
new file mode 100644
index 000000000..81bc327da
--- /dev/null
+++ b/inference-chain/api/inference/inference/pruning_state.pulsar.go
@@ -0,0 +1,674 @@
+// 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_PruningState protoreflect.MessageDescriptor
+ fd_PruningState_poc_batches_pruned_epoch protoreflect.FieldDescriptor
+ fd_PruningState_poc_validations_pruned_epoch protoreflect.FieldDescriptor
+ fd_PruningState_inference_pruned_epoch protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_pruning_state_proto_init()
+ md_PruningState = File_inference_inference_pruning_state_proto.Messages().ByName("PruningState")
+ fd_PruningState_poc_batches_pruned_epoch = md_PruningState.Fields().ByName("poc_batches_pruned_epoch")
+ fd_PruningState_poc_validations_pruned_epoch = md_PruningState.Fields().ByName("poc_validations_pruned_epoch")
+ fd_PruningState_inference_pruned_epoch = md_PruningState.Fields().ByName("inference_pruned_epoch")
+}
+
+var _ protoreflect.Message = (*fastReflection_PruningState)(nil)
+
+type fastReflection_PruningState PruningState
+
+func (x *PruningState) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_PruningState)(x)
+}
+
+func (x *PruningState) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_pruning_state_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_PruningState_messageType fastReflection_PruningState_messageType
+var _ protoreflect.MessageType = fastReflection_PruningState_messageType{}
+
+type fastReflection_PruningState_messageType struct{}
+
+func (x fastReflection_PruningState_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_PruningState)(nil)
+}
+func (x fastReflection_PruningState_messageType) New() protoreflect.Message {
+ return new(fastReflection_PruningState)
+}
+func (x fastReflection_PruningState_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_PruningState
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_PruningState) Descriptor() protoreflect.MessageDescriptor {
+ return md_PruningState
+}
+
+// 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_PruningState) Type() protoreflect.MessageType {
+ return _fastReflection_PruningState_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_PruningState) New() protoreflect.Message {
+ return new(fastReflection_PruningState)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_PruningState) Interface() protoreflect.ProtoMessage {
+ return (*PruningState)(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_PruningState) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.PocBatchesPrunedEpoch != int64(0) {
+ value := protoreflect.ValueOfInt64(x.PocBatchesPrunedEpoch)
+ if !f(fd_PruningState_poc_batches_pruned_epoch, value) {
+ return
+ }
+ }
+ if x.PocValidationsPrunedEpoch != int64(0) {
+ value := protoreflect.ValueOfInt64(x.PocValidationsPrunedEpoch)
+ if !f(fd_PruningState_poc_validations_pruned_epoch, value) {
+ return
+ }
+ }
+ if x.InferencePrunedEpoch != int64(0) {
+ value := protoreflect.ValueOfInt64(x.InferencePrunedEpoch)
+ if !f(fd_PruningState_inference_pruned_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_PruningState) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.PruningState.poc_batches_pruned_epoch":
+ return x.PocBatchesPrunedEpoch != int64(0)
+ case "inference.inference.PruningState.poc_validations_pruned_epoch":
+ return x.PocValidationsPrunedEpoch != int64(0)
+ case "inference.inference.PruningState.inference_pruned_epoch":
+ return x.InferencePrunedEpoch != int64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PruningState"))
+ }
+ panic(fmt.Errorf("message inference.inference.PruningState 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_PruningState) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.PruningState.poc_batches_pruned_epoch":
+ x.PocBatchesPrunedEpoch = int64(0)
+ case "inference.inference.PruningState.poc_validations_pruned_epoch":
+ x.PocValidationsPrunedEpoch = int64(0)
+ case "inference.inference.PruningState.inference_pruned_epoch":
+ x.InferencePrunedEpoch = int64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PruningState"))
+ }
+ panic(fmt.Errorf("message inference.inference.PruningState 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_PruningState) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.PruningState.poc_batches_pruned_epoch":
+ value := x.PocBatchesPrunedEpoch
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.PruningState.poc_validations_pruned_epoch":
+ value := x.PocValidationsPrunedEpoch
+ return protoreflect.ValueOfInt64(value)
+ case "inference.inference.PruningState.inference_pruned_epoch":
+ value := x.InferencePrunedEpoch
+ return protoreflect.ValueOfInt64(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PruningState"))
+ }
+ panic(fmt.Errorf("message inference.inference.PruningState 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_PruningState) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.PruningState.poc_batches_pruned_epoch":
+ x.PocBatchesPrunedEpoch = value.Int()
+ case "inference.inference.PruningState.poc_validations_pruned_epoch":
+ x.PocValidationsPrunedEpoch = value.Int()
+ case "inference.inference.PruningState.inference_pruned_epoch":
+ x.InferencePrunedEpoch = value.Int()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PruningState"))
+ }
+ panic(fmt.Errorf("message inference.inference.PruningState 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_PruningState) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.PruningState.poc_batches_pruned_epoch":
+ panic(fmt.Errorf("field poc_batches_pruned_epoch of message inference.inference.PruningState is not mutable"))
+ case "inference.inference.PruningState.poc_validations_pruned_epoch":
+ panic(fmt.Errorf("field poc_validations_pruned_epoch of message inference.inference.PruningState is not mutable"))
+ case "inference.inference.PruningState.inference_pruned_epoch":
+ panic(fmt.Errorf("field inference_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"))
+ }
+ panic(fmt.Errorf("message inference.inference.PruningState 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_PruningState) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.PruningState.poc_batches_pruned_epoch":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.PruningState.poc_validations_pruned_epoch":
+ return protoreflect.ValueOfInt64(int64(0))
+ case "inference.inference.PruningState.inference_pruned_epoch":
+ return protoreflect.ValueOfInt64(int64(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PruningState"))
+ }
+ panic(fmt.Errorf("message inference.inference.PruningState 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_PruningState) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.PruningState", 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_PruningState) 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_PruningState) 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_PruningState) 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_PruningState) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*PruningState)
+ 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.PocBatchesPrunedEpoch != 0 {
+ n += 1 + runtime.Sov(uint64(x.PocBatchesPrunedEpoch))
+ }
+ if x.PocValidationsPrunedEpoch != 0 {
+ n += 1 + runtime.Sov(uint64(x.PocValidationsPrunedEpoch))
+ }
+ if x.InferencePrunedEpoch != 0 {
+ n += 1 + runtime.Sov(uint64(x.InferencePrunedEpoch))
+ }
+ 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().(*PruningState)
+ 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.InferencePrunedEpoch != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.InferencePrunedEpoch))
+ i--
+ dAtA[i] = 0x18
+ }
+ if x.PocValidationsPrunedEpoch != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.PocValidationsPrunedEpoch))
+ i--
+ dAtA[i] = 0x10
+ }
+ if x.PocBatchesPrunedEpoch != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.PocBatchesPrunedEpoch))
+ 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().(*PruningState)
+ 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: PruningState: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: PruningState: 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 PocBatchesPrunedEpoch", wireType)
+ }
+ x.PocBatchesPrunedEpoch = 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.PocBatchesPrunedEpoch |= 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 PocValidationsPrunedEpoch", wireType)
+ }
+ x.PocValidationsPrunedEpoch = 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.PocValidationsPrunedEpoch |= 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 InferencePrunedEpoch", wireType)
+ }
+ x.InferencePrunedEpoch = 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.InferencePrunedEpoch |= 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,
+ }
+}
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// protoc-gen-go v1.27.0
+// protoc (unknown)
+// source: inference/inference/pruning_state.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)
+)
+
+type PruningState struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ PocBatchesPrunedEpoch int64 `protobuf:"varint,1,opt,name=poc_batches_pruned_epoch,json=pocBatchesPrunedEpoch,proto3" json:"poc_batches_pruned_epoch,omitempty"`
+ PocValidationsPrunedEpoch int64 `protobuf:"varint,2,opt,name=poc_validations_pruned_epoch,json=pocValidationsPrunedEpoch,proto3" json:"poc_validations_pruned_epoch,omitempty"`
+ InferencePrunedEpoch int64 `protobuf:"varint,3,opt,name=inference_pruned_epoch,json=inferencePrunedEpoch,proto3" json:"inference_pruned_epoch,omitempty"`
+}
+
+func (x *PruningState) Reset() {
+ *x = PruningState{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_inference_inference_pruning_state_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *PruningState) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*PruningState) ProtoMessage() {}
+
+// Deprecated: Use PruningState.ProtoReflect.Descriptor instead.
+func (*PruningState) Descriptor() ([]byte, []int) {
+ return file_inference_inference_pruning_state_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *PruningState) GetPocBatchesPrunedEpoch() int64 {
+ if x != nil {
+ return x.PocBatchesPrunedEpoch
+ }
+ return 0
+}
+
+func (x *PruningState) GetPocValidationsPrunedEpoch() int64 {
+ if x != nil {
+ return x.PocValidationsPrunedEpoch
+ }
+ return 0
+}
+
+func (x *PruningState) GetInferencePrunedEpoch() int64 {
+ if x != nil {
+ return x.InferencePrunedEpoch
+ }
+ 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, 0xbe,
+ 0x01, 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,
+ 0x03, 0x52, 0x15, 0x70, 0x6f, 0x63, 0x42, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x50, 0x72, 0x75,
+ 0x6e, 0x65, 0x64, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x12, 0x3f, 0x0a, 0x1c, 0x70, 0x6f, 0x63, 0x5f,
+ 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x5f, 0x70, 0x72, 0x75, 0x6e,
+ 0x65, 0x64, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x19,
+ 0x70, 0x6f, 0x63, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x50, 0x72,
+ 0x75, 0x6e, 0x65, 0x64, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x12, 0x34, 0x0a, 0x16, 0x69, 0x6e, 0x66,
+ 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5f, 0x70, 0x72, 0x75, 0x6e, 0x65, 0x64, 0x5f, 0x65, 0x70,
+ 0x6f, 0x63, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x14, 0x69, 0x6e, 0x66, 0x65, 0x72,
+ 0x65, 0x6e, 0x63, 0x65, 0x50, 0x72, 0x75, 0x6e, 0x65, 0x64, 0x45, 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 (
+ file_inference_inference_pruning_state_proto_rawDescOnce sync.Once
+ file_inference_inference_pruning_state_proto_rawDescData = file_inference_inference_pruning_state_proto_rawDesc
+)
+
+func file_inference_inference_pruning_state_proto_rawDescGZIP() []byte {
+ file_inference_inference_pruning_state_proto_rawDescOnce.Do(func() {
+ file_inference_inference_pruning_state_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_inference_pruning_state_proto_rawDescData)
+ })
+ return file_inference_inference_pruning_state_proto_rawDescData
+}
+
+var file_inference_inference_pruning_state_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_inference_inference_pruning_state_proto_goTypes = []interface{}{
+ (*PruningState)(nil), // 0: inference.inference.PruningState
+}
+var file_inference_inference_pruning_state_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_pruning_state_proto_init() }
+func file_inference_inference_pruning_state_proto_init() {
+ if File_inference_inference_pruning_state_proto != nil {
+ return
+ }
+ if !protoimpl.UnsafeEnabled {
+ file_inference_inference_pruning_state_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*PruningState); 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_pruning_state_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 1,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_inference_inference_pruning_state_proto_goTypes,
+ DependencyIndexes: file_inference_inference_pruning_state_proto_depIdxs,
+ MessageInfos: file_inference_inference_pruning_state_proto_msgTypes,
+ }.Build()
+ File_inference_inference_pruning_state_proto = out.File
+ file_inference_inference_pruning_state_proto_rawDesc = nil
+ file_inference_inference_pruning_state_proto_goTypes = nil
+ file_inference_inference_pruning_state_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/inference/query.pulsar.go b/inference-chain/api/inference/inference/query.pulsar.go
new file mode 100644
index 000000000..5323d1a8f
--- /dev/null
+++ b/inference-chain/api/inference/inference/query.pulsar.go
@@ -0,0 +1,80594 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package inference
+
+import (
+ _ "cosmossdk.io/api/amino"
+ v1beta1 "cosmossdk.io/api/cosmos/base/query/v1beta1"
+ _ "cosmossdk.io/api/cosmos/base/v1beta1"
+ fmt "fmt"
+ runtime "github.com/cosmos/cosmos-proto/runtime"
+ _ "github.com/cosmos/gogoproto/gogoproto"
+ _ "google.golang.org/genproto/googleapis/api/annotations"
+ 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_QueryParamsRequest protoreflect.MessageDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryParamsRequest = File_inference_inference_query_proto.Messages().ByName("QueryParamsRequest")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryParamsRequest)(nil)
+
+type fastReflection_QueryParamsRequest QueryParamsRequest
+
+func (x *QueryParamsRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryParamsRequest)(x)
+}
+
+func (x *QueryParamsRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_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_QueryParamsRequest_messageType fastReflection_QueryParamsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryParamsRequest_messageType{}
+
+type fastReflection_QueryParamsRequest_messageType struct{}
+
+func (x fastReflection_QueryParamsRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryParamsRequest)(nil)
+}
+func (x fastReflection_QueryParamsRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryParamsRequest)
+}
+func (x fastReflection_QueryParamsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryParamsRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryParamsRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryParamsRequest
+}
+
+// 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_QueryParamsRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryParamsRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryParamsRequest) New() protoreflect.Message {
+ return new(fastReflection_QueryParamsRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryParamsRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryParamsRequest)(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_QueryParamsRequest) 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_QueryParamsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParamsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryParamsRequest 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_QueryParamsRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParamsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryParamsRequest 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_QueryParamsRequest) 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.QueryParamsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryParamsRequest 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_QueryParamsRequest) 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.QueryParamsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryParamsRequest 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_QueryParamsRequest) 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.QueryParamsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryParamsRequest 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_QueryParamsRequest) 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.QueryParamsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryParamsRequest 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_QueryParamsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryParamsRequest", 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_QueryParamsRequest) 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_QueryParamsRequest) 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_QueryParamsRequest) 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_QueryParamsRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryParamsRequest)
+ 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().(*QueryParamsRequest)
+ 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().(*QueryParamsRequest)
+ 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: QueryParamsRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryParamsRequest: 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 (
+ md_QueryParamsResponse protoreflect.MessageDescriptor
+ fd_QueryParamsResponse_params protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryParamsResponse = File_inference_inference_query_proto.Messages().ByName("QueryParamsResponse")
+ fd_QueryParamsResponse_params = md_QueryParamsResponse.Fields().ByName("params")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryParamsResponse)(nil)
+
+type fastReflection_QueryParamsResponse QueryParamsResponse
+
+func (x *QueryParamsResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryParamsResponse)(x)
+}
+
+func (x *QueryParamsResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_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_QueryParamsResponse_messageType fastReflection_QueryParamsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryParamsResponse_messageType{}
+
+type fastReflection_QueryParamsResponse_messageType struct{}
+
+func (x fastReflection_QueryParamsResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryParamsResponse)(nil)
+}
+func (x fastReflection_QueryParamsResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryParamsResponse)
+}
+func (x fastReflection_QueryParamsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryParamsResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryParamsResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryParamsResponse
+}
+
+// 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_QueryParamsResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryParamsResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryParamsResponse) New() protoreflect.Message {
+ return new(fastReflection_QueryParamsResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryParamsResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryParamsResponse)(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_QueryParamsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Params != nil {
+ value := protoreflect.ValueOfMessage(x.Params.ProtoReflect())
+ if !f(fd_QueryParamsResponse_params, 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_QueryParamsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryParamsResponse.params":
+ return x.Params != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryParamsResponse 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_QueryParamsResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryParamsResponse.params":
+ x.Params = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryParamsResponse 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_QueryParamsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryParamsResponse.params":
+ value := x.Params
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryParamsResponse 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_QueryParamsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryParamsResponse.params":
+ x.Params = value.Message().Interface().(*Params)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryParamsResponse 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_QueryParamsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryParamsResponse.params":
+ if x.Params == nil {
+ x.Params = new(Params)
+ }
+ return protoreflect.ValueOfMessage(x.Params.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryParamsResponse 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_QueryParamsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryParamsResponse.params":
+ m := new(Params)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParamsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryParamsResponse 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_QueryParamsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryParamsResponse", 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_QueryParamsResponse) 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_QueryParamsResponse) 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_QueryParamsResponse) 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_QueryParamsResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryParamsResponse)
+ 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.Params != nil {
+ l = options.Size(x.Params)
+ 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().(*QueryParamsResponse)
+ 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.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] = 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().(*QueryParamsResponse)
+ 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: QueryParamsResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryParamsResponse: 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 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
+ 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_QueryGetInferenceRequest protoreflect.MessageDescriptor
+ fd_QueryGetInferenceRequest_index protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryGetInferenceRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetInferenceRequest")
+ fd_QueryGetInferenceRequest_index = md_QueryGetInferenceRequest.Fields().ByName("index")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetInferenceRequest)(nil)
+
+type fastReflection_QueryGetInferenceRequest QueryGetInferenceRequest
+
+func (x *QueryGetInferenceRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetInferenceRequest)(x)
+}
+
+func (x *QueryGetInferenceRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_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_QueryGetInferenceRequest_messageType fastReflection_QueryGetInferenceRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetInferenceRequest_messageType{}
+
+type fastReflection_QueryGetInferenceRequest_messageType struct{}
+
+func (x fastReflection_QueryGetInferenceRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetInferenceRequest)(nil)
+}
+func (x fastReflection_QueryGetInferenceRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetInferenceRequest)
+}
+func (x fastReflection_QueryGetInferenceRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryGetInferenceRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryGetInferenceRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryGetInferenceRequest
+}
+
+// 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_QueryGetInferenceRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetInferenceRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryGetInferenceRequest) New() protoreflect.Message {
+ return new(fastReflection_QueryGetInferenceRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryGetInferenceRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetInferenceRequest)(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_QueryGetInferenceRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Index != "" {
+ value := protoreflect.ValueOfString(x.Index)
+ if !f(fd_QueryGetInferenceRequest_index, 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_QueryGetInferenceRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetInferenceRequest.index":
+ return x.Index != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetInferenceRequest 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_QueryGetInferenceRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetInferenceRequest.index":
+ x.Index = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetInferenceRequest 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_QueryGetInferenceRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryGetInferenceRequest.index":
+ value := x.Index
+ return protoreflect.ValueOfString(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetInferenceRequest 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_QueryGetInferenceRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetInferenceRequest.index":
+ x.Index = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetInferenceRequest 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_QueryGetInferenceRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetInferenceRequest.index":
+ panic(fmt.Errorf("field index of message inference.inference.QueryGetInferenceRequest is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetInferenceRequest 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_QueryGetInferenceRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetInferenceRequest.index":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetInferenceRequest 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_QueryGetInferenceRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetInferenceRequest", 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_QueryGetInferenceRequest) 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_QueryGetInferenceRequest) 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_QueryGetInferenceRequest) 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_QueryGetInferenceRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetInferenceRequest)
+ 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.Index)
+ 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().(*QueryGetInferenceRequest)
+ 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.Index) > 0 {
+ i -= len(x.Index)
+ copy(dAtA[i:], x.Index)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Index)))
+ 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().(*QueryGetInferenceRequest)
+ 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: QueryGetInferenceRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetInferenceRequest: 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 Index", 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.Index = 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_QueryGetInferenceResponse protoreflect.MessageDescriptor
+ fd_QueryGetInferenceResponse_inference protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryGetInferenceResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetInferenceResponse")
+ fd_QueryGetInferenceResponse_inference = md_QueryGetInferenceResponse.Fields().ByName("inference")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetInferenceResponse)(nil)
+
+type fastReflection_QueryGetInferenceResponse QueryGetInferenceResponse
+
+func (x *QueryGetInferenceResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetInferenceResponse)(x)
+}
+
+func (x *QueryGetInferenceResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[3]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryGetInferenceResponse_messageType fastReflection_QueryGetInferenceResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetInferenceResponse_messageType{}
+
+type fastReflection_QueryGetInferenceResponse_messageType struct{}
+
+func (x fastReflection_QueryGetInferenceResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetInferenceResponse)(nil)
+}
+func (x fastReflection_QueryGetInferenceResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetInferenceResponse)
+}
+func (x fastReflection_QueryGetInferenceResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryGetInferenceResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryGetInferenceResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryGetInferenceResponse
+}
+
+// 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_QueryGetInferenceResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetInferenceResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryGetInferenceResponse) New() protoreflect.Message {
+ return new(fastReflection_QueryGetInferenceResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryGetInferenceResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetInferenceResponse)(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_QueryGetInferenceResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Inference != nil {
+ value := protoreflect.ValueOfMessage(x.Inference.ProtoReflect())
+ if !f(fd_QueryGetInferenceResponse_inference, 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_QueryGetInferenceResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetInferenceResponse.inference":
+ return x.Inference != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetInferenceResponse 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_QueryGetInferenceResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetInferenceResponse.inference":
+ x.Inference = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetInferenceResponse 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_QueryGetInferenceResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryGetInferenceResponse.inference":
+ value := x.Inference
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetInferenceResponse 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_QueryGetInferenceResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetInferenceResponse.inference":
+ x.Inference = value.Message().Interface().(*Inference)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetInferenceResponse 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_QueryGetInferenceResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetInferenceResponse.inference":
+ if x.Inference == nil {
+ x.Inference = new(Inference)
+ }
+ return protoreflect.ValueOfMessage(x.Inference.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetInferenceResponse 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_QueryGetInferenceResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetInferenceResponse.inference":
+ m := new(Inference)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetInferenceResponse 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_QueryGetInferenceResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetInferenceResponse", 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_QueryGetInferenceResponse) 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_QueryGetInferenceResponse) 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_QueryGetInferenceResponse) 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_QueryGetInferenceResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetInferenceResponse)
+ 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.Inference != nil {
+ l = options.Size(x.Inference)
+ 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().(*QueryGetInferenceResponse)
+ 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.Inference != nil {
+ encoded, err := options.Marshal(x.Inference)
+ 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().(*QueryGetInferenceResponse)
+ 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: QueryGetInferenceResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetInferenceResponse: 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 Inference", 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.Inference == nil {
+ x.Inference = &Inference{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Inference); 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_QueryAllInferenceRequest protoreflect.MessageDescriptor
+ fd_QueryAllInferenceRequest_pagination protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryAllInferenceRequest = File_inference_inference_query_proto.Messages().ByName("QueryAllInferenceRequest")
+ fd_QueryAllInferenceRequest_pagination = md_QueryAllInferenceRequest.Fields().ByName("pagination")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryAllInferenceRequest)(nil)
+
+type fastReflection_QueryAllInferenceRequest QueryAllInferenceRequest
+
+func (x *QueryAllInferenceRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryAllInferenceRequest)(x)
+}
+
+func (x *QueryAllInferenceRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[4]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryAllInferenceRequest_messageType fastReflection_QueryAllInferenceRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllInferenceRequest_messageType{}
+
+type fastReflection_QueryAllInferenceRequest_messageType struct{}
+
+func (x fastReflection_QueryAllInferenceRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryAllInferenceRequest)(nil)
+}
+func (x fastReflection_QueryAllInferenceRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryAllInferenceRequest)
+}
+func (x fastReflection_QueryAllInferenceRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryAllInferenceRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryAllInferenceRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryAllInferenceRequest
+}
+
+// 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_QueryAllInferenceRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryAllInferenceRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryAllInferenceRequest) New() protoreflect.Message {
+ return new(fastReflection_QueryAllInferenceRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryAllInferenceRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryAllInferenceRequest)(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_QueryAllInferenceRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Pagination != nil {
+ value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+ if !f(fd_QueryAllInferenceRequest_pagination, 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_QueryAllInferenceRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllInferenceRequest.pagination":
+ return x.Pagination != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllInferenceRequest 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_QueryAllInferenceRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllInferenceRequest.pagination":
+ x.Pagination = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllInferenceRequest 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_QueryAllInferenceRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryAllInferenceRequest.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.QueryAllInferenceRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllInferenceRequest 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_QueryAllInferenceRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllInferenceRequest.pagination":
+ x.Pagination = value.Message().Interface().(*v1beta1.PageRequest)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllInferenceRequest 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_QueryAllInferenceRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllInferenceRequest.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.QueryAllInferenceRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllInferenceRequest 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_QueryAllInferenceRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllInferenceRequest.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.QueryAllInferenceRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllInferenceRequest 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_QueryAllInferenceRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllInferenceRequest", 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_QueryAllInferenceRequest) 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_QueryAllInferenceRequest) 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_QueryAllInferenceRequest) 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_QueryAllInferenceRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryAllInferenceRequest)
+ 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.Pagination != nil {
+ l = options.Size(x.Pagination)
+ 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().(*QueryAllInferenceRequest)
+ 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.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 {
+ 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().(*QueryAllInferenceRequest)
+ 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: QueryAllInferenceRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllInferenceRequest: 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:])
+ 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 = (*_QueryAllInferenceResponse_1_list)(nil)
+
+type _QueryAllInferenceResponse_1_list struct {
+ list *[]*Inference
+}
+
+func (x *_QueryAllInferenceResponse_1_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_QueryAllInferenceResponse_1_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryAllInferenceResponse_1_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*Inference)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_QueryAllInferenceResponse_1_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*Inference)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryAllInferenceResponse_1_list) AppendMutable() protoreflect.Value {
+ v := new(Inference)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryAllInferenceResponse_1_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_QueryAllInferenceResponse_1_list) NewElement() protoreflect.Value {
+ v := new(Inference)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryAllInferenceResponse_1_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_QueryAllInferenceResponse protoreflect.MessageDescriptor
+ fd_QueryAllInferenceResponse_inference protoreflect.FieldDescriptor
+ fd_QueryAllInferenceResponse_pagination protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryAllInferenceResponse = File_inference_inference_query_proto.Messages().ByName("QueryAllInferenceResponse")
+ fd_QueryAllInferenceResponse_inference = md_QueryAllInferenceResponse.Fields().ByName("inference")
+ fd_QueryAllInferenceResponse_pagination = md_QueryAllInferenceResponse.Fields().ByName("pagination")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryAllInferenceResponse)(nil)
+
+type fastReflection_QueryAllInferenceResponse QueryAllInferenceResponse
+
+func (x *QueryAllInferenceResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryAllInferenceResponse)(x)
+}
+
+func (x *QueryAllInferenceResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[5]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryAllInferenceResponse_messageType fastReflection_QueryAllInferenceResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllInferenceResponse_messageType{}
+
+type fastReflection_QueryAllInferenceResponse_messageType struct{}
+
+func (x fastReflection_QueryAllInferenceResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryAllInferenceResponse)(nil)
+}
+func (x fastReflection_QueryAllInferenceResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryAllInferenceResponse)
+}
+func (x fastReflection_QueryAllInferenceResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryAllInferenceResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryAllInferenceResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryAllInferenceResponse
+}
+
+// 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_QueryAllInferenceResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryAllInferenceResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryAllInferenceResponse) New() protoreflect.Message {
+ return new(fastReflection_QueryAllInferenceResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryAllInferenceResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryAllInferenceResponse)(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_QueryAllInferenceResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if len(x.Inference) != 0 {
+ value := protoreflect.ValueOfList(&_QueryAllInferenceResponse_1_list{list: &x.Inference})
+ if !f(fd_QueryAllInferenceResponse_inference, value) {
+ return
+ }
+ }
+ if x.Pagination != nil {
+ value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+ if !f(fd_QueryAllInferenceResponse_pagination, 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_QueryAllInferenceResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllInferenceResponse.inference":
+ return len(x.Inference) != 0
+ case "inference.inference.QueryAllInferenceResponse.pagination":
+ return x.Pagination != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllInferenceResponse 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_QueryAllInferenceResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllInferenceResponse.inference":
+ x.Inference = nil
+ case "inference.inference.QueryAllInferenceResponse.pagination":
+ x.Pagination = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllInferenceResponse 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_QueryAllInferenceResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryAllInferenceResponse.inference":
+ if len(x.Inference) == 0 {
+ return protoreflect.ValueOfList(&_QueryAllInferenceResponse_1_list{})
+ }
+ listValue := &_QueryAllInferenceResponse_1_list{list: &x.Inference}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.inference.QueryAllInferenceResponse.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.QueryAllInferenceResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllInferenceResponse 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_QueryAllInferenceResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllInferenceResponse.inference":
+ lv := value.List()
+ clv := lv.(*_QueryAllInferenceResponse_1_list)
+ x.Inference = *clv.list
+ case "inference.inference.QueryAllInferenceResponse.pagination":
+ x.Pagination = value.Message().Interface().(*v1beta1.PageResponse)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllInferenceResponse 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_QueryAllInferenceResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllInferenceResponse.inference":
+ if x.Inference == nil {
+ x.Inference = []*Inference{}
+ }
+ value := &_QueryAllInferenceResponse_1_list{list: &x.Inference}
+ return protoreflect.ValueOfList(value)
+ case "inference.inference.QueryAllInferenceResponse.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.QueryAllInferenceResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllInferenceResponse 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_QueryAllInferenceResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllInferenceResponse.inference":
+ list := []*Inference{}
+ return protoreflect.ValueOfList(&_QueryAllInferenceResponse_1_list{list: &list})
+ case "inference.inference.QueryAllInferenceResponse.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.QueryAllInferenceResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllInferenceResponse 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_QueryAllInferenceResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllInferenceResponse", 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_QueryAllInferenceResponse) 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_QueryAllInferenceResponse) 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_QueryAllInferenceResponse) 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_QueryAllInferenceResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryAllInferenceResponse)
+ 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.Inference) > 0 {
+ for _, e := range x.Inference {
+ 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)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*QueryAllInferenceResponse)
+ 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.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.Inference) > 0 {
+ for iNdEx := len(x.Inference) - 1; iNdEx >= 0; iNdEx-- {
+ encoded, err := options.Marshal(x.Inference[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().(*QueryAllInferenceResponse)
+ 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: QueryAllInferenceResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllInferenceResponse: 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 Inference", 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.Inference = append(x.Inference, &Inference{})
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Inference[len(x.Inference)-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
+ 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_QueryGetParticipantRequest protoreflect.MessageDescriptor
+ fd_QueryGetParticipantRequest_index protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryGetParticipantRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetParticipantRequest")
+ fd_QueryGetParticipantRequest_index = md_QueryGetParticipantRequest.Fields().ByName("index")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetParticipantRequest)(nil)
+
+type fastReflection_QueryGetParticipantRequest QueryGetParticipantRequest
+
+func (x *QueryGetParticipantRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetParticipantRequest)(x)
+}
+
+func (x *QueryGetParticipantRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[6]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryGetParticipantRequest_messageType fastReflection_QueryGetParticipantRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetParticipantRequest_messageType{}
+
+type fastReflection_QueryGetParticipantRequest_messageType struct{}
+
+func (x fastReflection_QueryGetParticipantRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetParticipantRequest)(nil)
+}
+func (x fastReflection_QueryGetParticipantRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetParticipantRequest)
+}
+func (x fastReflection_QueryGetParticipantRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryGetParticipantRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryGetParticipantRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryGetParticipantRequest
+}
+
+// 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_QueryGetParticipantRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetParticipantRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryGetParticipantRequest) New() protoreflect.Message {
+ return new(fastReflection_QueryGetParticipantRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryGetParticipantRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetParticipantRequest)(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_QueryGetParticipantRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Index != "" {
+ value := protoreflect.ValueOfString(x.Index)
+ if !f(fd_QueryGetParticipantRequest_index, 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_QueryGetParticipantRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetParticipantRequest.index":
+ return x.Index != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetParticipantRequest 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_QueryGetParticipantRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetParticipantRequest.index":
+ x.Index = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetParticipantRequest 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_QueryGetParticipantRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryGetParticipantRequest.index":
+ value := x.Index
+ return protoreflect.ValueOfString(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetParticipantRequest 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_QueryGetParticipantRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetParticipantRequest.index":
+ x.Index = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetParticipantRequest 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_QueryGetParticipantRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetParticipantRequest.index":
+ panic(fmt.Errorf("field index of message inference.inference.QueryGetParticipantRequest is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetParticipantRequest 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_QueryGetParticipantRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetParticipantRequest.index":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetParticipantRequest 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_QueryGetParticipantRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetParticipantRequest", 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_QueryGetParticipantRequest) 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_QueryGetParticipantRequest) 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_QueryGetParticipantRequest) 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_QueryGetParticipantRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetParticipantRequest)
+ 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.Index)
+ 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().(*QueryGetParticipantRequest)
+ 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.Index) > 0 {
+ i -= len(x.Index)
+ copy(dAtA[i:], x.Index)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Index)))
+ 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().(*QueryGetParticipantRequest)
+ 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: QueryGetParticipantRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetParticipantRequest: 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 Index", 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.Index = 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_QueryGetParticipantResponse protoreflect.MessageDescriptor
+ fd_QueryGetParticipantResponse_participant protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryGetParticipantResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetParticipantResponse")
+ fd_QueryGetParticipantResponse_participant = md_QueryGetParticipantResponse.Fields().ByName("participant")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetParticipantResponse)(nil)
+
+type fastReflection_QueryGetParticipantResponse QueryGetParticipantResponse
+
+func (x *QueryGetParticipantResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetParticipantResponse)(x)
+}
+
+func (x *QueryGetParticipantResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_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_QueryGetParticipantResponse_messageType fastReflection_QueryGetParticipantResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetParticipantResponse_messageType{}
+
+type fastReflection_QueryGetParticipantResponse_messageType struct{}
+
+func (x fastReflection_QueryGetParticipantResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetParticipantResponse)(nil)
+}
+func (x fastReflection_QueryGetParticipantResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetParticipantResponse)
+}
+func (x fastReflection_QueryGetParticipantResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryGetParticipantResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryGetParticipantResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryGetParticipantResponse
+}
+
+// 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_QueryGetParticipantResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetParticipantResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryGetParticipantResponse) New() protoreflect.Message {
+ return new(fastReflection_QueryGetParticipantResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryGetParticipantResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetParticipantResponse)(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_QueryGetParticipantResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Participant != nil {
+ value := protoreflect.ValueOfMessage(x.Participant.ProtoReflect())
+ if !f(fd_QueryGetParticipantResponse_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_QueryGetParticipantResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetParticipantResponse.participant":
+ return x.Participant != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetParticipantResponse 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_QueryGetParticipantResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetParticipantResponse.participant":
+ x.Participant = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetParticipantResponse 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_QueryGetParticipantResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryGetParticipantResponse.participant":
+ value := x.Participant
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetParticipantResponse 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_QueryGetParticipantResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetParticipantResponse.participant":
+ x.Participant = value.Message().Interface().(*Participant)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetParticipantResponse 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_QueryGetParticipantResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetParticipantResponse.participant":
+ if x.Participant == nil {
+ x.Participant = new(Participant)
+ }
+ return protoreflect.ValueOfMessage(x.Participant.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetParticipantResponse 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_QueryGetParticipantResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetParticipantResponse.participant":
+ m := new(Participant)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetParticipantResponse 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_QueryGetParticipantResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetParticipantResponse", 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_QueryGetParticipantResponse) 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_QueryGetParticipantResponse) 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_QueryGetParticipantResponse) 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_QueryGetParticipantResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetParticipantResponse)
+ 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.Participant != nil {
+ l = options.Size(x.Participant)
+ 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().(*QueryGetParticipantResponse)
+ 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.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 {
+ 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().(*QueryGetParticipantResponse)
+ 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: QueryGetParticipantResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetParticipantResponse: 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
+ 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_QueryAllParticipantRequest protoreflect.MessageDescriptor
+ fd_QueryAllParticipantRequest_pagination protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryAllParticipantRequest = File_inference_inference_query_proto.Messages().ByName("QueryAllParticipantRequest")
+ fd_QueryAllParticipantRequest_pagination = md_QueryAllParticipantRequest.Fields().ByName("pagination")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryAllParticipantRequest)(nil)
+
+type fastReflection_QueryAllParticipantRequest QueryAllParticipantRequest
+
+func (x *QueryAllParticipantRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryAllParticipantRequest)(x)
+}
+
+func (x *QueryAllParticipantRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_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_QueryAllParticipantRequest_messageType fastReflection_QueryAllParticipantRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllParticipantRequest_messageType{}
+
+type fastReflection_QueryAllParticipantRequest_messageType struct{}
+
+func (x fastReflection_QueryAllParticipantRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryAllParticipantRequest)(nil)
+}
+func (x fastReflection_QueryAllParticipantRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryAllParticipantRequest)
+}
+func (x fastReflection_QueryAllParticipantRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryAllParticipantRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryAllParticipantRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryAllParticipantRequest
+}
+
+// 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_QueryAllParticipantRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryAllParticipantRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryAllParticipantRequest) New() protoreflect.Message {
+ return new(fastReflection_QueryAllParticipantRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryAllParticipantRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryAllParticipantRequest)(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_QueryAllParticipantRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Pagination != nil {
+ value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+ if !f(fd_QueryAllParticipantRequest_pagination, 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_QueryAllParticipantRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllParticipantRequest.pagination":
+ return x.Pagination != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllParticipantRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllParticipantRequest 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_QueryAllParticipantRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllParticipantRequest.pagination":
+ x.Pagination = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllParticipantRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllParticipantRequest 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_QueryAllParticipantRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryAllParticipantRequest.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.QueryAllParticipantRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllParticipantRequest 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_QueryAllParticipantRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllParticipantRequest.pagination":
+ x.Pagination = value.Message().Interface().(*v1beta1.PageRequest)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllParticipantRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllParticipantRequest 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_QueryAllParticipantRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllParticipantRequest.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.QueryAllParticipantRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllParticipantRequest 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_QueryAllParticipantRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllParticipantRequest.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.QueryAllParticipantRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllParticipantRequest 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_QueryAllParticipantRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllParticipantRequest", 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_QueryAllParticipantRequest) 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_QueryAllParticipantRequest) 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_QueryAllParticipantRequest) 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_QueryAllParticipantRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryAllParticipantRequest)
+ 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.Pagination != nil {
+ l = options.Size(x.Pagination)
+ 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().(*QueryAllParticipantRequest)
+ 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.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 {
+ 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().(*QueryAllParticipantRequest)
+ 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: QueryAllParticipantRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllParticipantRequest: 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:])
+ 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 = (*_QueryAllParticipantResponse_1_list)(nil)
+
+type _QueryAllParticipantResponse_1_list struct {
+ list *[]*Participant
+}
+
+func (x *_QueryAllParticipantResponse_1_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_QueryAllParticipantResponse_1_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryAllParticipantResponse_1_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*Participant)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_QueryAllParticipantResponse_1_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*Participant)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryAllParticipantResponse_1_list) AppendMutable() protoreflect.Value {
+ v := new(Participant)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryAllParticipantResponse_1_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_QueryAllParticipantResponse_1_list) NewElement() protoreflect.Value {
+ v := new(Participant)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryAllParticipantResponse_1_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_QueryAllParticipantResponse protoreflect.MessageDescriptor
+ fd_QueryAllParticipantResponse_participant protoreflect.FieldDescriptor
+ fd_QueryAllParticipantResponse_pagination protoreflect.FieldDescriptor
+ fd_QueryAllParticipantResponse_block_height protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryAllParticipantResponse = File_inference_inference_query_proto.Messages().ByName("QueryAllParticipantResponse")
+ fd_QueryAllParticipantResponse_participant = md_QueryAllParticipantResponse.Fields().ByName("participant")
+ fd_QueryAllParticipantResponse_pagination = md_QueryAllParticipantResponse.Fields().ByName("pagination")
+ fd_QueryAllParticipantResponse_block_height = md_QueryAllParticipantResponse.Fields().ByName("block_height")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryAllParticipantResponse)(nil)
+
+type fastReflection_QueryAllParticipantResponse QueryAllParticipantResponse
+
+func (x *QueryAllParticipantResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryAllParticipantResponse)(x)
+}
+
+func (x *QueryAllParticipantResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_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_QueryAllParticipantResponse_messageType fastReflection_QueryAllParticipantResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllParticipantResponse_messageType{}
+
+type fastReflection_QueryAllParticipantResponse_messageType struct{}
+
+func (x fastReflection_QueryAllParticipantResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryAllParticipantResponse)(nil)
+}
+func (x fastReflection_QueryAllParticipantResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryAllParticipantResponse)
+}
+func (x fastReflection_QueryAllParticipantResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryAllParticipantResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryAllParticipantResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryAllParticipantResponse
+}
+
+// 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_QueryAllParticipantResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryAllParticipantResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryAllParticipantResponse) New() protoreflect.Message {
+ return new(fastReflection_QueryAllParticipantResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryAllParticipantResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryAllParticipantResponse)(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_QueryAllParticipantResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if len(x.Participant) != 0 {
+ value := protoreflect.ValueOfList(&_QueryAllParticipantResponse_1_list{list: &x.Participant})
+ if !f(fd_QueryAllParticipantResponse_participant, value) {
+ return
+ }
+ }
+ if x.Pagination != nil {
+ value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+ if !f(fd_QueryAllParticipantResponse_pagination, value) {
+ return
+ }
+ }
+ if x.BlockHeight != int64(0) {
+ value := protoreflect.ValueOfInt64(x.BlockHeight)
+ if !f(fd_QueryAllParticipantResponse_block_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_QueryAllParticipantResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllParticipantResponse.participant":
+ return len(x.Participant) != 0
+ case "inference.inference.QueryAllParticipantResponse.pagination":
+ return x.Pagination != nil
+ case "inference.inference.QueryAllParticipantResponse.block_height":
+ return x.BlockHeight != int64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllParticipantResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllParticipantResponse 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_QueryAllParticipantResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllParticipantResponse.participant":
+ x.Participant = nil
+ case "inference.inference.QueryAllParticipantResponse.pagination":
+ x.Pagination = nil
+ case "inference.inference.QueryAllParticipantResponse.block_height":
+ x.BlockHeight = int64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllParticipantResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllParticipantResponse 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_QueryAllParticipantResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryAllParticipantResponse.participant":
+ if len(x.Participant) == 0 {
+ return protoreflect.ValueOfList(&_QueryAllParticipantResponse_1_list{})
+ }
+ listValue := &_QueryAllParticipantResponse_1_list{list: &x.Participant}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.inference.QueryAllParticipantResponse.pagination":
+ value := x.Pagination
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ case "inference.inference.QueryAllParticipantResponse.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.QueryAllParticipantResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllParticipantResponse 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_QueryAllParticipantResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllParticipantResponse.participant":
+ lv := value.List()
+ clv := lv.(*_QueryAllParticipantResponse_1_list)
+ x.Participant = *clv.list
+ case "inference.inference.QueryAllParticipantResponse.pagination":
+ x.Pagination = value.Message().Interface().(*v1beta1.PageResponse)
+ case "inference.inference.QueryAllParticipantResponse.block_height":
+ x.BlockHeight = value.Int()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllParticipantResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllParticipantResponse 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_QueryAllParticipantResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllParticipantResponse.participant":
+ if x.Participant == nil {
+ x.Participant = []*Participant{}
+ }
+ value := &_QueryAllParticipantResponse_1_list{list: &x.Participant}
+ return protoreflect.ValueOfList(value)
+ case "inference.inference.QueryAllParticipantResponse.pagination":
+ if x.Pagination == nil {
+ x.Pagination = new(v1beta1.PageResponse)
+ }
+ return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+ case "inference.inference.QueryAllParticipantResponse.block_height":
+ panic(fmt.Errorf("field block_height of message inference.inference.QueryAllParticipantResponse is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllParticipantResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllParticipantResponse 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_QueryAllParticipantResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllParticipantResponse.participant":
+ list := []*Participant{}
+ return protoreflect.ValueOfList(&_QueryAllParticipantResponse_1_list{list: &list})
+ case "inference.inference.QueryAllParticipantResponse.pagination":
+ m := new(v1beta1.PageResponse)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ case "inference.inference.QueryAllParticipantResponse.block_height":
+ return protoreflect.ValueOfInt64(int64(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllParticipantResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllParticipantResponse 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_QueryAllParticipantResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllParticipantResponse", 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_QueryAllParticipantResponse) 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_QueryAllParticipantResponse) 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_QueryAllParticipantResponse) 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_QueryAllParticipantResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryAllParticipantResponse)
+ 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.Participant) > 0 {
+ for _, e := range x.Participant {
+ 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.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().(*QueryAllParticipantResponse)
+ 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.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)))
+ i--
+ dAtA[i] = 0x12
+ }
+ if len(x.Participant) > 0 {
+ for iNdEx := len(x.Participant) - 1; iNdEx >= 0; iNdEx-- {
+ encoded, err := options.Marshal(x.Participant[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().(*QueryAllParticipantResponse)
+ 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: QueryAllParticipantResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllParticipantResponse: 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
+ }
+ x.Participant = append(x.Participant, &Participant{})
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Participant[len(x.Participant)-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)
+ }
+ 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
+ }
+ }
+ 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_QueryInferenceParticipantRequest protoreflect.MessageDescriptor
+ fd_QueryInferenceParticipantRequest_address protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryInferenceParticipantRequest = File_inference_inference_query_proto.Messages().ByName("QueryInferenceParticipantRequest")
+ fd_QueryInferenceParticipantRequest_address = md_QueryInferenceParticipantRequest.Fields().ByName("address")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryInferenceParticipantRequest)(nil)
+
+type fastReflection_QueryInferenceParticipantRequest QueryInferenceParticipantRequest
+
+func (x *QueryInferenceParticipantRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryInferenceParticipantRequest)(x)
+}
+
+func (x *QueryInferenceParticipantRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[10]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryInferenceParticipantRequest_messageType fastReflection_QueryInferenceParticipantRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryInferenceParticipantRequest_messageType{}
+
+type fastReflection_QueryInferenceParticipantRequest_messageType struct{}
+
+func (x fastReflection_QueryInferenceParticipantRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryInferenceParticipantRequest)(nil)
+}
+func (x fastReflection_QueryInferenceParticipantRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryInferenceParticipantRequest)
+}
+func (x fastReflection_QueryInferenceParticipantRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryInferenceParticipantRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryInferenceParticipantRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryInferenceParticipantRequest
+}
+
+// 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_QueryInferenceParticipantRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryInferenceParticipantRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryInferenceParticipantRequest) New() protoreflect.Message {
+ return new(fastReflection_QueryInferenceParticipantRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryInferenceParticipantRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryInferenceParticipantRequest)(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_QueryInferenceParticipantRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Address != "" {
+ value := protoreflect.ValueOfString(x.Address)
+ if !f(fd_QueryInferenceParticipantRequest_address, 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_QueryInferenceParticipantRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryInferenceParticipantRequest.address":
+ return x.Address != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferenceParticipantRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInferenceParticipantRequest 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_QueryInferenceParticipantRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryInferenceParticipantRequest.address":
+ x.Address = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferenceParticipantRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInferenceParticipantRequest 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_QueryInferenceParticipantRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryInferenceParticipantRequest.address":
+ value := x.Address
+ return protoreflect.ValueOfString(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferenceParticipantRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInferenceParticipantRequest 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_QueryInferenceParticipantRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryInferenceParticipantRequest.address":
+ x.Address = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferenceParticipantRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInferenceParticipantRequest 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_QueryInferenceParticipantRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryInferenceParticipantRequest.address":
+ panic(fmt.Errorf("field address of message inference.inference.QueryInferenceParticipantRequest is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferenceParticipantRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInferenceParticipantRequest 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_QueryInferenceParticipantRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryInferenceParticipantRequest.address":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferenceParticipantRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInferenceParticipantRequest 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_QueryInferenceParticipantRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryInferenceParticipantRequest", 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_QueryInferenceParticipantRequest) 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_QueryInferenceParticipantRequest) 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_QueryInferenceParticipantRequest) 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_QueryInferenceParticipantRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryInferenceParticipantRequest)
+ 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.Address)
+ 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().(*QueryInferenceParticipantRequest)
+ 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.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 {
+ 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().(*QueryInferenceParticipantRequest)
+ 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: QueryInferenceParticipantRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryInferenceParticipantRequest: 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
+ 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_QueryInferenceParticipantResponse protoreflect.MessageDescriptor
+ fd_QueryInferenceParticipantResponse_pubkey protoreflect.FieldDescriptor
+ fd_QueryInferenceParticipantResponse_balance protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryInferenceParticipantResponse = File_inference_inference_query_proto.Messages().ByName("QueryInferenceParticipantResponse")
+ fd_QueryInferenceParticipantResponse_pubkey = md_QueryInferenceParticipantResponse.Fields().ByName("pubkey")
+ fd_QueryInferenceParticipantResponse_balance = md_QueryInferenceParticipantResponse.Fields().ByName("balance")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryInferenceParticipantResponse)(nil)
+
+type fastReflection_QueryInferenceParticipantResponse QueryInferenceParticipantResponse
+
+func (x *QueryInferenceParticipantResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryInferenceParticipantResponse)(x)
+}
+
+func (x *QueryInferenceParticipantResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[11]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryInferenceParticipantResponse_messageType fastReflection_QueryInferenceParticipantResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryInferenceParticipantResponse_messageType{}
+
+type fastReflection_QueryInferenceParticipantResponse_messageType struct{}
+
+func (x fastReflection_QueryInferenceParticipantResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryInferenceParticipantResponse)(nil)
+}
+func (x fastReflection_QueryInferenceParticipantResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryInferenceParticipantResponse)
+}
+func (x fastReflection_QueryInferenceParticipantResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryInferenceParticipantResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryInferenceParticipantResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryInferenceParticipantResponse
+}
+
+// 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_QueryInferenceParticipantResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryInferenceParticipantResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryInferenceParticipantResponse) New() protoreflect.Message {
+ return new(fastReflection_QueryInferenceParticipantResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryInferenceParticipantResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryInferenceParticipantResponse)(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_QueryInferenceParticipantResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Pubkey != "" {
+ value := protoreflect.ValueOfString(x.Pubkey)
+ if !f(fd_QueryInferenceParticipantResponse_pubkey, value) {
+ return
+ }
+ }
+ if x.Balance != int64(0) {
+ value := protoreflect.ValueOfInt64(x.Balance)
+ if !f(fd_QueryInferenceParticipantResponse_balance, 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_QueryInferenceParticipantResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryInferenceParticipantResponse.pubkey":
+ return x.Pubkey != ""
+ case "inference.inference.QueryInferenceParticipantResponse.balance":
+ return x.Balance != int64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferenceParticipantResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInferenceParticipantResponse 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_QueryInferenceParticipantResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryInferenceParticipantResponse.pubkey":
+ x.Pubkey = ""
+ case "inference.inference.QueryInferenceParticipantResponse.balance":
+ x.Balance = int64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferenceParticipantResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInferenceParticipantResponse 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_QueryInferenceParticipantResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryInferenceParticipantResponse.pubkey":
+ value := x.Pubkey
+ return protoreflect.ValueOfString(value)
+ case "inference.inference.QueryInferenceParticipantResponse.balance":
+ value := x.Balance
+ return protoreflect.ValueOfInt64(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferenceParticipantResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInferenceParticipantResponse 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_QueryInferenceParticipantResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryInferenceParticipantResponse.pubkey":
+ x.Pubkey = value.Interface().(string)
+ case "inference.inference.QueryInferenceParticipantResponse.balance":
+ x.Balance = value.Int()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferenceParticipantResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInferenceParticipantResponse 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_QueryInferenceParticipantResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryInferenceParticipantResponse.pubkey":
+ panic(fmt.Errorf("field pubkey of message inference.inference.QueryInferenceParticipantResponse is not mutable"))
+ case "inference.inference.QueryInferenceParticipantResponse.balance":
+ panic(fmt.Errorf("field balance of message inference.inference.QueryInferenceParticipantResponse is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferenceParticipantResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInferenceParticipantResponse 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_QueryInferenceParticipantResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryInferenceParticipantResponse.pubkey":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.QueryInferenceParticipantResponse.balance":
+ return protoreflect.ValueOfInt64(int64(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferenceParticipantResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInferenceParticipantResponse 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_QueryInferenceParticipantResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryInferenceParticipantResponse", 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_QueryInferenceParticipantResponse) 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_QueryInferenceParticipantResponse) 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_QueryInferenceParticipantResponse) 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_QueryInferenceParticipantResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryInferenceParticipantResponse)
+ 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.Pubkey)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.Balance != 0 {
+ n += 1 + runtime.Sov(uint64(x.Balance))
+ }
+ 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().(*QueryInferenceParticipantResponse)
+ 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.Balance != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.Balance))
+ i--
+ dAtA[i] = 0x10
+ }
+ 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] = 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().(*QueryInferenceParticipantResponse)
+ 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: QueryInferenceParticipantResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryInferenceParticipantResponse: 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 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 2:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Balance", wireType)
+ }
+ x.Balance = 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.Balance |= 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_QueryGetRandomExecutorRequest protoreflect.MessageDescriptor
+ fd_QueryGetRandomExecutorRequest_model protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryGetRandomExecutorRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetRandomExecutorRequest")
+ fd_QueryGetRandomExecutorRequest_model = md_QueryGetRandomExecutorRequest.Fields().ByName("model")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetRandomExecutorRequest)(nil)
+
+type fastReflection_QueryGetRandomExecutorRequest QueryGetRandomExecutorRequest
+
+func (x *QueryGetRandomExecutorRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetRandomExecutorRequest)(x)
+}
+
+func (x *QueryGetRandomExecutorRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[12]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryGetRandomExecutorRequest_messageType fastReflection_QueryGetRandomExecutorRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetRandomExecutorRequest_messageType{}
+
+type fastReflection_QueryGetRandomExecutorRequest_messageType struct{}
+
+func (x fastReflection_QueryGetRandomExecutorRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetRandomExecutorRequest)(nil)
+}
+func (x fastReflection_QueryGetRandomExecutorRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetRandomExecutorRequest)
+}
+func (x fastReflection_QueryGetRandomExecutorRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryGetRandomExecutorRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryGetRandomExecutorRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryGetRandomExecutorRequest
+}
+
+// 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_QueryGetRandomExecutorRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetRandomExecutorRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryGetRandomExecutorRequest) New() protoreflect.Message {
+ return new(fastReflection_QueryGetRandomExecutorRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryGetRandomExecutorRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetRandomExecutorRequest)(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_QueryGetRandomExecutorRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Model != "" {
+ value := protoreflect.ValueOfString(x.Model)
+ if !f(fd_QueryGetRandomExecutorRequest_model, 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_QueryGetRandomExecutorRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetRandomExecutorRequest.model":
+ return x.Model != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetRandomExecutorRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetRandomExecutorRequest 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_QueryGetRandomExecutorRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetRandomExecutorRequest.model":
+ x.Model = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetRandomExecutorRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetRandomExecutorRequest 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_QueryGetRandomExecutorRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryGetRandomExecutorRequest.model":
+ value := x.Model
+ return protoreflect.ValueOfString(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetRandomExecutorRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetRandomExecutorRequest 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_QueryGetRandomExecutorRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetRandomExecutorRequest.model":
+ x.Model = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetRandomExecutorRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetRandomExecutorRequest 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_QueryGetRandomExecutorRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetRandomExecutorRequest.model":
+ panic(fmt.Errorf("field model of message inference.inference.QueryGetRandomExecutorRequest is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetRandomExecutorRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetRandomExecutorRequest 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_QueryGetRandomExecutorRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetRandomExecutorRequest.model":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetRandomExecutorRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetRandomExecutorRequest 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_QueryGetRandomExecutorRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetRandomExecutorRequest", 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_QueryGetRandomExecutorRequest) 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_QueryGetRandomExecutorRequest) 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_QueryGetRandomExecutorRequest) 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_QueryGetRandomExecutorRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetRandomExecutorRequest)
+ 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.Model)
+ 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().(*QueryGetRandomExecutorRequest)
+ 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.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 {
+ 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().(*QueryGetRandomExecutorRequest)
+ 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: QueryGetRandomExecutorRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetRandomExecutorRequest: 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
+ 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_QueryGetRandomExecutorResponse protoreflect.MessageDescriptor
+ fd_QueryGetRandomExecutorResponse_executor protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryGetRandomExecutorResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetRandomExecutorResponse")
+ fd_QueryGetRandomExecutorResponse_executor = md_QueryGetRandomExecutorResponse.Fields().ByName("executor")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetRandomExecutorResponse)(nil)
+
+type fastReflection_QueryGetRandomExecutorResponse QueryGetRandomExecutorResponse
+
+func (x *QueryGetRandomExecutorResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetRandomExecutorResponse)(x)
+}
+
+func (x *QueryGetRandomExecutorResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[13]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryGetRandomExecutorResponse_messageType fastReflection_QueryGetRandomExecutorResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetRandomExecutorResponse_messageType{}
+
+type fastReflection_QueryGetRandomExecutorResponse_messageType struct{}
+
+func (x fastReflection_QueryGetRandomExecutorResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetRandomExecutorResponse)(nil)
+}
+func (x fastReflection_QueryGetRandomExecutorResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetRandomExecutorResponse)
+}
+func (x fastReflection_QueryGetRandomExecutorResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryGetRandomExecutorResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryGetRandomExecutorResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryGetRandomExecutorResponse
+}
+
+// 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_QueryGetRandomExecutorResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetRandomExecutorResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryGetRandomExecutorResponse) New() protoreflect.Message {
+ return new(fastReflection_QueryGetRandomExecutorResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryGetRandomExecutorResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetRandomExecutorResponse)(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_QueryGetRandomExecutorResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Executor != nil {
+ value := protoreflect.ValueOfMessage(x.Executor.ProtoReflect())
+ if !f(fd_QueryGetRandomExecutorResponse_executor, 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_QueryGetRandomExecutorResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetRandomExecutorResponse.executor":
+ return x.Executor != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetRandomExecutorResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetRandomExecutorResponse 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_QueryGetRandomExecutorResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetRandomExecutorResponse.executor":
+ x.Executor = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetRandomExecutorResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetRandomExecutorResponse 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_QueryGetRandomExecutorResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryGetRandomExecutorResponse.executor":
+ value := x.Executor
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetRandomExecutorResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetRandomExecutorResponse 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_QueryGetRandomExecutorResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetRandomExecutorResponse.executor":
+ x.Executor = value.Message().Interface().(*Participant)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetRandomExecutorResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetRandomExecutorResponse 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_QueryGetRandomExecutorResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetRandomExecutorResponse.executor":
+ if x.Executor == nil {
+ x.Executor = new(Participant)
+ }
+ return protoreflect.ValueOfMessage(x.Executor.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetRandomExecutorResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetRandomExecutorResponse 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_QueryGetRandomExecutorResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetRandomExecutorResponse.executor":
+ m := new(Participant)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetRandomExecutorResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetRandomExecutorResponse 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_QueryGetRandomExecutorResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetRandomExecutorResponse", 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_QueryGetRandomExecutorResponse) 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_QueryGetRandomExecutorResponse) 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_QueryGetRandomExecutorResponse) 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_QueryGetRandomExecutorResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetRandomExecutorResponse)
+ 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.Executor != nil {
+ l = options.Size(x.Executor)
+ 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().(*QueryGetRandomExecutorResponse)
+ 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.Executor != nil {
+ encoded, err := options.Marshal(x.Executor)
+ 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().(*QueryGetRandomExecutorResponse)
+ 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: QueryGetRandomExecutorResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetRandomExecutorResponse: 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 Executor", 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.Executor == nil {
+ x.Executor = &Participant{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Executor); 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_QueryGetEpochGroupDataRequest protoreflect.MessageDescriptor
+ fd_QueryGetEpochGroupDataRequest_epoch_index protoreflect.FieldDescriptor
+ fd_QueryGetEpochGroupDataRequest_model_id protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryGetEpochGroupDataRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetEpochGroupDataRequest")
+ fd_QueryGetEpochGroupDataRequest_epoch_index = md_QueryGetEpochGroupDataRequest.Fields().ByName("epoch_index")
+ fd_QueryGetEpochGroupDataRequest_model_id = md_QueryGetEpochGroupDataRequest.Fields().ByName("model_id")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetEpochGroupDataRequest)(nil)
+
+type fastReflection_QueryGetEpochGroupDataRequest QueryGetEpochGroupDataRequest
+
+func (x *QueryGetEpochGroupDataRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetEpochGroupDataRequest)(x)
+}
+
+func (x *QueryGetEpochGroupDataRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[14]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryGetEpochGroupDataRequest_messageType fastReflection_QueryGetEpochGroupDataRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetEpochGroupDataRequest_messageType{}
+
+type fastReflection_QueryGetEpochGroupDataRequest_messageType struct{}
+
+func (x fastReflection_QueryGetEpochGroupDataRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetEpochGroupDataRequest)(nil)
+}
+func (x fastReflection_QueryGetEpochGroupDataRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetEpochGroupDataRequest)
+}
+func (x fastReflection_QueryGetEpochGroupDataRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryGetEpochGroupDataRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryGetEpochGroupDataRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryGetEpochGroupDataRequest
+}
+
+// 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_QueryGetEpochGroupDataRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetEpochGroupDataRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryGetEpochGroupDataRequest) New() protoreflect.Message {
+ return new(fastReflection_QueryGetEpochGroupDataRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryGetEpochGroupDataRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetEpochGroupDataRequest)(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_QueryGetEpochGroupDataRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.EpochIndex != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.EpochIndex)
+ if !f(fd_QueryGetEpochGroupDataRequest_epoch_index, value) {
+ return
+ }
+ }
+ if x.ModelId != "" {
+ value := protoreflect.ValueOfString(x.ModelId)
+ if !f(fd_QueryGetEpochGroupDataRequest_model_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_QueryGetEpochGroupDataRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetEpochGroupDataRequest.epoch_index":
+ return x.EpochIndex != uint64(0)
+ case "inference.inference.QueryGetEpochGroupDataRequest.model_id":
+ return x.ModelId != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochGroupDataRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupDataRequest 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_QueryGetEpochGroupDataRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetEpochGroupDataRequest.epoch_index":
+ x.EpochIndex = uint64(0)
+ case "inference.inference.QueryGetEpochGroupDataRequest.model_id":
+ x.ModelId = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochGroupDataRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupDataRequest 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_QueryGetEpochGroupDataRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryGetEpochGroupDataRequest.epoch_index":
+ value := x.EpochIndex
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.QueryGetEpochGroupDataRequest.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.QueryGetEpochGroupDataRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupDataRequest 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_QueryGetEpochGroupDataRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetEpochGroupDataRequest.epoch_index":
+ x.EpochIndex = value.Uint()
+ case "inference.inference.QueryGetEpochGroupDataRequest.model_id":
+ x.ModelId = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochGroupDataRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupDataRequest 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_QueryGetEpochGroupDataRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetEpochGroupDataRequest.epoch_index":
+ panic(fmt.Errorf("field epoch_index of message inference.inference.QueryGetEpochGroupDataRequest is not mutable"))
+ case "inference.inference.QueryGetEpochGroupDataRequest.model_id":
+ panic(fmt.Errorf("field model_id of message inference.inference.QueryGetEpochGroupDataRequest is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochGroupDataRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupDataRequest 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_QueryGetEpochGroupDataRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetEpochGroupDataRequest.epoch_index":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.QueryGetEpochGroupDataRequest.model_id":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochGroupDataRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupDataRequest 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_QueryGetEpochGroupDataRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetEpochGroupDataRequest", 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_QueryGetEpochGroupDataRequest) 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_QueryGetEpochGroupDataRequest) 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_QueryGetEpochGroupDataRequest) 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_QueryGetEpochGroupDataRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetEpochGroupDataRequest)
+ 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.ModelId)
+ 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().(*QueryGetEpochGroupDataRequest)
+ 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.ModelId) > 0 {
+ i -= len(x.ModelId)
+ copy(dAtA[i:], x.ModelId)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ModelId)))
+ 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().(*QueryGetEpochGroupDataRequest)
+ 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: QueryGetEpochGroupDataRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetEpochGroupDataRequest: 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 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:])
+ 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_QueryGetEpochGroupDataResponse protoreflect.MessageDescriptor
+ fd_QueryGetEpochGroupDataResponse_epoch_group_data protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryGetEpochGroupDataResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetEpochGroupDataResponse")
+ fd_QueryGetEpochGroupDataResponse_epoch_group_data = md_QueryGetEpochGroupDataResponse.Fields().ByName("epoch_group_data")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetEpochGroupDataResponse)(nil)
+
+type fastReflection_QueryGetEpochGroupDataResponse QueryGetEpochGroupDataResponse
+
+func (x *QueryGetEpochGroupDataResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetEpochGroupDataResponse)(x)
+}
+
+func (x *QueryGetEpochGroupDataResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[15]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryGetEpochGroupDataResponse_messageType fastReflection_QueryGetEpochGroupDataResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetEpochGroupDataResponse_messageType{}
+
+type fastReflection_QueryGetEpochGroupDataResponse_messageType struct{}
+
+func (x fastReflection_QueryGetEpochGroupDataResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetEpochGroupDataResponse)(nil)
+}
+func (x fastReflection_QueryGetEpochGroupDataResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetEpochGroupDataResponse)
+}
+func (x fastReflection_QueryGetEpochGroupDataResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryGetEpochGroupDataResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryGetEpochGroupDataResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryGetEpochGroupDataResponse
+}
+
+// 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_QueryGetEpochGroupDataResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetEpochGroupDataResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryGetEpochGroupDataResponse) New() protoreflect.Message {
+ return new(fastReflection_QueryGetEpochGroupDataResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryGetEpochGroupDataResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetEpochGroupDataResponse)(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_QueryGetEpochGroupDataResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.EpochGroupData != nil {
+ value := protoreflect.ValueOfMessage(x.EpochGroupData.ProtoReflect())
+ if !f(fd_QueryGetEpochGroupDataResponse_epoch_group_data, 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_QueryGetEpochGroupDataResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetEpochGroupDataResponse.epoch_group_data":
+ return x.EpochGroupData != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochGroupDataResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupDataResponse 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_QueryGetEpochGroupDataResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetEpochGroupDataResponse.epoch_group_data":
+ x.EpochGroupData = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochGroupDataResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupDataResponse 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_QueryGetEpochGroupDataResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryGetEpochGroupDataResponse.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.QueryGetEpochGroupDataResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupDataResponse 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_QueryGetEpochGroupDataResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetEpochGroupDataResponse.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.QueryGetEpochGroupDataResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupDataResponse 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_QueryGetEpochGroupDataResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetEpochGroupDataResponse.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.QueryGetEpochGroupDataResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupDataResponse 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_QueryGetEpochGroupDataResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetEpochGroupDataResponse.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.QueryGetEpochGroupDataResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupDataResponse 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_QueryGetEpochGroupDataResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetEpochGroupDataResponse", 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_QueryGetEpochGroupDataResponse) 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_QueryGetEpochGroupDataResponse) 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_QueryGetEpochGroupDataResponse) 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_QueryGetEpochGroupDataResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetEpochGroupDataResponse)
+ 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.EpochGroupData != nil {
+ l = options.Size(x.EpochGroupData)
+ 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().(*QueryGetEpochGroupDataResponse)
+ 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.EpochGroupData != nil {
+ encoded, err := options.Marshal(x.EpochGroupData)
+ 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().(*QueryGetEpochGroupDataResponse)
+ 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: QueryGetEpochGroupDataResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetEpochGroupDataResponse: 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)
+ }
+ 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.EpochGroupData == nil {
+ x.EpochGroupData = &EpochGroupData{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.EpochGroupData); 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_QueryAllEpochGroupDataRequest protoreflect.MessageDescriptor
+ fd_QueryAllEpochGroupDataRequest_pagination protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryAllEpochGroupDataRequest = File_inference_inference_query_proto.Messages().ByName("QueryAllEpochGroupDataRequest")
+ fd_QueryAllEpochGroupDataRequest_pagination = md_QueryAllEpochGroupDataRequest.Fields().ByName("pagination")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryAllEpochGroupDataRequest)(nil)
+
+type fastReflection_QueryAllEpochGroupDataRequest QueryAllEpochGroupDataRequest
+
+func (x *QueryAllEpochGroupDataRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryAllEpochGroupDataRequest)(x)
+}
+
+func (x *QueryAllEpochGroupDataRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[16]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryAllEpochGroupDataRequest_messageType fastReflection_QueryAllEpochGroupDataRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllEpochGroupDataRequest_messageType{}
+
+type fastReflection_QueryAllEpochGroupDataRequest_messageType struct{}
+
+func (x fastReflection_QueryAllEpochGroupDataRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryAllEpochGroupDataRequest)(nil)
+}
+func (x fastReflection_QueryAllEpochGroupDataRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryAllEpochGroupDataRequest)
+}
+func (x fastReflection_QueryAllEpochGroupDataRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryAllEpochGroupDataRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryAllEpochGroupDataRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryAllEpochGroupDataRequest
+}
+
+// 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_QueryAllEpochGroupDataRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryAllEpochGroupDataRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryAllEpochGroupDataRequest) New() protoreflect.Message {
+ return new(fastReflection_QueryAllEpochGroupDataRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryAllEpochGroupDataRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryAllEpochGroupDataRequest)(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_QueryAllEpochGroupDataRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Pagination != nil {
+ value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+ if !f(fd_QueryAllEpochGroupDataRequest_pagination, 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_QueryAllEpochGroupDataRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllEpochGroupDataRequest.pagination":
+ return x.Pagination != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochGroupDataRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupDataRequest 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_QueryAllEpochGroupDataRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllEpochGroupDataRequest.pagination":
+ x.Pagination = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochGroupDataRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupDataRequest 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_QueryAllEpochGroupDataRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryAllEpochGroupDataRequest.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.QueryAllEpochGroupDataRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupDataRequest 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_QueryAllEpochGroupDataRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllEpochGroupDataRequest.pagination":
+ x.Pagination = value.Message().Interface().(*v1beta1.PageRequest)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochGroupDataRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupDataRequest 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_QueryAllEpochGroupDataRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllEpochGroupDataRequest.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.QueryAllEpochGroupDataRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupDataRequest 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_QueryAllEpochGroupDataRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllEpochGroupDataRequest.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.QueryAllEpochGroupDataRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupDataRequest 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_QueryAllEpochGroupDataRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllEpochGroupDataRequest", 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_QueryAllEpochGroupDataRequest) 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_QueryAllEpochGroupDataRequest) 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_QueryAllEpochGroupDataRequest) 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_QueryAllEpochGroupDataRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryAllEpochGroupDataRequest)
+ 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.Pagination != nil {
+ l = options.Size(x.Pagination)
+ 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().(*QueryAllEpochGroupDataRequest)
+ 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.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 {
+ 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().(*QueryAllEpochGroupDataRequest)
+ 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: QueryAllEpochGroupDataRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllEpochGroupDataRequest: 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:])
+ 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 = (*_QueryAllEpochGroupDataResponse_1_list)(nil)
+
+type _QueryAllEpochGroupDataResponse_1_list struct {
+ list *[]*EpochGroupData
+}
+
+func (x *_QueryAllEpochGroupDataResponse_1_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_QueryAllEpochGroupDataResponse_1_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryAllEpochGroupDataResponse_1_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*EpochGroupData)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_QueryAllEpochGroupDataResponse_1_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*EpochGroupData)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryAllEpochGroupDataResponse_1_list) AppendMutable() protoreflect.Value {
+ v := new(EpochGroupData)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryAllEpochGroupDataResponse_1_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_QueryAllEpochGroupDataResponse_1_list) NewElement() protoreflect.Value {
+ v := new(EpochGroupData)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryAllEpochGroupDataResponse_1_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_QueryAllEpochGroupDataResponse protoreflect.MessageDescriptor
+ fd_QueryAllEpochGroupDataResponse_epoch_group_data protoreflect.FieldDescriptor
+ fd_QueryAllEpochGroupDataResponse_pagination protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryAllEpochGroupDataResponse = File_inference_inference_query_proto.Messages().ByName("QueryAllEpochGroupDataResponse")
+ fd_QueryAllEpochGroupDataResponse_epoch_group_data = md_QueryAllEpochGroupDataResponse.Fields().ByName("epoch_group_data")
+ fd_QueryAllEpochGroupDataResponse_pagination = md_QueryAllEpochGroupDataResponse.Fields().ByName("pagination")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryAllEpochGroupDataResponse)(nil)
+
+type fastReflection_QueryAllEpochGroupDataResponse QueryAllEpochGroupDataResponse
+
+func (x *QueryAllEpochGroupDataResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryAllEpochGroupDataResponse)(x)
+}
+
+func (x *QueryAllEpochGroupDataResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[17]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryAllEpochGroupDataResponse_messageType fastReflection_QueryAllEpochGroupDataResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllEpochGroupDataResponse_messageType{}
+
+type fastReflection_QueryAllEpochGroupDataResponse_messageType struct{}
+
+func (x fastReflection_QueryAllEpochGroupDataResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryAllEpochGroupDataResponse)(nil)
+}
+func (x fastReflection_QueryAllEpochGroupDataResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryAllEpochGroupDataResponse)
+}
+func (x fastReflection_QueryAllEpochGroupDataResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryAllEpochGroupDataResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryAllEpochGroupDataResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryAllEpochGroupDataResponse
+}
+
+// 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_QueryAllEpochGroupDataResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryAllEpochGroupDataResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryAllEpochGroupDataResponse) New() protoreflect.Message {
+ return new(fastReflection_QueryAllEpochGroupDataResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryAllEpochGroupDataResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryAllEpochGroupDataResponse)(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_QueryAllEpochGroupDataResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if len(x.EpochGroupData) != 0 {
+ value := protoreflect.ValueOfList(&_QueryAllEpochGroupDataResponse_1_list{list: &x.EpochGroupData})
+ if !f(fd_QueryAllEpochGroupDataResponse_epoch_group_data, value) {
+ return
+ }
+ }
+ if x.Pagination != nil {
+ value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+ if !f(fd_QueryAllEpochGroupDataResponse_pagination, 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_QueryAllEpochGroupDataResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllEpochGroupDataResponse.epoch_group_data":
+ return len(x.EpochGroupData) != 0
+ case "inference.inference.QueryAllEpochGroupDataResponse.pagination":
+ return x.Pagination != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochGroupDataResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupDataResponse 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_QueryAllEpochGroupDataResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllEpochGroupDataResponse.epoch_group_data":
+ x.EpochGroupData = nil
+ case "inference.inference.QueryAllEpochGroupDataResponse.pagination":
+ x.Pagination = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochGroupDataResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupDataResponse 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_QueryAllEpochGroupDataResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryAllEpochGroupDataResponse.epoch_group_data":
+ if len(x.EpochGroupData) == 0 {
+ return protoreflect.ValueOfList(&_QueryAllEpochGroupDataResponse_1_list{})
+ }
+ listValue := &_QueryAllEpochGroupDataResponse_1_list{list: &x.EpochGroupData}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.inference.QueryAllEpochGroupDataResponse.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.QueryAllEpochGroupDataResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupDataResponse 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_QueryAllEpochGroupDataResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllEpochGroupDataResponse.epoch_group_data":
+ lv := value.List()
+ clv := lv.(*_QueryAllEpochGroupDataResponse_1_list)
+ x.EpochGroupData = *clv.list
+ case "inference.inference.QueryAllEpochGroupDataResponse.pagination":
+ x.Pagination = value.Message().Interface().(*v1beta1.PageResponse)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochGroupDataResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupDataResponse 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_QueryAllEpochGroupDataResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllEpochGroupDataResponse.epoch_group_data":
+ if x.EpochGroupData == nil {
+ x.EpochGroupData = []*EpochGroupData{}
+ }
+ value := &_QueryAllEpochGroupDataResponse_1_list{list: &x.EpochGroupData}
+ return protoreflect.ValueOfList(value)
+ case "inference.inference.QueryAllEpochGroupDataResponse.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.QueryAllEpochGroupDataResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupDataResponse 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_QueryAllEpochGroupDataResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllEpochGroupDataResponse.epoch_group_data":
+ list := []*EpochGroupData{}
+ return protoreflect.ValueOfList(&_QueryAllEpochGroupDataResponse_1_list{list: &list})
+ case "inference.inference.QueryAllEpochGroupDataResponse.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.QueryAllEpochGroupDataResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupDataResponse 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_QueryAllEpochGroupDataResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllEpochGroupDataResponse", 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_QueryAllEpochGroupDataResponse) 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_QueryAllEpochGroupDataResponse) 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_QueryAllEpochGroupDataResponse) 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_QueryAllEpochGroupDataResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryAllEpochGroupDataResponse)
+ 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.EpochGroupData) > 0 {
+ for _, e := range x.EpochGroupData {
+ 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)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*QueryAllEpochGroupDataResponse)
+ 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.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.EpochGroupData) > 0 {
+ for iNdEx := len(x.EpochGroupData) - 1; iNdEx >= 0; iNdEx-- {
+ encoded, err := options.Marshal(x.EpochGroupData[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().(*QueryAllEpochGroupDataResponse)
+ 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: QueryAllEpochGroupDataResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllEpochGroupDataResponse: 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)
+ }
+ 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.EpochGroupData = append(x.EpochGroupData, &EpochGroupData{})
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.EpochGroupData[len(x.EpochGroupData)-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
+ 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_QueryGetSettleAmountRequest protoreflect.MessageDescriptor
+ fd_QueryGetSettleAmountRequest_participant protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryGetSettleAmountRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetSettleAmountRequest")
+ fd_QueryGetSettleAmountRequest_participant = md_QueryGetSettleAmountRequest.Fields().ByName("participant")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetSettleAmountRequest)(nil)
+
+type fastReflection_QueryGetSettleAmountRequest QueryGetSettleAmountRequest
+
+func (x *QueryGetSettleAmountRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetSettleAmountRequest)(x)
+}
+
+func (x *QueryGetSettleAmountRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[18]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryGetSettleAmountRequest_messageType fastReflection_QueryGetSettleAmountRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetSettleAmountRequest_messageType{}
+
+type fastReflection_QueryGetSettleAmountRequest_messageType struct{}
+
+func (x fastReflection_QueryGetSettleAmountRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetSettleAmountRequest)(nil)
+}
+func (x fastReflection_QueryGetSettleAmountRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetSettleAmountRequest)
+}
+func (x fastReflection_QueryGetSettleAmountRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryGetSettleAmountRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryGetSettleAmountRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryGetSettleAmountRequest
+}
+
+// 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_QueryGetSettleAmountRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetSettleAmountRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryGetSettleAmountRequest) New() protoreflect.Message {
+ return new(fastReflection_QueryGetSettleAmountRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryGetSettleAmountRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetSettleAmountRequest)(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_QueryGetSettleAmountRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Participant != "" {
+ value := protoreflect.ValueOfString(x.Participant)
+ if !f(fd_QueryGetSettleAmountRequest_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_QueryGetSettleAmountRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetSettleAmountRequest.participant":
+ return x.Participant != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetSettleAmountRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetSettleAmountRequest 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_QueryGetSettleAmountRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetSettleAmountRequest.participant":
+ x.Participant = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetSettleAmountRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetSettleAmountRequest 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_QueryGetSettleAmountRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryGetSettleAmountRequest.participant":
+ value := x.Participant
+ return protoreflect.ValueOfString(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetSettleAmountRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetSettleAmountRequest 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_QueryGetSettleAmountRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetSettleAmountRequest.participant":
+ x.Participant = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetSettleAmountRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetSettleAmountRequest 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_QueryGetSettleAmountRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetSettleAmountRequest.participant":
+ panic(fmt.Errorf("field participant of message inference.inference.QueryGetSettleAmountRequest is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetSettleAmountRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetSettleAmountRequest 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_QueryGetSettleAmountRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetSettleAmountRequest.participant":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetSettleAmountRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetSettleAmountRequest 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_QueryGetSettleAmountRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetSettleAmountRequest", 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_QueryGetSettleAmountRequest) 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_QueryGetSettleAmountRequest) 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_QueryGetSettleAmountRequest) 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_QueryGetSettleAmountRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetSettleAmountRequest)
+ 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().(*QueryGetSettleAmountRequest)
+ 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().(*QueryGetSettleAmountRequest)
+ 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: QueryGetSettleAmountRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetSettleAmountRequest: 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_QueryGetSettleAmountResponse protoreflect.MessageDescriptor
+ fd_QueryGetSettleAmountResponse_settle_amount protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryGetSettleAmountResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetSettleAmountResponse")
+ fd_QueryGetSettleAmountResponse_settle_amount = md_QueryGetSettleAmountResponse.Fields().ByName("settle_amount")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetSettleAmountResponse)(nil)
+
+type fastReflection_QueryGetSettleAmountResponse QueryGetSettleAmountResponse
+
+func (x *QueryGetSettleAmountResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetSettleAmountResponse)(x)
+}
+
+func (x *QueryGetSettleAmountResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[19]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryGetSettleAmountResponse_messageType fastReflection_QueryGetSettleAmountResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetSettleAmountResponse_messageType{}
+
+type fastReflection_QueryGetSettleAmountResponse_messageType struct{}
+
+func (x fastReflection_QueryGetSettleAmountResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetSettleAmountResponse)(nil)
+}
+func (x fastReflection_QueryGetSettleAmountResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetSettleAmountResponse)
+}
+func (x fastReflection_QueryGetSettleAmountResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryGetSettleAmountResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryGetSettleAmountResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryGetSettleAmountResponse
+}
+
+// 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_QueryGetSettleAmountResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetSettleAmountResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryGetSettleAmountResponse) New() protoreflect.Message {
+ return new(fastReflection_QueryGetSettleAmountResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryGetSettleAmountResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetSettleAmountResponse)(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_QueryGetSettleAmountResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.SettleAmount != nil {
+ value := protoreflect.ValueOfMessage(x.SettleAmount.ProtoReflect())
+ if !f(fd_QueryGetSettleAmountResponse_settle_amount, 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_QueryGetSettleAmountResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetSettleAmountResponse.settle_amount":
+ return x.SettleAmount != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetSettleAmountResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetSettleAmountResponse 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_QueryGetSettleAmountResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetSettleAmountResponse.settle_amount":
+ x.SettleAmount = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetSettleAmountResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetSettleAmountResponse 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_QueryGetSettleAmountResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryGetSettleAmountResponse.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.QueryGetSettleAmountResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetSettleAmountResponse 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_QueryGetSettleAmountResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetSettleAmountResponse.settle_amount":
+ x.SettleAmount = value.Message().Interface().(*SettleAmount)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetSettleAmountResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetSettleAmountResponse 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_QueryGetSettleAmountResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetSettleAmountResponse.settle_amount":
+ if x.SettleAmount == nil {
+ x.SettleAmount = new(SettleAmount)
+ }
+ return protoreflect.ValueOfMessage(x.SettleAmount.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetSettleAmountResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetSettleAmountResponse 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_QueryGetSettleAmountResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetSettleAmountResponse.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.QueryGetSettleAmountResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetSettleAmountResponse 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_QueryGetSettleAmountResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetSettleAmountResponse", 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_QueryGetSettleAmountResponse) 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_QueryGetSettleAmountResponse) 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_QueryGetSettleAmountResponse) 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_QueryGetSettleAmountResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetSettleAmountResponse)
+ 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.SettleAmount != nil {
+ l = options.Size(x.SettleAmount)
+ 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().(*QueryGetSettleAmountResponse)
+ 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.SettleAmount != nil {
+ encoded, err := options.Marshal(x.SettleAmount)
+ 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().(*QueryGetSettleAmountResponse)
+ 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: QueryGetSettleAmountResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetSettleAmountResponse: 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 SettleAmount", 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.SettleAmount == nil {
+ x.SettleAmount = &SettleAmount{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.SettleAmount); 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_QueryAllSettleAmountRequest protoreflect.MessageDescriptor
+ fd_QueryAllSettleAmountRequest_pagination protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryAllSettleAmountRequest = File_inference_inference_query_proto.Messages().ByName("QueryAllSettleAmountRequest")
+ fd_QueryAllSettleAmountRequest_pagination = md_QueryAllSettleAmountRequest.Fields().ByName("pagination")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryAllSettleAmountRequest)(nil)
+
+type fastReflection_QueryAllSettleAmountRequest QueryAllSettleAmountRequest
+
+func (x *QueryAllSettleAmountRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryAllSettleAmountRequest)(x)
+}
+
+func (x *QueryAllSettleAmountRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[20]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryAllSettleAmountRequest_messageType fastReflection_QueryAllSettleAmountRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllSettleAmountRequest_messageType{}
+
+type fastReflection_QueryAllSettleAmountRequest_messageType struct{}
+
+func (x fastReflection_QueryAllSettleAmountRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryAllSettleAmountRequest)(nil)
+}
+func (x fastReflection_QueryAllSettleAmountRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryAllSettleAmountRequest)
+}
+func (x fastReflection_QueryAllSettleAmountRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryAllSettleAmountRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryAllSettleAmountRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryAllSettleAmountRequest
+}
+
+// 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_QueryAllSettleAmountRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryAllSettleAmountRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryAllSettleAmountRequest) New() protoreflect.Message {
+ return new(fastReflection_QueryAllSettleAmountRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryAllSettleAmountRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryAllSettleAmountRequest)(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_QueryAllSettleAmountRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Pagination != nil {
+ value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+ if !f(fd_QueryAllSettleAmountRequest_pagination, 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_QueryAllSettleAmountRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllSettleAmountRequest.pagination":
+ return x.Pagination != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllSettleAmountRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllSettleAmountRequest 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_QueryAllSettleAmountRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllSettleAmountRequest.pagination":
+ x.Pagination = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllSettleAmountRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllSettleAmountRequest 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_QueryAllSettleAmountRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryAllSettleAmountRequest.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.QueryAllSettleAmountRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllSettleAmountRequest 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_QueryAllSettleAmountRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllSettleAmountRequest.pagination":
+ x.Pagination = value.Message().Interface().(*v1beta1.PageRequest)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllSettleAmountRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllSettleAmountRequest 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_QueryAllSettleAmountRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllSettleAmountRequest.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.QueryAllSettleAmountRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllSettleAmountRequest 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_QueryAllSettleAmountRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllSettleAmountRequest.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.QueryAllSettleAmountRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllSettleAmountRequest 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_QueryAllSettleAmountRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllSettleAmountRequest", 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_QueryAllSettleAmountRequest) 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_QueryAllSettleAmountRequest) 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_QueryAllSettleAmountRequest) 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_QueryAllSettleAmountRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryAllSettleAmountRequest)
+ 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.Pagination != nil {
+ l = options.Size(x.Pagination)
+ 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().(*QueryAllSettleAmountRequest)
+ 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.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 {
+ 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().(*QueryAllSettleAmountRequest)
+ 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: QueryAllSettleAmountRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllSettleAmountRequest: 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:])
+ 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 = (*_QueryAllSettleAmountResponse_1_list)(nil)
+
+type _QueryAllSettleAmountResponse_1_list struct {
+ list *[]*SettleAmount
+}
+
+func (x *_QueryAllSettleAmountResponse_1_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_QueryAllSettleAmountResponse_1_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryAllSettleAmountResponse_1_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*SettleAmount)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_QueryAllSettleAmountResponse_1_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*SettleAmount)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryAllSettleAmountResponse_1_list) AppendMutable() protoreflect.Value {
+ v := new(SettleAmount)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryAllSettleAmountResponse_1_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_QueryAllSettleAmountResponse_1_list) NewElement() protoreflect.Value {
+ v := new(SettleAmount)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryAllSettleAmountResponse_1_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_QueryAllSettleAmountResponse protoreflect.MessageDescriptor
+ fd_QueryAllSettleAmountResponse_settle_amount protoreflect.FieldDescriptor
+ fd_QueryAllSettleAmountResponse_pagination protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryAllSettleAmountResponse = File_inference_inference_query_proto.Messages().ByName("QueryAllSettleAmountResponse")
+ fd_QueryAllSettleAmountResponse_settle_amount = md_QueryAllSettleAmountResponse.Fields().ByName("settle_amount")
+ fd_QueryAllSettleAmountResponse_pagination = md_QueryAllSettleAmountResponse.Fields().ByName("pagination")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryAllSettleAmountResponse)(nil)
+
+type fastReflection_QueryAllSettleAmountResponse QueryAllSettleAmountResponse
+
+func (x *QueryAllSettleAmountResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryAllSettleAmountResponse)(x)
+}
+
+func (x *QueryAllSettleAmountResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[21]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryAllSettleAmountResponse_messageType fastReflection_QueryAllSettleAmountResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllSettleAmountResponse_messageType{}
+
+type fastReflection_QueryAllSettleAmountResponse_messageType struct{}
+
+func (x fastReflection_QueryAllSettleAmountResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryAllSettleAmountResponse)(nil)
+}
+func (x fastReflection_QueryAllSettleAmountResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryAllSettleAmountResponse)
+}
+func (x fastReflection_QueryAllSettleAmountResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryAllSettleAmountResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryAllSettleAmountResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryAllSettleAmountResponse
+}
+
+// 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_QueryAllSettleAmountResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryAllSettleAmountResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryAllSettleAmountResponse) New() protoreflect.Message {
+ return new(fastReflection_QueryAllSettleAmountResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryAllSettleAmountResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryAllSettleAmountResponse)(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_QueryAllSettleAmountResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if len(x.SettleAmount) != 0 {
+ value := protoreflect.ValueOfList(&_QueryAllSettleAmountResponse_1_list{list: &x.SettleAmount})
+ if !f(fd_QueryAllSettleAmountResponse_settle_amount, value) {
+ return
+ }
+ }
+ if x.Pagination != nil {
+ value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+ if !f(fd_QueryAllSettleAmountResponse_pagination, 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_QueryAllSettleAmountResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllSettleAmountResponse.settle_amount":
+ return len(x.SettleAmount) != 0
+ case "inference.inference.QueryAllSettleAmountResponse.pagination":
+ return x.Pagination != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllSettleAmountResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllSettleAmountResponse 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_QueryAllSettleAmountResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllSettleAmountResponse.settle_amount":
+ x.SettleAmount = nil
+ case "inference.inference.QueryAllSettleAmountResponse.pagination":
+ x.Pagination = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllSettleAmountResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllSettleAmountResponse 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_QueryAllSettleAmountResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryAllSettleAmountResponse.settle_amount":
+ if len(x.SettleAmount) == 0 {
+ return protoreflect.ValueOfList(&_QueryAllSettleAmountResponse_1_list{})
+ }
+ listValue := &_QueryAllSettleAmountResponse_1_list{list: &x.SettleAmount}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.inference.QueryAllSettleAmountResponse.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.QueryAllSettleAmountResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllSettleAmountResponse 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_QueryAllSettleAmountResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllSettleAmountResponse.settle_amount":
+ lv := value.List()
+ clv := lv.(*_QueryAllSettleAmountResponse_1_list)
+ x.SettleAmount = *clv.list
+ case "inference.inference.QueryAllSettleAmountResponse.pagination":
+ x.Pagination = value.Message().Interface().(*v1beta1.PageResponse)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllSettleAmountResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllSettleAmountResponse 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_QueryAllSettleAmountResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllSettleAmountResponse.settle_amount":
+ if x.SettleAmount == nil {
+ x.SettleAmount = []*SettleAmount{}
+ }
+ value := &_QueryAllSettleAmountResponse_1_list{list: &x.SettleAmount}
+ return protoreflect.ValueOfList(value)
+ case "inference.inference.QueryAllSettleAmountResponse.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.QueryAllSettleAmountResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllSettleAmountResponse 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_QueryAllSettleAmountResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllSettleAmountResponse.settle_amount":
+ list := []*SettleAmount{}
+ return protoreflect.ValueOfList(&_QueryAllSettleAmountResponse_1_list{list: &list})
+ case "inference.inference.QueryAllSettleAmountResponse.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.QueryAllSettleAmountResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllSettleAmountResponse 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_QueryAllSettleAmountResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllSettleAmountResponse", 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_QueryAllSettleAmountResponse) 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_QueryAllSettleAmountResponse) 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_QueryAllSettleAmountResponse) 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_QueryAllSettleAmountResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryAllSettleAmountResponse)
+ 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.SettleAmount) > 0 {
+ for _, e := range x.SettleAmount {
+ 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)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*QueryAllSettleAmountResponse)
+ 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.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.SettleAmount) > 0 {
+ for iNdEx := len(x.SettleAmount) - 1; iNdEx >= 0; iNdEx-- {
+ encoded, err := options.Marshal(x.SettleAmount[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().(*QueryAllSettleAmountResponse)
+ 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: QueryAllSettleAmountResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllSettleAmountResponse: 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 SettleAmount", 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.SettleAmount = append(x.SettleAmount, &SettleAmount{})
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.SettleAmount[len(x.SettleAmount)-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
+ 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_QueryGetEpochGroupValidationsRequest protoreflect.MessageDescriptor
+ fd_QueryGetEpochGroupValidationsRequest_participant protoreflect.FieldDescriptor
+ fd_QueryGetEpochGroupValidationsRequest_epoch_index 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetEpochGroupValidationsRequest)(nil)
+
+type fastReflection_QueryGetEpochGroupValidationsRequest QueryGetEpochGroupValidationsRequest
+
+func (x *QueryGetEpochGroupValidationsRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetEpochGroupValidationsRequest)(x)
+}
+
+func (x *QueryGetEpochGroupValidationsRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[22]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryGetEpochGroupValidationsRequest_messageType fastReflection_QueryGetEpochGroupValidationsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetEpochGroupValidationsRequest_messageType{}
+
+type fastReflection_QueryGetEpochGroupValidationsRequest_messageType struct{}
+
+func (x fastReflection_QueryGetEpochGroupValidationsRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetEpochGroupValidationsRequest)(nil)
+}
+func (x fastReflection_QueryGetEpochGroupValidationsRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetEpochGroupValidationsRequest)
+}
+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_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_QueryGetEpochGroupValidationsRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetEpochGroupValidationsRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryGetEpochGroupValidationsRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetEpochGroupValidationsRequest)(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_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
+ }
+ }
+}
+
+// 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_QueryGetEpochGroupValidationsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryGetEpochGroupValidationsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupValidationsRequest 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_QueryGetEpochGroupValidationsRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ 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.QueryGetEpochGroupValidationsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupValidationsRequest 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_QueryGetEpochGroupValidationsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ 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.QueryGetEpochGroupValidationsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupValidationsRequest 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_QueryGetEpochGroupValidationsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ 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.QueryGetEpochGroupValidationsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupValidationsRequest 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_QueryGetEpochGroupValidationsRequest) 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"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochGroupValidationsRequest"))
+ }
+ 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_QueryGetEpochGroupValidationsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryGetEpochGroupValidationsRequest"))
+ }
+ 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_QueryGetEpochGroupValidationsRequest) 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("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_QueryGetEpochGroupValidationsRequest) 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_QueryGetEpochGroupValidationsRequest) 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_QueryGetEpochGroupValidationsRequest) 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_QueryGetEpochGroupValidationsRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetEpochGroupValidationsRequest)
+ 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.EpochIndex != 0 {
+ n += 1 + runtime.Sov(uint64(x.EpochIndex))
+ }
+ 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().(*QueryGetEpochGroupValidationsRequest)
+ 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.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
+ }
+ 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().(*QueryGetEpochGroupValidationsRequest)
+ 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: QueryGetEpochGroupValidationsRequest: 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)
+ }
+ 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 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:])
+ 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_QueryGetEpochGroupValidationsResponse protoreflect.MessageDescriptor
+ fd_QueryGetEpochGroupValidationsResponse_epoch_group_validations 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetEpochGroupValidationsResponse)(nil)
+
+type fastReflection_QueryGetEpochGroupValidationsResponse QueryGetEpochGroupValidationsResponse
+
+func (x *QueryGetEpochGroupValidationsResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetEpochGroupValidationsResponse)(x)
+}
+
+func (x *QueryGetEpochGroupValidationsResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[23]
+ 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_QueryGetEpochGroupValidationsResponse_messageType fastReflection_QueryGetEpochGroupValidationsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetEpochGroupValidationsResponse_messageType{}
+
+type fastReflection_QueryGetEpochGroupValidationsResponse_messageType struct{}
+
+func (x fastReflection_QueryGetEpochGroupValidationsResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetEpochGroupValidationsResponse)(nil)
+}
+func (x fastReflection_QueryGetEpochGroupValidationsResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetEpochGroupValidationsResponse)
+}
+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_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_QueryGetEpochGroupValidationsResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetEpochGroupValidationsResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryGetEpochGroupValidationsResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetEpochGroupValidationsResponse)(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_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
+ }
+ }
+}
+
+// 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_QueryGetEpochGroupValidationsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryGetEpochGroupValidationsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupValidationsResponse 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_QueryGetEpochGroupValidationsResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetEpochGroupValidationsResponse.epoch_group_validations":
+ x.EpochGroupValidations = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochGroupValidationsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupValidationsResponse 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_QueryGetEpochGroupValidationsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ 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.QueryGetEpochGroupValidationsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupValidationsResponse 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_QueryGetEpochGroupValidationsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ 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.QueryGetEpochGroupValidationsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupValidationsResponse 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_QueryGetEpochGroupValidationsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetEpochGroupValidationsResponse.epoch_group_validations":
+ if x.EpochGroupValidations == nil {
+ x.EpochGroupValidations = new(EpochGroupValidations)
+ }
+ return protoreflect.ValueOfMessage(x.EpochGroupValidations.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochGroupValidationsResponse"))
+ }
+ 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_QueryGetEpochGroupValidationsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryGetEpochGroupValidationsResponse"))
+ }
+ 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_QueryGetEpochGroupValidationsResponse) 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("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_QueryGetEpochGroupValidationsResponse) 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_QueryGetEpochGroupValidationsResponse) 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_QueryGetEpochGroupValidationsResponse) 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_QueryGetEpochGroupValidationsResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetEpochGroupValidationsResponse)
+ 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.EpochGroupValidations != nil {
+ l = options.Size(x.EpochGroupValidations)
+ 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().(*QueryGetEpochGroupValidationsResponse)
+ 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.EpochGroupValidations != nil {
+ encoded, err := options.Marshal(x.EpochGroupValidations)
+ 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().(*QueryGetEpochGroupValidationsResponse)
+ 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: QueryGetEpochGroupValidationsResponse: 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)
+ }
+ 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)
+ }
+ 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.EpochGroupValidations == nil {
+ x.EpochGroupValidations = &EpochGroupValidations{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.EpochGroupValidations); 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_QueryAllEpochGroupValidationsRequest protoreflect.MessageDescriptor
+ fd_QueryAllEpochGroupValidationsRequest_pagination 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryAllEpochGroupValidationsRequest)(nil)
+
+type fastReflection_QueryAllEpochGroupValidationsRequest QueryAllEpochGroupValidationsRequest
+
+func (x *QueryAllEpochGroupValidationsRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryAllEpochGroupValidationsRequest)(x)
+}
+
+func (x *QueryAllEpochGroupValidationsRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[24]
+ 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_QueryAllEpochGroupValidationsRequest_messageType fastReflection_QueryAllEpochGroupValidationsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllEpochGroupValidationsRequest_messageType{}
+
+type fastReflection_QueryAllEpochGroupValidationsRequest_messageType struct{}
+
+func (x fastReflection_QueryAllEpochGroupValidationsRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryAllEpochGroupValidationsRequest)(nil)
+}
+func (x fastReflection_QueryAllEpochGroupValidationsRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryAllEpochGroupValidationsRequest)
+}
+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_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_QueryAllEpochGroupValidationsRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryAllEpochGroupValidationsRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryAllEpochGroupValidationsRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryAllEpochGroupValidationsRequest)(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_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
+ }
+ }
+}
+
+// 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_QueryAllEpochGroupValidationsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryAllEpochGroupValidationsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupValidationsRequest 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_QueryAllEpochGroupValidationsRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllEpochGroupValidationsRequest.pagination":
+ x.Pagination = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochGroupValidationsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupValidationsRequest 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_QueryAllEpochGroupValidationsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ 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.QueryAllEpochGroupValidationsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupValidationsRequest 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_QueryAllEpochGroupValidationsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ 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.QueryAllEpochGroupValidationsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupValidationsRequest 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_QueryAllEpochGroupValidationsRequest) 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())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochGroupValidationsRequest"))
+ }
+ 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_QueryAllEpochGroupValidationsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryAllEpochGroupValidationsRequest"))
+ }
+ 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_QueryAllEpochGroupValidationsRequest) 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("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_QueryAllEpochGroupValidationsRequest) 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_QueryAllEpochGroupValidationsRequest) 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_QueryAllEpochGroupValidationsRequest) 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_QueryAllEpochGroupValidationsRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryAllEpochGroupValidationsRequest)
+ 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.Pagination != nil {
+ l = options.Size(x.Pagination)
+ 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().(*QueryAllEpochGroupValidationsRequest)
+ 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.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 {
+ 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().(*QueryAllEpochGroupValidationsRequest)
+ 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: QueryAllEpochGroupValidationsRequest: 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)
+ }
+ 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:])
+ 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 = (*_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
+)
+
+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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryAllEpochGroupValidationsResponse)(nil)
+
+type fastReflection_QueryAllEpochGroupValidationsResponse QueryAllEpochGroupValidationsResponse
+
+func (x *QueryAllEpochGroupValidationsResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryAllEpochGroupValidationsResponse)(x)
+}
+
+func (x *QueryAllEpochGroupValidationsResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[25]
+ 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_QueryAllEpochGroupValidationsResponse_messageType fastReflection_QueryAllEpochGroupValidationsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllEpochGroupValidationsResponse_messageType{}
+
+type fastReflection_QueryAllEpochGroupValidationsResponse_messageType struct{}
+
+func (x fastReflection_QueryAllEpochGroupValidationsResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryAllEpochGroupValidationsResponse)(nil)
+}
+func (x fastReflection_QueryAllEpochGroupValidationsResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryAllEpochGroupValidationsResponse)
+}
+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_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_QueryAllEpochGroupValidationsResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryAllEpochGroupValidationsResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryAllEpochGroupValidationsResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryAllEpochGroupValidationsResponse)(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_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
+ }
+ }
+}
+
+// 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_QueryAllEpochGroupValidationsResponse) 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
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochGroupValidationsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupValidationsResponse 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_QueryAllEpochGroupValidationsResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ 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.QueryAllEpochGroupValidationsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupValidationsResponse 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_QueryAllEpochGroupValidationsResponse) 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
+ 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("message inference.inference.QueryAllEpochGroupValidationsResponse 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_QueryAllEpochGroupValidationsResponse) 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)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochGroupValidationsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupValidationsResponse 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_QueryAllEpochGroupValidationsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllEpochGroupValidationsResponse.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)
+ }
+ return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochGroupValidationsResponse"))
+ }
+ 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_QueryAllEpochGroupValidationsResponse) 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)
+ 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("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_QueryAllEpochGroupValidationsResponse) 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("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_QueryAllEpochGroupValidationsResponse) 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_QueryAllEpochGroupValidationsResponse) 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_QueryAllEpochGroupValidationsResponse) 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_QueryAllEpochGroupValidationsResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryAllEpochGroupValidationsResponse)
+ 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.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)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*QueryAllEpochGroupValidationsResponse)
+ 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.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,
+ 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().(*QueryAllEpochGroupValidationsResponse)
+ 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: QueryAllEpochGroupValidationsResponse: 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)
+ }
+ 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)
+ }
+ 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.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
+ 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_QueryPocBatchesForStageRequest protoreflect.MessageDescriptor
+ fd_QueryPocBatchesForStageRequest_block_height 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryPocBatchesForStageRequest)(nil)
+
+type fastReflection_QueryPocBatchesForStageRequest QueryPocBatchesForStageRequest
+
+func (x *QueryPocBatchesForStageRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryPocBatchesForStageRequest)(x)
+}
+
+func (x *QueryPocBatchesForStageRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[26]
+ 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_QueryPocBatchesForStageRequest_messageType fastReflection_QueryPocBatchesForStageRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryPocBatchesForStageRequest_messageType{}
+
+type fastReflection_QueryPocBatchesForStageRequest_messageType struct{}
+
+func (x fastReflection_QueryPocBatchesForStageRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryPocBatchesForStageRequest)(nil)
+}
+func (x fastReflection_QueryPocBatchesForStageRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryPocBatchesForStageRequest)
+}
+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_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_QueryPocBatchesForStageRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryPocBatchesForStageRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryPocBatchesForStageRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryPocBatchesForStageRequest)(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_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
+ }
+ }
+}
+
+// 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_QueryPocBatchesForStageRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryPocBatchesForStageRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryPocBatchesForStageRequest 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_QueryPocBatchesForStageRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ 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.QueryPocBatchesForStageRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryPocBatchesForStageRequest 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_QueryPocBatchesForStageRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ 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.QueryPocBatchesForStageRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryPocBatchesForStageRequest 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_QueryPocBatchesForStageRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ 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.QueryPocBatchesForStageRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryPocBatchesForStageRequest 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_QueryPocBatchesForStageRequest) 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"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocBatchesForStageRequest"))
+ }
+ 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_QueryPocBatchesForStageRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryPocBatchesForStageRequest"))
+ }
+ 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_QueryPocBatchesForStageRequest) 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("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_QueryPocBatchesForStageRequest) 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_QueryPocBatchesForStageRequest) 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_QueryPocBatchesForStageRequest) 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_QueryPocBatchesForStageRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryPocBatchesForStageRequest)
+ 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.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().(*QueryPocBatchesForStageRequest)
+ 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.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().(*QueryPocBatchesForStageRequest)
+ 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: QueryPocBatchesForStageRequest: 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)
+ }
+ 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
+ }
+ }
+ 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 = (*_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_QueryPocBatchesForStageResponse protoreflect.MessageDescriptor
+ fd_QueryPocBatchesForStageResponse_poc_batch 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryPocBatchesForStageResponse)(nil)
+
+type fastReflection_QueryPocBatchesForStageResponse QueryPocBatchesForStageResponse
+
+func (x *QueryPocBatchesForStageResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryPocBatchesForStageResponse)(x)
+}
+
+func (x *QueryPocBatchesForStageResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[27]
+ 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_QueryPocBatchesForStageResponse_messageType fastReflection_QueryPocBatchesForStageResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryPocBatchesForStageResponse_messageType{}
+
+type fastReflection_QueryPocBatchesForStageResponse_messageType struct{}
+
+func (x fastReflection_QueryPocBatchesForStageResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryPocBatchesForStageResponse)(nil)
+}
+func (x fastReflection_QueryPocBatchesForStageResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryPocBatchesForStageResponse)
+}
+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_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_QueryPocBatchesForStageResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryPocBatchesForStageResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryPocBatchesForStageResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryPocBatchesForStageResponse)(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_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
+ }
+ }
+}
+
+// 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_QueryPocBatchesForStageResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryPocBatchesForStageResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryPocBatchesForStageResponse 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_QueryPocBatchesForStageResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ 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.QueryPocBatchesForStageResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryPocBatchesForStageResponse 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_QueryPocBatchesForStageResponse) 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{})
+ }
+ 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.QueryPocBatchesForStageResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryPocBatchesForStageResponse 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_QueryPocBatchesForStageResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ 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.QueryPocBatchesForStageResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryPocBatchesForStageResponse 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_QueryPocBatchesForStageResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryPocBatchesForStageResponse"))
+ }
+ 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_QueryPocBatchesForStageResponse) 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})
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocBatchesForStageResponse"))
+ }
+ 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_QueryPocBatchesForStageResponse) 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("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_QueryPocBatchesForStageResponse) 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_QueryPocBatchesForStageResponse) 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_QueryPocBatchesForStageResponse) 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_QueryPocBatchesForStageResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryPocBatchesForStageResponse)
+ 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.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)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*QueryPocBatchesForStageResponse)
+ 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.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...)
+ } 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().(*QueryPocBatchesForStageResponse)
+ 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: QueryPocBatchesForStageResponse: 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)
+ }
+ 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)
+ }
+ 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.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:])
+ 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 = (*_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
+)
+
+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")
+}
+
+var _ protoreflect.Message = (*fastReflection_PoCBatchesWithParticipants)(nil)
+
+type fastReflection_PoCBatchesWithParticipants PoCBatchesWithParticipants
+
+func (x *PoCBatchesWithParticipants) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_PoCBatchesWithParticipants)(x)
+}
+
+func (x *PoCBatchesWithParticipants) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[28]
+ 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_PoCBatchesWithParticipants_messageType fastReflection_PoCBatchesWithParticipants_messageType
+var _ protoreflect.MessageType = fastReflection_PoCBatchesWithParticipants_messageType{}
+
+type fastReflection_PoCBatchesWithParticipants_messageType struct{}
+
+func (x fastReflection_PoCBatchesWithParticipants_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_PoCBatchesWithParticipants)(nil)
+}
+func (x fastReflection_PoCBatchesWithParticipants_messageType) New() protoreflect.Message {
+ return new(fastReflection_PoCBatchesWithParticipants)
+}
+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_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_PoCBatchesWithParticipants) Type() protoreflect.MessageType {
+ return _fastReflection_PoCBatchesWithParticipants_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_PoCBatchesWithParticipants) Interface() protoreflect.ProtoMessage {
+ return (*PoCBatchesWithParticipants)(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_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
+ }
+ }
+}
+
+// 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_PoCBatchesWithParticipants) 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
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCBatchesWithParticipants"))
+ }
+ panic(fmt.Errorf("message inference.inference.PoCBatchesWithParticipants 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_PoCBatchesWithParticipants) 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
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCBatchesWithParticipants"))
+ }
+ panic(fmt.Errorf("message inference.inference.PoCBatchesWithParticipants 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_PoCBatchesWithParticipants) 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)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCBatchesWithParticipants"))
+ }
+ panic(fmt.Errorf("message inference.inference.PoCBatchesWithParticipants 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_PoCBatchesWithParticipants) 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
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCBatchesWithParticipants"))
+ }
+ panic(fmt.Errorf("message inference.inference.PoCBatchesWithParticipants 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_PoCBatchesWithParticipants) 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"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCBatchesWithParticipants"))
+ }
+ 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_PoCBatchesWithParticipants) 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})
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCBatchesWithParticipants"))
+ }
+ 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_PoCBatchesWithParticipants) 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("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_PoCBatchesWithParticipants) 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_PoCBatchesWithParticipants) 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_PoCBatchesWithParticipants) 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_PoCBatchesWithParticipants) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*PoCBatchesWithParticipants)
+ 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))
+ }
+ 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.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().(*PoCBatchesWithParticipants)
+ 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.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)))
+ 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().(*PoCBatchesWithParticipants)
+ 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: PoCBatchesWithParticipants: 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)
+ }
+ 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)
+ }
+ 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.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:])
+ 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_QueryPocValidationsForStageRequest protoreflect.MessageDescriptor
+ fd_QueryPocValidationsForStageRequest_block_height 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryPocValidationsForStageRequest)(nil)
+
+type fastReflection_QueryPocValidationsForStageRequest QueryPocValidationsForStageRequest
+
+func (x *QueryPocValidationsForStageRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryPocValidationsForStageRequest)(x)
+}
+
+func (x *QueryPocValidationsForStageRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[29]
+ 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_QueryPocValidationsForStageRequest_messageType fastReflection_QueryPocValidationsForStageRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryPocValidationsForStageRequest_messageType{}
+
+type fastReflection_QueryPocValidationsForStageRequest_messageType struct{}
+
+func (x fastReflection_QueryPocValidationsForStageRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryPocValidationsForStageRequest)(nil)
+}
+func (x fastReflection_QueryPocValidationsForStageRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryPocValidationsForStageRequest)
+}
+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_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_QueryPocValidationsForStageRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryPocValidationsForStageRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryPocValidationsForStageRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryPocValidationsForStageRequest)(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_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
+ }
+ }
+}
+
+// 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_QueryPocValidationsForStageRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryPocValidationsForStageRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryPocValidationsForStageRequest 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_QueryPocValidationsForStageRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ 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.QueryPocValidationsForStageRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryPocValidationsForStageRequest 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_QueryPocValidationsForStageRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ 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.QueryPocValidationsForStageRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryPocValidationsForStageRequest 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_QueryPocValidationsForStageRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ 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.QueryPocValidationsForStageRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryPocValidationsForStageRequest 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_QueryPocValidationsForStageRequest) 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"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocValidationsForStageRequest"))
+ }
+ 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_QueryPocValidationsForStageRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryPocValidationsForStageRequest"))
+ }
+ 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_QueryPocValidationsForStageRequest) 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("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_QueryPocValidationsForStageRequest) 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_QueryPocValidationsForStageRequest) 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_QueryPocValidationsForStageRequest) 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_QueryPocValidationsForStageRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryPocValidationsForStageRequest)
+ 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.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().(*QueryPocValidationsForStageRequest)
+ 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.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().(*QueryPocValidationsForStageRequest)
+ 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: QueryPocValidationsForStageRequest: 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)
+ }
+ 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
+ }
+ }
+ 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 = (*_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_QueryPocValidationsForStageResponse protoreflect.MessageDescriptor
+ fd_QueryPocValidationsForStageResponse_poc_validation 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryPocValidationsForStageResponse)(nil)
+
+type fastReflection_QueryPocValidationsForStageResponse QueryPocValidationsForStageResponse
+
+func (x *QueryPocValidationsForStageResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryPocValidationsForStageResponse)(x)
+}
+
+func (x *QueryPocValidationsForStageResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[30]
+ 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_QueryPocValidationsForStageResponse_messageType fastReflection_QueryPocValidationsForStageResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryPocValidationsForStageResponse_messageType{}
+
+type fastReflection_QueryPocValidationsForStageResponse_messageType struct{}
+
+func (x fastReflection_QueryPocValidationsForStageResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryPocValidationsForStageResponse)(nil)
+}
+func (x fastReflection_QueryPocValidationsForStageResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryPocValidationsForStageResponse)
+}
+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_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_QueryPocValidationsForStageResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryPocValidationsForStageResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryPocValidationsForStageResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryPocValidationsForStageResponse)(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_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
+ }
+ }
+}
+
+// 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_QueryPocValidationsForStageResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryPocValidationsForStageResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryPocValidationsForStageResponse 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_QueryPocValidationsForStageResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ 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.QueryPocValidationsForStageResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryPocValidationsForStageResponse 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_QueryPocValidationsForStageResponse) 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{})
+ }
+ 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.QueryPocValidationsForStageResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryPocValidationsForStageResponse 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_QueryPocValidationsForStageResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ 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.QueryPocValidationsForStageResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryPocValidationsForStageResponse 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_QueryPocValidationsForStageResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryPocValidationsForStageResponse"))
+ }
+ 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_QueryPocValidationsForStageResponse) 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})
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocValidationsForStageResponse"))
+ }
+ 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_QueryPocValidationsForStageResponse) 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("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_QueryPocValidationsForStageResponse) 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_QueryPocValidationsForStageResponse) 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_QueryPocValidationsForStageResponse) 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_QueryPocValidationsForStageResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryPocValidationsForStageResponse)
+ 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.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)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*QueryPocValidationsForStageResponse)
+ 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.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,
+ Buf: input.Buf,
+ }, nil
+ }
+ unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+ x := input.Message.Interface().(*QueryPocValidationsForStageResponse)
+ 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: QueryPocValidationsForStageResponse: 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)
+ }
+ 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)
+ }
+ 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, &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:])
+ 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 = (*_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
+)
+
+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")
+}
+
+var _ protoreflect.Message = (*fastReflection_PoCValidationsWithParticipants)(nil)
+
+type fastReflection_PoCValidationsWithParticipants PoCValidationsWithParticipants
+
+func (x *PoCValidationsWithParticipants) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_PoCValidationsWithParticipants)(x)
+}
+
+func (x *PoCValidationsWithParticipants) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[31]
+ 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_PoCValidationsWithParticipants_messageType fastReflection_PoCValidationsWithParticipants_messageType
+var _ protoreflect.MessageType = fastReflection_PoCValidationsWithParticipants_messageType{}
+
+type fastReflection_PoCValidationsWithParticipants_messageType struct{}
+
+func (x fastReflection_PoCValidationsWithParticipants_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_PoCValidationsWithParticipants)(nil)
+}
+func (x fastReflection_PoCValidationsWithParticipants_messageType) New() protoreflect.Message {
+ return new(fastReflection_PoCValidationsWithParticipants)
+}
+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_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_PoCValidationsWithParticipants) Type() protoreflect.MessageType {
+ return _fastReflection_PoCValidationsWithParticipants_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_PoCValidationsWithParticipants) Interface() protoreflect.ProtoMessage {
+ return (*PoCValidationsWithParticipants)(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_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) {
+ 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_PoCValidationsWithParticipants) 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
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCValidationsWithParticipants"))
+ }
+ panic(fmt.Errorf("message inference.inference.PoCValidationsWithParticipants 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_PoCValidationsWithParticipants) 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
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCValidationsWithParticipants"))
+ }
+ panic(fmt.Errorf("message inference.inference.PoCValidationsWithParticipants 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_PoCValidationsWithParticipants) 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)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCValidationsWithParticipants"))
+ }
+ panic(fmt.Errorf("message inference.inference.PoCValidationsWithParticipants 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_PoCValidationsWithParticipants) 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
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCValidationsWithParticipants"))
+ }
+ panic(fmt.Errorf("message inference.inference.PoCValidationsWithParticipants 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_PoCValidationsWithParticipants) 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"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCValidationsWithParticipants"))
+ }
+ 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_PoCValidationsWithParticipants) 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})
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCValidationsWithParticipants"))
+ }
+ 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_PoCValidationsWithParticipants) 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("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_PoCValidationsWithParticipants) 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_PoCValidationsWithParticipants) 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_PoCValidationsWithParticipants) 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_PoCValidationsWithParticipants) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*PoCValidationsWithParticipants)
+ 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))
+ }
+ 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.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().(*PoCValidationsWithParticipants)
+ 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.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)))
+ 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().(*PoCValidationsWithParticipants)
+ 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: PoCValidationsWithParticipants: 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)
+ }
+ 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, &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:])
+ 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_QueryGetCurrentEpochRequest protoreflect.MessageDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryGetCurrentEpochRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetCurrentEpochRequest")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetCurrentEpochRequest)(nil)
+
+type fastReflection_QueryGetCurrentEpochRequest QueryGetCurrentEpochRequest
+
+func (x *QueryGetCurrentEpochRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetCurrentEpochRequest)(x)
+}
+
+func (x *QueryGetCurrentEpochRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[32]
+ 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_QueryGetCurrentEpochRequest_messageType fastReflection_QueryGetCurrentEpochRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetCurrentEpochRequest_messageType{}
+
+type fastReflection_QueryGetCurrentEpochRequest_messageType struct{}
+
+func (x fastReflection_QueryGetCurrentEpochRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetCurrentEpochRequest)(nil)
+}
+func (x fastReflection_QueryGetCurrentEpochRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetCurrentEpochRequest)
+}
+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_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_QueryGetCurrentEpochRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetCurrentEpochRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryGetCurrentEpochRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetCurrentEpochRequest)(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_QueryGetCurrentEpochRequest) 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_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.QueryGetCurrentEpochRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetCurrentEpochRequest 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_QueryGetCurrentEpochRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetCurrentEpochRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetCurrentEpochRequest 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_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.QueryGetCurrentEpochRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetCurrentEpochRequest 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_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.QueryGetCurrentEpochRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetCurrentEpochRequest 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_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.QueryGetCurrentEpochRequest"))
+ }
+ 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_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.QueryGetCurrentEpochRequest"))
+ }
+ 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_QueryGetCurrentEpochRequest) 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("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_QueryGetCurrentEpochRequest) 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_QueryGetCurrentEpochRequest) 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_QueryGetCurrentEpochRequest) 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_QueryGetCurrentEpochRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetCurrentEpochRequest)
+ 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().(*QueryGetCurrentEpochRequest)
+ 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().(*QueryGetCurrentEpochRequest)
+ 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: QueryGetCurrentEpochRequest: 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)
+ }
+ 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 (
+ md_QueryGetCurrentEpochResponse protoreflect.MessageDescriptor
+ fd_QueryGetCurrentEpochResponse_epoch protoreflect.FieldDescriptor
+)
+
+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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetCurrentEpochResponse)(nil)
+
+type fastReflection_QueryGetCurrentEpochResponse QueryGetCurrentEpochResponse
+
+func (x *QueryGetCurrentEpochResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetCurrentEpochResponse)(x)
+}
+
+func (x *QueryGetCurrentEpochResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[33]
+ 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_QueryGetCurrentEpochResponse_messageType fastReflection_QueryGetCurrentEpochResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetCurrentEpochResponse_messageType{}
+
+type fastReflection_QueryGetCurrentEpochResponse_messageType struct{}
+
+func (x fastReflection_QueryGetCurrentEpochResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetCurrentEpochResponse)(nil)
+}
+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_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_QueryGetCurrentEpochResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetCurrentEpochResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryGetCurrentEpochResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetCurrentEpochResponse)(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_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
+ }
+ }
+}
+
+// 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_QueryGetCurrentEpochResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryGetCurrentEpochResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetCurrentEpochResponse 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_QueryGetCurrentEpochResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ 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.QueryGetCurrentEpochResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetCurrentEpochResponse 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_QueryGetCurrentEpochResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ 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.QueryGetCurrentEpochResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetCurrentEpochResponse 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_QueryGetCurrentEpochResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ 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.QueryGetCurrentEpochResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetCurrentEpochResponse 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_QueryGetCurrentEpochResponse) 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"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetCurrentEpochResponse"))
+ }
+ 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_QueryGetCurrentEpochResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryGetCurrentEpochResponse"))
+ }
+ 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_QueryGetCurrentEpochResponse) 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("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_QueryGetCurrentEpochResponse) 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_QueryGetCurrentEpochResponse) 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_QueryGetCurrentEpochResponse) 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_QueryGetCurrentEpochResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetCurrentEpochResponse)
+ 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))
+ }
+ 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().(*QueryGetCurrentEpochResponse)
+ 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.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().(*QueryGetCurrentEpochResponse)
+ 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: QueryGetCurrentEpochResponse: 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)
+ }
+ 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
+ }
+ }
+ 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_QueryGetTokenomicsDataRequest protoreflect.MessageDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryGetTokenomicsDataRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetTokenomicsDataRequest")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetTokenomicsDataRequest)(nil)
+
+type fastReflection_QueryGetTokenomicsDataRequest QueryGetTokenomicsDataRequest
+
+func (x *QueryGetTokenomicsDataRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetTokenomicsDataRequest)(x)
+}
+
+func (x *QueryGetTokenomicsDataRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[34]
+ 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_QueryGetTokenomicsDataRequest_messageType fastReflection_QueryGetTokenomicsDataRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetTokenomicsDataRequest_messageType{}
+
+type fastReflection_QueryGetTokenomicsDataRequest_messageType struct{}
+
+func (x fastReflection_QueryGetTokenomicsDataRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetTokenomicsDataRequest)(nil)
+}
+func (x fastReflection_QueryGetTokenomicsDataRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetTokenomicsDataRequest)
+}
+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_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_QueryGetTokenomicsDataRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetTokenomicsDataRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryGetTokenomicsDataRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetTokenomicsDataRequest)(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_QueryGetTokenomicsDataRequest) 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_QueryGetTokenomicsDataRequest) 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("message inference.inference.QueryGetTokenomicsDataRequest 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_QueryGetTokenomicsDataRequest) 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("message inference.inference.QueryGetTokenomicsDataRequest 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_QueryGetTokenomicsDataRequest) 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("message inference.inference.QueryGetTokenomicsDataRequest 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_QueryGetTokenomicsDataRequest) 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("message inference.inference.QueryGetTokenomicsDataRequest 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_QueryGetTokenomicsDataRequest) 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("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_QueryGetTokenomicsDataRequest) 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("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_QueryGetTokenomicsDataRequest) 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("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_QueryGetTokenomicsDataRequest) 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_QueryGetTokenomicsDataRequest) 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_QueryGetTokenomicsDataRequest) 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_QueryGetTokenomicsDataRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetTokenomicsDataRequest)
+ 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().(*QueryGetTokenomicsDataRequest)
+ 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().(*QueryGetTokenomicsDataRequest)
+ 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: QueryGetTokenomicsDataRequest: 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)
+ }
+ 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 (
+ md_QueryGetTokenomicsDataResponse protoreflect.MessageDescriptor
+ fd_QueryGetTokenomicsDataResponse_tokenomics_data 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetTokenomicsDataResponse)(nil)
+
+type fastReflection_QueryGetTokenomicsDataResponse QueryGetTokenomicsDataResponse
+
+func (x *QueryGetTokenomicsDataResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetTokenomicsDataResponse)(x)
+}
+
+func (x *QueryGetTokenomicsDataResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[35]
+ 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_QueryGetTokenomicsDataResponse_messageType fastReflection_QueryGetTokenomicsDataResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetTokenomicsDataResponse_messageType{}
+
+type fastReflection_QueryGetTokenomicsDataResponse_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_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_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_QueryGetTokenomicsDataResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetTokenomicsDataResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryGetTokenomicsDataResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetTokenomicsDataResponse)(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_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
+ }
+ }
+}
+
+// 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_QueryGetTokenomicsDataResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryGetTokenomicsDataResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetTokenomicsDataResponse 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_QueryGetTokenomicsDataResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ 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.QueryGetTokenomicsDataResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetTokenomicsDataResponse 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_QueryGetTokenomicsDataResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryGetTokenomicsDataResponse.tokenomics_data":
+ value := x.TokenomicsData
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTokenomicsDataResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetTokenomicsDataResponse 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_QueryGetTokenomicsDataResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ 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.QueryGetTokenomicsDataResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetTokenomicsDataResponse 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_QueryGetTokenomicsDataResponse) 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())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTokenomicsDataResponse"))
+ }
+ 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_QueryGetTokenomicsDataResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetTokenomicsDataResponse.tokenomics_data":
+ m := new(TokenomicsData)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTokenomicsDataResponse"))
+ }
+ 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_QueryGetTokenomicsDataResponse) 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("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_QueryGetTokenomicsDataResponse) 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_QueryGetTokenomicsDataResponse) 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_QueryGetTokenomicsDataResponse) 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_QueryGetTokenomicsDataResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetTokenomicsDataResponse)
+ 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.TokenomicsData != nil {
+ l = options.Size(x.TokenomicsData)
+ 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().(*QueryGetTokenomicsDataResponse)
+ 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.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)))
+ 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().(*QueryGetTokenomicsDataResponse)
+ 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: QueryGetTokenomicsDataResponse: 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)
+ }
+ 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)
+ }
+ 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.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:])
+ 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_QueryGetUnitOfComputePriceProposalRequest protoreflect.MessageDescriptor
+ fd_QueryGetUnitOfComputePriceProposalRequest_participant protoreflect.FieldDescriptor
+)
+
+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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetUnitOfComputePriceProposalRequest)(nil)
+
+type fastReflection_QueryGetUnitOfComputePriceProposalRequest QueryGetUnitOfComputePriceProposalRequest
+
+func (x *QueryGetUnitOfComputePriceProposalRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetUnitOfComputePriceProposalRequest)(x)
+}
+
+func (x *QueryGetUnitOfComputePriceProposalRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[36]
+ 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_QueryGetUnitOfComputePriceProposalRequest_messageType fastReflection_QueryGetUnitOfComputePriceProposalRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetUnitOfComputePriceProposalRequest_messageType{}
+
+type fastReflection_QueryGetUnitOfComputePriceProposalRequest_messageType struct{}
+
+func (x fastReflection_QueryGetUnitOfComputePriceProposalRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetUnitOfComputePriceProposalRequest)(nil)
+}
+func (x fastReflection_QueryGetUnitOfComputePriceProposalRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetUnitOfComputePriceProposalRequest)
+}
+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_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_QueryGetUnitOfComputePriceProposalRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetUnitOfComputePriceProposalRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryGetUnitOfComputePriceProposalRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetUnitOfComputePriceProposalRequest)(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_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.
+//
+// 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_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.QueryGetUnitOfComputePriceProposalRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetUnitOfComputePriceProposalRequest 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_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.QueryGetUnitOfComputePriceProposalRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetUnitOfComputePriceProposalRequest 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_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.QueryGetUnitOfComputePriceProposalRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetUnitOfComputePriceProposalRequest 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_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.QueryGetUnitOfComputePriceProposalRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetUnitOfComputePriceProposalRequest 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_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.QueryGetUnitOfComputePriceProposalRequest"))
+ }
+ 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_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.QueryGetUnitOfComputePriceProposalRequest"))
+ }
+ 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_QueryGetUnitOfComputePriceProposalRequest) 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("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_QueryGetUnitOfComputePriceProposalRequest) 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_QueryGetUnitOfComputePriceProposalRequest) 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_QueryGetUnitOfComputePriceProposalRequest) 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_QueryGetUnitOfComputePriceProposalRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetUnitOfComputePriceProposalRequest)
+ 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().(*QueryGetUnitOfComputePriceProposalRequest)
+ 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().(*QueryGetUnitOfComputePriceProposalRequest)
+ 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: QueryGetUnitOfComputePriceProposalRequest: 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)
+ }
+ 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_QueryGetUnitOfComputePriceProposalResponse protoreflect.MessageDescriptor
+ fd_QueryGetUnitOfComputePriceProposalResponse_proposal protoreflect.FieldDescriptor
+ fd_QueryGetUnitOfComputePriceProposalResponse_default 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetUnitOfComputePriceProposalResponse)(nil)
+
+type fastReflection_QueryGetUnitOfComputePriceProposalResponse QueryGetUnitOfComputePriceProposalResponse
+
+func (x *QueryGetUnitOfComputePriceProposalResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetUnitOfComputePriceProposalResponse)(x)
+}
+
+func (x *QueryGetUnitOfComputePriceProposalResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[37]
+ 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_QueryGetUnitOfComputePriceProposalResponse_messageType fastReflection_QueryGetUnitOfComputePriceProposalResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetUnitOfComputePriceProposalResponse_messageType{}
+
+type fastReflection_QueryGetUnitOfComputePriceProposalResponse_messageType struct{}
+
+func (x fastReflection_QueryGetUnitOfComputePriceProposalResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetUnitOfComputePriceProposalResponse)(nil)
+}
+func (x fastReflection_QueryGetUnitOfComputePriceProposalResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetUnitOfComputePriceProposalResponse)
+}
+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_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_QueryGetUnitOfComputePriceProposalResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetUnitOfComputePriceProposalResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryGetUnitOfComputePriceProposalResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetUnitOfComputePriceProposalResponse)(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_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
+ }
+ }
+}
+
+// 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_QueryGetUnitOfComputePriceProposalResponse) 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)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetUnitOfComputePriceProposalResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetUnitOfComputePriceProposalResponse 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_QueryGetUnitOfComputePriceProposalResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ 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.QueryGetUnitOfComputePriceProposalResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetUnitOfComputePriceProposalResponse 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_QueryGetUnitOfComputePriceProposalResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ 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.QueryGetUnitOfComputePriceProposalResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetUnitOfComputePriceProposalResponse 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_QueryGetUnitOfComputePriceProposalResponse) 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()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetUnitOfComputePriceProposalResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetUnitOfComputePriceProposalResponse 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_QueryGetUnitOfComputePriceProposalResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetUnitOfComputePriceProposalResponse.proposal":
+ if x.Proposal == nil {
+ x.Proposal = new(UnitOfComputePriceProposal)
+ }
+ 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.QueryGetUnitOfComputePriceProposalResponse"))
+ }
+ 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_QueryGetUnitOfComputePriceProposalResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryGetUnitOfComputePriceProposalResponse"))
+ }
+ 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_QueryGetUnitOfComputePriceProposalResponse) 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("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_QueryGetUnitOfComputePriceProposalResponse) 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_QueryGetUnitOfComputePriceProposalResponse) 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_QueryGetUnitOfComputePriceProposalResponse) 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_QueryGetUnitOfComputePriceProposalResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetUnitOfComputePriceProposalResponse)
+ 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.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)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*QueryGetUnitOfComputePriceProposalResponse)
+ 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.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,
+ 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().(*QueryGetUnitOfComputePriceProposalResponse)
+ 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: QueryGetUnitOfComputePriceProposalResponse: 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)
+ }
+ 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)
+ }
+ 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.Proposal == nil {
+ x.Proposal = &UnitOfComputePriceProposal{}
+ }
+ 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:])
+ 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_QueryCurrentEpochGroupDataRequest protoreflect.MessageDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryCurrentEpochGroupDataRequest = File_inference_inference_query_proto.Messages().ByName("QueryCurrentEpochGroupDataRequest")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryCurrentEpochGroupDataRequest)(nil)
+
+type fastReflection_QueryCurrentEpochGroupDataRequest QueryCurrentEpochGroupDataRequest
+
+func (x *QueryCurrentEpochGroupDataRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryCurrentEpochGroupDataRequest)(x)
+}
+
+func (x *QueryCurrentEpochGroupDataRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[38]
+ 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_QueryCurrentEpochGroupDataRequest_messageType fastReflection_QueryCurrentEpochGroupDataRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryCurrentEpochGroupDataRequest_messageType{}
+
+type fastReflection_QueryCurrentEpochGroupDataRequest_messageType struct{}
+
+func (x fastReflection_QueryCurrentEpochGroupDataRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryCurrentEpochGroupDataRequest)(nil)
+}
+func (x fastReflection_QueryCurrentEpochGroupDataRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryCurrentEpochGroupDataRequest)
+}
+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_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_QueryCurrentEpochGroupDataRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryCurrentEpochGroupDataRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryCurrentEpochGroupDataRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryCurrentEpochGroupDataRequest)(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_QueryCurrentEpochGroupDataRequest) 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_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.QueryCurrentEpochGroupDataRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryCurrentEpochGroupDataRequest 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_QueryCurrentEpochGroupDataRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCurrentEpochGroupDataRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryCurrentEpochGroupDataRequest 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_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.QueryCurrentEpochGroupDataRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryCurrentEpochGroupDataRequest 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_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.QueryCurrentEpochGroupDataRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryCurrentEpochGroupDataRequest 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_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.QueryCurrentEpochGroupDataRequest"))
+ }
+ 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_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.QueryCurrentEpochGroupDataRequest"))
+ }
+ 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_QueryCurrentEpochGroupDataRequest) 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("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_QueryCurrentEpochGroupDataRequest) 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_QueryCurrentEpochGroupDataRequest) 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_QueryCurrentEpochGroupDataRequest) 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_QueryCurrentEpochGroupDataRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryCurrentEpochGroupDataRequest)
+ 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().(*QueryCurrentEpochGroupDataRequest)
+ 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().(*QueryCurrentEpochGroupDataRequest)
+ 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: QueryCurrentEpochGroupDataRequest: 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)
+ }
+ 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 (
+ md_QueryCurrentEpochGroupDataResponse protoreflect.MessageDescriptor
+ fd_QueryCurrentEpochGroupDataResponse_epoch_group_data 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryCurrentEpochGroupDataResponse)(nil)
+
+type fastReflection_QueryCurrentEpochGroupDataResponse QueryCurrentEpochGroupDataResponse
+
+func (x *QueryCurrentEpochGroupDataResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryCurrentEpochGroupDataResponse)(x)
+}
+
+func (x *QueryCurrentEpochGroupDataResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[39]
+ 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_QueryCurrentEpochGroupDataResponse_messageType fastReflection_QueryCurrentEpochGroupDataResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryCurrentEpochGroupDataResponse_messageType{}
+
+type fastReflection_QueryCurrentEpochGroupDataResponse_messageType struct{}
+
+func (x fastReflection_QueryCurrentEpochGroupDataResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryCurrentEpochGroupDataResponse)(nil)
+}
+func (x fastReflection_QueryCurrentEpochGroupDataResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryCurrentEpochGroupDataResponse)
+}
+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_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_QueryCurrentEpochGroupDataResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryCurrentEpochGroupDataResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryCurrentEpochGroupDataResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryCurrentEpochGroupDataResponse)(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_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) {
+ 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_QueryCurrentEpochGroupDataResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryCurrentEpochGroupDataResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryCurrentEpochGroupDataResponse 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_QueryCurrentEpochGroupDataResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ 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.QueryCurrentEpochGroupDataResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryCurrentEpochGroupDataResponse 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_QueryCurrentEpochGroupDataResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ 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.QueryCurrentEpochGroupDataResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryCurrentEpochGroupDataResponse 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_QueryCurrentEpochGroupDataResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ 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.QueryCurrentEpochGroupDataResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryCurrentEpochGroupDataResponse 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_QueryCurrentEpochGroupDataResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryCurrentEpochGroupDataResponse"))
+ }
+ 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_QueryCurrentEpochGroupDataResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryCurrentEpochGroupDataResponse"))
+ }
+ 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_QueryCurrentEpochGroupDataResponse) 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("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_QueryCurrentEpochGroupDataResponse) 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_QueryCurrentEpochGroupDataResponse) 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_QueryCurrentEpochGroupDataResponse) 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_QueryCurrentEpochGroupDataResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryCurrentEpochGroupDataResponse)
+ 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.EpochGroupData != nil {
+ l = options.Size(x.EpochGroupData)
+ 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().(*QueryCurrentEpochGroupDataResponse)
+ 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.EpochGroupData != nil {
+ encoded, err := options.Marshal(x.EpochGroupData)
+ 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().(*QueryCurrentEpochGroupDataResponse)
+ 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: QueryCurrentEpochGroupDataResponse: 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)
+ }
+ 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)
+ }
+ 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.EpochGroupData == nil {
+ x.EpochGroupData = &EpochGroupData{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.EpochGroupData); 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_QueryPreviousEpochGroupDataRequest protoreflect.MessageDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryPreviousEpochGroupDataRequest = File_inference_inference_query_proto.Messages().ByName("QueryPreviousEpochGroupDataRequest")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryPreviousEpochGroupDataRequest)(nil)
+
+type fastReflection_QueryPreviousEpochGroupDataRequest QueryPreviousEpochGroupDataRequest
+
+func (x *QueryPreviousEpochGroupDataRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryPreviousEpochGroupDataRequest)(x)
+}
+
+func (x *QueryPreviousEpochGroupDataRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[40]
+ 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_QueryPreviousEpochGroupDataRequest_messageType fastReflection_QueryPreviousEpochGroupDataRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryPreviousEpochGroupDataRequest_messageType{}
+
+type fastReflection_QueryPreviousEpochGroupDataRequest_messageType struct{}
+
+func (x fastReflection_QueryPreviousEpochGroupDataRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryPreviousEpochGroupDataRequest)(nil)
+}
+func (x fastReflection_QueryPreviousEpochGroupDataRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryPreviousEpochGroupDataRequest)
+}
+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_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_QueryPreviousEpochGroupDataRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryPreviousEpochGroupDataRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryPreviousEpochGroupDataRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryPreviousEpochGroupDataRequest)(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_QueryPreviousEpochGroupDataRequest) 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_QueryPreviousEpochGroupDataRequest) 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("message inference.inference.QueryPreviousEpochGroupDataRequest 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_QueryPreviousEpochGroupDataRequest) 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("message inference.inference.QueryPreviousEpochGroupDataRequest 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_QueryPreviousEpochGroupDataRequest) 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("message inference.inference.QueryPreviousEpochGroupDataRequest 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_QueryPreviousEpochGroupDataRequest) 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("message inference.inference.QueryPreviousEpochGroupDataRequest 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_QueryPreviousEpochGroupDataRequest) 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("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_QueryPreviousEpochGroupDataRequest) 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("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_QueryPreviousEpochGroupDataRequest) 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("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_QueryPreviousEpochGroupDataRequest) 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_QueryPreviousEpochGroupDataRequest) 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_QueryPreviousEpochGroupDataRequest) 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_QueryPreviousEpochGroupDataRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryPreviousEpochGroupDataRequest)
+ 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().(*QueryPreviousEpochGroupDataRequest)
+ 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().(*QueryPreviousEpochGroupDataRequest)
+ 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: QueryPreviousEpochGroupDataRequest: 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)
+ }
+ 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 (
+ md_QueryPreviousEpochGroupDataResponse protoreflect.MessageDescriptor
+ fd_QueryPreviousEpochGroupDataResponse_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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryPreviousEpochGroupDataResponse)(nil)
+
+type fastReflection_QueryPreviousEpochGroupDataResponse QueryPreviousEpochGroupDataResponse
+
+func (x *QueryPreviousEpochGroupDataResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryPreviousEpochGroupDataResponse)(x)
+}
+
+func (x *QueryPreviousEpochGroupDataResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_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_QueryPreviousEpochGroupDataResponse_messageType fastReflection_QueryPreviousEpochGroupDataResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryPreviousEpochGroupDataResponse_messageType{}
+
+type fastReflection_QueryPreviousEpochGroupDataResponse_messageType struct{}
+
+func (x fastReflection_QueryPreviousEpochGroupDataResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryPreviousEpochGroupDataResponse)(nil)
+}
+func (x fastReflection_QueryPreviousEpochGroupDataResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryPreviousEpochGroupDataResponse)
+}
+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_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_QueryPreviousEpochGroupDataResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryPreviousEpochGroupDataResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryPreviousEpochGroupDataResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryPreviousEpochGroupDataResponse)(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_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
+ }
+ }
+}
+
+// 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_QueryPreviousEpochGroupDataResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryPreviousEpochGroupDataResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryPreviousEpochGroupDataResponse 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_QueryPreviousEpochGroupDataResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ 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.QueryPreviousEpochGroupDataResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryPreviousEpochGroupDataResponse 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_QueryPreviousEpochGroupDataResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ 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.QueryPreviousEpochGroupDataResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryPreviousEpochGroupDataResponse 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_QueryPreviousEpochGroupDataResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ 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.QueryPreviousEpochGroupDataResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryPreviousEpochGroupDataResponse 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_QueryPreviousEpochGroupDataResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryPreviousEpochGroupDataResponse.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("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_QueryPreviousEpochGroupDataResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryPreviousEpochGroupDataResponse"))
+ }
+ 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_QueryPreviousEpochGroupDataResponse) 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("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_QueryPreviousEpochGroupDataResponse) 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_QueryPreviousEpochGroupDataResponse) 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_QueryPreviousEpochGroupDataResponse) 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_QueryPreviousEpochGroupDataResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryPreviousEpochGroupDataResponse)
+ 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.EpochGroupData != nil {
+ l = options.Size(x.EpochGroupData)
+ 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().(*QueryPreviousEpochGroupDataResponse)
+ 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.EpochGroupData != nil {
+ encoded, err := options.Marshal(x.EpochGroupData)
+ 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().(*QueryPreviousEpochGroupDataResponse)
+ 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: QueryPreviousEpochGroupDataResponse: 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)
+ }
+ 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)
+ }
+ 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.EpochGroupData == nil {
+ x.EpochGroupData = &EpochGroupData{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.EpochGroupData); 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_QueryModelsAllRequest protoreflect.MessageDescriptor
+ fd_QueryModelsAllRequest_pagination protoreflect.FieldDescriptor
+)
+
+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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryModelsAllRequest)(nil)
+
+type fastReflection_QueryModelsAllRequest QueryModelsAllRequest
+
+func (x *QueryModelsAllRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryModelsAllRequest)(x)
+}
+
+func (x *QueryModelsAllRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_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_QueryModelsAllRequest_messageType fastReflection_QueryModelsAllRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryModelsAllRequest_messageType{}
+
+type fastReflection_QueryModelsAllRequest_messageType struct{}
+
+func (x fastReflection_QueryModelsAllRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryModelsAllRequest)(nil)
+}
+func (x fastReflection_QueryModelsAllRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryModelsAllRequest)
+}
+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_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_QueryModelsAllRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryModelsAllRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryModelsAllRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryModelsAllRequest)(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_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
+ }
+ }
+}
+
+// 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_QueryModelsAllRequest) 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("message inference.inference.QueryModelsAllRequest 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_QueryModelsAllRequest) 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("message inference.inference.QueryModelsAllRequest 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_QueryModelsAllRequest) 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("message inference.inference.QueryModelsAllRequest 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_QueryModelsAllRequest) 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("message inference.inference.QueryModelsAllRequest 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_QueryModelsAllRequest) 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("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_QueryModelsAllRequest) 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("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_QueryModelsAllRequest) 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("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_QueryModelsAllRequest) 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_QueryModelsAllRequest) 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_QueryModelsAllRequest) 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_QueryModelsAllRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryModelsAllRequest)
+ 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.Pagination != nil {
+ l = options.Size(x.Pagination)
+ 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().(*QueryModelsAllRequest)
+ 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.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 {
+ 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().(*QueryModelsAllRequest)
+ 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: QueryModelsAllRequest: 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)
+ }
+ 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:])
+ 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 = (*_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
+)
+
+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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryModelsAllResponse)(nil)
+
+type fastReflection_QueryModelsAllResponse QueryModelsAllResponse
+
+func (x *QueryModelsAllResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryModelsAllResponse)(x)
+}
+
+func (x *QueryModelsAllResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_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_QueryModelsAllResponse_messageType fastReflection_QueryModelsAllResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryModelsAllResponse_messageType{}
+
+type fastReflection_QueryModelsAllResponse_messageType struct{}
+
+func (x fastReflection_QueryModelsAllResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryModelsAllResponse)(nil)
+}
+func (x fastReflection_QueryModelsAllResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryModelsAllResponse)
+}
+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_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_QueryModelsAllResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryModelsAllResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryModelsAllResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryModelsAllResponse)(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_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
+ }
+ }
+}
+
+// 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_QueryModelsAllResponse) 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
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryModelsAllResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryModelsAllResponse 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_QueryModelsAllResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ 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.QueryModelsAllResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryModelsAllResponse 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_QueryModelsAllResponse) 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
+ 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("message inference.inference.QueryModelsAllResponse 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_QueryModelsAllResponse) 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)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryModelsAllResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryModelsAllResponse 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_QueryModelsAllResponse) 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)
+ }
+ return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryModelsAllResponse"))
+ }
+ 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_QueryModelsAllResponse) 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)
+ 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("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_QueryModelsAllResponse) 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("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_QueryModelsAllResponse) 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_QueryModelsAllResponse) 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_QueryModelsAllResponse) 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_QueryModelsAllResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryModelsAllResponse)
+ 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.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 {
+ n += len(x.unknownFields)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*QueryModelsAllResponse)
+ 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.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.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...)
+ } 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().(*QueryModelsAllResponse)
+ 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: QueryModelsAllResponse: 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)
+ }
+ 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)
+ }
+ 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:])
+ 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_QueryGetTopMinerRequest protoreflect.MessageDescriptor
+ fd_QueryGetTopMinerRequest_address protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryGetTopMinerRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetTopMinerRequest")
+ fd_QueryGetTopMinerRequest_address = md_QueryGetTopMinerRequest.Fields().ByName("address")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetTopMinerRequest)(nil)
+
+type fastReflection_QueryGetTopMinerRequest QueryGetTopMinerRequest
+
+func (x *QueryGetTopMinerRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetTopMinerRequest)(x)
+}
+
+func (x *QueryGetTopMinerRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_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_QueryGetTopMinerRequest_messageType fastReflection_QueryGetTopMinerRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetTopMinerRequest_messageType{}
+
+type fastReflection_QueryGetTopMinerRequest_messageType struct{}
+
+func (x fastReflection_QueryGetTopMinerRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetTopMinerRequest)(nil)
+}
+func (x fastReflection_QueryGetTopMinerRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetTopMinerRequest)
+}
+func (x fastReflection_QueryGetTopMinerRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryGetTopMinerRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryGetTopMinerRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryGetTopMinerRequest
+}
+
+// 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_QueryGetTopMinerRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetTopMinerRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryGetTopMinerRequest) New() protoreflect.Message {
+ return new(fastReflection_QueryGetTopMinerRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryGetTopMinerRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetTopMinerRequest)(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_QueryGetTopMinerRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Address != "" {
+ value := protoreflect.ValueOfString(x.Address)
+ if !f(fd_QueryGetTopMinerRequest_address, 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_QueryGetTopMinerRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetTopMinerRequest.address":
+ return x.Address != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTopMinerRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetTopMinerRequest 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_QueryGetTopMinerRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetTopMinerRequest.address":
+ x.Address = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTopMinerRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetTopMinerRequest 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_QueryGetTopMinerRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryGetTopMinerRequest.address":
+ value := x.Address
+ return protoreflect.ValueOfString(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTopMinerRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetTopMinerRequest 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_QueryGetTopMinerRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetTopMinerRequest.address":
+ x.Address = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTopMinerRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetTopMinerRequest 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_QueryGetTopMinerRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetTopMinerRequest.address":
+ panic(fmt.Errorf("field address of message inference.inference.QueryGetTopMinerRequest is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTopMinerRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetTopMinerRequest 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_QueryGetTopMinerRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetTopMinerRequest.address":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTopMinerRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetTopMinerRequest 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_QueryGetTopMinerRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetTopMinerRequest", 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_QueryGetTopMinerRequest) 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_QueryGetTopMinerRequest) 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_QueryGetTopMinerRequest) 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_QueryGetTopMinerRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetTopMinerRequest)
+ 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.Address)
+ 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().(*QueryGetTopMinerRequest)
+ 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.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 {
+ 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().(*QueryGetTopMinerRequest)
+ 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: QueryGetTopMinerRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetTopMinerRequest: 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
+ 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_QueryGetTopMinerResponse protoreflect.MessageDescriptor
+ fd_QueryGetTopMinerResponse_top_miner protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryGetTopMinerResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetTopMinerResponse")
+ fd_QueryGetTopMinerResponse_top_miner = md_QueryGetTopMinerResponse.Fields().ByName("top_miner")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetTopMinerResponse)(nil)
+
+type fastReflection_QueryGetTopMinerResponse QueryGetTopMinerResponse
+
+func (x *QueryGetTopMinerResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetTopMinerResponse)(x)
+}
+
+func (x *QueryGetTopMinerResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_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_QueryGetTopMinerResponse_messageType fastReflection_QueryGetTopMinerResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetTopMinerResponse_messageType{}
+
+type fastReflection_QueryGetTopMinerResponse_messageType struct{}
+
+func (x fastReflection_QueryGetTopMinerResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetTopMinerResponse)(nil)
+}
+func (x fastReflection_QueryGetTopMinerResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetTopMinerResponse)
+}
+func (x fastReflection_QueryGetTopMinerResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryGetTopMinerResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryGetTopMinerResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryGetTopMinerResponse
+}
+
+// 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_QueryGetTopMinerResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetTopMinerResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryGetTopMinerResponse) New() protoreflect.Message {
+ return new(fastReflection_QueryGetTopMinerResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryGetTopMinerResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetTopMinerResponse)(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_QueryGetTopMinerResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.TopMiner != nil {
+ value := protoreflect.ValueOfMessage(x.TopMiner.ProtoReflect())
+ if !f(fd_QueryGetTopMinerResponse_top_miner, 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_QueryGetTopMinerResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetTopMinerResponse.top_miner":
+ return x.TopMiner != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTopMinerResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetTopMinerResponse 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_QueryGetTopMinerResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetTopMinerResponse.top_miner":
+ x.TopMiner = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTopMinerResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetTopMinerResponse 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_QueryGetTopMinerResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryGetTopMinerResponse.top_miner":
+ value := x.TopMiner
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTopMinerResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetTopMinerResponse 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_QueryGetTopMinerResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetTopMinerResponse.top_miner":
+ x.TopMiner = value.Message().Interface().(*TopMiner)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTopMinerResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetTopMinerResponse 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_QueryGetTopMinerResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetTopMinerResponse.top_miner":
+ if x.TopMiner == nil {
+ x.TopMiner = new(TopMiner)
+ }
+ return protoreflect.ValueOfMessage(x.TopMiner.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTopMinerResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetTopMinerResponse 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_QueryGetTopMinerResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetTopMinerResponse.top_miner":
+ m := new(TopMiner)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTopMinerResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetTopMinerResponse 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_QueryGetTopMinerResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetTopMinerResponse", 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_QueryGetTopMinerResponse) 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_QueryGetTopMinerResponse) 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_QueryGetTopMinerResponse) 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_QueryGetTopMinerResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetTopMinerResponse)
+ 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.TopMiner != nil {
+ l = options.Size(x.TopMiner)
+ 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().(*QueryGetTopMinerResponse)
+ 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.TopMiner != nil {
+ encoded, err := options.Marshal(x.TopMiner)
+ 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().(*QueryGetTopMinerResponse)
+ 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: QueryGetTopMinerResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetTopMinerResponse: 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 TopMiner", 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.TopMiner == nil {
+ x.TopMiner = &TopMiner{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.TopMiner); 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_QueryAllTopMinerRequest protoreflect.MessageDescriptor
+ fd_QueryAllTopMinerRequest_pagination protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryAllTopMinerRequest = File_inference_inference_query_proto.Messages().ByName("QueryAllTopMinerRequest")
+ fd_QueryAllTopMinerRequest_pagination = md_QueryAllTopMinerRequest.Fields().ByName("pagination")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryAllTopMinerRequest)(nil)
+
+type fastReflection_QueryAllTopMinerRequest QueryAllTopMinerRequest
+
+func (x *QueryAllTopMinerRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryAllTopMinerRequest)(x)
+}
+
+func (x *QueryAllTopMinerRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_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_QueryAllTopMinerRequest_messageType fastReflection_QueryAllTopMinerRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllTopMinerRequest_messageType{}
+
+type fastReflection_QueryAllTopMinerRequest_messageType struct{}
+
+func (x fastReflection_QueryAllTopMinerRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryAllTopMinerRequest)(nil)
+}
+func (x fastReflection_QueryAllTopMinerRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryAllTopMinerRequest)
+}
+func (x fastReflection_QueryAllTopMinerRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryAllTopMinerRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryAllTopMinerRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryAllTopMinerRequest
+}
+
+// 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_QueryAllTopMinerRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryAllTopMinerRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryAllTopMinerRequest) New() protoreflect.Message {
+ return new(fastReflection_QueryAllTopMinerRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryAllTopMinerRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryAllTopMinerRequest)(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_QueryAllTopMinerRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Pagination != nil {
+ value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+ if !f(fd_QueryAllTopMinerRequest_pagination, 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_QueryAllTopMinerRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllTopMinerRequest.pagination":
+ return x.Pagination != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllTopMinerRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllTopMinerRequest 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_QueryAllTopMinerRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllTopMinerRequest.pagination":
+ x.Pagination = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllTopMinerRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllTopMinerRequest 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_QueryAllTopMinerRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryAllTopMinerRequest.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.QueryAllTopMinerRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllTopMinerRequest 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_QueryAllTopMinerRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllTopMinerRequest.pagination":
+ x.Pagination = value.Message().Interface().(*v1beta1.PageRequest)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllTopMinerRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllTopMinerRequest 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_QueryAllTopMinerRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllTopMinerRequest.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.QueryAllTopMinerRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllTopMinerRequest 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_QueryAllTopMinerRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllTopMinerRequest.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.QueryAllTopMinerRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllTopMinerRequest 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_QueryAllTopMinerRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllTopMinerRequest", 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_QueryAllTopMinerRequest) 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_QueryAllTopMinerRequest) 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_QueryAllTopMinerRequest) 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_QueryAllTopMinerRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryAllTopMinerRequest)
+ 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.Pagination != nil {
+ l = options.Size(x.Pagination)
+ 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().(*QueryAllTopMinerRequest)
+ 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.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 {
+ 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().(*QueryAllTopMinerRequest)
+ 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: QueryAllTopMinerRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllTopMinerRequest: 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:])
+ 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 = (*_QueryAllTopMinerResponse_1_list)(nil)
+
+type _QueryAllTopMinerResponse_1_list struct {
+ list *[]*TopMiner
+}
+
+func (x *_QueryAllTopMinerResponse_1_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_QueryAllTopMinerResponse_1_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryAllTopMinerResponse_1_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*TopMiner)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_QueryAllTopMinerResponse_1_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*TopMiner)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryAllTopMinerResponse_1_list) AppendMutable() protoreflect.Value {
+ v := new(TopMiner)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryAllTopMinerResponse_1_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_QueryAllTopMinerResponse_1_list) NewElement() protoreflect.Value {
+ v := new(TopMiner)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryAllTopMinerResponse_1_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_QueryAllTopMinerResponse protoreflect.MessageDescriptor
+ fd_QueryAllTopMinerResponse_top_miner protoreflect.FieldDescriptor
+ fd_QueryAllTopMinerResponse_pagination protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryAllTopMinerResponse = File_inference_inference_query_proto.Messages().ByName("QueryAllTopMinerResponse")
+ fd_QueryAllTopMinerResponse_top_miner = md_QueryAllTopMinerResponse.Fields().ByName("top_miner")
+ fd_QueryAllTopMinerResponse_pagination = md_QueryAllTopMinerResponse.Fields().ByName("pagination")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryAllTopMinerResponse)(nil)
+
+type fastReflection_QueryAllTopMinerResponse QueryAllTopMinerResponse
+
+func (x *QueryAllTopMinerResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryAllTopMinerResponse)(x)
+}
+
+func (x *QueryAllTopMinerResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[47]
+ 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_QueryAllTopMinerResponse_messageType fastReflection_QueryAllTopMinerResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllTopMinerResponse_messageType{}
+
+type fastReflection_QueryAllTopMinerResponse_messageType struct{}
+
+func (x fastReflection_QueryAllTopMinerResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryAllTopMinerResponse)(nil)
+}
+func (x fastReflection_QueryAllTopMinerResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryAllTopMinerResponse)
+}
+func (x fastReflection_QueryAllTopMinerResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryAllTopMinerResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryAllTopMinerResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryAllTopMinerResponse
+}
+
+// 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_QueryAllTopMinerResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryAllTopMinerResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryAllTopMinerResponse) New() protoreflect.Message {
+ return new(fastReflection_QueryAllTopMinerResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryAllTopMinerResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryAllTopMinerResponse)(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_QueryAllTopMinerResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if len(x.TopMiner) != 0 {
+ value := protoreflect.ValueOfList(&_QueryAllTopMinerResponse_1_list{list: &x.TopMiner})
+ if !f(fd_QueryAllTopMinerResponse_top_miner, value) {
+ return
+ }
+ }
+ if x.Pagination != nil {
+ value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+ if !f(fd_QueryAllTopMinerResponse_pagination, 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_QueryAllTopMinerResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllTopMinerResponse.top_miner":
+ return len(x.TopMiner) != 0
+ case "inference.inference.QueryAllTopMinerResponse.pagination":
+ return x.Pagination != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllTopMinerResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllTopMinerResponse 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_QueryAllTopMinerResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllTopMinerResponse.top_miner":
+ x.TopMiner = nil
+ case "inference.inference.QueryAllTopMinerResponse.pagination":
+ x.Pagination = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllTopMinerResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllTopMinerResponse 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_QueryAllTopMinerResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryAllTopMinerResponse.top_miner":
+ if len(x.TopMiner) == 0 {
+ return protoreflect.ValueOfList(&_QueryAllTopMinerResponse_1_list{})
+ }
+ listValue := &_QueryAllTopMinerResponse_1_list{list: &x.TopMiner}
+ return protoreflect.ValueOfList(listValue)
+ case "inference.inference.QueryAllTopMinerResponse.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.QueryAllTopMinerResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllTopMinerResponse 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_QueryAllTopMinerResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllTopMinerResponse.top_miner":
+ lv := value.List()
+ clv := lv.(*_QueryAllTopMinerResponse_1_list)
+ x.TopMiner = *clv.list
+ case "inference.inference.QueryAllTopMinerResponse.pagination":
+ x.Pagination = value.Message().Interface().(*v1beta1.PageResponse)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllTopMinerResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllTopMinerResponse 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_QueryAllTopMinerResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllTopMinerResponse.top_miner":
+ if x.TopMiner == nil {
+ x.TopMiner = []*TopMiner{}
+ }
+ value := &_QueryAllTopMinerResponse_1_list{list: &x.TopMiner}
+ return protoreflect.ValueOfList(value)
+ case "inference.inference.QueryAllTopMinerResponse.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.QueryAllTopMinerResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllTopMinerResponse 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_QueryAllTopMinerResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllTopMinerResponse.top_miner":
+ list := []*TopMiner{}
+ return protoreflect.ValueOfList(&_QueryAllTopMinerResponse_1_list{list: &list})
+ case "inference.inference.QueryAllTopMinerResponse.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.QueryAllTopMinerResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllTopMinerResponse 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_QueryAllTopMinerResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllTopMinerResponse", 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_QueryAllTopMinerResponse) 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_QueryAllTopMinerResponse) 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_QueryAllTopMinerResponse) 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_QueryAllTopMinerResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryAllTopMinerResponse)
+ 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.TopMiner) > 0 {
+ for _, e := range x.TopMiner {
+ 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)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*QueryAllTopMinerResponse)
+ 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.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.TopMiner) > 0 {
+ for iNdEx := len(x.TopMiner) - 1; iNdEx >= 0; iNdEx-- {
+ encoded, err := options.Marshal(x.TopMiner[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().(*QueryAllTopMinerResponse)
+ 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: QueryAllTopMinerResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllTopMinerResponse: 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 TopMiner", 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.TopMiner = append(x.TopMiner, &TopMiner{})
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.TopMiner[len(x.TopMiner)-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
+ 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_QueryGetInferenceTimeoutRequest protoreflect.MessageDescriptor
+ fd_QueryGetInferenceTimeoutRequest_expirationHeight protoreflect.FieldDescriptor
+ fd_QueryGetInferenceTimeoutRequest_inferenceId 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetInferenceTimeoutRequest)(nil)
+
+type fastReflection_QueryGetInferenceTimeoutRequest QueryGetInferenceTimeoutRequest
+
+func (x *QueryGetInferenceTimeoutRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetInferenceTimeoutRequest)(x)
+}
+
+func (x *QueryGetInferenceTimeoutRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[48]
+ 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_QueryGetInferenceTimeoutRequest_messageType fastReflection_QueryGetInferenceTimeoutRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetInferenceTimeoutRequest_messageType{}
+
+type fastReflection_QueryGetInferenceTimeoutRequest_messageType struct{}
+
+func (x fastReflection_QueryGetInferenceTimeoutRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetInferenceTimeoutRequest)(nil)
+}
+func (x fastReflection_QueryGetInferenceTimeoutRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetInferenceTimeoutRequest)
+}
+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_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_QueryGetInferenceTimeoutRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetInferenceTimeoutRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryGetInferenceTimeoutRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetInferenceTimeoutRequest)(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_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
+ }
+ }
+}
+
+// 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_QueryGetInferenceTimeoutRequest) 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 != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceTimeoutRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetInferenceTimeoutRequest 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_QueryGetInferenceTimeoutRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ 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.QueryGetInferenceTimeoutRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetInferenceTimeoutRequest 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_QueryGetInferenceTimeoutRequest) 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)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceTimeoutRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetInferenceTimeoutRequest 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_QueryGetInferenceTimeoutRequest) 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)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceTimeoutRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetInferenceTimeoutRequest 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_QueryGetInferenceTimeoutRequest) 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"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceTimeoutRequest"))
+ }
+ 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_QueryGetInferenceTimeoutRequest) 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("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceTimeoutRequest"))
+ }
+ 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_QueryGetInferenceTimeoutRequest) 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("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_QueryGetInferenceTimeoutRequest) 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_QueryGetInferenceTimeoutRequest) 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_QueryGetInferenceTimeoutRequest) 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_QueryGetInferenceTimeoutRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetInferenceTimeoutRequest)
+ 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.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 {
+ n += len(x.unknownFields)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*QueryGetInferenceTimeoutRequest)
+ 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.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))
+ 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().(*QueryGetInferenceTimeoutRequest)
+ 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: QueryGetInferenceTimeoutRequest: 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)
+ }
+ 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)
+ }
+ 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.InferenceId = 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_QueryGetInferenceTimeoutResponse protoreflect.MessageDescriptor
+ fd_QueryGetInferenceTimeoutResponse_inference_timeout 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetInferenceTimeoutResponse)(nil)
+
+type fastReflection_QueryGetInferenceTimeoutResponse QueryGetInferenceTimeoutResponse
+
+func (x *QueryGetInferenceTimeoutResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetInferenceTimeoutResponse)(x)
+}
+
+func (x *QueryGetInferenceTimeoutResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[49]
+ 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_QueryGetInferenceTimeoutResponse_messageType fastReflection_QueryGetInferenceTimeoutResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetInferenceTimeoutResponse_messageType{}
+
+type fastReflection_QueryGetInferenceTimeoutResponse_messageType struct{}
+
+func (x fastReflection_QueryGetInferenceTimeoutResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetInferenceTimeoutResponse)(nil)
+}
+func (x fastReflection_QueryGetInferenceTimeoutResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetInferenceTimeoutResponse)
+}
+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_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_QueryGetInferenceTimeoutResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetInferenceTimeoutResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryGetInferenceTimeoutResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetInferenceTimeoutResponse)(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_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
+ }
+ }
+}
+
+// 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_QueryGetInferenceTimeoutResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryGetInferenceTimeoutResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetInferenceTimeoutResponse 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_QueryGetInferenceTimeoutResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetInferenceTimeoutResponse.inference_timeout":
+ x.InferenceTimeout = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceTimeoutResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetInferenceTimeoutResponse 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_QueryGetInferenceTimeoutResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ 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.QueryGetInferenceTimeoutResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetInferenceTimeoutResponse 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_QueryGetInferenceTimeoutResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ 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.QueryGetInferenceTimeoutResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetInferenceTimeoutResponse 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_QueryGetInferenceTimeoutResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetInferenceTimeoutResponse.inference_timeout":
+ if x.InferenceTimeout == nil {
+ x.InferenceTimeout = new(InferenceTimeout)
+ }
+ return protoreflect.ValueOfMessage(x.InferenceTimeout.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceTimeoutResponse"))
+ }
+ 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_QueryGetInferenceTimeoutResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryGetInferenceTimeoutResponse"))
+ }
+ 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_QueryGetInferenceTimeoutResponse) 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("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_QueryGetInferenceTimeoutResponse) 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_QueryGetInferenceTimeoutResponse) 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_QueryGetInferenceTimeoutResponse) 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_QueryGetInferenceTimeoutResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetInferenceTimeoutResponse)
+ 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.InferenceTimeout != nil {
+ l = options.Size(x.InferenceTimeout)
+ 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().(*QueryGetInferenceTimeoutResponse)
+ 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.InferenceTimeout != nil {
+ encoded, err := options.Marshal(x.InferenceTimeout)
+ 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().(*QueryGetInferenceTimeoutResponse)
+ 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: QueryGetInferenceTimeoutResponse: 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)
+ }
+ 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)
+ }
+ 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.InferenceTimeout == nil {
+ x.InferenceTimeout = &InferenceTimeout{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.InferenceTimeout); 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_QueryAllInferenceTimeoutRequest protoreflect.MessageDescriptor
+ fd_QueryAllInferenceTimeoutRequest_pagination 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryAllInferenceTimeoutRequest)(nil)
+
+type fastReflection_QueryAllInferenceTimeoutRequest QueryAllInferenceTimeoutRequest
+
+func (x *QueryAllInferenceTimeoutRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryAllInferenceTimeoutRequest)(x)
+}
+
+func (x *QueryAllInferenceTimeoutRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[50]
+ 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_QueryAllInferenceTimeoutRequest_messageType fastReflection_QueryAllInferenceTimeoutRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllInferenceTimeoutRequest_messageType{}
+
+type fastReflection_QueryAllInferenceTimeoutRequest_messageType struct{}
+
+func (x fastReflection_QueryAllInferenceTimeoutRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryAllInferenceTimeoutRequest)(nil)
+}
+func (x fastReflection_QueryAllInferenceTimeoutRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryAllInferenceTimeoutRequest)
+}
+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_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_QueryAllInferenceTimeoutRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryAllInferenceTimeoutRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryAllInferenceTimeoutRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryAllInferenceTimeoutRequest)(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_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
+ }
+ }
+}
+
+// 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_QueryAllInferenceTimeoutRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryAllInferenceTimeoutRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllInferenceTimeoutRequest 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_QueryAllInferenceTimeoutRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllInferenceTimeoutRequest.pagination":
+ x.Pagination = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceTimeoutRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllInferenceTimeoutRequest 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_QueryAllInferenceTimeoutRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ 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.QueryAllInferenceTimeoutRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllInferenceTimeoutRequest 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_QueryAllInferenceTimeoutRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ 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.QueryAllInferenceTimeoutRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllInferenceTimeoutRequest 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_QueryAllInferenceTimeoutRequest) 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())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceTimeoutRequest"))
+ }
+ 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_QueryAllInferenceTimeoutRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryAllInferenceTimeoutRequest"))
+ }
+ 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_QueryAllInferenceTimeoutRequest) 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("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_QueryAllInferenceTimeoutRequest) 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_QueryAllInferenceTimeoutRequest) 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_QueryAllInferenceTimeoutRequest) 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_QueryAllInferenceTimeoutRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryAllInferenceTimeoutRequest)
+ 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.Pagination != nil {
+ l = options.Size(x.Pagination)
+ 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().(*QueryAllInferenceTimeoutRequest)
+ 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.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 {
+ 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().(*QueryAllInferenceTimeoutRequest)
+ 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: QueryAllInferenceTimeoutRequest: 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)
+ }
+ 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:])
+ 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 = (*_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
+)
+
+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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryAllInferenceTimeoutResponse)(nil)
+
+type fastReflection_QueryAllInferenceTimeoutResponse QueryAllInferenceTimeoutResponse
+
+func (x *QueryAllInferenceTimeoutResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryAllInferenceTimeoutResponse)(x)
+}
+
+func (x *QueryAllInferenceTimeoutResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[51]
+ 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_QueryAllInferenceTimeoutResponse_messageType fastReflection_QueryAllInferenceTimeoutResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllInferenceTimeoutResponse_messageType{}
+
+type fastReflection_QueryAllInferenceTimeoutResponse_messageType struct{}
+
+func (x fastReflection_QueryAllInferenceTimeoutResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryAllInferenceTimeoutResponse)(nil)
+}
+func (x fastReflection_QueryAllInferenceTimeoutResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryAllInferenceTimeoutResponse)
+}
+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_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_QueryAllInferenceTimeoutResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryAllInferenceTimeoutResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryAllInferenceTimeoutResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryAllInferenceTimeoutResponse)(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_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
+ }
+ }
+}
+
+// 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_QueryAllInferenceTimeoutResponse) 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
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceTimeoutResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllInferenceTimeoutResponse 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_QueryAllInferenceTimeoutResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ 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.QueryAllInferenceTimeoutResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllInferenceTimeoutResponse 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_QueryAllInferenceTimeoutResponse) 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
+ 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("message inference.inference.QueryAllInferenceTimeoutResponse 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_QueryAllInferenceTimeoutResponse) 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)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceTimeoutResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllInferenceTimeoutResponse 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_QueryAllInferenceTimeoutResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllInferenceTimeoutResponse.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)
+ }
+ return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceTimeoutResponse"))
+ }
+ 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_QueryAllInferenceTimeoutResponse) 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)
+ 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("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_QueryAllInferenceTimeoutResponse) 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("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_QueryAllInferenceTimeoutResponse) 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_QueryAllInferenceTimeoutResponse) 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_QueryAllInferenceTimeoutResponse) 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_QueryAllInferenceTimeoutResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryAllInferenceTimeoutResponse)
+ 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.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 {
+ n += len(x.unknownFields)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*QueryAllInferenceTimeoutResponse)
+ 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.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.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...)
+ } 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().(*QueryAllInferenceTimeoutResponse)
+ 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: QueryAllInferenceTimeoutResponse: 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)
+ }
+ 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)
+ }
+ 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.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 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 {
+ 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_QueryGetInferenceValidationDetailsRequest protoreflect.MessageDescriptor
+ fd_QueryGetInferenceValidationDetailsRequest_epochId protoreflect.FieldDescriptor
+ fd_QueryGetInferenceValidationDetailsRequest_inferenceId 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetInferenceValidationDetailsRequest)(nil)
+
+type fastReflection_QueryGetInferenceValidationDetailsRequest QueryGetInferenceValidationDetailsRequest
+
+func (x *QueryGetInferenceValidationDetailsRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetInferenceValidationDetailsRequest)(x)
+}
+
+func (x *QueryGetInferenceValidationDetailsRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[52]
+ 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_QueryGetInferenceValidationDetailsRequest_messageType fastReflection_QueryGetInferenceValidationDetailsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetInferenceValidationDetailsRequest_messageType{}
+
+type fastReflection_QueryGetInferenceValidationDetailsRequest_messageType struct{}
+
+func (x fastReflection_QueryGetInferenceValidationDetailsRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetInferenceValidationDetailsRequest)(nil)
+}
+func (x fastReflection_QueryGetInferenceValidationDetailsRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetInferenceValidationDetailsRequest)
+}
+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_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_QueryGetInferenceValidationDetailsRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetInferenceValidationDetailsRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryGetInferenceValidationDetailsRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetInferenceValidationDetailsRequest)(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_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
+ }
+ }
+}
+
+// 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_QueryGetInferenceValidationDetailsRequest) 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 != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationDetailsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationDetailsRequest 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_QueryGetInferenceValidationDetailsRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ 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.QueryGetInferenceValidationDetailsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationDetailsRequest 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_QueryGetInferenceValidationDetailsRequest) 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)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationDetailsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationDetailsRequest 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_QueryGetInferenceValidationDetailsRequest) 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)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationDetailsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationDetailsRequest 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_QueryGetInferenceValidationDetailsRequest) 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:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationDetailsRequest"))
+ }
+ 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_QueryGetInferenceValidationDetailsRequest) 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("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationDetailsRequest"))
+ }
+ 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_QueryGetInferenceValidationDetailsRequest) 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("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_QueryGetInferenceValidationDetailsRequest) 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_QueryGetInferenceValidationDetailsRequest) 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_QueryGetInferenceValidationDetailsRequest) 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_QueryGetInferenceValidationDetailsRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetInferenceValidationDetailsRequest)
+ 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.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 {
+ n += len(x.unknownFields)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*QueryGetInferenceValidationDetailsRequest)
+ 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.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))
+ 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().(*QueryGetInferenceValidationDetailsRequest)
+ 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: QueryGetInferenceValidationDetailsRequest: 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)
+ }
+ 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)
+ }
+ 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.InferenceId = 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_QueryGetInferenceValidationDetailsResponse protoreflect.MessageDescriptor
+ fd_QueryGetInferenceValidationDetailsResponse_inferenceValidationDetails 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetInferenceValidationDetailsResponse)(nil)
+
+type fastReflection_QueryGetInferenceValidationDetailsResponse QueryGetInferenceValidationDetailsResponse
+
+func (x *QueryGetInferenceValidationDetailsResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetInferenceValidationDetailsResponse)(x)
+}
+
+func (x *QueryGetInferenceValidationDetailsResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[53]
+ 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_QueryGetInferenceValidationDetailsResponse_messageType fastReflection_QueryGetInferenceValidationDetailsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetInferenceValidationDetailsResponse_messageType{}
+
+type fastReflection_QueryGetInferenceValidationDetailsResponse_messageType struct{}
+
+func (x fastReflection_QueryGetInferenceValidationDetailsResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetInferenceValidationDetailsResponse)(nil)
+}
+func (x fastReflection_QueryGetInferenceValidationDetailsResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetInferenceValidationDetailsResponse)
+}
+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_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_QueryGetInferenceValidationDetailsResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetInferenceValidationDetailsResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryGetInferenceValidationDetailsResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetInferenceValidationDetailsResponse)(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_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
+ }
+ }
+}
+
+// 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_QueryGetInferenceValidationDetailsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryGetInferenceValidationDetailsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationDetailsResponse 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_QueryGetInferenceValidationDetailsResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetInferenceValidationDetailsResponse.inferenceValidationDetails":
+ x.InferenceValidationDetails = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationDetailsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationDetailsResponse 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_QueryGetInferenceValidationDetailsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ 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.QueryGetInferenceValidationDetailsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationDetailsResponse 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_QueryGetInferenceValidationDetailsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ 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.QueryGetInferenceValidationDetailsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationDetailsResponse 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_QueryGetInferenceValidationDetailsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetInferenceValidationDetailsResponse.inferenceValidationDetails":
+ if x.InferenceValidationDetails == nil {
+ x.InferenceValidationDetails = new(InferenceValidationDetails)
+ }
+ return protoreflect.ValueOfMessage(x.InferenceValidationDetails.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationDetailsResponse"))
+ }
+ 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_QueryGetInferenceValidationDetailsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryGetInferenceValidationDetailsResponse"))
+ }
+ 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_QueryGetInferenceValidationDetailsResponse) 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("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_QueryGetInferenceValidationDetailsResponse) 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_QueryGetInferenceValidationDetailsResponse) 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_QueryGetInferenceValidationDetailsResponse) 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_QueryGetInferenceValidationDetailsResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetInferenceValidationDetailsResponse)
+ 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.InferenceValidationDetails != nil {
+ l = options.Size(x.InferenceValidationDetails)
+ 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().(*QueryGetInferenceValidationDetailsResponse)
+ 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.InferenceValidationDetails != nil {
+ encoded, err := options.Marshal(x.InferenceValidationDetails)
+ 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().(*QueryGetInferenceValidationDetailsResponse)
+ 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: QueryGetInferenceValidationDetailsResponse: 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)
+ }
+ 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)
+ }
+ 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.InferenceValidationDetails == nil {
+ x.InferenceValidationDetails = &InferenceValidationDetails{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.InferenceValidationDetails); 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_QueryAllInferenceValidationDetailsRequest protoreflect.MessageDescriptor
+ fd_QueryAllInferenceValidationDetailsRequest_pagination 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryAllInferenceValidationDetailsRequest)(nil)
+
+type fastReflection_QueryAllInferenceValidationDetailsRequest QueryAllInferenceValidationDetailsRequest
+
+func (x *QueryAllInferenceValidationDetailsRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryAllInferenceValidationDetailsRequest)(x)
+}
+
+func (x *QueryAllInferenceValidationDetailsRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[54]
+ 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_QueryAllInferenceValidationDetailsRequest_messageType fastReflection_QueryAllInferenceValidationDetailsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllInferenceValidationDetailsRequest_messageType{}
+
+type fastReflection_QueryAllInferenceValidationDetailsRequest_messageType struct{}
+
+func (x fastReflection_QueryAllInferenceValidationDetailsRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryAllInferenceValidationDetailsRequest)(nil)
+}
+func (x fastReflection_QueryAllInferenceValidationDetailsRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryAllInferenceValidationDetailsRequest)
+}
+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_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_QueryAllInferenceValidationDetailsRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryAllInferenceValidationDetailsRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryAllInferenceValidationDetailsRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryAllInferenceValidationDetailsRequest)(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_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
+ }
+ }
+}
+
+// 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_QueryAllInferenceValidationDetailsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryAllInferenceValidationDetailsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllInferenceValidationDetailsRequest 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_QueryAllInferenceValidationDetailsRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllInferenceValidationDetailsRequest.pagination":
+ x.Pagination = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceValidationDetailsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllInferenceValidationDetailsRequest 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_QueryAllInferenceValidationDetailsRequest) 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"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllInferenceValidationDetailsRequest 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_QueryAllInferenceValidationDetailsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ 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.QueryAllInferenceValidationDetailsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllInferenceValidationDetailsRequest 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_QueryAllInferenceValidationDetailsRequest) 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())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceValidationDetailsRequest"))
+ }
+ 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_QueryAllInferenceValidationDetailsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryAllInferenceValidationDetailsRequest"))
+ }
+ 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_QueryAllInferenceValidationDetailsRequest) 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("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_QueryAllInferenceValidationDetailsRequest) 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_QueryAllInferenceValidationDetailsRequest) 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_QueryAllInferenceValidationDetailsRequest) 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_QueryAllInferenceValidationDetailsRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryAllInferenceValidationDetailsRequest)
+ 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.Pagination != nil {
+ l = options.Size(x.Pagination)
+ 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().(*QueryAllInferenceValidationDetailsRequest)
+ 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.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 {
+ 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().(*QueryAllInferenceValidationDetailsRequest)
+ 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: QueryAllInferenceValidationDetailsRequest: 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)
+ }
+ 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:])
+ 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 = (*_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
+)
+
+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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryAllInferenceValidationDetailsResponse)(nil)
+
+type fastReflection_QueryAllInferenceValidationDetailsResponse QueryAllInferenceValidationDetailsResponse
+
+func (x *QueryAllInferenceValidationDetailsResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryAllInferenceValidationDetailsResponse)(x)
+}
+
+func (x *QueryAllInferenceValidationDetailsResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[55]
+ 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_QueryAllInferenceValidationDetailsResponse_messageType fastReflection_QueryAllInferenceValidationDetailsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllInferenceValidationDetailsResponse_messageType{}
+
+type fastReflection_QueryAllInferenceValidationDetailsResponse_messageType struct{}
+
+func (x fastReflection_QueryAllInferenceValidationDetailsResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryAllInferenceValidationDetailsResponse)(nil)
+}
+func (x fastReflection_QueryAllInferenceValidationDetailsResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryAllInferenceValidationDetailsResponse)
+}
+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_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_QueryAllInferenceValidationDetailsResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryAllInferenceValidationDetailsResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryAllInferenceValidationDetailsResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryAllInferenceValidationDetailsResponse)(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_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) {
+ 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_QueryAllInferenceValidationDetailsResponse) 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
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceValidationDetailsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllInferenceValidationDetailsResponse 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_QueryAllInferenceValidationDetailsResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ 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.QueryAllInferenceValidationDetailsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllInferenceValidationDetailsResponse 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_QueryAllInferenceValidationDetailsResponse) 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
+ 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("message inference.inference.QueryAllInferenceValidationDetailsResponse 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_QueryAllInferenceValidationDetailsResponse) 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)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceValidationDetailsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllInferenceValidationDetailsResponse 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_QueryAllInferenceValidationDetailsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllInferenceValidationDetailsResponse.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)
+ }
+ return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceValidationDetailsResponse"))
+ }
+ 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_QueryAllInferenceValidationDetailsResponse) 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)
+ 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("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_QueryAllInferenceValidationDetailsResponse) 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("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_QueryAllInferenceValidationDetailsResponse) 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_QueryAllInferenceValidationDetailsResponse) 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_QueryAllInferenceValidationDetailsResponse) 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_QueryAllInferenceValidationDetailsResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryAllInferenceValidationDetailsResponse)
+ 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.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)
+ 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().(*QueryAllInferenceValidationDetailsResponse)
+ 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.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.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
+ }
+ }
+ 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().(*QueryAllInferenceValidationDetailsResponse)
+ 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: QueryAllInferenceValidationDetailsResponse: 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)
+ }
+ 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)
+ }
+ 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.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 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 {
+ 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 = (*_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
+)
+
+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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetInferenceValidationParametersRequest)(nil)
+
+type fastReflection_QueryGetInferenceValidationParametersRequest QueryGetInferenceValidationParametersRequest
+
+func (x *QueryGetInferenceValidationParametersRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetInferenceValidationParametersRequest)(x)
+}
+
+func (x *QueryGetInferenceValidationParametersRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[56]
+ 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_QueryGetInferenceValidationParametersRequest_messageType fastReflection_QueryGetInferenceValidationParametersRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetInferenceValidationParametersRequest_messageType{}
+
+type fastReflection_QueryGetInferenceValidationParametersRequest_messageType struct{}
+
+func (x fastReflection_QueryGetInferenceValidationParametersRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetInferenceValidationParametersRequest)(nil)
+}
+func (x fastReflection_QueryGetInferenceValidationParametersRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetInferenceValidationParametersRequest)
+}
+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_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_QueryGetInferenceValidationParametersRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetInferenceValidationParametersRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryGetInferenceValidationParametersRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetInferenceValidationParametersRequest)(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_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) {
+ 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_QueryGetInferenceValidationParametersRequest) 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 != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationParametersRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationParametersRequest 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_QueryGetInferenceValidationParametersRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ 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.QueryGetInferenceValidationParametersRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationParametersRequest 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_QueryGetInferenceValidationParametersRequest) 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)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationParametersRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationParametersRequest 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_QueryGetInferenceValidationParametersRequest) 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)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationParametersRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationParametersRequest 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_QueryGetInferenceValidationParametersRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryGetInferenceValidationParametersRequest"))
+ }
+ 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_QueryGetInferenceValidationParametersRequest) 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("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationParametersRequest"))
+ }
+ 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_QueryGetInferenceValidationParametersRequest) 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("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_QueryGetInferenceValidationParametersRequest) 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_QueryGetInferenceValidationParametersRequest) 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_QueryGetInferenceValidationParametersRequest) 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_QueryGetInferenceValidationParametersRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetInferenceValidationParametersRequest)
+ 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.Ids) > 0 {
+ for _, s := range x.Ids {
+ l = len(s)
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ }
+ l = len(x.Requester)
+ 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().(*QueryGetInferenceValidationParametersRequest)
+ 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.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 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().(*QueryGetInferenceValidationParametersRequest)
+ 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: QueryGetInferenceValidationParametersRequest: 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)
+ }
+ 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)
+ }
+ 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.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 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:])
+ 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 = (*_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_power 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_power = md_QueryGetInferenceValidationParametersResponse.Fields().ByName("validator_power")
+ 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[57]
+ 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_QueryGetInferenceValidationParametersResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetInferenceValidationParametersResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryGetInferenceValidationParametersResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetInferenceValidationParametersResponse)(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_QueryGetInferenceValidationParametersResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.ValidatorPower != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.ValidatorPower)
+ if !f(fd_QueryGetInferenceValidationParametersResponse_validator_power, 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
+ }
+ }
+}
+
+// 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_QueryGetInferenceValidationParametersResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetInferenceValidationParametersResponse.validator_power":
+ return x.ValidatorPower != uint64(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.QueryGetInferenceValidationParametersResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationParametersResponse 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_QueryGetInferenceValidationParametersResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetInferenceValidationParametersResponse.validator_power":
+ x.ValidatorPower = uint64(0)
+ 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.QueryGetInferenceValidationParametersResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationParametersResponse 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_QueryGetInferenceValidationParametersResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryGetInferenceValidationParametersResponse.validator_power":
+ value := x.ValidatorPower
+ return protoreflect.ValueOfUint64(value)
+ 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.QueryGetInferenceValidationParametersResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationParametersResponse 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_QueryGetInferenceValidationParametersResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetInferenceValidationParametersResponse.validator_power":
+ x.ValidatorPower = value.Uint()
+ 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.QueryGetInferenceValidationParametersResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationParametersResponse 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_QueryGetInferenceValidationParametersResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.validator_power":
+ panic(fmt.Errorf("field validator_power of message inference.inference.QueryGetInferenceValidationParametersResponse is not mutable"))
+ 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.QueryGetInferenceValidationParametersResponse"))
+ }
+ 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_QueryGetInferenceValidationParametersResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetInferenceValidationParametersResponse.validator_power":
+ return protoreflect.ValueOfUint64(uint64(0))
+ 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.QueryGetInferenceValidationParametersResponse"))
+ }
+ 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_QueryGetInferenceValidationParametersResponse) 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("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_QueryGetInferenceValidationParametersResponse) 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_QueryGetInferenceValidationParametersResponse) 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_QueryGetInferenceValidationParametersResponse) 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_QueryGetInferenceValidationParametersResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetInferenceValidationParametersResponse)
+ 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.ValidatorPower != 0 {
+ n += 1 + runtime.Sov(uint64(x.ValidatorPower))
+ }
+ 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)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*QueryGetInferenceValidationParametersResponse)
+ 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.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] = 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 x.ValidatorPower != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.ValidatorPower))
+ 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().(*QueryGetInferenceValidationParametersResponse)
+ 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: QueryGetInferenceValidationParametersResponse: 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)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidatorPower", wireType)
+ }
+ x.ValidatorPower = 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.ValidatorPower |= 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 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)
+ }
+ 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:])
+ 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_QueryGetEpochPerformanceSummaryRequest protoreflect.MessageDescriptor
+ fd_QueryGetEpochPerformanceSummaryRequest_epoch_index protoreflect.FieldDescriptor
+ fd_QueryGetEpochPerformanceSummaryRequest_participantId protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryGetEpochPerformanceSummaryRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetEpochPerformanceSummaryRequest")
+ fd_QueryGetEpochPerformanceSummaryRequest_epoch_index = md_QueryGetEpochPerformanceSummaryRequest.Fields().ByName("epoch_index")
+ fd_QueryGetEpochPerformanceSummaryRequest_participantId = md_QueryGetEpochPerformanceSummaryRequest.Fields().ByName("participantId")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetEpochPerformanceSummaryRequest)(nil)
+
+type fastReflection_QueryGetEpochPerformanceSummaryRequest QueryGetEpochPerformanceSummaryRequest
+
+func (x *QueryGetEpochPerformanceSummaryRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetEpochPerformanceSummaryRequest)(x)
+}
+
+func (x *QueryGetEpochPerformanceSummaryRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[58]
+ 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_QueryGetEpochPerformanceSummaryRequest_messageType fastReflection_QueryGetEpochPerformanceSummaryRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetEpochPerformanceSummaryRequest_messageType{}
+
+type fastReflection_QueryGetEpochPerformanceSummaryRequest_messageType struct{}
+
+func (x fastReflection_QueryGetEpochPerformanceSummaryRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetEpochPerformanceSummaryRequest)(nil)
+}
+func (x fastReflection_QueryGetEpochPerformanceSummaryRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetEpochPerformanceSummaryRequest)
+}
+func (x fastReflection_QueryGetEpochPerformanceSummaryRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryGetEpochPerformanceSummaryRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryGetEpochPerformanceSummaryRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryGetEpochPerformanceSummaryRequest
+}
+
+// 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_QueryGetEpochPerformanceSummaryRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetEpochPerformanceSummaryRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryGetEpochPerformanceSummaryRequest) New() protoreflect.Message {
+ return new(fastReflection_QueryGetEpochPerformanceSummaryRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryGetEpochPerformanceSummaryRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetEpochPerformanceSummaryRequest)(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_QueryGetEpochPerformanceSummaryRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.EpochIndex != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.EpochIndex)
+ if !f(fd_QueryGetEpochPerformanceSummaryRequest_epoch_index, value) {
+ return
+ }
+ }
+ if x.ParticipantId != "" {
+ value := protoreflect.ValueOfString(x.ParticipantId)
+ if !f(fd_QueryGetEpochPerformanceSummaryRequest_participantId, 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_QueryGetEpochPerformanceSummaryRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetEpochPerformanceSummaryRequest.epoch_index":
+ return x.EpochIndex != uint64(0)
+ case "inference.inference.QueryGetEpochPerformanceSummaryRequest.participantId":
+ return x.ParticipantId != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochPerformanceSummaryRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetEpochPerformanceSummaryRequest 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_QueryGetEpochPerformanceSummaryRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetEpochPerformanceSummaryRequest.epoch_index":
+ x.EpochIndex = uint64(0)
+ case "inference.inference.QueryGetEpochPerformanceSummaryRequest.participantId":
+ x.ParticipantId = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochPerformanceSummaryRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetEpochPerformanceSummaryRequest 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_QueryGetEpochPerformanceSummaryRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryGetEpochPerformanceSummaryRequest.epoch_index":
+ value := x.EpochIndex
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.QueryGetEpochPerformanceSummaryRequest.participantId":
+ value := x.ParticipantId
+ return protoreflect.ValueOfString(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochPerformanceSummaryRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetEpochPerformanceSummaryRequest 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_QueryGetEpochPerformanceSummaryRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetEpochPerformanceSummaryRequest.epoch_index":
+ x.EpochIndex = value.Uint()
+ case "inference.inference.QueryGetEpochPerformanceSummaryRequest.participantId":
+ x.ParticipantId = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochPerformanceSummaryRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetEpochPerformanceSummaryRequest 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_QueryGetEpochPerformanceSummaryRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetEpochPerformanceSummaryRequest.epoch_index":
+ panic(fmt.Errorf("field epoch_index of message inference.inference.QueryGetEpochPerformanceSummaryRequest is not mutable"))
+ case "inference.inference.QueryGetEpochPerformanceSummaryRequest.participantId":
+ panic(fmt.Errorf("field participantId of message inference.inference.QueryGetEpochPerformanceSummaryRequest is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochPerformanceSummaryRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetEpochPerformanceSummaryRequest 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_QueryGetEpochPerformanceSummaryRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetEpochPerformanceSummaryRequest.epoch_index":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.QueryGetEpochPerformanceSummaryRequest.participantId":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochPerformanceSummaryRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetEpochPerformanceSummaryRequest 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_QueryGetEpochPerformanceSummaryRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetEpochPerformanceSummaryRequest", 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_QueryGetEpochPerformanceSummaryRequest) 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_QueryGetEpochPerformanceSummaryRequest) 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_QueryGetEpochPerformanceSummaryRequest) 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_QueryGetEpochPerformanceSummaryRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetEpochPerformanceSummaryRequest)
+ 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.ParticipantId)
+ 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().(*QueryGetEpochPerformanceSummaryRequest)
+ 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.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--
+ 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().(*QueryGetEpochPerformanceSummaryRequest)
+ 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: QueryGetEpochPerformanceSummaryRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetEpochPerformanceSummaryRequest: 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 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:])
+ 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_QueryGetEpochPerformanceSummaryResponse protoreflect.MessageDescriptor
+ fd_QueryGetEpochPerformanceSummaryResponse_epochPerformanceSummary protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryGetEpochPerformanceSummaryResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetEpochPerformanceSummaryResponse")
+ fd_QueryGetEpochPerformanceSummaryResponse_epochPerformanceSummary = md_QueryGetEpochPerformanceSummaryResponse.Fields().ByName("epochPerformanceSummary")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetEpochPerformanceSummaryResponse)(nil)
+
+type fastReflection_QueryGetEpochPerformanceSummaryResponse QueryGetEpochPerformanceSummaryResponse
+
+func (x *QueryGetEpochPerformanceSummaryResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetEpochPerformanceSummaryResponse)(x)
+}
+
+func (x *QueryGetEpochPerformanceSummaryResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[59]
+ 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_QueryGetEpochPerformanceSummaryResponse_messageType fastReflection_QueryGetEpochPerformanceSummaryResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetEpochPerformanceSummaryResponse_messageType{}
+
+type fastReflection_QueryGetEpochPerformanceSummaryResponse_messageType struct{}
+
+func (x fastReflection_QueryGetEpochPerformanceSummaryResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetEpochPerformanceSummaryResponse)(nil)
+}
+func (x fastReflection_QueryGetEpochPerformanceSummaryResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetEpochPerformanceSummaryResponse)
+}
+func (x fastReflection_QueryGetEpochPerformanceSummaryResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryGetEpochPerformanceSummaryResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryGetEpochPerformanceSummaryResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryGetEpochPerformanceSummaryResponse
+}
+
+// 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_QueryGetEpochPerformanceSummaryResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetEpochPerformanceSummaryResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryGetEpochPerformanceSummaryResponse) New() protoreflect.Message {
+ return new(fastReflection_QueryGetEpochPerformanceSummaryResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryGetEpochPerformanceSummaryResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetEpochPerformanceSummaryResponse)(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_QueryGetEpochPerformanceSummaryResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.EpochPerformanceSummary != nil {
+ value := protoreflect.ValueOfMessage(x.EpochPerformanceSummary.ProtoReflect())
+ if !f(fd_QueryGetEpochPerformanceSummaryResponse_epochPerformanceSummary, 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_QueryGetEpochPerformanceSummaryResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetEpochPerformanceSummaryResponse.epochPerformanceSummary":
+ return x.EpochPerformanceSummary != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochPerformanceSummaryResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetEpochPerformanceSummaryResponse 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_QueryGetEpochPerformanceSummaryResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetEpochPerformanceSummaryResponse.epochPerformanceSummary":
+ x.EpochPerformanceSummary = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochPerformanceSummaryResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetEpochPerformanceSummaryResponse 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_QueryGetEpochPerformanceSummaryResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryGetEpochPerformanceSummaryResponse.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.QueryGetEpochPerformanceSummaryResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetEpochPerformanceSummaryResponse 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_QueryGetEpochPerformanceSummaryResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetEpochPerformanceSummaryResponse.epochPerformanceSummary":
+ x.EpochPerformanceSummary = value.Message().Interface().(*EpochPerformanceSummary)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochPerformanceSummaryResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetEpochPerformanceSummaryResponse 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_QueryGetEpochPerformanceSummaryResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetEpochPerformanceSummaryResponse.epochPerformanceSummary":
+ if x.EpochPerformanceSummary == nil {
+ x.EpochPerformanceSummary = new(EpochPerformanceSummary)
+ }
+ return protoreflect.ValueOfMessage(x.EpochPerformanceSummary.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochPerformanceSummaryResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetEpochPerformanceSummaryResponse 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_QueryGetEpochPerformanceSummaryResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetEpochPerformanceSummaryResponse.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.QueryGetEpochPerformanceSummaryResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetEpochPerformanceSummaryResponse 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_QueryGetEpochPerformanceSummaryResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetEpochPerformanceSummaryResponse", 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_QueryGetEpochPerformanceSummaryResponse) 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_QueryGetEpochPerformanceSummaryResponse) 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_QueryGetEpochPerformanceSummaryResponse) 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_QueryGetEpochPerformanceSummaryResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetEpochPerformanceSummaryResponse)
+ 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.EpochPerformanceSummary != nil {
+ l = options.Size(x.EpochPerformanceSummary)
+ 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().(*QueryGetEpochPerformanceSummaryResponse)
+ 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.EpochPerformanceSummary != nil {
+ encoded, err := options.Marshal(x.EpochPerformanceSummary)
+ 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().(*QueryGetEpochPerformanceSummaryResponse)
+ 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: QueryGetEpochPerformanceSummaryResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetEpochPerformanceSummaryResponse: 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)
+ }
+ 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.EpochPerformanceSummary == nil {
+ x.EpochPerformanceSummary = &EpochPerformanceSummary{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.EpochPerformanceSummary); 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_QueryAllEpochPerformanceSummaryRequest protoreflect.MessageDescriptor
+ fd_QueryAllEpochPerformanceSummaryRequest_pagination 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryAllEpochPerformanceSummaryRequest)(nil)
+
+type fastReflection_QueryAllEpochPerformanceSummaryRequest QueryAllEpochPerformanceSummaryRequest
+
+func (x *QueryAllEpochPerformanceSummaryRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryAllEpochPerformanceSummaryRequest)(x)
+}
+
+func (x *QueryAllEpochPerformanceSummaryRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[60]
+ 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_QueryAllEpochPerformanceSummaryRequest_messageType fastReflection_QueryAllEpochPerformanceSummaryRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllEpochPerformanceSummaryRequest_messageType{}
+
+type fastReflection_QueryAllEpochPerformanceSummaryRequest_messageType struct{}
+
+func (x fastReflection_QueryAllEpochPerformanceSummaryRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryAllEpochPerformanceSummaryRequest)(nil)
+}
+func (x fastReflection_QueryAllEpochPerformanceSummaryRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryAllEpochPerformanceSummaryRequest)
+}
+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_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_QueryAllEpochPerformanceSummaryRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryAllEpochPerformanceSummaryRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryAllEpochPerformanceSummaryRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryAllEpochPerformanceSummaryRequest)(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_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
+ }
+ }
+}
+
+// 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_QueryAllEpochPerformanceSummaryRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryAllEpochPerformanceSummaryRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllEpochPerformanceSummaryRequest 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_QueryAllEpochPerformanceSummaryRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllEpochPerformanceSummaryRequest.pagination":
+ x.Pagination = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochPerformanceSummaryRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllEpochPerformanceSummaryRequest 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_QueryAllEpochPerformanceSummaryRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ 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.QueryAllEpochPerformanceSummaryRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllEpochPerformanceSummaryRequest 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_QueryAllEpochPerformanceSummaryRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ 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.QueryAllEpochPerformanceSummaryRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllEpochPerformanceSummaryRequest 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_QueryAllEpochPerformanceSummaryRequest) 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())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochPerformanceSummaryRequest"))
+ }
+ 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_QueryAllEpochPerformanceSummaryRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryAllEpochPerformanceSummaryRequest"))
+ }
+ 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_QueryAllEpochPerformanceSummaryRequest) 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("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_QueryAllEpochPerformanceSummaryRequest) 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_QueryAllEpochPerformanceSummaryRequest) 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_QueryAllEpochPerformanceSummaryRequest) 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_QueryAllEpochPerformanceSummaryRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryAllEpochPerformanceSummaryRequest)
+ 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.Pagination != nil {
+ l = options.Size(x.Pagination)
+ 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().(*QueryAllEpochPerformanceSummaryRequest)
+ 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.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 {
+ 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().(*QueryAllEpochPerformanceSummaryRequest)
+ 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: QueryAllEpochPerformanceSummaryRequest: 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)
+ }
+ 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:])
+ 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 = (*_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)
+}
+
+func (x *_QueryAllEpochPerformanceSummaryResponse_1_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryAllEpochPerformanceSummaryResponse_1_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*EpochPerformanceSummary)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_QueryAllEpochPerformanceSummaryResponse_1_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*EpochPerformanceSummary)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryAllEpochPerformanceSummaryResponse_1_list) AppendMutable() protoreflect.Value {
+ v := new(EpochPerformanceSummary)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+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 *_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[61]
+ 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_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_QueryAllEpochPerformanceSummaryResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryAllEpochPerformanceSummaryResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryAllEpochPerformanceSummaryResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryAllEpochPerformanceSummaryResponse)(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_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
+ }
+ }
+}
+
+// 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_QueryAllEpochPerformanceSummaryResponse) 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
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochPerformanceSummaryResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllEpochPerformanceSummaryResponse 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_QueryAllEpochPerformanceSummaryResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ 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.QueryAllEpochPerformanceSummaryResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllEpochPerformanceSummaryResponse 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_QueryAllEpochPerformanceSummaryResponse) 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
+ 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("message inference.inference.QueryAllEpochPerformanceSummaryResponse 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_QueryAllEpochPerformanceSummaryResponse) 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)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochPerformanceSummaryResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllEpochPerformanceSummaryResponse 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_QueryAllEpochPerformanceSummaryResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllEpochPerformanceSummaryResponse.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)
+ }
+ return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochPerformanceSummaryResponse"))
+ }
+ 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_QueryAllEpochPerformanceSummaryResponse) 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)
+ 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("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_QueryAllEpochPerformanceSummaryResponse) 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("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_QueryAllEpochPerformanceSummaryResponse) 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_QueryAllEpochPerformanceSummaryResponse) 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_QueryAllEpochPerformanceSummaryResponse) 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_QueryAllEpochPerformanceSummaryResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryAllEpochPerformanceSummaryResponse)
+ 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.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 {
+ n += len(x.unknownFields)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*QueryAllEpochPerformanceSummaryResponse)
+ 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.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.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...)
+ } 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().(*QueryAllEpochPerformanceSummaryResponse)
+ 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: QueryAllEpochPerformanceSummaryResponse: 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)
+ }
+ 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)
+ }
+ 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.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 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 {
+ 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_QueryTrainingTaskRequest protoreflect.MessageDescriptor
+ fd_QueryTrainingTaskRequest_id protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryTrainingTaskRequest = File_inference_inference_query_proto.Messages().ByName("QueryTrainingTaskRequest")
+ fd_QueryTrainingTaskRequest_id = md_QueryTrainingTaskRequest.Fields().ByName("id")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryTrainingTaskRequest)(nil)
+
+type fastReflection_QueryTrainingTaskRequest QueryTrainingTaskRequest
+
+func (x *QueryTrainingTaskRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryTrainingTaskRequest)(x)
+}
+
+func (x *QueryTrainingTaskRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[62]
+ 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_QueryTrainingTaskRequest_messageType fastReflection_QueryTrainingTaskRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryTrainingTaskRequest_messageType{}
+
+type fastReflection_QueryTrainingTaskRequest_messageType struct{}
+
+func (x fastReflection_QueryTrainingTaskRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryTrainingTaskRequest)(nil)
+}
+func (x fastReflection_QueryTrainingTaskRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryTrainingTaskRequest)
+}
+func (x fastReflection_QueryTrainingTaskRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryTrainingTaskRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryTrainingTaskRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryTrainingTaskRequest
+}
+
+// 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_QueryTrainingTaskRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryTrainingTaskRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryTrainingTaskRequest) New() protoreflect.Message {
+ return new(fastReflection_QueryTrainingTaskRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryTrainingTaskRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryTrainingTaskRequest)(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_QueryTrainingTaskRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Id != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.Id)
+ if !f(fd_QueryTrainingTaskRequest_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_QueryTrainingTaskRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingTaskRequest.id":
+ return x.Id != uint64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingTaskRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingTaskRequest 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_QueryTrainingTaskRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingTaskRequest.id":
+ x.Id = uint64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingTaskRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingTaskRequest 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_QueryTrainingTaskRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryTrainingTaskRequest.id":
+ value := x.Id
+ return protoreflect.ValueOfUint64(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingTaskRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingTaskRequest 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_QueryTrainingTaskRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingTaskRequest.id":
+ x.Id = value.Uint()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingTaskRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingTaskRequest 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_QueryTrainingTaskRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingTaskRequest.id":
+ panic(fmt.Errorf("field id of message inference.inference.QueryTrainingTaskRequest is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingTaskRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingTaskRequest 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_QueryTrainingTaskRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingTaskRequest.id":
+ return protoreflect.ValueOfUint64(uint64(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingTaskRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingTaskRequest 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_QueryTrainingTaskRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryTrainingTaskRequest", 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_QueryTrainingTaskRequest) 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_QueryTrainingTaskRequest) 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_QueryTrainingTaskRequest) 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_QueryTrainingTaskRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryTrainingTaskRequest)
+ 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().(*QueryTrainingTaskRequest)
+ 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().(*QueryTrainingTaskRequest)
+ 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: QueryTrainingTaskRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryTrainingTaskRequest: 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_QueryTrainingTaskResponse protoreflect.MessageDescriptor
+ fd_QueryTrainingTaskResponse_task protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryTrainingTaskResponse = File_inference_inference_query_proto.Messages().ByName("QueryTrainingTaskResponse")
+ fd_QueryTrainingTaskResponse_task = md_QueryTrainingTaskResponse.Fields().ByName("task")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryTrainingTaskResponse)(nil)
+
+type fastReflection_QueryTrainingTaskResponse QueryTrainingTaskResponse
+
+func (x *QueryTrainingTaskResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryTrainingTaskResponse)(x)
+}
+
+func (x *QueryTrainingTaskResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[63]
+ 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_QueryTrainingTaskResponse_messageType fastReflection_QueryTrainingTaskResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryTrainingTaskResponse_messageType{}
+
+type fastReflection_QueryTrainingTaskResponse_messageType struct{}
+
+func (x fastReflection_QueryTrainingTaskResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryTrainingTaskResponse)(nil)
+}
+func (x fastReflection_QueryTrainingTaskResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryTrainingTaskResponse)
+}
+func (x fastReflection_QueryTrainingTaskResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryTrainingTaskResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryTrainingTaskResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryTrainingTaskResponse
+}
+
+// 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_QueryTrainingTaskResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryTrainingTaskResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryTrainingTaskResponse) New() protoreflect.Message {
+ return new(fastReflection_QueryTrainingTaskResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryTrainingTaskResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryTrainingTaskResponse)(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_QueryTrainingTaskResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Task != nil {
+ value := protoreflect.ValueOfMessage(x.Task.ProtoReflect())
+ if !f(fd_QueryTrainingTaskResponse_task, 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_QueryTrainingTaskResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingTaskResponse.task":
+ return x.Task != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingTaskResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingTaskResponse 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_QueryTrainingTaskResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingTaskResponse.task":
+ x.Task = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingTaskResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingTaskResponse 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_QueryTrainingTaskResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryTrainingTaskResponse.task":
+ value := x.Task
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingTaskResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingTaskResponse 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_QueryTrainingTaskResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingTaskResponse.task":
+ x.Task = value.Message().Interface().(*TrainingTask)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingTaskResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingTaskResponse 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_QueryTrainingTaskResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingTaskResponse.task":
+ if x.Task == nil {
+ x.Task = new(TrainingTask)
+ }
+ return protoreflect.ValueOfMessage(x.Task.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingTaskResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingTaskResponse 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_QueryTrainingTaskResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingTaskResponse.task":
+ m := new(TrainingTask)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingTaskResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingTaskResponse 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_QueryTrainingTaskResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryTrainingTaskResponse", 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_QueryTrainingTaskResponse) 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_QueryTrainingTaskResponse) 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_QueryTrainingTaskResponse) 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_QueryTrainingTaskResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryTrainingTaskResponse)
+ 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.Task != nil {
+ l = options.Size(x.Task)
+ 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().(*QueryTrainingTaskResponse)
+ 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.Task != nil {
+ encoded, err := options.Marshal(x.Task)
+ 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().(*QueryTrainingTaskResponse)
+ 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: QueryTrainingTaskResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryTrainingTaskResponse: 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 Task", 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.Task == nil {
+ x.Task = &TrainingTask{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Task); 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_QueryHardwareNodesRequest protoreflect.MessageDescriptor
+ fd_QueryHardwareNodesRequest_participant 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryHardwareNodesRequest)(nil)
+
+type fastReflection_QueryHardwareNodesRequest QueryHardwareNodesRequest
+
+func (x *QueryHardwareNodesRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryHardwareNodesRequest)(x)
+}
+
+func (x *QueryHardwareNodesRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[64]
+ 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_QueryHardwareNodesRequest_messageType fastReflection_QueryHardwareNodesRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryHardwareNodesRequest_messageType{}
+
+type fastReflection_QueryHardwareNodesRequest_messageType struct{}
+
+func (x fastReflection_QueryHardwareNodesRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryHardwareNodesRequest)(nil)
+}
+func (x fastReflection_QueryHardwareNodesRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryHardwareNodesRequest)
+}
+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_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_QueryHardwareNodesRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryHardwareNodesRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryHardwareNodesRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryHardwareNodesRequest)(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_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.
+//
+// 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_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.QueryHardwareNodesRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryHardwareNodesRequest 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_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.QueryHardwareNodesRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryHardwareNodesRequest 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_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.QueryHardwareNodesRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryHardwareNodesRequest 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_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.QueryHardwareNodesRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryHardwareNodesRequest 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_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.QueryHardwareNodesRequest"))
+ }
+ 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_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.QueryHardwareNodesRequest"))
+ }
+ 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_QueryHardwareNodesRequest) 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("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_QueryHardwareNodesRequest) 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_QueryHardwareNodesRequest) 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_QueryHardwareNodesRequest) 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_QueryHardwareNodesRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryHardwareNodesRequest)
+ 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().(*QueryHardwareNodesRequest)
+ 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().(*QueryHardwareNodesRequest)
+ 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: QueryHardwareNodesRequest: 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)
+ }
+ 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_QueryHardwareNodesResponse protoreflect.MessageDescriptor
+ fd_QueryHardwareNodesResponse_nodes protoreflect.FieldDescriptor
+)
+
+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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryHardwareNodesResponse)(nil)
+
+type fastReflection_QueryHardwareNodesResponse QueryHardwareNodesResponse
+
+func (x *QueryHardwareNodesResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryHardwareNodesResponse)(x)
+}
+
+func (x *QueryHardwareNodesResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[65]
+ 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_QueryHardwareNodesResponse_messageType fastReflection_QueryHardwareNodesResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryHardwareNodesResponse_messageType{}
+
+type fastReflection_QueryHardwareNodesResponse_messageType struct{}
+
+func (x fastReflection_QueryHardwareNodesResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryHardwareNodesResponse)(nil)
+}
+func (x fastReflection_QueryHardwareNodesResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryHardwareNodesResponse)
+}
+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_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_QueryHardwareNodesResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryHardwareNodesResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryHardwareNodesResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryHardwareNodesResponse)(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_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
+ }
+ }
+}
+
+// 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_QueryHardwareNodesResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryHardwareNodesResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryHardwareNodesResponse 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_QueryHardwareNodesResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryHardwareNodesResponse.nodes":
+ x.Nodes = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryHardwareNodesResponse 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_QueryHardwareNodesResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ 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.QueryHardwareNodesResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryHardwareNodesResponse 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_QueryHardwareNodesResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ 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.QueryHardwareNodesResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryHardwareNodesResponse 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_QueryHardwareNodesResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryHardwareNodesResponse.nodes":
+ if x.Nodes == nil {
+ x.Nodes = new(HardwareNodes)
+ }
+ return protoreflect.ValueOfMessage(x.Nodes.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesResponse"))
+ }
+ 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_QueryHardwareNodesResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryHardwareNodesResponse"))
+ }
+ 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_QueryHardwareNodesResponse) 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("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_QueryHardwareNodesResponse) 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_QueryHardwareNodesResponse) 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_QueryHardwareNodesResponse) 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_QueryHardwareNodesResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryHardwareNodesResponse)
+ 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.Nodes != nil {
+ l = options.Size(x.Nodes)
+ 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().(*QueryHardwareNodesResponse)
+ 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.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...)
+ } 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().(*QueryHardwareNodesResponse)
+ 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: QueryHardwareNodesResponse: 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)
+ }
+ 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)
+ }
+ 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.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
+ 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_QueryHardwareNodesAllRequest protoreflect.MessageDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryHardwareNodesAllRequest = File_inference_inference_query_proto.Messages().ByName("QueryHardwareNodesAllRequest")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryHardwareNodesAllRequest)(nil)
+
+type fastReflection_QueryHardwareNodesAllRequest QueryHardwareNodesAllRequest
+
+func (x *QueryHardwareNodesAllRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryHardwareNodesAllRequest)(x)
+}
+
+func (x *QueryHardwareNodesAllRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[66]
+ 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_QueryHardwareNodesAllRequest_messageType fastReflection_QueryHardwareNodesAllRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryHardwareNodesAllRequest_messageType{}
+
+type fastReflection_QueryHardwareNodesAllRequest_messageType struct{}
+
+func (x fastReflection_QueryHardwareNodesAllRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryHardwareNodesAllRequest)(nil)
+}
+func (x fastReflection_QueryHardwareNodesAllRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryHardwareNodesAllRequest)
+}
+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_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_QueryHardwareNodesAllRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryHardwareNodesAllRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryHardwareNodesAllRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryHardwareNodesAllRequest)(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_QueryHardwareNodesAllRequest) 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_QueryHardwareNodesAllRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesAllRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryHardwareNodesAllRequest 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_QueryHardwareNodesAllRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesAllRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryHardwareNodesAllRequest 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_QueryHardwareNodesAllRequest) 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.QueryHardwareNodesAllRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryHardwareNodesAllRequest 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_QueryHardwareNodesAllRequest) 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.QueryHardwareNodesAllRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryHardwareNodesAllRequest 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_QueryHardwareNodesAllRequest) 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.QueryHardwareNodesAllRequest"))
+ }
+ 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_QueryHardwareNodesAllRequest) 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.QueryHardwareNodesAllRequest"))
+ }
+ 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_QueryHardwareNodesAllRequest) 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("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_QueryHardwareNodesAllRequest) 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_QueryHardwareNodesAllRequest) 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_QueryHardwareNodesAllRequest) 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_QueryHardwareNodesAllRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryHardwareNodesAllRequest)
+ 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().(*QueryHardwareNodesAllRequest)
+ 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().(*QueryHardwareNodesAllRequest)
+ 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: QueryHardwareNodesAllRequest: 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)
+ }
+ 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 = (*_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
+)
+
+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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryHardwareNodesAllResponse)(nil)
+
+type fastReflection_QueryHardwareNodesAllResponse QueryHardwareNodesAllResponse
+
+func (x *QueryHardwareNodesAllResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryHardwareNodesAllResponse)(x)
+}
+
+func (x *QueryHardwareNodesAllResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[67]
+ 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_QueryHardwareNodesAllResponse_messageType fastReflection_QueryHardwareNodesAllResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryHardwareNodesAllResponse_messageType{}
+
+type fastReflection_QueryHardwareNodesAllResponse_messageType struct{}
+
+func (x fastReflection_QueryHardwareNodesAllResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryHardwareNodesAllResponse)(nil)
+}
+func (x fastReflection_QueryHardwareNodesAllResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryHardwareNodesAllResponse)
+}
+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_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_QueryHardwareNodesAllResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryHardwareNodesAllResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryHardwareNodesAllResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryHardwareNodesAllResponse)(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_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
+ }
+ }
+}
+
+// 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_QueryHardwareNodesAllResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryHardwareNodesAllResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryHardwareNodesAllResponse 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_QueryHardwareNodesAllResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryHardwareNodesAllResponse.nodes":
+ x.Nodes = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesAllResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryHardwareNodesAllResponse 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_QueryHardwareNodesAllResponse) 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)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesAllResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryHardwareNodesAllResponse 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_QueryHardwareNodesAllResponse) 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
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesAllResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryHardwareNodesAllResponse 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_QueryHardwareNodesAllResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryHardwareNodesAllResponse"))
+ }
+ 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_QueryHardwareNodesAllResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryHardwareNodesAllResponse"))
+ }
+ 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_QueryHardwareNodesAllResponse) 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("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_QueryHardwareNodesAllResponse) 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_QueryHardwareNodesAllResponse) 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_QueryHardwareNodesAllResponse) 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_QueryHardwareNodesAllResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryHardwareNodesAllResponse)
+ 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.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)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*QueryHardwareNodesAllResponse)
+ 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.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...)
+ } 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().(*QueryHardwareNodesAllResponse)
+ 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: QueryHardwareNodesAllResponse: 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)
+ }
+ 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)
+ }
+ 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.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:])
+ 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_QueryQueuedTrainingTasksRequest protoreflect.MessageDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryQueuedTrainingTasksRequest = File_inference_inference_query_proto.Messages().ByName("QueryQueuedTrainingTasksRequest")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryQueuedTrainingTasksRequest)(nil)
+
+type fastReflection_QueryQueuedTrainingTasksRequest QueryQueuedTrainingTasksRequest
+
+func (x *QueryQueuedTrainingTasksRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryQueuedTrainingTasksRequest)(x)
+}
+
+func (x *QueryQueuedTrainingTasksRequest) 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_QueryQueuedTrainingTasksRequest_messageType fastReflection_QueryQueuedTrainingTasksRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryQueuedTrainingTasksRequest_messageType{}
+
+type fastReflection_QueryQueuedTrainingTasksRequest_messageType struct{}
+
+func (x fastReflection_QueryQueuedTrainingTasksRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryQueuedTrainingTasksRequest)(nil)
+}
+func (x fastReflection_QueryQueuedTrainingTasksRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryQueuedTrainingTasksRequest)
+}
+func (x fastReflection_QueryQueuedTrainingTasksRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryQueuedTrainingTasksRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryQueuedTrainingTasksRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryQueuedTrainingTasksRequest
+}
+
+// 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_QueryQueuedTrainingTasksRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryQueuedTrainingTasksRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryQueuedTrainingTasksRequest) New() protoreflect.Message {
+ return new(fastReflection_QueryQueuedTrainingTasksRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryQueuedTrainingTasksRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryQueuedTrainingTasksRequest)(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_QueryQueuedTrainingTasksRequest) 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_QueryQueuedTrainingTasksRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryQueuedTrainingTasksRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryQueuedTrainingTasksRequest 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_QueryQueuedTrainingTasksRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryQueuedTrainingTasksRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryQueuedTrainingTasksRequest 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_QueryQueuedTrainingTasksRequest) 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.QueryQueuedTrainingTasksRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryQueuedTrainingTasksRequest 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_QueryQueuedTrainingTasksRequest) 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.QueryQueuedTrainingTasksRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryQueuedTrainingTasksRequest 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_QueryQueuedTrainingTasksRequest) 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.QueryQueuedTrainingTasksRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryQueuedTrainingTasksRequest 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_QueryQueuedTrainingTasksRequest) 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.QueryQueuedTrainingTasksRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryQueuedTrainingTasksRequest 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_QueryQueuedTrainingTasksRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryQueuedTrainingTasksRequest", 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_QueryQueuedTrainingTasksRequest) 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_QueryQueuedTrainingTasksRequest) 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_QueryQueuedTrainingTasksRequest) 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_QueryQueuedTrainingTasksRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryQueuedTrainingTasksRequest)
+ 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().(*QueryQueuedTrainingTasksRequest)
+ 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().(*QueryQueuedTrainingTasksRequest)
+ 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: QueryQueuedTrainingTasksRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryQueuedTrainingTasksRequest: 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 = (*_QueryQueuedTrainingTasksResponse_1_list)(nil)
+
+type _QueryQueuedTrainingTasksResponse_1_list struct {
+ list *[]*TrainingTask
+}
+
+func (x *_QueryQueuedTrainingTasksResponse_1_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_QueryQueuedTrainingTasksResponse_1_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryQueuedTrainingTasksResponse_1_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*TrainingTask)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_QueryQueuedTrainingTasksResponse_1_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*TrainingTask)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryQueuedTrainingTasksResponse_1_list) AppendMutable() protoreflect.Value {
+ v := new(TrainingTask)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryQueuedTrainingTasksResponse_1_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_QueryQueuedTrainingTasksResponse_1_list) NewElement() protoreflect.Value {
+ v := new(TrainingTask)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryQueuedTrainingTasksResponse_1_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_QueryQueuedTrainingTasksResponse protoreflect.MessageDescriptor
+ fd_QueryQueuedTrainingTasksResponse_tasks protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryQueuedTrainingTasksResponse = File_inference_inference_query_proto.Messages().ByName("QueryQueuedTrainingTasksResponse")
+ fd_QueryQueuedTrainingTasksResponse_tasks = md_QueryQueuedTrainingTasksResponse.Fields().ByName("tasks")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryQueuedTrainingTasksResponse)(nil)
+
+type fastReflection_QueryQueuedTrainingTasksResponse QueryQueuedTrainingTasksResponse
+
+func (x *QueryQueuedTrainingTasksResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryQueuedTrainingTasksResponse)(x)
+}
+
+func (x *QueryQueuedTrainingTasksResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[69]
+ 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_QueryQueuedTrainingTasksResponse_messageType fastReflection_QueryQueuedTrainingTasksResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryQueuedTrainingTasksResponse_messageType{}
+
+type fastReflection_QueryQueuedTrainingTasksResponse_messageType struct{}
+
+func (x fastReflection_QueryQueuedTrainingTasksResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryQueuedTrainingTasksResponse)(nil)
+}
+func (x fastReflection_QueryQueuedTrainingTasksResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryQueuedTrainingTasksResponse)
+}
+func (x fastReflection_QueryQueuedTrainingTasksResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryQueuedTrainingTasksResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryQueuedTrainingTasksResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryQueuedTrainingTasksResponse
+}
+
+// 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_QueryQueuedTrainingTasksResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryQueuedTrainingTasksResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryQueuedTrainingTasksResponse) New() protoreflect.Message {
+ return new(fastReflection_QueryQueuedTrainingTasksResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryQueuedTrainingTasksResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryQueuedTrainingTasksResponse)(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_QueryQueuedTrainingTasksResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if len(x.Tasks) != 0 {
+ value := protoreflect.ValueOfList(&_QueryQueuedTrainingTasksResponse_1_list{list: &x.Tasks})
+ if !f(fd_QueryQueuedTrainingTasksResponse_tasks, 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_QueryQueuedTrainingTasksResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryQueuedTrainingTasksResponse.tasks":
+ return len(x.Tasks) != 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryQueuedTrainingTasksResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryQueuedTrainingTasksResponse 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_QueryQueuedTrainingTasksResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryQueuedTrainingTasksResponse.tasks":
+ x.Tasks = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryQueuedTrainingTasksResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryQueuedTrainingTasksResponse 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_QueryQueuedTrainingTasksResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryQueuedTrainingTasksResponse.tasks":
+ if len(x.Tasks) == 0 {
+ return protoreflect.ValueOfList(&_QueryQueuedTrainingTasksResponse_1_list{})
+ }
+ listValue := &_QueryQueuedTrainingTasksResponse_1_list{list: &x.Tasks}
+ return protoreflect.ValueOfList(listValue)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryQueuedTrainingTasksResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryQueuedTrainingTasksResponse 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_QueryQueuedTrainingTasksResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryQueuedTrainingTasksResponse.tasks":
+ lv := value.List()
+ clv := lv.(*_QueryQueuedTrainingTasksResponse_1_list)
+ x.Tasks = *clv.list
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryQueuedTrainingTasksResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryQueuedTrainingTasksResponse 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_QueryQueuedTrainingTasksResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryQueuedTrainingTasksResponse.tasks":
+ if x.Tasks == nil {
+ x.Tasks = []*TrainingTask{}
+ }
+ value := &_QueryQueuedTrainingTasksResponse_1_list{list: &x.Tasks}
+ return protoreflect.ValueOfList(value)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryQueuedTrainingTasksResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryQueuedTrainingTasksResponse 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_QueryQueuedTrainingTasksResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryQueuedTrainingTasksResponse.tasks":
+ list := []*TrainingTask{}
+ return protoreflect.ValueOfList(&_QueryQueuedTrainingTasksResponse_1_list{list: &list})
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryQueuedTrainingTasksResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryQueuedTrainingTasksResponse 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_QueryQueuedTrainingTasksResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryQueuedTrainingTasksResponse", 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_QueryQueuedTrainingTasksResponse) 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_QueryQueuedTrainingTasksResponse) 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_QueryQueuedTrainingTasksResponse) 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_QueryQueuedTrainingTasksResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryQueuedTrainingTasksResponse)
+ 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.Tasks) > 0 {
+ for _, e := range x.Tasks {
+ 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().(*QueryQueuedTrainingTasksResponse)
+ 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.Tasks) > 0 {
+ for iNdEx := len(x.Tasks) - 1; iNdEx >= 0; iNdEx-- {
+ encoded, err := options.Marshal(x.Tasks[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().(*QueryQueuedTrainingTasksResponse)
+ 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: QueryQueuedTrainingTasksResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryQueuedTrainingTasksResponse: 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 Tasks", 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.Tasks = append(x.Tasks, &TrainingTask{})
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Tasks[len(x.Tasks)-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_QueryTrainingTaskAllRequest protoreflect.MessageDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryTrainingTaskAllRequest = File_inference_inference_query_proto.Messages().ByName("QueryTrainingTaskAllRequest")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryTrainingTaskAllRequest)(nil)
+
+type fastReflection_QueryTrainingTaskAllRequest QueryTrainingTaskAllRequest
+
+func (x *QueryTrainingTaskAllRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryTrainingTaskAllRequest)(x)
+}
+
+func (x *QueryTrainingTaskAllRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[70]
+ 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_QueryTrainingTaskAllRequest_messageType fastReflection_QueryTrainingTaskAllRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryTrainingTaskAllRequest_messageType{}
+
+type fastReflection_QueryTrainingTaskAllRequest_messageType struct{}
+
+func (x fastReflection_QueryTrainingTaskAllRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryTrainingTaskAllRequest)(nil)
+}
+func (x fastReflection_QueryTrainingTaskAllRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryTrainingTaskAllRequest)
+}
+func (x fastReflection_QueryTrainingTaskAllRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryTrainingTaskAllRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryTrainingTaskAllRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryTrainingTaskAllRequest
+}
+
+// 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_QueryTrainingTaskAllRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryTrainingTaskAllRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryTrainingTaskAllRequest) New() protoreflect.Message {
+ return new(fastReflection_QueryTrainingTaskAllRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryTrainingTaskAllRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryTrainingTaskAllRequest)(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_QueryTrainingTaskAllRequest) 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_QueryTrainingTaskAllRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingTaskAllRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingTaskAllRequest 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_QueryTrainingTaskAllRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingTaskAllRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingTaskAllRequest 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_QueryTrainingTaskAllRequest) 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.QueryTrainingTaskAllRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingTaskAllRequest 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_QueryTrainingTaskAllRequest) 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.QueryTrainingTaskAllRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingTaskAllRequest 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_QueryTrainingTaskAllRequest) 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.QueryTrainingTaskAllRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingTaskAllRequest 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_QueryTrainingTaskAllRequest) 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.QueryTrainingTaskAllRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingTaskAllRequest 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_QueryTrainingTaskAllRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryTrainingTaskAllRequest", 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_QueryTrainingTaskAllRequest) 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_QueryTrainingTaskAllRequest) 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_QueryTrainingTaskAllRequest) 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_QueryTrainingTaskAllRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryTrainingTaskAllRequest)
+ 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().(*QueryTrainingTaskAllRequest)
+ 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().(*QueryTrainingTaskAllRequest)
+ 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: QueryTrainingTaskAllRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryTrainingTaskAllRequest: 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 = (*_QueryTrainingTaskAllResponse_1_list)(nil)
+
+type _QueryTrainingTaskAllResponse_1_list struct {
+ list *[]*TrainingTask
+}
+
+func (x *_QueryTrainingTaskAllResponse_1_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_QueryTrainingTaskAllResponse_1_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryTrainingTaskAllResponse_1_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*TrainingTask)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_QueryTrainingTaskAllResponse_1_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*TrainingTask)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryTrainingTaskAllResponse_1_list) AppendMutable() protoreflect.Value {
+ v := new(TrainingTask)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryTrainingTaskAllResponse_1_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_QueryTrainingTaskAllResponse_1_list) NewElement() protoreflect.Value {
+ v := new(TrainingTask)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryTrainingTaskAllResponse_1_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_QueryTrainingTaskAllResponse protoreflect.MessageDescriptor
+ fd_QueryTrainingTaskAllResponse_tasks protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryTrainingTaskAllResponse = File_inference_inference_query_proto.Messages().ByName("QueryTrainingTaskAllResponse")
+ fd_QueryTrainingTaskAllResponse_tasks = md_QueryTrainingTaskAllResponse.Fields().ByName("tasks")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryTrainingTaskAllResponse)(nil)
+
+type fastReflection_QueryTrainingTaskAllResponse QueryTrainingTaskAllResponse
+
+func (x *QueryTrainingTaskAllResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryTrainingTaskAllResponse)(x)
+}
+
+func (x *QueryTrainingTaskAllResponse) 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 {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryTrainingTaskAllResponse_messageType fastReflection_QueryTrainingTaskAllResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryTrainingTaskAllResponse_messageType{}
+
+type fastReflection_QueryTrainingTaskAllResponse_messageType struct{}
+
+func (x fastReflection_QueryTrainingTaskAllResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryTrainingTaskAllResponse)(nil)
+}
+func (x fastReflection_QueryTrainingTaskAllResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryTrainingTaskAllResponse)
+}
+func (x fastReflection_QueryTrainingTaskAllResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryTrainingTaskAllResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryTrainingTaskAllResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryTrainingTaskAllResponse
+}
+
+// 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_QueryTrainingTaskAllResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryTrainingTaskAllResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryTrainingTaskAllResponse) New() protoreflect.Message {
+ return new(fastReflection_QueryTrainingTaskAllResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryTrainingTaskAllResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryTrainingTaskAllResponse)(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_QueryTrainingTaskAllResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if len(x.Tasks) != 0 {
+ value := protoreflect.ValueOfList(&_QueryTrainingTaskAllResponse_1_list{list: &x.Tasks})
+ if !f(fd_QueryTrainingTaskAllResponse_tasks, 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_QueryTrainingTaskAllResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingTaskAllResponse.tasks":
+ return len(x.Tasks) != 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingTaskAllResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingTaskAllResponse 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_QueryTrainingTaskAllResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingTaskAllResponse.tasks":
+ x.Tasks = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingTaskAllResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingTaskAllResponse 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_QueryTrainingTaskAllResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryTrainingTaskAllResponse.tasks":
+ if len(x.Tasks) == 0 {
+ return protoreflect.ValueOfList(&_QueryTrainingTaskAllResponse_1_list{})
+ }
+ listValue := &_QueryTrainingTaskAllResponse_1_list{list: &x.Tasks}
+ return protoreflect.ValueOfList(listValue)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingTaskAllResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingTaskAllResponse 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_QueryTrainingTaskAllResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingTaskAllResponse.tasks":
+ lv := value.List()
+ clv := lv.(*_QueryTrainingTaskAllResponse_1_list)
+ x.Tasks = *clv.list
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingTaskAllResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingTaskAllResponse 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_QueryTrainingTaskAllResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingTaskAllResponse.tasks":
+ if x.Tasks == nil {
+ x.Tasks = []*TrainingTask{}
+ }
+ value := &_QueryTrainingTaskAllResponse_1_list{list: &x.Tasks}
+ return protoreflect.ValueOfList(value)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingTaskAllResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingTaskAllResponse 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_QueryTrainingTaskAllResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingTaskAllResponse.tasks":
+ list := []*TrainingTask{}
+ return protoreflect.ValueOfList(&_QueryTrainingTaskAllResponse_1_list{list: &list})
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingTaskAllResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingTaskAllResponse 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_QueryTrainingTaskAllResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryTrainingTaskAllResponse", 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_QueryTrainingTaskAllResponse) 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_QueryTrainingTaskAllResponse) 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_QueryTrainingTaskAllResponse) 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_QueryTrainingTaskAllResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryTrainingTaskAllResponse)
+ 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.Tasks) > 0 {
+ for _, e := range x.Tasks {
+ 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().(*QueryTrainingTaskAllResponse)
+ 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.Tasks) > 0 {
+ for iNdEx := len(x.Tasks) - 1; iNdEx >= 0; iNdEx-- {
+ encoded, err := options.Marshal(x.Tasks[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().(*QueryTrainingTaskAllResponse)
+ 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: QueryTrainingTaskAllResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryTrainingTaskAllResponse: 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 Tasks", 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.Tasks = append(x.Tasks, &TrainingTask{})
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Tasks[len(x.Tasks)-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_QueryGetParticipantCurrentStatsRequest protoreflect.MessageDescriptor
+ fd_QueryGetParticipantCurrentStatsRequest_participantId protoreflect.FieldDescriptor
+)
+
+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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetParticipantCurrentStatsRequest)(nil)
+
+type fastReflection_QueryGetParticipantCurrentStatsRequest QueryGetParticipantCurrentStatsRequest
+
+func (x *QueryGetParticipantCurrentStatsRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetParticipantCurrentStatsRequest)(x)
+}
+
+func (x *QueryGetParticipantCurrentStatsRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[72]
+ 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_QueryGetParticipantCurrentStatsRequest_messageType fastReflection_QueryGetParticipantCurrentStatsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetParticipantCurrentStatsRequest_messageType{}
+
+type fastReflection_QueryGetParticipantCurrentStatsRequest_messageType struct{}
+
+func (x fastReflection_QueryGetParticipantCurrentStatsRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetParticipantCurrentStatsRequest)(nil)
+}
+func (x fastReflection_QueryGetParticipantCurrentStatsRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetParticipantCurrentStatsRequest)
+}
+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_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_QueryGetParticipantCurrentStatsRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetParticipantCurrentStatsRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryGetParticipantCurrentStatsRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetParticipantCurrentStatsRequest)(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_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.
+//
+// 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_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.QueryGetParticipantCurrentStatsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetParticipantCurrentStatsRequest 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_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.QueryGetParticipantCurrentStatsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetParticipantCurrentStatsRequest 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_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.QueryGetParticipantCurrentStatsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetParticipantCurrentStatsRequest 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_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.QueryGetParticipantCurrentStatsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetParticipantCurrentStatsRequest 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_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.QueryGetParticipantCurrentStatsRequest"))
+ }
+ 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_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.QueryGetParticipantCurrentStatsRequest"))
+ }
+ 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_QueryGetParticipantCurrentStatsRequest) 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("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_QueryGetParticipantCurrentStatsRequest) 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_QueryGetParticipantCurrentStatsRequest) 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_QueryGetParticipantCurrentStatsRequest) 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_QueryGetParticipantCurrentStatsRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetParticipantCurrentStatsRequest)
+ 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.ParticipantId)
+ 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().(*QueryGetParticipantCurrentStatsRequest)
+ 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.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 {
+ 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().(*QueryGetParticipantCurrentStatsRequest)
+ 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: QueryGetParticipantCurrentStatsRequest: 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)
+ }
+ 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:])
+ 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_QueryGetParticipantCurrentStatsResponse protoreflect.MessageDescriptor
+ fd_QueryGetParticipantCurrentStatsResponse_weight protoreflect.FieldDescriptor
+ fd_QueryGetParticipantCurrentStatsResponse_reputation 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetParticipantCurrentStatsResponse)(nil)
+
+type fastReflection_QueryGetParticipantCurrentStatsResponse QueryGetParticipantCurrentStatsResponse
+
+func (x *QueryGetParticipantCurrentStatsResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetParticipantCurrentStatsResponse)(x)
+}
+
+func (x *QueryGetParticipantCurrentStatsResponse) 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_QueryGetParticipantCurrentStatsResponse_messageType fastReflection_QueryGetParticipantCurrentStatsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetParticipantCurrentStatsResponse_messageType{}
+
+type fastReflection_QueryGetParticipantCurrentStatsResponse_messageType struct{}
+
+func (x fastReflection_QueryGetParticipantCurrentStatsResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetParticipantCurrentStatsResponse)(nil)
+}
+func (x fastReflection_QueryGetParticipantCurrentStatsResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetParticipantCurrentStatsResponse)
+}
+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_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_QueryGetParticipantCurrentStatsResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetParticipantCurrentStatsResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryGetParticipantCurrentStatsResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetParticipantCurrentStatsResponse)(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_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) {
+ 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_QueryGetParticipantCurrentStatsResponse) 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)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantCurrentStatsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetParticipantCurrentStatsResponse 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_QueryGetParticipantCurrentStatsResponse) 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)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantCurrentStatsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetParticipantCurrentStatsResponse 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_QueryGetParticipantCurrentStatsResponse) 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)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantCurrentStatsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetParticipantCurrentStatsResponse 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_QueryGetParticipantCurrentStatsResponse) 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())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantCurrentStatsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetParticipantCurrentStatsResponse 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_QueryGetParticipantCurrentStatsResponse) 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"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantCurrentStatsResponse"))
+ }
+ 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_QueryGetParticipantCurrentStatsResponse) 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))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantCurrentStatsResponse"))
+ }
+ 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_QueryGetParticipantCurrentStatsResponse) 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("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_QueryGetParticipantCurrentStatsResponse) 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_QueryGetParticipantCurrentStatsResponse) 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_QueryGetParticipantCurrentStatsResponse) 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_QueryGetParticipantCurrentStatsResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetParticipantCurrentStatsResponse)
+ 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.Weight != 0 {
+ n += 1 + runtime.Sov(uint64(x.Weight))
+ }
+ if x.Reputation != 0 {
+ n += 1 + runtime.Sov(uint64(x.Reputation))
+ }
+ 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().(*QueryGetParticipantCurrentStatsResponse)
+ 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.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 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().(*QueryGetParticipantCurrentStatsResponse)
+ 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: QueryGetParticipantCurrentStatsResponse: 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)
+ }
+ 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)
+ }
+ 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 2:
+ 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,
+ Size: size,
+ Marshal: marshal,
+ Unmarshal: unmarshal,
+ Merge: nil,
+ CheckInitialized: nil,
+ }
+}
+
+var (
+ md_QueryGetAllParticipantCurrentStatsRequest protoreflect.MessageDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryGetAllParticipantCurrentStatsRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetAllParticipantCurrentStatsRequest")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetAllParticipantCurrentStatsRequest)(nil)
+
+type fastReflection_QueryGetAllParticipantCurrentStatsRequest QueryGetAllParticipantCurrentStatsRequest
+
+func (x *QueryGetAllParticipantCurrentStatsRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetAllParticipantCurrentStatsRequest)(x)
+}
+
+func (x *QueryGetAllParticipantCurrentStatsRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[74]
+ 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_QueryGetAllParticipantCurrentStatsRequest_messageType fastReflection_QueryGetAllParticipantCurrentStatsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetAllParticipantCurrentStatsRequest_messageType{}
+
+type fastReflection_QueryGetAllParticipantCurrentStatsRequest_messageType struct{}
+
+func (x fastReflection_QueryGetAllParticipantCurrentStatsRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetAllParticipantCurrentStatsRequest)(nil)
+}
+func (x fastReflection_QueryGetAllParticipantCurrentStatsRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetAllParticipantCurrentStatsRequest)
+}
+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_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_QueryGetAllParticipantCurrentStatsRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetAllParticipantCurrentStatsRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryGetAllParticipantCurrentStatsRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetAllParticipantCurrentStatsRequest)(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_QueryGetAllParticipantCurrentStatsRequest) 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_QueryGetAllParticipantCurrentStatsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllParticipantCurrentStatsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetAllParticipantCurrentStatsRequest 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_QueryGetAllParticipantCurrentStatsRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllParticipantCurrentStatsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetAllParticipantCurrentStatsRequest 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_QueryGetAllParticipantCurrentStatsRequest) 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.QueryGetAllParticipantCurrentStatsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetAllParticipantCurrentStatsRequest 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_QueryGetAllParticipantCurrentStatsRequest) 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.QueryGetAllParticipantCurrentStatsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetAllParticipantCurrentStatsRequest 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_QueryGetAllParticipantCurrentStatsRequest) 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.QueryGetAllParticipantCurrentStatsRequest"))
+ }
+ 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_QueryGetAllParticipantCurrentStatsRequest) 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.QueryGetAllParticipantCurrentStatsRequest"))
+ }
+ 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_QueryGetAllParticipantCurrentStatsRequest) 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("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_QueryGetAllParticipantCurrentStatsRequest) 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_QueryGetAllParticipantCurrentStatsRequest) 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_QueryGetAllParticipantCurrentStatsRequest) 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_QueryGetAllParticipantCurrentStatsRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetAllParticipantCurrentStatsRequest)
+ 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().(*QueryGetAllParticipantCurrentStatsRequest)
+ 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().(*QueryGetAllParticipantCurrentStatsRequest)
+ 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: QueryGetAllParticipantCurrentStatsRequest: 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)
+ }
+ 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 = (*_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
+)
+
+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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetAllParticipantCurrentStatsResponse)(nil)
+
+type fastReflection_QueryGetAllParticipantCurrentStatsResponse QueryGetAllParticipantCurrentStatsResponse
+
+func (x *QueryGetAllParticipantCurrentStatsResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetAllParticipantCurrentStatsResponse)(x)
+}
+
+func (x *QueryGetAllParticipantCurrentStatsResponse) 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_QueryGetAllParticipantCurrentStatsResponse_messageType fastReflection_QueryGetAllParticipantCurrentStatsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetAllParticipantCurrentStatsResponse_messageType{}
+
+type fastReflection_QueryGetAllParticipantCurrentStatsResponse_messageType struct{}
+
+func (x fastReflection_QueryGetAllParticipantCurrentStatsResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetAllParticipantCurrentStatsResponse)(nil)
+}
+func (x fastReflection_QueryGetAllParticipantCurrentStatsResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetAllParticipantCurrentStatsResponse)
+}
+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_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_QueryGetAllParticipantCurrentStatsResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetAllParticipantCurrentStatsResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryGetAllParticipantCurrentStatsResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetAllParticipantCurrentStatsResponse)(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_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) {
+ return
+ }
+ }
+ if x.EpochId != int64(0) {
+ value := protoreflect.ValueOfInt64(x.EpochId)
+ if !f(fd_QueryGetAllParticipantCurrentStatsResponse_epoch_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_QueryGetAllParticipantCurrentStatsResponse) 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)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllParticipantCurrentStatsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetAllParticipantCurrentStatsResponse 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_QueryGetAllParticipantCurrentStatsResponse) 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)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllParticipantCurrentStatsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetAllParticipantCurrentStatsResponse 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_QueryGetAllParticipantCurrentStatsResponse) 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)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllParticipantCurrentStatsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetAllParticipantCurrentStatsResponse 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_QueryGetAllParticipantCurrentStatsResponse) 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()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllParticipantCurrentStatsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetAllParticipantCurrentStatsResponse 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_QueryGetAllParticipantCurrentStatsResponse) 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"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllParticipantCurrentStatsResponse"))
+ }
+ 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_QueryGetAllParticipantCurrentStatsResponse) 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))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllParticipantCurrentStatsResponse"))
+ }
+ 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_QueryGetAllParticipantCurrentStatsResponse) 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("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_QueryGetAllParticipantCurrentStatsResponse) 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_QueryGetAllParticipantCurrentStatsResponse) 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_QueryGetAllParticipantCurrentStatsResponse) 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_QueryGetAllParticipantCurrentStatsResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetAllParticipantCurrentStatsResponse)
+ 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.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.EpochId != 0 {
+ n += 1 + runtime.Sov(uint64(x.EpochId))
+ }
+ 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().(*QueryGetAllParticipantCurrentStatsResponse)
+ 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.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))
+ 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 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().(*QueryGetAllParticipantCurrentStatsResponse)
+ 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: QueryGetAllParticipantCurrentStatsResponse: 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)
+ }
+ 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)
+ }
+ 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 3:
+ 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 |= 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_ParticipantCurrentStats protoreflect.MessageDescriptor
+ fd_ParticipantCurrentStats_participant_id protoreflect.FieldDescriptor
+ fd_ParticipantCurrentStats_weight protoreflect.FieldDescriptor
+ fd_ParticipantCurrentStats_reputation protoreflect.FieldDescriptor
+)
+
+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_reputation = md_ParticipantCurrentStats.Fields().ByName("reputation")
+}
+
+var _ protoreflect.Message = (*fastReflection_ParticipantCurrentStats)(nil)
+
+type fastReflection_ParticipantCurrentStats ParticipantCurrentStats
+
+func (x *ParticipantCurrentStats) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_ParticipantCurrentStats)(x)
+}
+
+func (x *ParticipantCurrentStats) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[76]
+ 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_ParticipantCurrentStats_messageType fastReflection_ParticipantCurrentStats_messageType
+var _ protoreflect.MessageType = fastReflection_ParticipantCurrentStats_messageType{}
+
+type fastReflection_ParticipantCurrentStats_messageType struct{}
+
+func (x fastReflection_ParticipantCurrentStats_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_ParticipantCurrentStats)(nil)
+}
+func (x fastReflection_ParticipantCurrentStats_messageType) New() protoreflect.Message {
+ return new(fastReflection_ParticipantCurrentStats)
+}
+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_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_ParticipantCurrentStats) Type() protoreflect.MessageType {
+ return _fastReflection_ParticipantCurrentStats_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_ParticipantCurrentStats) Interface() protoreflect.ProtoMessage {
+ return (*ParticipantCurrentStats)(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_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.Reputation != int32(0) {
+ value := protoreflect.ValueOfInt32(x.Reputation)
+ if !f(fd_ParticipantCurrentStats_reputation, 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_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.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("message inference.inference.ParticipantCurrentStats 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_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.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("message inference.inference.ParticipantCurrentStats 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_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.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("message inference.inference.ParticipantCurrentStats 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_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.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("message inference.inference.ParticipantCurrentStats 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_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.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("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_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.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("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_ParticipantCurrentStats) 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("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_ParticipantCurrentStats) 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_ParticipantCurrentStats) 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_ParticipantCurrentStats) 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_ParticipantCurrentStats) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*ParticipantCurrentStats)
+ 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.ParticipantId)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.Weight != 0 {
+ n += 1 + runtime.Sov(uint64(x.Weight))
+ }
+ if x.Reputation != 0 {
+ n += 1 + runtime.Sov(uint64(x.Reputation))
+ }
+ 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().(*ParticipantCurrentStats)
+ 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.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 {
+ 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().(*ParticipantCurrentStats)
+ 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: ParticipantCurrentStats: 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)
+ }
+ 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 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,
+ Size: size,
+ Marshal: marshal,
+ Unmarshal: unmarshal,
+ Merge: nil,
+ CheckInitialized: 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
+)
+
+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")
+}
+
+var _ protoreflect.Message = (*fastReflection_ParticipantFullStats)(nil)
+
+type fastReflection_ParticipantFullStats ParticipantFullStats
+
+func (x *ParticipantFullStats) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_ParticipantFullStats)(x)
+}
+
+func (x *ParticipantFullStats) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[77]
+ 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_ParticipantFullStats_messageType fastReflection_ParticipantFullStats_messageType
+var _ protoreflect.MessageType = fastReflection_ParticipantFullStats_messageType{}
+
+type fastReflection_ParticipantFullStats_messageType struct{}
+
+func (x fastReflection_ParticipantFullStats_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_ParticipantFullStats)(nil)
+}
+func (x fastReflection_ParticipantFullStats_messageType) New() protoreflect.Message {
+ return new(fastReflection_ParticipantFullStats)
+}
+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_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_ParticipantFullStats) Type() protoreflect.MessageType {
+ return _fastReflection_ParticipantFullStats_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_ParticipantFullStats) Interface() protoreflect.ProtoMessage {
+ return (*ParticipantFullStats)(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_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
+ }
+ }
+}
+
+// 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_ParticipantFullStats) 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)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantFullStats"))
+ }
+ panic(fmt.Errorf("message inference.inference.ParticipantFullStats 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_ParticipantFullStats) 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)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantFullStats"))
+ }
+ panic(fmt.Errorf("message inference.inference.ParticipantFullStats 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_ParticipantFullStats) 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)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantFullStats"))
+ }
+ panic(fmt.Errorf("message inference.inference.ParticipantFullStats 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_ParticipantFullStats) 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())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantFullStats"))
+ }
+ panic(fmt.Errorf("message inference.inference.ParticipantFullStats 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_ParticipantFullStats) 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"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantFullStats"))
+ }
+ 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_ParticipantFullStats) 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"))
+ }
+ 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_ParticipantFullStats) 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("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_ParticipantFullStats) 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_ParticipantFullStats) 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_ParticipantFullStats) 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_ParticipantFullStats) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*ParticipantFullStats)
+ 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.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)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*ParticipantFullStats)
+ 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.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...)
+ } 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().(*ParticipantFullStats)
+ 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: ParticipantFullStats: 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)
+ }
+ 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)
+ }
+ 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.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.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
+ }
+ }
+
+ 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_QueryParticipantsFullStatsRequest protoreflect.MessageDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryParticipantsFullStatsRequest = File_inference_inference_query_proto.Messages().ByName("QueryParticipantsFullStatsRequest")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryParticipantsFullStatsRequest)(nil)
+
+type fastReflection_QueryParticipantsFullStatsRequest QueryParticipantsFullStatsRequest
+
+func (x *QueryParticipantsFullStatsRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryParticipantsFullStatsRequest)(x)
+}
+
+func (x *QueryParticipantsFullStatsRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[78]
+ 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_QueryParticipantsFullStatsRequest_messageType fastReflection_QueryParticipantsFullStatsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryParticipantsFullStatsRequest_messageType{}
+
+type fastReflection_QueryParticipantsFullStatsRequest_messageType struct{}
+
+func (x fastReflection_QueryParticipantsFullStatsRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryParticipantsFullStatsRequest)(nil)
+}
+func (x fastReflection_QueryParticipantsFullStatsRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryParticipantsFullStatsRequest)
+}
+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_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_QueryParticipantsFullStatsRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryParticipantsFullStatsRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryParticipantsFullStatsRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryParticipantsFullStatsRequest)(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_QueryParticipantsFullStatsRequest) 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_QueryParticipantsFullStatsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsFullStatsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryParticipantsFullStatsRequest 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_QueryParticipantsFullStatsRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsFullStatsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryParticipantsFullStatsRequest 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_QueryParticipantsFullStatsRequest) 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.QueryParticipantsFullStatsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryParticipantsFullStatsRequest 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_QueryParticipantsFullStatsRequest) 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.QueryParticipantsFullStatsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryParticipantsFullStatsRequest 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_QueryParticipantsFullStatsRequest) 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.QueryParticipantsFullStatsRequest"))
+ }
+ 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_QueryParticipantsFullStatsRequest) 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.QueryParticipantsFullStatsRequest"))
+ }
+ 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_QueryParticipantsFullStatsRequest) 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("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_QueryParticipantsFullStatsRequest) 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_QueryParticipantsFullStatsRequest) 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_QueryParticipantsFullStatsRequest) 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_QueryParticipantsFullStatsRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryParticipantsFullStatsRequest)
+ 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().(*QueryParticipantsFullStatsRequest)
+ 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().(*QueryParticipantsFullStatsRequest)
+ 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: QueryParticipantsFullStatsRequest: 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)
+ }
+ 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 = (*_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
+)
+
+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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryParticipantsFullStatsResponse)(nil)
+
+type fastReflection_QueryParticipantsFullStatsResponse QueryParticipantsFullStatsResponse
+
+func (x *QueryParticipantsFullStatsResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryParticipantsFullStatsResponse)(x)
+}
+
+func (x *QueryParticipantsFullStatsResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[79]
+ 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_QueryParticipantsFullStatsResponse_messageType fastReflection_QueryParticipantsFullStatsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryParticipantsFullStatsResponse_messageType{}
+
+type fastReflection_QueryParticipantsFullStatsResponse_messageType struct{}
+
+func (x fastReflection_QueryParticipantsFullStatsResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryParticipantsFullStatsResponse)(nil)
+}
+func (x fastReflection_QueryParticipantsFullStatsResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryParticipantsFullStatsResponse)
+}
+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_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_QueryParticipantsFullStatsResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryParticipantsFullStatsResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryParticipantsFullStatsResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryParticipantsFullStatsResponse)(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_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
+ }
+ }
+}
+
+// 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_QueryParticipantsFullStatsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryParticipantsFullStatsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryParticipantsFullStatsResponse 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_QueryParticipantsFullStatsResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ 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.QueryParticipantsFullStatsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryParticipantsFullStatsResponse 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_QueryParticipantsFullStatsResponse) 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)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsFullStatsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryParticipantsFullStatsResponse 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_QueryParticipantsFullStatsResponse) 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
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsFullStatsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryParticipantsFullStatsResponse 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_QueryParticipantsFullStatsResponse) 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)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsFullStatsResponse"))
+ }
+ 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_QueryParticipantsFullStatsResponse) 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})
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsFullStatsResponse"))
+ }
+ 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_QueryParticipantsFullStatsResponse) 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("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_QueryParticipantsFullStatsResponse) 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_QueryParticipantsFullStatsResponse) 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_QueryParticipantsFullStatsResponse) 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_QueryParticipantsFullStatsResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryParticipantsFullStatsResponse)
+ 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.ParticipantsStats) > 0 {
+ for _, e := range x.ParticipantsStats {
+ 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().(*QueryParticipantsFullStatsResponse)
+ 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.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 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().(*QueryParticipantsFullStatsResponse)
+ 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: QueryParticipantsFullStatsResponse: 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)
+ }
+ 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)
+ }
+ 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.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
+ 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_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_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_QueryStatsByTimePeriodByDeveloperRequest)(nil)
+
+type fastReflection_QueryStatsByTimePeriodByDeveloperRequest QueryStatsByTimePeriodByDeveloperRequest
+
+func (x *QueryStatsByTimePeriodByDeveloperRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryStatsByTimePeriodByDeveloperRequest)(x)
+}
+
+func (x *QueryStatsByTimePeriodByDeveloperRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[80]
+ 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_QueryStatsByTimePeriodByDeveloperRequest_messageType fastReflection_QueryStatsByTimePeriodByDeveloperRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryStatsByTimePeriodByDeveloperRequest_messageType{}
+
+type fastReflection_QueryStatsByTimePeriodByDeveloperRequest_messageType struct{}
+
+func (x fastReflection_QueryStatsByTimePeriodByDeveloperRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryStatsByTimePeriodByDeveloperRequest)(nil)
+}
+func (x fastReflection_QueryStatsByTimePeriodByDeveloperRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryStatsByTimePeriodByDeveloperRequest)
+}
+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_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_QueryStatsByTimePeriodByDeveloperRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryStatsByTimePeriodByDeveloperRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryStatsByTimePeriodByDeveloperRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryStatsByTimePeriodByDeveloperRequest)(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_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
+ }
+ }
+}
+
+// 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_QueryStatsByTimePeriodByDeveloperRequest) 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("message inference.inference.QueryStatsByTimePeriodByDeveloperRequest 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_QueryStatsByTimePeriodByDeveloperRequest) 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("message inference.inference.QueryStatsByTimePeriodByDeveloperRequest 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_QueryStatsByTimePeriodByDeveloperRequest) 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("message inference.inference.QueryStatsByTimePeriodByDeveloperRequest 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_QueryStatsByTimePeriodByDeveloperRequest) 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("message inference.inference.QueryStatsByTimePeriodByDeveloperRequest 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_QueryStatsByTimePeriodByDeveloperRequest) 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("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_QueryStatsByTimePeriodByDeveloperRequest) 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("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_QueryStatsByTimePeriodByDeveloperRequest) 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("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_QueryStatsByTimePeriodByDeveloperRequest) 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_QueryStatsByTimePeriodByDeveloperRequest) 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_QueryStatsByTimePeriodByDeveloperRequest) 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_QueryStatsByTimePeriodByDeveloperRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryStatsByTimePeriodByDeveloperRequest)
+ 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.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)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*QueryStatsByTimePeriodByDeveloperRequest)
+ 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.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 {
+ 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().(*QueryStatsByTimePeriodByDeveloperRequest)
+ 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: QueryStatsByTimePeriodByDeveloperRequest: 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)
+ }
+ 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:])
+ 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 = (*_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_QueryStatsByTimePeriodByDeveloperResponse protoreflect.MessageDescriptor
+ fd_QueryStatsByTimePeriodByDeveloperResponse_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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryStatsByTimePeriodByDeveloperResponse)(nil)
+
+type fastReflection_QueryStatsByTimePeriodByDeveloperResponse QueryStatsByTimePeriodByDeveloperResponse
+
+func (x *QueryStatsByTimePeriodByDeveloperResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryStatsByTimePeriodByDeveloperResponse)(x)
+}
+
+func (x *QueryStatsByTimePeriodByDeveloperResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[81]
+ 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_QueryStatsByTimePeriodByDeveloperResponse_messageType fastReflection_QueryStatsByTimePeriodByDeveloperResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryStatsByTimePeriodByDeveloperResponse_messageType{}
+
+type fastReflection_QueryStatsByTimePeriodByDeveloperResponse_messageType struct{}
+
+func (x fastReflection_QueryStatsByTimePeriodByDeveloperResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryStatsByTimePeriodByDeveloperResponse)(nil)
+}
+func (x fastReflection_QueryStatsByTimePeriodByDeveloperResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryStatsByTimePeriodByDeveloperResponse)
+}
+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_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_QueryStatsByTimePeriodByDeveloperResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryStatsByTimePeriodByDeveloperResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryStatsByTimePeriodByDeveloperResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryStatsByTimePeriodByDeveloperResponse)(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_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
+ }
+ }
+}
+
+// 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_QueryStatsByTimePeriodByDeveloperResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryStatsByTimePeriodByDeveloperResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryStatsByTimePeriodByDeveloperResponse 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_QueryStatsByTimePeriodByDeveloperResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryStatsByTimePeriodByDeveloperResponse.stats":
+ x.Stats = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryStatsByTimePeriodByDeveloperResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryStatsByTimePeriodByDeveloperResponse 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_QueryStatsByTimePeriodByDeveloperResponse) 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{})
+ }
+ 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.QueryStatsByTimePeriodByDeveloperResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryStatsByTimePeriodByDeveloperResponse 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_QueryStatsByTimePeriodByDeveloperResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ 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.QueryStatsByTimePeriodByDeveloperResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryStatsByTimePeriodByDeveloperResponse 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_QueryStatsByTimePeriodByDeveloperResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryStatsByTimePeriodByDeveloperResponse"))
+ }
+ 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_QueryStatsByTimePeriodByDeveloperResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryStatsByTimePeriodByDeveloperResponse"))
+ }
+ 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_QueryStatsByTimePeriodByDeveloperResponse) 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("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_QueryStatsByTimePeriodByDeveloperResponse) 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_QueryStatsByTimePeriodByDeveloperResponse) 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_QueryStatsByTimePeriodByDeveloperResponse) 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_QueryStatsByTimePeriodByDeveloperResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryStatsByTimePeriodByDeveloperResponse)
+ 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.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)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*QueryStatsByTimePeriodByDeveloperResponse)
+ 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.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...)
+ } 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().(*QueryStatsByTimePeriodByDeveloperResponse)
+ 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: QueryStatsByTimePeriodByDeveloperResponse: 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)
+ }
+ 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
+ }
+ 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:])
+ 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_QueryStatsByDeveloperAndEpochBackwardsRequest protoreflect.MessageDescriptor
+ fd_QueryStatsByDeveloperAndEpochBackwardsRequest_developer protoreflect.FieldDescriptor
+ fd_QueryStatsByDeveloperAndEpochBackwardsRequest_epochs_n 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest)(nil)
+
+type fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest QueryStatsByDeveloperAndEpochBackwardsRequest
+
+func (x *QueryStatsByDeveloperAndEpochBackwardsRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest)(x)
+}
+
+func (x *QueryStatsByDeveloperAndEpochBackwardsRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[82]
+ 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_QueryStatsByDeveloperAndEpochBackwardsRequest_messageType fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest_messageType{}
+
+type fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest_messageType struct{}
+
+func (x fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest)(nil)
+}
+func (x fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest)
+}
+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_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_QueryStatsByDeveloperAndEpochBackwardsRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryStatsByDeveloperAndEpochBackwardsRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryStatsByDeveloperAndEpochBackwardsRequest)(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_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.EpochsN != int32(0) {
+ value := protoreflect.ValueOfInt32(x.EpochsN)
+ if !f(fd_QueryStatsByDeveloperAndEpochBackwardsRequest_epochs_n, 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_QueryStatsByDeveloperAndEpochBackwardsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryStatsByDeveloperAndEpochBackwardsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest 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_QueryStatsByDeveloperAndEpochBackwardsRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ 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.QueryStatsByDeveloperAndEpochBackwardsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest 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_QueryStatsByDeveloperAndEpochBackwardsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ 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.QueryStatsByDeveloperAndEpochBackwardsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest 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_QueryStatsByDeveloperAndEpochBackwardsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ 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.QueryStatsByDeveloperAndEpochBackwardsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest 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_QueryStatsByDeveloperAndEpochBackwardsRequest) 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"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest"))
+ }
+ 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_QueryStatsByDeveloperAndEpochBackwardsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryStatsByDeveloperAndEpochBackwardsRequest"))
+ }
+ 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_QueryStatsByDeveloperAndEpochBackwardsRequest) 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("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_QueryStatsByDeveloperAndEpochBackwardsRequest) 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_QueryStatsByDeveloperAndEpochBackwardsRequest) 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_QueryStatsByDeveloperAndEpochBackwardsRequest) 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_QueryStatsByDeveloperAndEpochBackwardsRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryStatsByDeveloperAndEpochBackwardsRequest)
+ 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.Developer)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.EpochsN != 0 {
+ n += 1 + runtime.Sov(uint64(x.EpochsN))
+ }
+ 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().(*QueryStatsByDeveloperAndEpochBackwardsRequest)
+ 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.EpochsN != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochsN))
+ 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 {
+ 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().(*QueryStatsByDeveloperAndEpochBackwardsRequest)
+ 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: QueryStatsByDeveloperAndEpochBackwardsRequest: 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)
+ }
+ 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 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
+ }
+ }
+ 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_QueryInferencesAndTokensStatsByEpochsBackwardsRequest protoreflect.MessageDescriptor
+ fd_QueryInferencesAndTokensStatsByEpochsBackwardsRequest_epochs_n 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest)(nil)
+
+type fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest QueryInferencesAndTokensStatsByEpochsBackwardsRequest
+
+func (x *QueryInferencesAndTokensStatsByEpochsBackwardsRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest)(x)
+}
+
+func (x *QueryInferencesAndTokensStatsByEpochsBackwardsRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[83]
+ 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_QueryInferencesAndTokensStatsByEpochsBackwardsRequest_messageType fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest_messageType{}
+
+type fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest_messageType struct{}
+
+func (x fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest)(nil)
+}
+func (x fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest)
+}
+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_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_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryInferencesAndTokensStatsByEpochsBackwardsRequest)(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_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
+ }
+ }
+}
+
+// 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_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryInferencesAndTokensStatsByEpochsBackwardsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest 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_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ 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.QueryInferencesAndTokensStatsByEpochsBackwardsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest 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_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ 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.QueryInferencesAndTokensStatsByEpochsBackwardsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest 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_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ 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.QueryInferencesAndTokensStatsByEpochsBackwardsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest 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_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) 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"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest"))
+ }
+ 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_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryInferencesAndTokensStatsByEpochsBackwardsRequest"))
+ }
+ 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_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) 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("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_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) 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_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) 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_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) 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_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryInferencesAndTokensStatsByEpochsBackwardsRequest)
+ 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.EpochsN != 0 {
+ n += 1 + runtime.Sov(uint64(x.EpochsN))
+ }
+ 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().(*QueryInferencesAndTokensStatsByEpochsBackwardsRequest)
+ 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.EpochsN != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochsN))
+ 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().(*QueryInferencesAndTokensStatsByEpochsBackwardsRequest)
+ 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: QueryInferencesAndTokensStatsByEpochsBackwardsRequest: 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)
+ }
+ 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)
+ }
+ 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
+ }
+ }
+ 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_QueryInferencesAndTokensStatsByTimePeriodRequest protoreflect.MessageDescriptor
+ fd_QueryInferencesAndTokensStatsByTimePeriodRequest_time_from protoreflect.FieldDescriptor
+ fd_QueryInferencesAndTokensStatsByTimePeriodRequest_time_to 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest)(nil)
+
+type fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest QueryInferencesAndTokensStatsByTimePeriodRequest
+
+func (x *QueryInferencesAndTokensStatsByTimePeriodRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest)(x)
+}
+
+func (x *QueryInferencesAndTokensStatsByTimePeriodRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[84]
+ 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_QueryInferencesAndTokensStatsByTimePeriodRequest_messageType fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest_messageType{}
+
+type fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest_messageType struct{}
+
+func (x fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest)(nil)
+}
+func (x fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest)
+}
+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_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_QueryInferencesAndTokensStatsByTimePeriodRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryInferencesAndTokensStatsByTimePeriodRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryInferencesAndTokensStatsByTimePeriodRequest)(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_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.TimeTo != int64(0) {
+ value := protoreflect.ValueOfInt64(x.TimeTo)
+ if !f(fd_QueryInferencesAndTokensStatsByTimePeriodRequest_time_to, 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_QueryInferencesAndTokensStatsByTimePeriodRequest) 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)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest 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_QueryInferencesAndTokensStatsByTimePeriodRequest) 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)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest 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_QueryInferencesAndTokensStatsByTimePeriodRequest) 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)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest 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_QueryInferencesAndTokensStatsByTimePeriodRequest) 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()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest 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_QueryInferencesAndTokensStatsByTimePeriodRequest) 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"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest"))
+ }
+ 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_QueryInferencesAndTokensStatsByTimePeriodRequest) 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))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest"))
+ }
+ 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_QueryInferencesAndTokensStatsByTimePeriodRequest) 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("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_QueryInferencesAndTokensStatsByTimePeriodRequest) 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_QueryInferencesAndTokensStatsByTimePeriodRequest) 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_QueryInferencesAndTokensStatsByTimePeriodRequest) 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_QueryInferencesAndTokensStatsByTimePeriodRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryInferencesAndTokensStatsByTimePeriodRequest)
+ 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.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)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*QueryInferencesAndTokensStatsByTimePeriodRequest)
+ 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.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...)
+ } 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().(*QueryInferencesAndTokensStatsByTimePeriodRequest)
+ 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: QueryInferencesAndTokensStatsByTimePeriodRequest: 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)
+ }
+ 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:
+ 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:])
+ 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_QueryInferencesAndTokensStatsByModelsRequest protoreflect.MessageDescriptor
+ fd_QueryInferencesAndTokensStatsByModelsRequest_time_from protoreflect.FieldDescriptor
+ fd_QueryInferencesAndTokensStatsByModelsRequest_time_to 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryInferencesAndTokensStatsByModelsRequest)(nil)
+
+type fastReflection_QueryInferencesAndTokensStatsByModelsRequest QueryInferencesAndTokensStatsByModelsRequest
+
+func (x *QueryInferencesAndTokensStatsByModelsRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryInferencesAndTokensStatsByModelsRequest)(x)
+}
+
+func (x *QueryInferencesAndTokensStatsByModelsRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[85]
+ 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_QueryInferencesAndTokensStatsByModelsRequest_messageType fastReflection_QueryInferencesAndTokensStatsByModelsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryInferencesAndTokensStatsByModelsRequest_messageType{}
+
+type fastReflection_QueryInferencesAndTokensStatsByModelsRequest_messageType struct{}
+
+func (x fastReflection_QueryInferencesAndTokensStatsByModelsRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryInferencesAndTokensStatsByModelsRequest)(nil)
+}
+func (x fastReflection_QueryInferencesAndTokensStatsByModelsRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryInferencesAndTokensStatsByModelsRequest)
+}
+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_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_QueryInferencesAndTokensStatsByModelsRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryInferencesAndTokensStatsByModelsRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryInferencesAndTokensStatsByModelsRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryInferencesAndTokensStatsByModelsRequest)(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_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
+ }
+ }
+}
+
+// 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_QueryInferencesAndTokensStatsByModelsRequest) 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)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByModelsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByModelsRequest 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_QueryInferencesAndTokensStatsByModelsRequest) 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)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByModelsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByModelsRequest 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_QueryInferencesAndTokensStatsByModelsRequest) 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)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByModelsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByModelsRequest 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_QueryInferencesAndTokensStatsByModelsRequest) 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()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByModelsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByModelsRequest 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_QueryInferencesAndTokensStatsByModelsRequest) 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"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByModelsRequest"))
+ }
+ 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_QueryInferencesAndTokensStatsByModelsRequest) 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))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByModelsRequest"))
+ }
+ 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_QueryInferencesAndTokensStatsByModelsRequest) 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("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_QueryInferencesAndTokensStatsByModelsRequest) 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_QueryInferencesAndTokensStatsByModelsRequest) 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_QueryInferencesAndTokensStatsByModelsRequest) 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_QueryInferencesAndTokensStatsByModelsRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryInferencesAndTokensStatsByModelsRequest)
+ 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.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)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*QueryInferencesAndTokensStatsByModelsRequest)
+ 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.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...)
+ } 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().(*QueryInferencesAndTokensStatsByModelsRequest)
+ 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: QueryInferencesAndTokensStatsByModelsRequest: 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)
+ }
+ 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:
+ 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:])
+ 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_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_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_ModelStats)(nil)
+
+type fastReflection_ModelStats ModelStats
+
+func (x *ModelStats) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_ModelStats)(x)
+}
+
+func (x *ModelStats) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[86]
+ 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_ModelStats_messageType fastReflection_ModelStats_messageType
+var _ protoreflect.MessageType = fastReflection_ModelStats_messageType{}
+
+type fastReflection_ModelStats_messageType struct{}
+
+func (x fastReflection_ModelStats_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_ModelStats)(nil)
+}
+func (x fastReflection_ModelStats_messageType) New() protoreflect.Message {
+ return new(fastReflection_ModelStats)
+}
+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_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_ModelStats) Type() protoreflect.MessageType {
+ return _fastReflection_ModelStats_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_ModelStats) Interface() protoreflect.ProtoMessage {
+ return (*ModelStats)(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_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) {
+ return
+ }
+ }
+ if x.Inferences != int32(0) {
+ value := protoreflect.ValueOfInt32(x.Inferences)
+ if !f(fd_ModelStats_inferences, 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_ModelStats) 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)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelStats"))
+ }
+ panic(fmt.Errorf("message inference.inference.ModelStats 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_ModelStats) 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)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelStats"))
+ }
+ panic(fmt.Errorf("message inference.inference.ModelStats 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_ModelStats) 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
+ 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("message inference.inference.ModelStats 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_ModelStats) 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())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelStats"))
+ }
+ panic(fmt.Errorf("message inference.inference.ModelStats 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_ModelStats) 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"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelStats"))
+ }
+ 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_ModelStats) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.ModelStats.model":
+ return protoreflect.ValueOfString("")
+ case "inference.inference.ModelStats.ai_tokens":
+ 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("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_ModelStats) 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("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_ModelStats) 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_ModelStats) 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_ModelStats) 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_ModelStats) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*ModelStats)
+ 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.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.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().(*ModelStats)
+ 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.Inferences != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.Inferences))
+ i--
+ dAtA[i] = 0x18
+ }
+ if x.AiTokens != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.AiTokens))
+ 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 {
+ 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().(*ModelStats)
+ 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: ModelStats: 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)
+ }
+ 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)
+ }
+ x.AiTokens = 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.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 Inferences", wireType)
+ }
+ 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
+ }
+ }
+ 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 = (*_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
+)
+
+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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryInferencesAndTokensStatsByModelsResponse)(nil)
+
+type fastReflection_QueryInferencesAndTokensStatsByModelsResponse QueryInferencesAndTokensStatsByModelsResponse
+
+func (x *QueryInferencesAndTokensStatsByModelsResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryInferencesAndTokensStatsByModelsResponse)(x)
+}
+
+func (x *QueryInferencesAndTokensStatsByModelsResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[87]
+ 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_QueryInferencesAndTokensStatsByModelsResponse_messageType fastReflection_QueryInferencesAndTokensStatsByModelsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryInferencesAndTokensStatsByModelsResponse_messageType{}
+
+type fastReflection_QueryInferencesAndTokensStatsByModelsResponse_messageType struct{}
+
+func (x fastReflection_QueryInferencesAndTokensStatsByModelsResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryInferencesAndTokensStatsByModelsResponse)(nil)
+}
+func (x fastReflection_QueryInferencesAndTokensStatsByModelsResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryInferencesAndTokensStatsByModelsResponse)
+}
+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_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_QueryInferencesAndTokensStatsByModelsResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryInferencesAndTokensStatsByModelsResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryInferencesAndTokensStatsByModelsResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryInferencesAndTokensStatsByModelsResponse)(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_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.
+//
+// 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_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.QueryInferencesAndTokensStatsByModelsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByModelsResponse 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_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.QueryInferencesAndTokensStatsByModelsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByModelsResponse 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_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.QueryInferencesAndTokensStatsByModelsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByModelsResponse 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_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.QueryInferencesAndTokensStatsByModelsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByModelsResponse 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_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.QueryInferencesAndTokensStatsByModelsResponse"))
+ }
+ 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_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.QueryInferencesAndTokensStatsByModelsResponse"))
+ }
+ 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_QueryInferencesAndTokensStatsByModelsResponse) 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("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_QueryInferencesAndTokensStatsByModelsResponse) 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_QueryInferencesAndTokensStatsByModelsResponse) 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_QueryInferencesAndTokensStatsByModelsResponse) 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_QueryInferencesAndTokensStatsByModelsResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryInferencesAndTokensStatsByModelsResponse)
+ 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.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)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*QueryInferencesAndTokensStatsByModelsResponse)
+ 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.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 {
+ 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().(*QueryInferencesAndTokensStatsByModelsResponse)
+ 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: QueryInferencesAndTokensStatsByModelsResponse: 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)
+ }
+ 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:])
+ 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_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_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_QueryInferencesAndTokensStatsResponse)(nil)
+
+type fastReflection_QueryInferencesAndTokensStatsResponse QueryInferencesAndTokensStatsResponse
+
+func (x *QueryInferencesAndTokensStatsResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryInferencesAndTokensStatsResponse)(x)
+}
+
+func (x *QueryInferencesAndTokensStatsResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[88]
+ 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_QueryInferencesAndTokensStatsResponse_messageType fastReflection_QueryInferencesAndTokensStatsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryInferencesAndTokensStatsResponse_messageType{}
+
+type fastReflection_QueryInferencesAndTokensStatsResponse_messageType struct{}
+
+func (x fastReflection_QueryInferencesAndTokensStatsResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryInferencesAndTokensStatsResponse)(nil)
+}
+func (x fastReflection_QueryInferencesAndTokensStatsResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryInferencesAndTokensStatsResponse)
+}
+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_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_QueryInferencesAndTokensStatsResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryInferencesAndTokensStatsResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryInferencesAndTokensStatsResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryInferencesAndTokensStatsResponse)(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_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
+ }
+ }
+}
+
+// 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_QueryInferencesAndTokensStatsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryInferencesAndTokensStatsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsResponse 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_QueryInferencesAndTokensStatsResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ 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.QueryInferencesAndTokensStatsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsResponse 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_QueryInferencesAndTokensStatsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ 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.QueryInferencesAndTokensStatsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsResponse 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_QueryInferencesAndTokensStatsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ 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.QueryInferencesAndTokensStatsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsResponse 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_QueryInferencesAndTokensStatsResponse) 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"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsResponse"))
+ }
+ 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_QueryInferencesAndTokensStatsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryInferencesAndTokensStatsResponse"))
+ }
+ 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_QueryInferencesAndTokensStatsResponse) 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("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_QueryInferencesAndTokensStatsResponse) 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_QueryInferencesAndTokensStatsResponse) 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_QueryInferencesAndTokensStatsResponse) 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_QueryInferencesAndTokensStatsResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryInferencesAndTokensStatsResponse)
+ 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.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)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*QueryInferencesAndTokensStatsResponse)
+ 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.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
+ }
+ 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().(*QueryInferencesAndTokensStatsResponse)
+ 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: QueryInferencesAndTokensStatsResponse: 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)
+ }
+ 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)
+ }
+ x.AiTokens = 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.AiTokens |= 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 Inferences", wireType)
+ }
+ 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
+ }
+ }
+ 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 {
+ 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_QueryCountAllParticipantsRequest protoreflect.MessageDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryCountAllParticipantsRequest = File_inference_inference_query_proto.Messages().ByName("QueryCountAllParticipantsRequest")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryCountAllParticipantsRequest)(nil)
+
+type fastReflection_QueryCountAllParticipantsRequest QueryCountAllParticipantsRequest
+
+func (x *QueryCountAllParticipantsRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryCountAllParticipantsRequest)(x)
+}
+
+func (x *QueryCountAllParticipantsRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[89]
+ 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_QueryCountAllParticipantsRequest_messageType fastReflection_QueryCountAllParticipantsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryCountAllParticipantsRequest_messageType{}
+
+type fastReflection_QueryCountAllParticipantsRequest_messageType struct{}
+
+func (x fastReflection_QueryCountAllParticipantsRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryCountAllParticipantsRequest)(nil)
+}
+func (x fastReflection_QueryCountAllParticipantsRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryCountAllParticipantsRequest)
+}
+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_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_QueryCountAllParticipantsRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryCountAllParticipantsRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryCountAllParticipantsRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryCountAllParticipantsRequest)(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_QueryCountAllParticipantsRequest) 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_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.QueryCountAllParticipantsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryCountAllParticipantsRequest 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_QueryCountAllParticipantsRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountAllParticipantsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryCountAllParticipantsRequest 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_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.QueryCountAllParticipantsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryCountAllParticipantsRequest 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_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.QueryCountAllParticipantsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryCountAllParticipantsRequest 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_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.QueryCountAllParticipantsRequest"))
+ }
+ 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_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.QueryCountAllParticipantsRequest"))
+ }
+ 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_QueryCountAllParticipantsRequest) 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("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_QueryCountAllParticipantsRequest) 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_QueryCountAllParticipantsRequest) 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_QueryCountAllParticipantsRequest) 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_QueryCountAllParticipantsRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryCountAllParticipantsRequest)
+ 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().(*QueryCountAllParticipantsRequest)
+ 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().(*QueryCountAllParticipantsRequest)
+ 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: QueryCountAllParticipantsRequest: 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)
+ }
+ 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 (
+ md_QueryCountAllParticipantsResponse protoreflect.MessageDescriptor
+ fd_QueryCountAllParticipantsResponse_total 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryCountAllParticipantsResponse)(nil)
+
+type fastReflection_QueryCountAllParticipantsResponse QueryCountAllParticipantsResponse
+
+func (x *QueryCountAllParticipantsResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryCountAllParticipantsResponse)(x)
+}
+
+func (x *QueryCountAllParticipantsResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[90]
+ 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_QueryCountAllParticipantsResponse_messageType fastReflection_QueryCountAllParticipantsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryCountAllParticipantsResponse_messageType{}
+
+type fastReflection_QueryCountAllParticipantsResponse_messageType struct{}
+
+func (x fastReflection_QueryCountAllParticipantsResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryCountAllParticipantsResponse)(nil)
+}
+func (x fastReflection_QueryCountAllParticipantsResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryCountAllParticipantsResponse)
+}
+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_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_QueryCountAllParticipantsResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryCountAllParticipantsResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryCountAllParticipantsResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryCountAllParticipantsResponse)(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_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
+ }
+ }
+}
+
+// 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_QueryCountAllParticipantsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryCountAllParticipantsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryCountAllParticipantsResponse 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_QueryCountAllParticipantsResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ 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.QueryCountAllParticipantsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryCountAllParticipantsResponse 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_QueryCountAllParticipantsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ 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.QueryCountAllParticipantsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryCountAllParticipantsResponse 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_QueryCountAllParticipantsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ 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.QueryCountAllParticipantsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryCountAllParticipantsResponse 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_QueryCountAllParticipantsResponse) 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"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountAllParticipantsResponse"))
+ }
+ 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_QueryCountAllParticipantsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryCountAllParticipantsResponse"))
+ }
+ 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_QueryCountAllParticipantsResponse) 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("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_QueryCountAllParticipantsResponse) 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_QueryCountAllParticipantsResponse) 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_QueryCountAllParticipantsResponse) 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_QueryCountAllParticipantsResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryCountAllParticipantsResponse)
+ 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.Total != 0 {
+ n += 1 + runtime.Sov(uint64(x.Total))
+ }
+ 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().(*QueryCountAllParticipantsResponse)
+ 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.Total != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.Total))
+ 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().(*QueryCountAllParticipantsResponse)
+ 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: QueryCountAllParticipantsResponse: 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)
+ }
+ 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)
+ }
+ x.Total = 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.Total |= 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_QueryDebugStatsRequest protoreflect.MessageDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryDebugStatsRequest = File_inference_inference_query_proto.Messages().ByName("QueryDebugStatsRequest")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryDebugStatsRequest)(nil)
+
+type fastReflection_QueryDebugStatsRequest QueryDebugStatsRequest
+
+func (x *QueryDebugStatsRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryDebugStatsRequest)(x)
+}
+
+func (x *QueryDebugStatsRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[91]
+ 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_QueryDebugStatsRequest_messageType fastReflection_QueryDebugStatsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryDebugStatsRequest_messageType{}
+
+type fastReflection_QueryDebugStatsRequest_messageType struct{}
+
+func (x fastReflection_QueryDebugStatsRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryDebugStatsRequest)(nil)
+}
+func (x fastReflection_QueryDebugStatsRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryDebugStatsRequest)
+}
+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_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_QueryDebugStatsRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryDebugStatsRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryDebugStatsRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryDebugStatsRequest)(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_QueryDebugStatsRequest) 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_QueryDebugStatsRequest) 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("message inference.inference.QueryDebugStatsRequest 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_QueryDebugStatsRequest) 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("message inference.inference.QueryDebugStatsRequest 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_QueryDebugStatsRequest) 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("message inference.inference.QueryDebugStatsRequest 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_QueryDebugStatsRequest) 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("message inference.inference.QueryDebugStatsRequest 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_QueryDebugStatsRequest) 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("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_QueryDebugStatsRequest) 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("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_QueryDebugStatsRequest) 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("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_QueryDebugStatsRequest) 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_QueryDebugStatsRequest) 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_QueryDebugStatsRequest) 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_QueryDebugStatsRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryDebugStatsRequest)
+ 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().(*QueryDebugStatsRequest)
+ 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().(*QueryDebugStatsRequest)
+ 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: QueryDebugStatsRequest: 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)
+ }
+ 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 = (*_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
+)
+
+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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryDebugStatsResponse)(nil)
+
+type fastReflection_QueryDebugStatsResponse QueryDebugStatsResponse
+
+func (x *QueryDebugStatsResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryDebugStatsResponse)(x)
+}
+
+func (x *QueryDebugStatsResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[92]
+ 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_QueryDebugStatsResponse_messageType fastReflection_QueryDebugStatsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryDebugStatsResponse_messageType{}
+
+type fastReflection_QueryDebugStatsResponse_messageType struct{}
+
+func (x fastReflection_QueryDebugStatsResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryDebugStatsResponse)(nil)
+}
+func (x fastReflection_QueryDebugStatsResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryDebugStatsResponse)
+}
+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) 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) Type() protoreflect.MessageType {
+ return _fastReflection_QueryDebugStatsResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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) Interface() protoreflect.ProtoMessage {
+ return (*QueryDebugStatsResponse)(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_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) {
+ 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_QueryDebugStatsResponse) 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
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse 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_QueryDebugStatsResponse) 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
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse 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_QueryDebugStatsResponse) 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)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse 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_QueryDebugStatsResponse) 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
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse 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_QueryDebugStatsResponse) 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)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse"))
+ }
+ 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) 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})
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse"))
+ }
+ 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) 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("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_QueryDebugStatsResponse) 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_QueryDebugStatsResponse) 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_QueryDebugStatsResponse) 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_QueryDebugStatsResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryDebugStatsResponse)
+ 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.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.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().(*QueryDebugStatsResponse)
+ 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.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 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().(*QueryDebugStatsResponse)
+ 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: QueryDebugStatsResponse: 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)
+ }
+ 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)
+ }
+ 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.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]...)
+ }
+ 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 = (*_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
+)
+
+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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryDebugStatsResponse_TemporaryTimeStat)(nil)
+
+type fastReflection_QueryDebugStatsResponse_TemporaryTimeStat QueryDebugStatsResponse_TemporaryTimeStat
+
+func (x *QueryDebugStatsResponse_TemporaryTimeStat) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryDebugStatsResponse_TemporaryTimeStat)(x)
+}
+
+func (x *QueryDebugStatsResponse_TemporaryTimeStat) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[151]
+ 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_QueryDebugStatsResponse_TemporaryTimeStat_messageType fastReflection_QueryDebugStatsResponse_TemporaryTimeStat_messageType
+var _ protoreflect.MessageType = fastReflection_QueryDebugStatsResponse_TemporaryTimeStat_messageType{}
+
+type fastReflection_QueryDebugStatsResponse_TemporaryTimeStat_messageType struct{}
+
+func (x fastReflection_QueryDebugStatsResponse_TemporaryTimeStat_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryDebugStatsResponse_TemporaryTimeStat)(nil)
+}
+func (x fastReflection_QueryDebugStatsResponse_TemporaryTimeStat_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryDebugStatsResponse_TemporaryTimeStat)
+}
+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_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_QueryDebugStatsResponse_TemporaryTimeStat) Type() protoreflect.MessageType {
+ return _fastReflection_QueryDebugStatsResponse_TemporaryTimeStat_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryDebugStatsResponse_TemporaryTimeStat) Interface() protoreflect.ProtoMessage {
+ return (*QueryDebugStatsResponse_TemporaryTimeStat)(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_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.
+//
+// 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_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.QueryDebugStatsResponse.TemporaryTimeStat"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse.TemporaryTimeStat 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_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.QueryDebugStatsResponse.TemporaryTimeStat"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse.TemporaryTimeStat 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_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.QueryDebugStatsResponse.TemporaryTimeStat"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse.TemporaryTimeStat 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_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.QueryDebugStatsResponse.TemporaryTimeStat"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse.TemporaryTimeStat 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_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.QueryDebugStatsResponse.TemporaryTimeStat"))
+ }
+ 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_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.QueryDebugStatsResponse.TemporaryTimeStat"))
+ }
+ 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_QueryDebugStatsResponse_TemporaryTimeStat) 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("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_QueryDebugStatsResponse_TemporaryTimeStat) 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_QueryDebugStatsResponse_TemporaryTimeStat) 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_QueryDebugStatsResponse_TemporaryTimeStat) 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_QueryDebugStatsResponse_TemporaryTimeStat) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryDebugStatsResponse_TemporaryTimeStat)
+ 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.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)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*QueryDebugStatsResponse_TemporaryTimeStat)
+ 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.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 {
+ 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().(*QueryDebugStatsResponse_TemporaryTimeStat)
+ 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: QueryDebugStatsResponse_TemporaryTimeStat: 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)
+ }
+ 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:])
+ 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 = (*_QueryDebugStatsResponse_TemporaryEpochStat_2_list)(nil)
+
+type _QueryDebugStatsResponse_TemporaryEpochStat_2_list struct {
+ list *[]*DeveloperStatsByEpoch
+}
+
+func (x *_QueryDebugStatsResponse_TemporaryEpochStat_2_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_QueryDebugStatsResponse_TemporaryEpochStat_2_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) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*DeveloperStatsByEpoch)
+ (*x.list)[i] = concreteValue
+}
+
+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[152]
+ 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_QueryDebugStatsResponse_TemporaryEpochStat_messageType fastReflection_QueryDebugStatsResponse_TemporaryEpochStat_messageType
+var _ protoreflect.MessageType = fastReflection_QueryDebugStatsResponse_TemporaryEpochStat_messageType{}
+
+type fastReflection_QueryDebugStatsResponse_TemporaryEpochStat_messageType struct{}
+
+func (x fastReflection_QueryDebugStatsResponse_TemporaryEpochStat_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryDebugStatsResponse_TemporaryEpochStat)(nil)
+}
+func (x fastReflection_QueryDebugStatsResponse_TemporaryEpochStat_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryDebugStatsResponse_TemporaryEpochStat)
+}
+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_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_QueryDebugStatsResponse_TemporaryEpochStat) Type() protoreflect.MessageType {
+ return _fastReflection_QueryDebugStatsResponse_TemporaryEpochStat_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryDebugStatsResponse_TemporaryEpochStat) Interface() protoreflect.ProtoMessage {
+ return (*QueryDebugStatsResponse_TemporaryEpochStat)(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_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 len(x.Stats) != 0 {
+ value := protoreflect.ValueOfList(&_QueryDebugStatsResponse_TemporaryEpochStat_2_list{list: &x.Stats})
+ if !f(fd_QueryDebugStatsResponse_TemporaryEpochStat_stats, 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_QueryDebugStatsResponse_TemporaryEpochStat) 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
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse.TemporaryEpochStat"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse.TemporaryEpochStat 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_QueryDebugStatsResponse_TemporaryEpochStat) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ 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.QueryDebugStatsResponse.TemporaryEpochStat"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse.TemporaryEpochStat 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_QueryDebugStatsResponse_TemporaryEpochStat) 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{})
+ }
+ 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.QueryDebugStatsResponse.TemporaryEpochStat"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse.TemporaryEpochStat 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_QueryDebugStatsResponse_TemporaryEpochStat) 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":
+ 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.QueryDebugStatsResponse.TemporaryEpochStat"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse.TemporaryEpochStat 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_QueryDebugStatsResponse_TemporaryEpochStat) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryDebugStatsResponse.TemporaryEpochStat"))
+ }
+ 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_QueryDebugStatsResponse_TemporaryEpochStat) 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})
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse.TemporaryEpochStat"))
+ }
+ 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_QueryDebugStatsResponse_TemporaryEpochStat) 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("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_QueryDebugStatsResponse_TemporaryEpochStat) 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_QueryDebugStatsResponse_TemporaryEpochStat) 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_QueryDebugStatsResponse_TemporaryEpochStat) 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_QueryDebugStatsResponse_TemporaryEpochStat) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryDebugStatsResponse_TemporaryEpochStat)
+ 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.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)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*QueryDebugStatsResponse_TemporaryEpochStat)
+ 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.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 {
+ 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().(*QueryDebugStatsResponse_TemporaryEpochStat)
+ 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: QueryDebugStatsResponse_TemporaryEpochStat: 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)
+ }
+ 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, &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:])
+ 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_QueryGetMinimumValidationAverageRequest protoreflect.MessageDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryGetMinimumValidationAverageRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetMinimumValidationAverageRequest")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetMinimumValidationAverageRequest)(nil)
+
+type fastReflection_QueryGetMinimumValidationAverageRequest QueryGetMinimumValidationAverageRequest
+
+func (x *QueryGetMinimumValidationAverageRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetMinimumValidationAverageRequest)(x)
+}
+
+func (x *QueryGetMinimumValidationAverageRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[93]
+ 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_QueryGetMinimumValidationAverageRequest_messageType fastReflection_QueryGetMinimumValidationAverageRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetMinimumValidationAverageRequest_messageType{}
+
+type fastReflection_QueryGetMinimumValidationAverageRequest_messageType struct{}
+
+func (x fastReflection_QueryGetMinimumValidationAverageRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetMinimumValidationAverageRequest)(nil)
+}
+func (x fastReflection_QueryGetMinimumValidationAverageRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetMinimumValidationAverageRequest)
+}
+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_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_QueryGetMinimumValidationAverageRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetMinimumValidationAverageRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryGetMinimumValidationAverageRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetMinimumValidationAverageRequest)(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_QueryGetMinimumValidationAverageRequest) 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_QueryGetMinimumValidationAverageRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMinimumValidationAverageRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetMinimumValidationAverageRequest 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_QueryGetMinimumValidationAverageRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMinimumValidationAverageRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetMinimumValidationAverageRequest 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_QueryGetMinimumValidationAverageRequest) 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.QueryGetMinimumValidationAverageRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetMinimumValidationAverageRequest 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_QueryGetMinimumValidationAverageRequest) 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.QueryGetMinimumValidationAverageRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetMinimumValidationAverageRequest 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_QueryGetMinimumValidationAverageRequest) 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.QueryGetMinimumValidationAverageRequest"))
+ }
+ 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_QueryGetMinimumValidationAverageRequest) 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.QueryGetMinimumValidationAverageRequest"))
+ }
+ 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_QueryGetMinimumValidationAverageRequest) 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("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_QueryGetMinimumValidationAverageRequest) 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_QueryGetMinimumValidationAverageRequest) 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_QueryGetMinimumValidationAverageRequest) 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_QueryGetMinimumValidationAverageRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetMinimumValidationAverageRequest)
+ 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().(*QueryGetMinimumValidationAverageRequest)
+ 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().(*QueryGetMinimumValidationAverageRequest)
+ 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: QueryGetMinimumValidationAverageRequest: 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)
+ }
+ 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 (
+ 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_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_QueryGetMinimumValidationAverageResponse)(nil)
+
+type fastReflection_QueryGetMinimumValidationAverageResponse QueryGetMinimumValidationAverageResponse
+
+func (x *QueryGetMinimumValidationAverageResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetMinimumValidationAverageResponse)(x)
+}
+
+func (x *QueryGetMinimumValidationAverageResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[94]
+ 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_QueryGetMinimumValidationAverageResponse_messageType fastReflection_QueryGetMinimumValidationAverageResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetMinimumValidationAverageResponse_messageType{}
+
+type fastReflection_QueryGetMinimumValidationAverageResponse_messageType struct{}
+
+func (x fastReflection_QueryGetMinimumValidationAverageResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetMinimumValidationAverageResponse)(nil)
+}
+func (x fastReflection_QueryGetMinimumValidationAverageResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetMinimumValidationAverageResponse)
+}
+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_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_QueryGetMinimumValidationAverageResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetMinimumValidationAverageResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryGetMinimumValidationAverageResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetMinimumValidationAverageResponse)(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_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
+ }
+ }
+}
+
+// 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_QueryGetMinimumValidationAverageResponse) 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)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMinimumValidationAverageResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetMinimumValidationAverageResponse 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_QueryGetMinimumValidationAverageResponse) 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)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMinimumValidationAverageResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetMinimumValidationAverageResponse 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_QueryGetMinimumValidationAverageResponse) 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
+ 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.QueryGetMinimumValidationAverageResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetMinimumValidationAverageResponse 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_QueryGetMinimumValidationAverageResponse) 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()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMinimumValidationAverageResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetMinimumValidationAverageResponse 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_QueryGetMinimumValidationAverageResponse) 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"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMinimumValidationAverageResponse"))
+ }
+ 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_QueryGetMinimumValidationAverageResponse) 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":
+ 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.QueryGetMinimumValidationAverageResponse"))
+ }
+ 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_QueryGetMinimumValidationAverageResponse) 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("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_QueryGetMinimumValidationAverageResponse) 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_QueryGetMinimumValidationAverageResponse) 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_QueryGetMinimumValidationAverageResponse) 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_QueryGetMinimumValidationAverageResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetMinimumValidationAverageResponse)
+ 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.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)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*QueryGetMinimumValidationAverageResponse)
+ 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.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 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...)
+ } 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().(*QueryGetMinimumValidationAverageResponse)
+ 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: QueryGetMinimumValidationAverageResponse: 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)
+ }
+ 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)
+ }
+ 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.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)
+ }
+ 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
+ }
+ }
+ 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_QueryInProgressTrainingTasksRequest protoreflect.MessageDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryInProgressTrainingTasksRequest = File_inference_inference_query_proto.Messages().ByName("QueryInProgressTrainingTasksRequest")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryInProgressTrainingTasksRequest)(nil)
+
+type fastReflection_QueryInProgressTrainingTasksRequest QueryInProgressTrainingTasksRequest
+
+func (x *QueryInProgressTrainingTasksRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryInProgressTrainingTasksRequest)(x)
+}
+
+func (x *QueryInProgressTrainingTasksRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[95]
+ 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_QueryInProgressTrainingTasksRequest_messageType fastReflection_QueryInProgressTrainingTasksRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryInProgressTrainingTasksRequest_messageType{}
+
+type fastReflection_QueryInProgressTrainingTasksRequest_messageType struct{}
+
+func (x fastReflection_QueryInProgressTrainingTasksRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryInProgressTrainingTasksRequest)(nil)
+}
+func (x fastReflection_QueryInProgressTrainingTasksRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryInProgressTrainingTasksRequest)
+}
+func (x fastReflection_QueryInProgressTrainingTasksRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryInProgressTrainingTasksRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryInProgressTrainingTasksRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryInProgressTrainingTasksRequest
+}
+
+// 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_QueryInProgressTrainingTasksRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryInProgressTrainingTasksRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryInProgressTrainingTasksRequest) New() protoreflect.Message {
+ return new(fastReflection_QueryInProgressTrainingTasksRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryInProgressTrainingTasksRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryInProgressTrainingTasksRequest)(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_QueryInProgressTrainingTasksRequest) 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_QueryInProgressTrainingTasksRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInProgressTrainingTasksRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInProgressTrainingTasksRequest 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_QueryInProgressTrainingTasksRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInProgressTrainingTasksRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInProgressTrainingTasksRequest 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_QueryInProgressTrainingTasksRequest) 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.QueryInProgressTrainingTasksRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInProgressTrainingTasksRequest 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_QueryInProgressTrainingTasksRequest) 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.QueryInProgressTrainingTasksRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInProgressTrainingTasksRequest 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_QueryInProgressTrainingTasksRequest) 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.QueryInProgressTrainingTasksRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInProgressTrainingTasksRequest 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_QueryInProgressTrainingTasksRequest) 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.QueryInProgressTrainingTasksRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInProgressTrainingTasksRequest 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_QueryInProgressTrainingTasksRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryInProgressTrainingTasksRequest", 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_QueryInProgressTrainingTasksRequest) 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_QueryInProgressTrainingTasksRequest) 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_QueryInProgressTrainingTasksRequest) 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_QueryInProgressTrainingTasksRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryInProgressTrainingTasksRequest)
+ 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().(*QueryInProgressTrainingTasksRequest)
+ 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().(*QueryInProgressTrainingTasksRequest)
+ 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: QueryInProgressTrainingTasksRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryInProgressTrainingTasksRequest: 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 = (*_QueryInProgressTrainingTasksResponse_1_list)(nil)
+
+type _QueryInProgressTrainingTasksResponse_1_list struct {
+ list *[]*TrainingTask
+}
+
+func (x *_QueryInProgressTrainingTasksResponse_1_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_QueryInProgressTrainingTasksResponse_1_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryInProgressTrainingTasksResponse_1_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*TrainingTask)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_QueryInProgressTrainingTasksResponse_1_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*TrainingTask)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryInProgressTrainingTasksResponse_1_list) AppendMutable() protoreflect.Value {
+ v := new(TrainingTask)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryInProgressTrainingTasksResponse_1_list) Truncate(n int) {
+ for i := n; i < len(*x.list); i++ {
+ (*x.list)[i] = nil
+ }
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_QueryInProgressTrainingTasksResponse_1_list) NewElement() protoreflect.Value {
+ v := new(TrainingTask)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryInProgressTrainingTasksResponse_1_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_QueryInProgressTrainingTasksResponse protoreflect.MessageDescriptor
+ fd_QueryInProgressTrainingTasksResponse_tasks protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryInProgressTrainingTasksResponse = File_inference_inference_query_proto.Messages().ByName("QueryInProgressTrainingTasksResponse")
+ fd_QueryInProgressTrainingTasksResponse_tasks = md_QueryInProgressTrainingTasksResponse.Fields().ByName("tasks")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryInProgressTrainingTasksResponse)(nil)
+
+type fastReflection_QueryInProgressTrainingTasksResponse QueryInProgressTrainingTasksResponse
+
+func (x *QueryInProgressTrainingTasksResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryInProgressTrainingTasksResponse)(x)
+}
+
+func (x *QueryInProgressTrainingTasksResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[96]
+ 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_QueryInProgressTrainingTasksResponse_messageType fastReflection_QueryInProgressTrainingTasksResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryInProgressTrainingTasksResponse_messageType{}
+
+type fastReflection_QueryInProgressTrainingTasksResponse_messageType struct{}
+
+func (x fastReflection_QueryInProgressTrainingTasksResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryInProgressTrainingTasksResponse)(nil)
+}
+func (x fastReflection_QueryInProgressTrainingTasksResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryInProgressTrainingTasksResponse)
+}
+func (x fastReflection_QueryInProgressTrainingTasksResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryInProgressTrainingTasksResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryInProgressTrainingTasksResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryInProgressTrainingTasksResponse
+}
+
+// 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_QueryInProgressTrainingTasksResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryInProgressTrainingTasksResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryInProgressTrainingTasksResponse) New() protoreflect.Message {
+ return new(fastReflection_QueryInProgressTrainingTasksResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryInProgressTrainingTasksResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryInProgressTrainingTasksResponse)(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_QueryInProgressTrainingTasksResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if len(x.Tasks) != 0 {
+ value := protoreflect.ValueOfList(&_QueryInProgressTrainingTasksResponse_1_list{list: &x.Tasks})
+ if !f(fd_QueryInProgressTrainingTasksResponse_tasks, 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_QueryInProgressTrainingTasksResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryInProgressTrainingTasksResponse.tasks":
+ return len(x.Tasks) != 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInProgressTrainingTasksResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInProgressTrainingTasksResponse 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_QueryInProgressTrainingTasksResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryInProgressTrainingTasksResponse.tasks":
+ x.Tasks = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInProgressTrainingTasksResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInProgressTrainingTasksResponse 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_QueryInProgressTrainingTasksResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryInProgressTrainingTasksResponse.tasks":
+ if len(x.Tasks) == 0 {
+ return protoreflect.ValueOfList(&_QueryInProgressTrainingTasksResponse_1_list{})
+ }
+ listValue := &_QueryInProgressTrainingTasksResponse_1_list{list: &x.Tasks}
+ return protoreflect.ValueOfList(listValue)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInProgressTrainingTasksResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInProgressTrainingTasksResponse 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_QueryInProgressTrainingTasksResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryInProgressTrainingTasksResponse.tasks":
+ lv := value.List()
+ clv := lv.(*_QueryInProgressTrainingTasksResponse_1_list)
+ x.Tasks = *clv.list
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInProgressTrainingTasksResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInProgressTrainingTasksResponse 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_QueryInProgressTrainingTasksResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryInProgressTrainingTasksResponse.tasks":
+ if x.Tasks == nil {
+ x.Tasks = []*TrainingTask{}
+ }
+ value := &_QueryInProgressTrainingTasksResponse_1_list{list: &x.Tasks}
+ return protoreflect.ValueOfList(value)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInProgressTrainingTasksResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInProgressTrainingTasksResponse 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_QueryInProgressTrainingTasksResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryInProgressTrainingTasksResponse.tasks":
+ list := []*TrainingTask{}
+ return protoreflect.ValueOfList(&_QueryInProgressTrainingTasksResponse_1_list{list: &list})
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInProgressTrainingTasksResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryInProgressTrainingTasksResponse 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_QueryInProgressTrainingTasksResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryInProgressTrainingTasksResponse", 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_QueryInProgressTrainingTasksResponse) 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_QueryInProgressTrainingTasksResponse) 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_QueryInProgressTrainingTasksResponse) 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_QueryInProgressTrainingTasksResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryInProgressTrainingTasksResponse)
+ 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.Tasks) > 0 {
+ for _, e := range x.Tasks {
+ 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().(*QueryInProgressTrainingTasksResponse)
+ 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.Tasks) > 0 {
+ for iNdEx := len(x.Tasks) - 1; iNdEx >= 0; iNdEx-- {
+ encoded, err := options.Marshal(x.Tasks[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().(*QueryInProgressTrainingTasksResponse)
+ 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: QueryInProgressTrainingTasksResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryInProgressTrainingTasksResponse: 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 Tasks", 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.Tasks = append(x.Tasks, &TrainingTask{})
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Tasks[len(x.Tasks)-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_QueryGetPartialUpgradeRequest protoreflect.MessageDescriptor
+ fd_QueryGetPartialUpgradeRequest_height protoreflect.FieldDescriptor
+)
+
+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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetPartialUpgradeRequest)(nil)
+
+type fastReflection_QueryGetPartialUpgradeRequest QueryGetPartialUpgradeRequest
+
+func (x *QueryGetPartialUpgradeRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetPartialUpgradeRequest)(x)
+}
+
+func (x *QueryGetPartialUpgradeRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[97]
+ 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_QueryGetPartialUpgradeRequest_messageType fastReflection_QueryGetPartialUpgradeRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetPartialUpgradeRequest_messageType{}
+
+type fastReflection_QueryGetPartialUpgradeRequest_messageType struct{}
+
+func (x fastReflection_QueryGetPartialUpgradeRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetPartialUpgradeRequest)(nil)
+}
+func (x fastReflection_QueryGetPartialUpgradeRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetPartialUpgradeRequest)
+}
+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_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_QueryGetPartialUpgradeRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetPartialUpgradeRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryGetPartialUpgradeRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetPartialUpgradeRequest)(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_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
+ }
+ }
+}
+
+// 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_QueryGetPartialUpgradeRequest) 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("message inference.inference.QueryGetPartialUpgradeRequest 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_QueryGetPartialUpgradeRequest) 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("message inference.inference.QueryGetPartialUpgradeRequest 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_QueryGetPartialUpgradeRequest) 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("message inference.inference.QueryGetPartialUpgradeRequest 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_QueryGetPartialUpgradeRequest) 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("message inference.inference.QueryGetPartialUpgradeRequest 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_QueryGetPartialUpgradeRequest) 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("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_QueryGetPartialUpgradeRequest) 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("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_QueryGetPartialUpgradeRequest) 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("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_QueryGetPartialUpgradeRequest) 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_QueryGetPartialUpgradeRequest) 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_QueryGetPartialUpgradeRequest) 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_QueryGetPartialUpgradeRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetPartialUpgradeRequest)
+ 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().(*QueryGetPartialUpgradeRequest)
+ 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().(*QueryGetPartialUpgradeRequest)
+ 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: QueryGetPartialUpgradeRequest: 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)
+ }
+ 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:])
+ 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_QueryGetPartialUpgradeResponse protoreflect.MessageDescriptor
+ fd_QueryGetPartialUpgradeResponse_partialUpgrade 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetPartialUpgradeResponse)(nil)
+
+type fastReflection_QueryGetPartialUpgradeResponse QueryGetPartialUpgradeResponse
+
+func (x *QueryGetPartialUpgradeResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetPartialUpgradeResponse)(x)
+}
+
+func (x *QueryGetPartialUpgradeResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[98]
+ 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_QueryGetPartialUpgradeResponse_messageType fastReflection_QueryGetPartialUpgradeResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetPartialUpgradeResponse_messageType{}
+
+type fastReflection_QueryGetPartialUpgradeResponse_messageType struct{}
+
+func (x fastReflection_QueryGetPartialUpgradeResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetPartialUpgradeResponse)(nil)
+}
+func (x fastReflection_QueryGetPartialUpgradeResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetPartialUpgradeResponse)
+}
+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_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_QueryGetPartialUpgradeResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetPartialUpgradeResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryGetPartialUpgradeResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetPartialUpgradeResponse)(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_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
+ }
+ }
+}
+
+// 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_QueryGetPartialUpgradeResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryGetPartialUpgradeResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetPartialUpgradeResponse 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_QueryGetPartialUpgradeResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetPartialUpgradeResponse.partialUpgrade":
+ x.PartialUpgrade = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetPartialUpgradeResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetPartialUpgradeResponse 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_QueryGetPartialUpgradeResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ 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.QueryGetPartialUpgradeResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetPartialUpgradeResponse 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_QueryGetPartialUpgradeResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ 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.QueryGetPartialUpgradeResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetPartialUpgradeResponse 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_QueryGetPartialUpgradeResponse) 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())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetPartialUpgradeResponse"))
+ }
+ 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_QueryGetPartialUpgradeResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryGetPartialUpgradeResponse"))
+ }
+ 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_QueryGetPartialUpgradeResponse) 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("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_QueryGetPartialUpgradeResponse) 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_QueryGetPartialUpgradeResponse) 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_QueryGetPartialUpgradeResponse) 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_QueryGetPartialUpgradeResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetPartialUpgradeResponse)
+ 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.PartialUpgrade != nil {
+ l = options.Size(x.PartialUpgrade)
+ 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().(*QueryGetPartialUpgradeResponse)
+ 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.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)))
+ 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().(*QueryGetPartialUpgradeResponse)
+ 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: QueryGetPartialUpgradeResponse: 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)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ 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 {
+ if shift >= 64 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.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.PartialUpgrade == nil {
+ x.PartialUpgrade = &PartialUpgrade{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.PartialUpgrade); 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_QueryAllPartialUpgradeRequest protoreflect.MessageDescriptor
+ fd_QueryAllPartialUpgradeRequest_pagination 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryAllPartialUpgradeRequest)(nil)
+
+type fastReflection_QueryAllPartialUpgradeRequest QueryAllPartialUpgradeRequest
+
+func (x *QueryAllPartialUpgradeRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryAllPartialUpgradeRequest)(x)
+}
+
+func (x *QueryAllPartialUpgradeRequest) 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 {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryAllPartialUpgradeRequest_messageType fastReflection_QueryAllPartialUpgradeRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllPartialUpgradeRequest_messageType{}
+
+type fastReflection_QueryAllPartialUpgradeRequest_messageType struct{}
+
+func (x fastReflection_QueryAllPartialUpgradeRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryAllPartialUpgradeRequest)(nil)
+}
+func (x fastReflection_QueryAllPartialUpgradeRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryAllPartialUpgradeRequest)
+}
+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_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_QueryAllPartialUpgradeRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryAllPartialUpgradeRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryAllPartialUpgradeRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryAllPartialUpgradeRequest)(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_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
+ }
+ }
+}
+
+// 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_QueryAllPartialUpgradeRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryAllPartialUpgradeRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllPartialUpgradeRequest 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_QueryAllPartialUpgradeRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllPartialUpgradeRequest.pagination":
+ x.Pagination = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPartialUpgradeRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllPartialUpgradeRequest 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_QueryAllPartialUpgradeRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ 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.QueryAllPartialUpgradeRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllPartialUpgradeRequest 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_QueryAllPartialUpgradeRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ 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.QueryAllPartialUpgradeRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllPartialUpgradeRequest 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_QueryAllPartialUpgradeRequest) 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())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPartialUpgradeRequest"))
+ }
+ 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_QueryAllPartialUpgradeRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryAllPartialUpgradeRequest"))
+ }
+ 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_QueryAllPartialUpgradeRequest) 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("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_QueryAllPartialUpgradeRequest) 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_QueryAllPartialUpgradeRequest) 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_QueryAllPartialUpgradeRequest) 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_QueryAllPartialUpgradeRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryAllPartialUpgradeRequest)
+ 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.Pagination != nil {
+ l = options.Size(x.Pagination)
+ 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().(*QueryAllPartialUpgradeRequest)
+ 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.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 {
+ 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().(*QueryAllPartialUpgradeRequest)
+ 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: QueryAllPartialUpgradeRequest: 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)
+ }
+ 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:])
+ 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 = (*_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)
+}
+
+func (x *_QueryAllPartialUpgradeResponse_1_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryAllPartialUpgradeResponse_1_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*PartialUpgrade)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_QueryAllPartialUpgradeResponse_1_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*PartialUpgrade)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryAllPartialUpgradeResponse_1_list) AppendMutable() protoreflect.Value {
+ v := new(PartialUpgrade)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+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 *_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[100]
+ 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{}
+
+type fastReflection_QueryAllPartialUpgradeResponse_messageType struct{}
+
+func (x fastReflection_QueryAllPartialUpgradeResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryAllPartialUpgradeResponse)(nil)
+}
+func (x fastReflection_QueryAllPartialUpgradeResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryAllPartialUpgradeResponse)
+}
+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_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_QueryAllPartialUpgradeResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryAllPartialUpgradeResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryAllPartialUpgradeResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryAllPartialUpgradeResponse)(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_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
+ }
+ }
+}
+
+// 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_QueryAllPartialUpgradeResponse) 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
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPartialUpgradeResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllPartialUpgradeResponse 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_QueryAllPartialUpgradeResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ 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.QueryAllPartialUpgradeResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllPartialUpgradeResponse 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_QueryAllPartialUpgradeResponse) 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
+ 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("message inference.inference.QueryAllPartialUpgradeResponse 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_QueryAllPartialUpgradeResponse) 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)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPartialUpgradeResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllPartialUpgradeResponse 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_QueryAllPartialUpgradeResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllPartialUpgradeResponse.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)
+ }
+ return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPartialUpgradeResponse"))
+ }
+ 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_QueryAllPartialUpgradeResponse) 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)
+ 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("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_QueryAllPartialUpgradeResponse) 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("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_QueryAllPartialUpgradeResponse) 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_QueryAllPartialUpgradeResponse) 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_QueryAllPartialUpgradeResponse) 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_QueryAllPartialUpgradeResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryAllPartialUpgradeResponse)
+ 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.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)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*QueryAllPartialUpgradeResponse)
+ 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.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,
+ 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().(*QueryAllPartialUpgradeResponse)
+ 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: QueryAllPartialUpgradeResponse: 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)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ 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 {
+ if shift >= 64 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.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.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
+ 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_QueryTrainingKvRecordRequest protoreflect.MessageDescriptor
+ fd_QueryTrainingKvRecordRequest_taskId protoreflect.FieldDescriptor
+ fd_QueryTrainingKvRecordRequest_key protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryTrainingKvRecordRequest = File_inference_inference_query_proto.Messages().ByName("QueryTrainingKvRecordRequest")
+ fd_QueryTrainingKvRecordRequest_taskId = md_QueryTrainingKvRecordRequest.Fields().ByName("taskId")
+ fd_QueryTrainingKvRecordRequest_key = md_QueryTrainingKvRecordRequest.Fields().ByName("key")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryTrainingKvRecordRequest)(nil)
+
+type fastReflection_QueryTrainingKvRecordRequest QueryTrainingKvRecordRequest
+
+func (x *QueryTrainingKvRecordRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryTrainingKvRecordRequest)(x)
+}
+
+func (x *QueryTrainingKvRecordRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[101]
+ 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_QueryTrainingKvRecordRequest_messageType fastReflection_QueryTrainingKvRecordRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryTrainingKvRecordRequest_messageType{}
+
+type fastReflection_QueryTrainingKvRecordRequest_messageType struct{}
+
+func (x fastReflection_QueryTrainingKvRecordRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryTrainingKvRecordRequest)(nil)
+}
+func (x fastReflection_QueryTrainingKvRecordRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryTrainingKvRecordRequest)
+}
+func (x fastReflection_QueryTrainingKvRecordRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryTrainingKvRecordRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryTrainingKvRecordRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryTrainingKvRecordRequest
+}
+
+// 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_QueryTrainingKvRecordRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryTrainingKvRecordRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryTrainingKvRecordRequest) New() protoreflect.Message {
+ return new(fastReflection_QueryTrainingKvRecordRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryTrainingKvRecordRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryTrainingKvRecordRequest)(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_QueryTrainingKvRecordRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.TaskId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.TaskId)
+ if !f(fd_QueryTrainingKvRecordRequest_taskId, value) {
+ return
+ }
+ }
+ if x.Key != "" {
+ value := protoreflect.ValueOfString(x.Key)
+ if !f(fd_QueryTrainingKvRecordRequest_key, 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_QueryTrainingKvRecordRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingKvRecordRequest.taskId":
+ return x.TaskId != uint64(0)
+ case "inference.inference.QueryTrainingKvRecordRequest.key":
+ return x.Key != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingKvRecordRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingKvRecordRequest 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_QueryTrainingKvRecordRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingKvRecordRequest.taskId":
+ x.TaskId = uint64(0)
+ case "inference.inference.QueryTrainingKvRecordRequest.key":
+ x.Key = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingKvRecordRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingKvRecordRequest 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_QueryTrainingKvRecordRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryTrainingKvRecordRequest.taskId":
+ value := x.TaskId
+ return protoreflect.ValueOfUint64(value)
+ case "inference.inference.QueryTrainingKvRecordRequest.key":
+ value := x.Key
+ return protoreflect.ValueOfString(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingKvRecordRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingKvRecordRequest 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_QueryTrainingKvRecordRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingKvRecordRequest.taskId":
+ x.TaskId = value.Uint()
+ case "inference.inference.QueryTrainingKvRecordRequest.key":
+ x.Key = value.Interface().(string)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingKvRecordRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingKvRecordRequest 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_QueryTrainingKvRecordRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingKvRecordRequest.taskId":
+ panic(fmt.Errorf("field taskId of message inference.inference.QueryTrainingKvRecordRequest is not mutable"))
+ case "inference.inference.QueryTrainingKvRecordRequest.key":
+ panic(fmt.Errorf("field key of message inference.inference.QueryTrainingKvRecordRequest is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingKvRecordRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingKvRecordRequest 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_QueryTrainingKvRecordRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingKvRecordRequest.taskId":
+ return protoreflect.ValueOfUint64(uint64(0))
+ case "inference.inference.QueryTrainingKvRecordRequest.key":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingKvRecordRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingKvRecordRequest 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_QueryTrainingKvRecordRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryTrainingKvRecordRequest", 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_QueryTrainingKvRecordRequest) 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_QueryTrainingKvRecordRequest) 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_QueryTrainingKvRecordRequest) 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_QueryTrainingKvRecordRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryTrainingKvRecordRequest)
+ 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.TaskId != 0 {
+ n += 1 + runtime.Sov(uint64(x.TaskId))
+ }
+ l = len(x.Key)
+ 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().(*QueryTrainingKvRecordRequest)
+ 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.Key) > 0 {
+ i -= len(x.Key)
+ copy(dAtA[i:], x.Key)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Key)))
+ i--
+ dAtA[i] = 0x12
+ }
+ if x.TaskId != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.TaskId))
+ 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().(*QueryTrainingKvRecordRequest)
+ 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: QueryTrainingKvRecordRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryTrainingKvRecordRequest: 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 TaskId", wireType)
+ }
+ x.TaskId = 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.TaskId |= 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 Key", 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.Key = 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_QueryTrainingKvRecordResponse protoreflect.MessageDescriptor
+ fd_QueryTrainingKvRecordResponse_record protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryTrainingKvRecordResponse = File_inference_inference_query_proto.Messages().ByName("QueryTrainingKvRecordResponse")
+ fd_QueryTrainingKvRecordResponse_record = md_QueryTrainingKvRecordResponse.Fields().ByName("record")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryTrainingKvRecordResponse)(nil)
+
+type fastReflection_QueryTrainingKvRecordResponse QueryTrainingKvRecordResponse
+
+func (x *QueryTrainingKvRecordResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryTrainingKvRecordResponse)(x)
+}
+
+func (x *QueryTrainingKvRecordResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[102]
+ 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_QueryTrainingKvRecordResponse_messageType fastReflection_QueryTrainingKvRecordResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryTrainingKvRecordResponse_messageType{}
+
+type fastReflection_QueryTrainingKvRecordResponse_messageType struct{}
+
+func (x fastReflection_QueryTrainingKvRecordResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryTrainingKvRecordResponse)(nil)
+}
+func (x fastReflection_QueryTrainingKvRecordResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryTrainingKvRecordResponse)
+}
+func (x fastReflection_QueryTrainingKvRecordResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryTrainingKvRecordResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryTrainingKvRecordResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryTrainingKvRecordResponse
+}
+
+// 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_QueryTrainingKvRecordResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryTrainingKvRecordResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryTrainingKvRecordResponse) New() protoreflect.Message {
+ return new(fastReflection_QueryTrainingKvRecordResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryTrainingKvRecordResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryTrainingKvRecordResponse)(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_QueryTrainingKvRecordResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Record != nil {
+ value := protoreflect.ValueOfMessage(x.Record.ProtoReflect())
+ if !f(fd_QueryTrainingKvRecordResponse_record, 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_QueryTrainingKvRecordResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingKvRecordResponse.record":
+ return x.Record != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingKvRecordResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingKvRecordResponse 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_QueryTrainingKvRecordResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingKvRecordResponse.record":
+ x.Record = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingKvRecordResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingKvRecordResponse 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_QueryTrainingKvRecordResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryTrainingKvRecordResponse.record":
+ value := x.Record
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingKvRecordResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingKvRecordResponse 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_QueryTrainingKvRecordResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingKvRecordResponse.record":
+ x.Record = value.Message().Interface().(*TrainingTaskKVRecord)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingKvRecordResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingKvRecordResponse 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_QueryTrainingKvRecordResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingKvRecordResponse.record":
+ if x.Record == nil {
+ x.Record = new(TrainingTaskKVRecord)
+ }
+ return protoreflect.ValueOfMessage(x.Record.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingKvRecordResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingKvRecordResponse 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_QueryTrainingKvRecordResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingKvRecordResponse.record":
+ m := new(TrainingTaskKVRecord)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingKvRecordResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingKvRecordResponse 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_QueryTrainingKvRecordResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryTrainingKvRecordResponse", 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_QueryTrainingKvRecordResponse) 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_QueryTrainingKvRecordResponse) 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_QueryTrainingKvRecordResponse) 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_QueryTrainingKvRecordResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryTrainingKvRecordResponse)
+ 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.Record != nil {
+ l = options.Size(x.Record)
+ 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().(*QueryTrainingKvRecordResponse)
+ 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.Record != nil {
+ encoded, err := options.Marshal(x.Record)
+ 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().(*QueryTrainingKvRecordResponse)
+ 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: QueryTrainingKvRecordResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryTrainingKvRecordResponse: 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 Record", 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.Record == nil {
+ x.Record = &TrainingTaskKVRecord{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Record); 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_QueryListTrainingKvRecordKeysRequest protoreflect.MessageDescriptor
+ fd_QueryListTrainingKvRecordKeysRequest_taskId protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryListTrainingKvRecordKeysRequest = File_inference_inference_query_proto.Messages().ByName("QueryListTrainingKvRecordKeysRequest")
+ fd_QueryListTrainingKvRecordKeysRequest_taskId = md_QueryListTrainingKvRecordKeysRequest.Fields().ByName("taskId")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryListTrainingKvRecordKeysRequest)(nil)
+
+type fastReflection_QueryListTrainingKvRecordKeysRequest QueryListTrainingKvRecordKeysRequest
+
+func (x *QueryListTrainingKvRecordKeysRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryListTrainingKvRecordKeysRequest)(x)
+}
+
+func (x *QueryListTrainingKvRecordKeysRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[103]
+ 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_QueryListTrainingKvRecordKeysRequest_messageType fastReflection_QueryListTrainingKvRecordKeysRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryListTrainingKvRecordKeysRequest_messageType{}
+
+type fastReflection_QueryListTrainingKvRecordKeysRequest_messageType struct{}
+
+func (x fastReflection_QueryListTrainingKvRecordKeysRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryListTrainingKvRecordKeysRequest)(nil)
+}
+func (x fastReflection_QueryListTrainingKvRecordKeysRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryListTrainingKvRecordKeysRequest)
+}
+func (x fastReflection_QueryListTrainingKvRecordKeysRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryListTrainingKvRecordKeysRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryListTrainingKvRecordKeysRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryListTrainingKvRecordKeysRequest
+}
+
+// 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_QueryListTrainingKvRecordKeysRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryListTrainingKvRecordKeysRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryListTrainingKvRecordKeysRequest) New() protoreflect.Message {
+ return new(fastReflection_QueryListTrainingKvRecordKeysRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryListTrainingKvRecordKeysRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryListTrainingKvRecordKeysRequest)(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_QueryListTrainingKvRecordKeysRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.TaskId != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.TaskId)
+ if !f(fd_QueryListTrainingKvRecordKeysRequest_taskId, 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_QueryListTrainingKvRecordKeysRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryListTrainingKvRecordKeysRequest.taskId":
+ return x.TaskId != uint64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryListTrainingKvRecordKeysRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryListTrainingKvRecordKeysRequest 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_QueryListTrainingKvRecordKeysRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryListTrainingKvRecordKeysRequest.taskId":
+ x.TaskId = uint64(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryListTrainingKvRecordKeysRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryListTrainingKvRecordKeysRequest 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_QueryListTrainingKvRecordKeysRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryListTrainingKvRecordKeysRequest.taskId":
+ value := x.TaskId
+ return protoreflect.ValueOfUint64(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryListTrainingKvRecordKeysRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryListTrainingKvRecordKeysRequest 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_QueryListTrainingKvRecordKeysRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryListTrainingKvRecordKeysRequest.taskId":
+ x.TaskId = value.Uint()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryListTrainingKvRecordKeysRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryListTrainingKvRecordKeysRequest 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_QueryListTrainingKvRecordKeysRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryListTrainingKvRecordKeysRequest.taskId":
+ panic(fmt.Errorf("field taskId of message inference.inference.QueryListTrainingKvRecordKeysRequest is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryListTrainingKvRecordKeysRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryListTrainingKvRecordKeysRequest 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_QueryListTrainingKvRecordKeysRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryListTrainingKvRecordKeysRequest.taskId":
+ return protoreflect.ValueOfUint64(uint64(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryListTrainingKvRecordKeysRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryListTrainingKvRecordKeysRequest 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_QueryListTrainingKvRecordKeysRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryListTrainingKvRecordKeysRequest", 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_QueryListTrainingKvRecordKeysRequest) 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_QueryListTrainingKvRecordKeysRequest) 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_QueryListTrainingKvRecordKeysRequest) 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_QueryListTrainingKvRecordKeysRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryListTrainingKvRecordKeysRequest)
+ 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.TaskId != 0 {
+ n += 1 + runtime.Sov(uint64(x.TaskId))
+ }
+ 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().(*QueryListTrainingKvRecordKeysRequest)
+ 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.TaskId != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.TaskId))
+ 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().(*QueryListTrainingKvRecordKeysRequest)
+ 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: QueryListTrainingKvRecordKeysRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryListTrainingKvRecordKeysRequest: 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 TaskId", wireType)
+ }
+ x.TaskId = 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.TaskId |= 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 _ protoreflect.List = (*_QueryListTrainingKvRecordKeysResponse_1_list)(nil)
+
+type _QueryListTrainingKvRecordKeysResponse_1_list struct {
+ list *[]string
+}
+
+func (x *_QueryListTrainingKvRecordKeysResponse_1_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_QueryListTrainingKvRecordKeysResponse_1_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfString((*x.list)[i])
+}
+
+func (x *_QueryListTrainingKvRecordKeysResponse_1_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.String()
+ concreteValue := valueUnwrapped
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_QueryListTrainingKvRecordKeysResponse_1_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.String()
+ concreteValue := valueUnwrapped
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryListTrainingKvRecordKeysResponse_1_list) AppendMutable() protoreflect.Value {
+ panic(fmt.Errorf("AppendMutable can not be called on message QueryListTrainingKvRecordKeysResponse at list field Keys as it is not of Message kind"))
+}
+
+func (x *_QueryListTrainingKvRecordKeysResponse_1_list) Truncate(n int) {
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_QueryListTrainingKvRecordKeysResponse_1_list) NewElement() protoreflect.Value {
+ v := ""
+ return protoreflect.ValueOfString(v)
+}
+
+func (x *_QueryListTrainingKvRecordKeysResponse_1_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_QueryListTrainingKvRecordKeysResponse protoreflect.MessageDescriptor
+ fd_QueryListTrainingKvRecordKeysResponse_keys protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryListTrainingKvRecordKeysResponse = File_inference_inference_query_proto.Messages().ByName("QueryListTrainingKvRecordKeysResponse")
+ fd_QueryListTrainingKvRecordKeysResponse_keys = md_QueryListTrainingKvRecordKeysResponse.Fields().ByName("keys")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryListTrainingKvRecordKeysResponse)(nil)
+
+type fastReflection_QueryListTrainingKvRecordKeysResponse QueryListTrainingKvRecordKeysResponse
+
+func (x *QueryListTrainingKvRecordKeysResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryListTrainingKvRecordKeysResponse)(x)
+}
+
+func (x *QueryListTrainingKvRecordKeysResponse) 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_QueryListTrainingKvRecordKeysResponse_messageType fastReflection_QueryListTrainingKvRecordKeysResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryListTrainingKvRecordKeysResponse_messageType{}
+
+type fastReflection_QueryListTrainingKvRecordKeysResponse_messageType struct{}
+
+func (x fastReflection_QueryListTrainingKvRecordKeysResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryListTrainingKvRecordKeysResponse)(nil)
+}
+func (x fastReflection_QueryListTrainingKvRecordKeysResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryListTrainingKvRecordKeysResponse)
+}
+func (x fastReflection_QueryListTrainingKvRecordKeysResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryListTrainingKvRecordKeysResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryListTrainingKvRecordKeysResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryListTrainingKvRecordKeysResponse
+}
+
+// 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_QueryListTrainingKvRecordKeysResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryListTrainingKvRecordKeysResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryListTrainingKvRecordKeysResponse) New() protoreflect.Message {
+ return new(fastReflection_QueryListTrainingKvRecordKeysResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryListTrainingKvRecordKeysResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryListTrainingKvRecordKeysResponse)(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_QueryListTrainingKvRecordKeysResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if len(x.Keys) != 0 {
+ value := protoreflect.ValueOfList(&_QueryListTrainingKvRecordKeysResponse_1_list{list: &x.Keys})
+ if !f(fd_QueryListTrainingKvRecordKeysResponse_keys, 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_QueryListTrainingKvRecordKeysResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryListTrainingKvRecordKeysResponse.keys":
+ return len(x.Keys) != 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryListTrainingKvRecordKeysResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryListTrainingKvRecordKeysResponse 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_QueryListTrainingKvRecordKeysResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryListTrainingKvRecordKeysResponse.keys":
+ x.Keys = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryListTrainingKvRecordKeysResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryListTrainingKvRecordKeysResponse 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_QueryListTrainingKvRecordKeysResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryListTrainingKvRecordKeysResponse.keys":
+ if len(x.Keys) == 0 {
+ return protoreflect.ValueOfList(&_QueryListTrainingKvRecordKeysResponse_1_list{})
+ }
+ listValue := &_QueryListTrainingKvRecordKeysResponse_1_list{list: &x.Keys}
+ return protoreflect.ValueOfList(listValue)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryListTrainingKvRecordKeysResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryListTrainingKvRecordKeysResponse 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_QueryListTrainingKvRecordKeysResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryListTrainingKvRecordKeysResponse.keys":
+ lv := value.List()
+ clv := lv.(*_QueryListTrainingKvRecordKeysResponse_1_list)
+ x.Keys = *clv.list
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryListTrainingKvRecordKeysResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryListTrainingKvRecordKeysResponse 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_QueryListTrainingKvRecordKeysResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryListTrainingKvRecordKeysResponse.keys":
+ if x.Keys == nil {
+ x.Keys = []string{}
+ }
+ value := &_QueryListTrainingKvRecordKeysResponse_1_list{list: &x.Keys}
+ return protoreflect.ValueOfList(value)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryListTrainingKvRecordKeysResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryListTrainingKvRecordKeysResponse 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_QueryListTrainingKvRecordKeysResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryListTrainingKvRecordKeysResponse.keys":
+ list := []string{}
+ return protoreflect.ValueOfList(&_QueryListTrainingKvRecordKeysResponse_1_list{list: &list})
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryListTrainingKvRecordKeysResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryListTrainingKvRecordKeysResponse 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_QueryListTrainingKvRecordKeysResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryListTrainingKvRecordKeysResponse", 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_QueryListTrainingKvRecordKeysResponse) 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_QueryListTrainingKvRecordKeysResponse) 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_QueryListTrainingKvRecordKeysResponse) 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_QueryListTrainingKvRecordKeysResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryListTrainingKvRecordKeysResponse)
+ 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.Keys) > 0 {
+ for _, s := range x.Keys {
+ 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().(*QueryListTrainingKvRecordKeysResponse)
+ 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.Keys) > 0 {
+ for iNdEx := len(x.Keys) - 1; iNdEx >= 0; iNdEx-- {
+ i -= len(x.Keys[iNdEx])
+ copy(dAtA[i:], x.Keys[iNdEx])
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Keys[iNdEx])))
+ 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().(*QueryListTrainingKvRecordKeysResponse)
+ 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: QueryListTrainingKvRecordKeysResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryListTrainingKvRecordKeysResponse: 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 Keys", 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.Keys = append(x.Keys, 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_QueryTrainingBarrierRequest protoreflect.MessageDescriptor
+ fd_QueryTrainingBarrierRequest_req protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryTrainingBarrierRequest = File_inference_inference_query_proto.Messages().ByName("QueryTrainingBarrierRequest")
+ fd_QueryTrainingBarrierRequest_req = md_QueryTrainingBarrierRequest.Fields().ByName("req")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryTrainingBarrierRequest)(nil)
+
+type fastReflection_QueryTrainingBarrierRequest QueryTrainingBarrierRequest
+
+func (x *QueryTrainingBarrierRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryTrainingBarrierRequest)(x)
+}
+
+func (x *QueryTrainingBarrierRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[105]
+ 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_QueryTrainingBarrierRequest_messageType fastReflection_QueryTrainingBarrierRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryTrainingBarrierRequest_messageType{}
+
+type fastReflection_QueryTrainingBarrierRequest_messageType struct{}
+
+func (x fastReflection_QueryTrainingBarrierRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryTrainingBarrierRequest)(nil)
+}
+func (x fastReflection_QueryTrainingBarrierRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryTrainingBarrierRequest)
+}
+func (x fastReflection_QueryTrainingBarrierRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryTrainingBarrierRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryTrainingBarrierRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryTrainingBarrierRequest
+}
+
+// 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_QueryTrainingBarrierRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryTrainingBarrierRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryTrainingBarrierRequest) New() protoreflect.Message {
+ return new(fastReflection_QueryTrainingBarrierRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryTrainingBarrierRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryTrainingBarrierRequest)(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_QueryTrainingBarrierRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Req != nil {
+ value := protoreflect.ValueOfMessage(x.Req.ProtoReflect())
+ if !f(fd_QueryTrainingBarrierRequest_req, 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_QueryTrainingBarrierRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingBarrierRequest.req":
+ return x.Req != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingBarrierRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingBarrierRequest 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_QueryTrainingBarrierRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingBarrierRequest.req":
+ x.Req = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingBarrierRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingBarrierRequest 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_QueryTrainingBarrierRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryTrainingBarrierRequest.req":
+ value := x.Req
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingBarrierRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingBarrierRequest 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_QueryTrainingBarrierRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingBarrierRequest.req":
+ x.Req = value.Message().Interface().(*GetBarrierStatusRequest)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingBarrierRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingBarrierRequest 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_QueryTrainingBarrierRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingBarrierRequest.req":
+ if x.Req == nil {
+ x.Req = new(GetBarrierStatusRequest)
+ }
+ return protoreflect.ValueOfMessage(x.Req.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingBarrierRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingBarrierRequest 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_QueryTrainingBarrierRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingBarrierRequest.req":
+ m := new(GetBarrierStatusRequest)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingBarrierRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingBarrierRequest 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_QueryTrainingBarrierRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryTrainingBarrierRequest", 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_QueryTrainingBarrierRequest) 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_QueryTrainingBarrierRequest) 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_QueryTrainingBarrierRequest) 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_QueryTrainingBarrierRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryTrainingBarrierRequest)
+ 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.Req != nil {
+ l = options.Size(x.Req)
+ 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().(*QueryTrainingBarrierRequest)
+ 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.Req != nil {
+ encoded, err := options.Marshal(x.Req)
+ 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().(*QueryTrainingBarrierRequest)
+ 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: QueryTrainingBarrierRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryTrainingBarrierRequest: 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 Req", 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.Req == nil {
+ x.Req = &GetBarrierStatusRequest{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Req); 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_QueryTrainingBarrierResponse protoreflect.MessageDescriptor
+ fd_QueryTrainingBarrierResponse_resp protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryTrainingBarrierResponse = File_inference_inference_query_proto.Messages().ByName("QueryTrainingBarrierResponse")
+ fd_QueryTrainingBarrierResponse_resp = md_QueryTrainingBarrierResponse.Fields().ByName("resp")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryTrainingBarrierResponse)(nil)
+
+type fastReflection_QueryTrainingBarrierResponse QueryTrainingBarrierResponse
+
+func (x *QueryTrainingBarrierResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryTrainingBarrierResponse)(x)
+}
+
+func (x *QueryTrainingBarrierResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[106]
+ 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_QueryTrainingBarrierResponse_messageType fastReflection_QueryTrainingBarrierResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryTrainingBarrierResponse_messageType{}
+
+type fastReflection_QueryTrainingBarrierResponse_messageType struct{}
+
+func (x fastReflection_QueryTrainingBarrierResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryTrainingBarrierResponse)(nil)
+}
+func (x fastReflection_QueryTrainingBarrierResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryTrainingBarrierResponse)
+}
+func (x fastReflection_QueryTrainingBarrierResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryTrainingBarrierResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryTrainingBarrierResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryTrainingBarrierResponse
+}
+
+// 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_QueryTrainingBarrierResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryTrainingBarrierResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryTrainingBarrierResponse) New() protoreflect.Message {
+ return new(fastReflection_QueryTrainingBarrierResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryTrainingBarrierResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryTrainingBarrierResponse)(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_QueryTrainingBarrierResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Resp != nil {
+ value := protoreflect.ValueOfMessage(x.Resp.ProtoReflect())
+ if !f(fd_QueryTrainingBarrierResponse_resp, 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_QueryTrainingBarrierResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingBarrierResponse.resp":
+ return x.Resp != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingBarrierResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingBarrierResponse 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_QueryTrainingBarrierResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingBarrierResponse.resp":
+ x.Resp = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingBarrierResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingBarrierResponse 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_QueryTrainingBarrierResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryTrainingBarrierResponse.resp":
+ value := x.Resp
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingBarrierResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingBarrierResponse 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_QueryTrainingBarrierResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingBarrierResponse.resp":
+ x.Resp = value.Message().Interface().(*GetBarrierStatusResponse)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingBarrierResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingBarrierResponse 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_QueryTrainingBarrierResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingBarrierResponse.resp":
+ if x.Resp == nil {
+ x.Resp = new(GetBarrierStatusResponse)
+ }
+ return protoreflect.ValueOfMessage(x.Resp.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingBarrierResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingBarrierResponse 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_QueryTrainingBarrierResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingBarrierResponse.resp":
+ m := new(GetBarrierStatusResponse)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingBarrierResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingBarrierResponse 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_QueryTrainingBarrierResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryTrainingBarrierResponse", 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_QueryTrainingBarrierResponse) 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_QueryTrainingBarrierResponse) 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_QueryTrainingBarrierResponse) 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_QueryTrainingBarrierResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryTrainingBarrierResponse)
+ 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.Resp != nil {
+ l = options.Size(x.Resp)
+ 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().(*QueryTrainingBarrierResponse)
+ 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.Resp != nil {
+ encoded, err := options.Marshal(x.Resp)
+ 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 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().(*QueryTrainingBarrierResponse)
+ 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: QueryTrainingBarrierResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryTrainingBarrierResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 2:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Resp", 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.Resp == nil {
+ x.Resp = &GetBarrierStatusResponse{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Resp); 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_QueryTrainingAliveNodesRequest protoreflect.MessageDescriptor
+ fd_QueryTrainingAliveNodesRequest_req protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryTrainingAliveNodesRequest = File_inference_inference_query_proto.Messages().ByName("QueryTrainingAliveNodesRequest")
+ fd_QueryTrainingAliveNodesRequest_req = md_QueryTrainingAliveNodesRequest.Fields().ByName("req")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryTrainingAliveNodesRequest)(nil)
+
+type fastReflection_QueryTrainingAliveNodesRequest QueryTrainingAliveNodesRequest
+
+func (x *QueryTrainingAliveNodesRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryTrainingAliveNodesRequest)(x)
+}
+
+func (x *QueryTrainingAliveNodesRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[107]
+ 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_QueryTrainingAliveNodesRequest_messageType fastReflection_QueryTrainingAliveNodesRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryTrainingAliveNodesRequest_messageType{}
+
+type fastReflection_QueryTrainingAliveNodesRequest_messageType struct{}
+
+func (x fastReflection_QueryTrainingAliveNodesRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryTrainingAliveNodesRequest)(nil)
+}
+func (x fastReflection_QueryTrainingAliveNodesRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryTrainingAliveNodesRequest)
+}
+func (x fastReflection_QueryTrainingAliveNodesRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryTrainingAliveNodesRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryTrainingAliveNodesRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryTrainingAliveNodesRequest
+}
+
+// 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_QueryTrainingAliveNodesRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryTrainingAliveNodesRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryTrainingAliveNodesRequest) New() protoreflect.Message {
+ return new(fastReflection_QueryTrainingAliveNodesRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryTrainingAliveNodesRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryTrainingAliveNodesRequest)(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_QueryTrainingAliveNodesRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Req != nil {
+ value := protoreflect.ValueOfMessage(x.Req.ProtoReflect())
+ if !f(fd_QueryTrainingAliveNodesRequest_req, 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_QueryTrainingAliveNodesRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingAliveNodesRequest.req":
+ return x.Req != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingAliveNodesRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingAliveNodesRequest 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_QueryTrainingAliveNodesRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingAliveNodesRequest.req":
+ x.Req = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingAliveNodesRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingAliveNodesRequest 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_QueryTrainingAliveNodesRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryTrainingAliveNodesRequest.req":
+ value := x.Req
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingAliveNodesRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingAliveNodesRequest 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_QueryTrainingAliveNodesRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingAliveNodesRequest.req":
+ x.Req = value.Message().Interface().(*GetAliveNodesRequest)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingAliveNodesRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingAliveNodesRequest 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_QueryTrainingAliveNodesRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingAliveNodesRequest.req":
+ if x.Req == nil {
+ x.Req = new(GetAliveNodesRequest)
+ }
+ return protoreflect.ValueOfMessage(x.Req.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingAliveNodesRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingAliveNodesRequest 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_QueryTrainingAliveNodesRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingAliveNodesRequest.req":
+ m := new(GetAliveNodesRequest)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingAliveNodesRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingAliveNodesRequest 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_QueryTrainingAliveNodesRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryTrainingAliveNodesRequest", 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_QueryTrainingAliveNodesRequest) 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_QueryTrainingAliveNodesRequest) 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_QueryTrainingAliveNodesRequest) 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_QueryTrainingAliveNodesRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryTrainingAliveNodesRequest)
+ 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.Req != nil {
+ l = options.Size(x.Req)
+ 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().(*QueryTrainingAliveNodesRequest)
+ 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.Req != nil {
+ encoded, err := options.Marshal(x.Req)
+ 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().(*QueryTrainingAliveNodesRequest)
+ 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: QueryTrainingAliveNodesRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryTrainingAliveNodesRequest: 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 Req", 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.Req == nil {
+ x.Req = &GetAliveNodesRequest{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Req); 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_QueryTrainingAliveNodesResponse protoreflect.MessageDescriptor
+ fd_QueryTrainingAliveNodesResponse_resp protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryTrainingAliveNodesResponse = File_inference_inference_query_proto.Messages().ByName("QueryTrainingAliveNodesResponse")
+ fd_QueryTrainingAliveNodesResponse_resp = md_QueryTrainingAliveNodesResponse.Fields().ByName("resp")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryTrainingAliveNodesResponse)(nil)
+
+type fastReflection_QueryTrainingAliveNodesResponse QueryTrainingAliveNodesResponse
+
+func (x *QueryTrainingAliveNodesResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryTrainingAliveNodesResponse)(x)
+}
+
+func (x *QueryTrainingAliveNodesResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[108]
+ 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_QueryTrainingAliveNodesResponse_messageType fastReflection_QueryTrainingAliveNodesResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryTrainingAliveNodesResponse_messageType{}
+
+type fastReflection_QueryTrainingAliveNodesResponse_messageType struct{}
+
+func (x fastReflection_QueryTrainingAliveNodesResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryTrainingAliveNodesResponse)(nil)
+}
+func (x fastReflection_QueryTrainingAliveNodesResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryTrainingAliveNodesResponse)
+}
+func (x fastReflection_QueryTrainingAliveNodesResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryTrainingAliveNodesResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryTrainingAliveNodesResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryTrainingAliveNodesResponse
+}
+
+// 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_QueryTrainingAliveNodesResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryTrainingAliveNodesResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryTrainingAliveNodesResponse) New() protoreflect.Message {
+ return new(fastReflection_QueryTrainingAliveNodesResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryTrainingAliveNodesResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryTrainingAliveNodesResponse)(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_QueryTrainingAliveNodesResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Resp != nil {
+ value := protoreflect.ValueOfMessage(x.Resp.ProtoReflect())
+ if !f(fd_QueryTrainingAliveNodesResponse_resp, 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_QueryTrainingAliveNodesResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingAliveNodesResponse.resp":
+ return x.Resp != nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingAliveNodesResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingAliveNodesResponse 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_QueryTrainingAliveNodesResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingAliveNodesResponse.resp":
+ x.Resp = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingAliveNodesResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingAliveNodesResponse 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_QueryTrainingAliveNodesResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryTrainingAliveNodesResponse.resp":
+ value := x.Resp
+ return protoreflect.ValueOfMessage(value.ProtoReflect())
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingAliveNodesResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingAliveNodesResponse 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_QueryTrainingAliveNodesResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingAliveNodesResponse.resp":
+ x.Resp = value.Message().Interface().(*GetAliveNodesResponse)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingAliveNodesResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingAliveNodesResponse 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_QueryTrainingAliveNodesResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingAliveNodesResponse.resp":
+ if x.Resp == nil {
+ x.Resp = new(GetAliveNodesResponse)
+ }
+ return protoreflect.ValueOfMessage(x.Resp.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingAliveNodesResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingAliveNodesResponse 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_QueryTrainingAliveNodesResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingAliveNodesResponse.resp":
+ m := new(GetAliveNodesResponse)
+ return protoreflect.ValueOfMessage(m.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingAliveNodesResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingAliveNodesResponse 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_QueryTrainingAliveNodesResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryTrainingAliveNodesResponse", 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_QueryTrainingAliveNodesResponse) 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_QueryTrainingAliveNodesResponse) 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_QueryTrainingAliveNodesResponse) 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_QueryTrainingAliveNodesResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryTrainingAliveNodesResponse)
+ 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.Resp != nil {
+ l = options.Size(x.Resp)
+ 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().(*QueryTrainingAliveNodesResponse)
+ 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.Resp != nil {
+ encoded, err := options.Marshal(x.Resp)
+ 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 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().(*QueryTrainingAliveNodesResponse)
+ 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: QueryTrainingAliveNodesResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryTrainingAliveNodesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 2:
+ if wireType != 2 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Resp", 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.Resp == nil {
+ x.Resp = &GetAliveNodesResponse{}
+ }
+ if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Resp); 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_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_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_QueryGetBridgeTransactionRequest)(nil)
+
+type fastReflection_QueryGetBridgeTransactionRequest QueryGetBridgeTransactionRequest
+
+func (x *QueryGetBridgeTransactionRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetBridgeTransactionRequest)(x)
+}
+
+func (x *QueryGetBridgeTransactionRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[109]
+ 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_QueryGetBridgeTransactionRequest_messageType fastReflection_QueryGetBridgeTransactionRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetBridgeTransactionRequest_messageType{}
+
+type fastReflection_QueryGetBridgeTransactionRequest_messageType struct{}
+
+func (x fastReflection_QueryGetBridgeTransactionRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetBridgeTransactionRequest)(nil)
+}
+func (x fastReflection_QueryGetBridgeTransactionRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetBridgeTransactionRequest)
+}
+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_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_QueryGetBridgeTransactionRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetBridgeTransactionRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryGetBridgeTransactionRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetBridgeTransactionRequest)(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_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
+ }
+ }
+}
+
+// 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_QueryGetBridgeTransactionRequest) 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 != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetBridgeTransactionRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetBridgeTransactionRequest 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_QueryGetBridgeTransactionRequest) 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 = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetBridgeTransactionRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetBridgeTransactionRequest 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_QueryGetBridgeTransactionRequest) 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)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetBridgeTransactionRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetBridgeTransactionRequest 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_QueryGetBridgeTransactionRequest) 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)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetBridgeTransactionRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetBridgeTransactionRequest 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_QueryGetBridgeTransactionRequest) 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"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetBridgeTransactionRequest"))
+ }
+ 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_QueryGetBridgeTransactionRequest) 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("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetBridgeTransactionRequest"))
+ }
+ 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_QueryGetBridgeTransactionRequest) 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("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_QueryGetBridgeTransactionRequest) 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_QueryGetBridgeTransactionRequest) 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_QueryGetBridgeTransactionRequest) 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_QueryGetBridgeTransactionRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetBridgeTransactionRequest)
+ 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.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 {
+ n += len(x.unknownFields)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*QueryGetBridgeTransactionRequest)
+ 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.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
+ }
+ 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().(*QueryGetBridgeTransactionRequest)
+ 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: QueryGetBridgeTransactionRequest: 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)
+ }
+ 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)
+ }
+ 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 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 postIndex > l {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+ }
+ x.ReceiptIndex = 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 = (*_QueryGetBridgeTransactionResponse_1_list)(nil)
+
+type _QueryGetBridgeTransactionResponse_1_list struct {
+ list *[]*BridgeTransaction
+}
+
+func (x *_QueryGetBridgeTransactionResponse_1_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_QueryGetBridgeTransactionResponse_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) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*BridgeTransaction)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_QueryGetBridgeTransactionResponse_1_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*BridgeTransaction)
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryGetBridgeTransactionResponse_1_list) AppendMutable() protoreflect.Value {
+ v := new(BridgeTransaction)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+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 *_QueryGetBridgeTransactionResponse_1_list) NewElement() protoreflect.Value {
+ v := new(BridgeTransaction)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryGetBridgeTransactionResponse_1_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_QueryGetBridgeTransactionResponse protoreflect.MessageDescriptor
+ fd_QueryGetBridgeTransactionResponse_bridgeTransactions 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetBridgeTransactionResponse)(nil)
+
+type fastReflection_QueryGetBridgeTransactionResponse QueryGetBridgeTransactionResponse
+
+func (x *QueryGetBridgeTransactionResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetBridgeTransactionResponse)(x)
+}
+
+func (x *QueryGetBridgeTransactionResponse) 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_QueryGetBridgeTransactionResponse_messageType fastReflection_QueryGetBridgeTransactionResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetBridgeTransactionResponse_messageType{}
+
+type fastReflection_QueryGetBridgeTransactionResponse_messageType struct{}
+
+func (x fastReflection_QueryGetBridgeTransactionResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetBridgeTransactionResponse)(nil)
+}
+func (x fastReflection_QueryGetBridgeTransactionResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetBridgeTransactionResponse)
+}
+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_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_QueryGetBridgeTransactionResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetBridgeTransactionResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryGetBridgeTransactionResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetBridgeTransactionResponse)(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_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) {
+ 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_QueryGetBridgeTransactionResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetBridgeTransactionResponse.bridgeTransactions":
+ return len(x.BridgeTransactions) != 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetBridgeTransactionResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetBridgeTransactionResponse 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_QueryGetBridgeTransactionResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetBridgeTransactionResponse.bridgeTransactions":
+ x.BridgeTransactions = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetBridgeTransactionResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetBridgeTransactionResponse 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_QueryGetBridgeTransactionResponse) 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{})
+ }
+ listValue := &_QueryGetBridgeTransactionResponse_1_list{list: &x.BridgeTransactions}
+ return protoreflect.ValueOfList(listValue)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetBridgeTransactionResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetBridgeTransactionResponse 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_QueryGetBridgeTransactionResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetBridgeTransactionResponse.bridgeTransactions":
+ lv := value.List()
+ clv := lv.(*_QueryGetBridgeTransactionResponse_1_list)
+ x.BridgeTransactions = *clv.list
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetBridgeTransactionResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetBridgeTransactionResponse 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_QueryGetBridgeTransactionResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetBridgeTransactionResponse.bridgeTransactions":
+ if x.BridgeTransactions == nil {
+ x.BridgeTransactions = []*BridgeTransaction{}
+ }
+ value := &_QueryGetBridgeTransactionResponse_1_list{list: &x.BridgeTransactions}
+ return protoreflect.ValueOfList(value)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetBridgeTransactionResponse"))
+ }
+ 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_QueryGetBridgeTransactionResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetBridgeTransactionResponse.bridgeTransactions":
+ list := []*BridgeTransaction{}
+ return protoreflect.ValueOfList(&_QueryGetBridgeTransactionResponse_1_list{list: &list})
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetBridgeTransactionResponse"))
+ }
+ 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_QueryGetBridgeTransactionResponse) 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("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_QueryGetBridgeTransactionResponse) 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_QueryGetBridgeTransactionResponse) 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_QueryGetBridgeTransactionResponse) 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_QueryGetBridgeTransactionResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetBridgeTransactionResponse)
+ 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.BridgeTransactions) > 0 {
+ for _, e := range x.BridgeTransactions {
+ 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().(*QueryGetBridgeTransactionResponse)
+ 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.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...)
+ } 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().(*QueryGetBridgeTransactionResponse)
+ 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: QueryGetBridgeTransactionResponse: 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)
+ }
+ 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)
+ }
+ 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.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
+ 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_QueryAllBridgeTransactionsRequest protoreflect.MessageDescriptor
+ fd_QueryAllBridgeTransactionsRequest_pagination 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryAllBridgeTransactionsRequest)(nil)
+
+type fastReflection_QueryAllBridgeTransactionsRequest QueryAllBridgeTransactionsRequest
+
+func (x *QueryAllBridgeTransactionsRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryAllBridgeTransactionsRequest)(x)
+}
+
+func (x *QueryAllBridgeTransactionsRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[111]
+ 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_QueryAllBridgeTransactionsRequest_messageType fastReflection_QueryAllBridgeTransactionsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllBridgeTransactionsRequest_messageType{}
+
+type fastReflection_QueryAllBridgeTransactionsRequest_messageType struct{}
+
+func (x fastReflection_QueryAllBridgeTransactionsRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryAllBridgeTransactionsRequest)(nil)
+}
+func (x fastReflection_QueryAllBridgeTransactionsRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryAllBridgeTransactionsRequest)
+}
+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_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_QueryAllBridgeTransactionsRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryAllBridgeTransactionsRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryAllBridgeTransactionsRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryAllBridgeTransactionsRequest)(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_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
+ }
+ }
+}
+
+// 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_QueryAllBridgeTransactionsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryAllBridgeTransactionsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllBridgeTransactionsRequest 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_QueryAllBridgeTransactionsRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllBridgeTransactionsRequest.pagination":
+ x.Pagination = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllBridgeTransactionsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllBridgeTransactionsRequest 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_QueryAllBridgeTransactionsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryAllBridgeTransactionsRequest.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.QueryAllBridgeTransactionsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllBridgeTransactionsRequest 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_QueryAllBridgeTransactionsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ 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.QueryAllBridgeTransactionsRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllBridgeTransactionsRequest 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_QueryAllBridgeTransactionsRequest) 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())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllBridgeTransactionsRequest"))
+ }
+ 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_QueryAllBridgeTransactionsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryAllBridgeTransactionsRequest.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.QueryAllBridgeTransactionsRequest"))
+ }
+ 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_QueryAllBridgeTransactionsRequest) 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("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_QueryAllBridgeTransactionsRequest) 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_QueryAllBridgeTransactionsRequest) 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_QueryAllBridgeTransactionsRequest) 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_QueryAllBridgeTransactionsRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryAllBridgeTransactionsRequest)
+ 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.Pagination != nil {
+ l = options.Size(x.Pagination)
+ 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().(*QueryAllBridgeTransactionsRequest)
+ 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.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 {
+ 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().(*QueryAllBridgeTransactionsRequest)
+ 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: QueryAllBridgeTransactionsRequest: 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)
+ }
+ 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:])
+ 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 = (*_QueryAllBridgeTransactionsResponse_1_list)(nil)
+
+type _QueryAllBridgeTransactionsResponse_1_list struct {
+ list *[]*BridgeTransaction
+}
+
+func (x *_QueryAllBridgeTransactionsResponse_1_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_QueryAllBridgeTransactionsResponse_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) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*BridgeTransaction)
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_QueryAllBridgeTransactionsResponse_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 {
+ v := new(BridgeTransaction)
+ *x.list = append(*x.list, v)
+ return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+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 *_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[112]
+ 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_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_QueryAllBridgeTransactionsResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryAllBridgeTransactionsResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryAllBridgeTransactionsResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryAllBridgeTransactionsResponse)(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_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
+ }
+ }
+}
+
+// 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_QueryAllBridgeTransactionsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryAllBridgeTransactionsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllBridgeTransactionsResponse 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_QueryAllBridgeTransactionsResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ 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.QueryAllBridgeTransactionsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllBridgeTransactionsResponse 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_QueryAllBridgeTransactionsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ 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.QueryAllBridgeTransactionsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllBridgeTransactionsResponse 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_QueryAllBridgeTransactionsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ 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.QueryAllBridgeTransactionsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryAllBridgeTransactionsResponse 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_QueryAllBridgeTransactionsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryAllBridgeTransactionsResponse"))
+ }
+ 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_QueryAllBridgeTransactionsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryAllBridgeTransactionsResponse"))
+ }
+ 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_QueryAllBridgeTransactionsResponse) 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("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_QueryAllBridgeTransactionsResponse) 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_QueryAllBridgeTransactionsResponse) 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_QueryAllBridgeTransactionsResponse) 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_QueryAllBridgeTransactionsResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryAllBridgeTransactionsResponse)
+ 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.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 {
+ n += len(x.unknownFields)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*QueryAllBridgeTransactionsResponse)
+ 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.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])
+ 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().(*QueryAllBridgeTransactionsResponse)
+ 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: QueryAllBridgeTransactionsResponse: 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)
+ }
+ 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)
+ }
+ 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.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
+ 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_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_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_WrappedTokenBalance)(nil)
+
+type fastReflection_WrappedTokenBalance WrappedTokenBalance
+
+func (x *WrappedTokenBalance) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_WrappedTokenBalance)(x)
+}
+
+func (x *WrappedTokenBalance) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[113]
+ 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_WrappedTokenBalance_messageType fastReflection_WrappedTokenBalance_messageType
+var _ protoreflect.MessageType = fastReflection_WrappedTokenBalance_messageType{}
+
+type fastReflection_WrappedTokenBalance_messageType struct{}
+
+func (x fastReflection_WrappedTokenBalance_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_WrappedTokenBalance)(nil)
+}
+func (x fastReflection_WrappedTokenBalance_messageType) New() protoreflect.Message {
+ return new(fastReflection_WrappedTokenBalance)
+}
+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_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_WrappedTokenBalance) Type() protoreflect.MessageType {
+ return _fastReflection_WrappedTokenBalance_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_WrappedTokenBalance) Interface() protoreflect.ProtoMessage {
+ return (*WrappedTokenBalance)(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_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
+ }
+ }
+}
+
+// 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_WrappedTokenBalance) 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 != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.WrappedTokenBalance"))
+ }
+ panic(fmt.Errorf("message inference.inference.WrappedTokenBalance 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_WrappedTokenBalance) 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 = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.WrappedTokenBalance"))
+ }
+ panic(fmt.Errorf("message inference.inference.WrappedTokenBalance 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_WrappedTokenBalance) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ 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.WrappedTokenBalance"))
+ }
+ panic(fmt.Errorf("message inference.inference.WrappedTokenBalance 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_WrappedTokenBalance) 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)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.WrappedTokenBalance"))
+ }
+ panic(fmt.Errorf("message inference.inference.WrappedTokenBalance 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_WrappedTokenBalance) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.WrappedTokenBalance.token_info":
+ if x.TokenInfo == nil {
+ x.TokenInfo = new(BridgeWrappedTokenContract)
+ }
+ 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.WrappedTokenBalance"))
+ }
+ 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_WrappedTokenBalance) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.WrappedTokenBalance"))
+ }
+ 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_WrappedTokenBalance) 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("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_WrappedTokenBalance) 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_WrappedTokenBalance) 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_WrappedTokenBalance) 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_WrappedTokenBalance) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*WrappedTokenBalance)
+ 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.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)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*WrappedTokenBalance)
+ 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.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...)
+ } 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().(*WrappedTokenBalance)
+ 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: WrappedTokenBalance: 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)
+ }
+ 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)
+ }
+ 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.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:])
+ 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_QueryWrappedTokenBalancesRequest protoreflect.MessageDescriptor
+ fd_QueryWrappedTokenBalancesRequest_address protoreflect.FieldDescriptor
+)
+
+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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryWrappedTokenBalancesRequest)(nil)
+
+type fastReflection_QueryWrappedTokenBalancesRequest QueryWrappedTokenBalancesRequest
+
+func (x *QueryWrappedTokenBalancesRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryWrappedTokenBalancesRequest)(x)
+}
+
+func (x *QueryWrappedTokenBalancesRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[114]
+ 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_QueryWrappedTokenBalancesRequest_messageType fastReflection_QueryWrappedTokenBalancesRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryWrappedTokenBalancesRequest_messageType{}
+
+type fastReflection_QueryWrappedTokenBalancesRequest_messageType struct{}
+
+func (x fastReflection_QueryWrappedTokenBalancesRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryWrappedTokenBalancesRequest)(nil)
+}
+func (x fastReflection_QueryWrappedTokenBalancesRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryWrappedTokenBalancesRequest)
+}
+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_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_QueryWrappedTokenBalancesRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryWrappedTokenBalancesRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryWrappedTokenBalancesRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryWrappedTokenBalancesRequest)(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_QueryWrappedTokenBalancesRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Address != "" {
+ value := protoreflect.ValueOfString(x.Address)
+ if !f(fd_QueryWrappedTokenBalancesRequest_address, 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_QueryWrappedTokenBalancesRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryWrappedTokenBalancesRequest.address":
+ return x.Address != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryWrappedTokenBalancesRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryWrappedTokenBalancesRequest 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_QueryWrappedTokenBalancesRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryWrappedTokenBalancesRequest.address":
+ x.Address = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryWrappedTokenBalancesRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryWrappedTokenBalancesRequest 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_QueryWrappedTokenBalancesRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ 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.QueryWrappedTokenBalancesRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryWrappedTokenBalancesRequest 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_QueryWrappedTokenBalancesRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ 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.QueryWrappedTokenBalancesRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryWrappedTokenBalancesRequest 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_QueryWrappedTokenBalancesRequest) 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"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryWrappedTokenBalancesRequest"))
+ }
+ 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_QueryWrappedTokenBalancesRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryWrappedTokenBalancesRequest.address":
+ return protoreflect.ValueOfString("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryWrappedTokenBalancesRequest"))
+ }
+ 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_QueryWrappedTokenBalancesRequest) 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("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_QueryWrappedTokenBalancesRequest) 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_QueryWrappedTokenBalancesRequest) 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_QueryWrappedTokenBalancesRequest) 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_QueryWrappedTokenBalancesRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryWrappedTokenBalancesRequest)
+ 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.Address)
+ 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().(*QueryWrappedTokenBalancesRequest)
+ 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.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 {
+ 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().(*QueryWrappedTokenBalancesRequest)
+ 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: QueryWrappedTokenBalancesRequest: 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)
+ }
+ 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
+ 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 = (*_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
+)
+
+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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryWrappedTokenBalancesResponse)(nil)
+
+type fastReflection_QueryWrappedTokenBalancesResponse QueryWrappedTokenBalancesResponse
+
+func (x *QueryWrappedTokenBalancesResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryWrappedTokenBalancesResponse)(x)
+}
+
+func (x *QueryWrappedTokenBalancesResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[115]
+ 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_QueryWrappedTokenBalancesResponse_messageType fastReflection_QueryWrappedTokenBalancesResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryWrappedTokenBalancesResponse_messageType{}
+
+type fastReflection_QueryWrappedTokenBalancesResponse_messageType struct{}
+
+func (x fastReflection_QueryWrappedTokenBalancesResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryWrappedTokenBalancesResponse)(nil)
+}
+func (x fastReflection_QueryWrappedTokenBalancesResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryWrappedTokenBalancesResponse)
+}
+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_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_QueryWrappedTokenBalancesResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryWrappedTokenBalancesResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryWrappedTokenBalancesResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryWrappedTokenBalancesResponse)(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_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
+ }
+ }
+}
+
+// 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_QueryWrappedTokenBalancesResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryWrappedTokenBalancesResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryWrappedTokenBalancesResponse 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_QueryWrappedTokenBalancesResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryWrappedTokenBalancesResponse.balances":
+ x.Balances = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryWrappedTokenBalancesResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryWrappedTokenBalancesResponse 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_QueryWrappedTokenBalancesResponse) 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)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryWrappedTokenBalancesResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryWrappedTokenBalancesResponse 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_QueryWrappedTokenBalancesResponse) 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
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryWrappedTokenBalancesResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryWrappedTokenBalancesResponse 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_QueryWrappedTokenBalancesResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryWrappedTokenBalancesResponse.balances":
+ if x.Balances == nil {
+ x.Balances = []*WrappedTokenBalance{}
+ }
+ 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.QueryWrappedTokenBalancesResponse"))
+ }
+ 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_QueryWrappedTokenBalancesResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryWrappedTokenBalancesResponse"))
+ }
+ 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_QueryWrappedTokenBalancesResponse) 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("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_QueryWrappedTokenBalancesResponse) 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_QueryWrappedTokenBalancesResponse) 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_QueryWrappedTokenBalancesResponse) 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_QueryWrappedTokenBalancesResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryWrappedTokenBalancesResponse)
+ 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.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)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*QueryWrappedTokenBalancesResponse)
+ 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.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 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().(*QueryWrappedTokenBalancesResponse)
+ 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: QueryWrappedTokenBalancesResponse: 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)
+ }
+ 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)
+ }
+ 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, &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
+ 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_QueryBridgeAddressesByChainRequest protoreflect.MessageDescriptor
+ fd_QueryBridgeAddressesByChainRequest_chain_id 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryBridgeAddressesByChainRequest)(nil)
+
+type fastReflection_QueryBridgeAddressesByChainRequest QueryBridgeAddressesByChainRequest
+
+func (x *QueryBridgeAddressesByChainRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryBridgeAddressesByChainRequest)(x)
+}
+
+func (x *QueryBridgeAddressesByChainRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[116]
+ 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_QueryBridgeAddressesByChainRequest_messageType fastReflection_QueryBridgeAddressesByChainRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryBridgeAddressesByChainRequest_messageType{}
+
+type fastReflection_QueryBridgeAddressesByChainRequest_messageType struct{}
+
+func (x fastReflection_QueryBridgeAddressesByChainRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryBridgeAddressesByChainRequest)(nil)
+}
+func (x fastReflection_QueryBridgeAddressesByChainRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryBridgeAddressesByChainRequest)
+}
+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_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_QueryBridgeAddressesByChainRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryBridgeAddressesByChainRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryBridgeAddressesByChainRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryBridgeAddressesByChainRequest)(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_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
+ }
+ }
+}
+
+// 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_QueryBridgeAddressesByChainRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryBridgeAddressesByChainRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryBridgeAddressesByChainRequest 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_QueryBridgeAddressesByChainRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryBridgeAddressesByChainRequest.chain_id":
+ x.ChainId = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryBridgeAddressesByChainRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryBridgeAddressesByChainRequest 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_QueryBridgeAddressesByChainRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ 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.QueryBridgeAddressesByChainRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryBridgeAddressesByChainRequest 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_QueryBridgeAddressesByChainRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ 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.QueryBridgeAddressesByChainRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryBridgeAddressesByChainRequest 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_QueryBridgeAddressesByChainRequest) 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"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryBridgeAddressesByChainRequest"))
+ }
+ 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_QueryBridgeAddressesByChainRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryBridgeAddressesByChainRequest"))
+ }
+ 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_QueryBridgeAddressesByChainRequest) 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("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_QueryBridgeAddressesByChainRequest) 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_QueryBridgeAddressesByChainRequest) 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_QueryBridgeAddressesByChainRequest) 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_QueryBridgeAddressesByChainRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryBridgeAddressesByChainRequest)
+ 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.ChainId)
+ 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().(*QueryBridgeAddressesByChainRequest)
+ 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.ChainId) > 0 {
+ i -= len(x.ChainId)
+ copy(dAtA[i:], x.ChainId)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ChainId)))
+ 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().(*QueryBridgeAddressesByChainRequest)
+ 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: QueryBridgeAddressesByChainRequest: 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)
+ }
+ 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)
+ }
+ 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
+ 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 = (*_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_QueryBridgeAddressesByChainResponse protoreflect.MessageDescriptor
+ fd_QueryBridgeAddressesByChainResponse_addresses 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryBridgeAddressesByChainResponse)(nil)
+
+type fastReflection_QueryBridgeAddressesByChainResponse QueryBridgeAddressesByChainResponse
+
+func (x *QueryBridgeAddressesByChainResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryBridgeAddressesByChainResponse)(x)
+}
+
+func (x *QueryBridgeAddressesByChainResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[117]
+ 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_QueryBridgeAddressesByChainResponse_messageType fastReflection_QueryBridgeAddressesByChainResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryBridgeAddressesByChainResponse_messageType{}
+
+type fastReflection_QueryBridgeAddressesByChainResponse_messageType struct{}
+
+func (x fastReflection_QueryBridgeAddressesByChainResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryBridgeAddressesByChainResponse)(nil)
+}
+func (x fastReflection_QueryBridgeAddressesByChainResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryBridgeAddressesByChainResponse)
+}
+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_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_QueryBridgeAddressesByChainResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryBridgeAddressesByChainResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryBridgeAddressesByChainResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryBridgeAddressesByChainResponse)(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_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
+ }
+ }
+}
+
+// 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_QueryBridgeAddressesByChainResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryBridgeAddressesByChainResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryBridgeAddressesByChainResponse 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_QueryBridgeAddressesByChainResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryBridgeAddressesByChainResponse.addresses":
+ x.Addresses = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryBridgeAddressesByChainResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryBridgeAddressesByChainResponse 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_QueryBridgeAddressesByChainResponse) 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{})
+ }
+ 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.QueryBridgeAddressesByChainResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryBridgeAddressesByChainResponse 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_QueryBridgeAddressesByChainResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ 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.QueryBridgeAddressesByChainResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryBridgeAddressesByChainResponse 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_QueryBridgeAddressesByChainResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryBridgeAddressesByChainResponse"))
+ }
+ 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_QueryBridgeAddressesByChainResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryBridgeAddressesByChainResponse"))
+ }
+ 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_QueryBridgeAddressesByChainResponse) 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("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_QueryBridgeAddressesByChainResponse) 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_QueryBridgeAddressesByChainResponse) 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_QueryBridgeAddressesByChainResponse) 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_QueryBridgeAddressesByChainResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryBridgeAddressesByChainResponse)
+ 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.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)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*QueryBridgeAddressesByChainResponse)
+ 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-- {
+ 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
+ }
+ }
+ 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().(*QueryBridgeAddressesByChainResponse)
+ 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: QueryBridgeAddressesByChainResponse: 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)
+ }
+ 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)
+ }
+ 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.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:])
+ 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_QueryValidateWrappedTokenForTradeRequest protoreflect.MessageDescriptor
+ fd_QueryValidateWrappedTokenForTradeRequest_contract_address 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryValidateWrappedTokenForTradeRequest)(nil)
+
+type fastReflection_QueryValidateWrappedTokenForTradeRequest QueryValidateWrappedTokenForTradeRequest
+
+func (x *QueryValidateWrappedTokenForTradeRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryValidateWrappedTokenForTradeRequest)(x)
+}
+
+func (x *QueryValidateWrappedTokenForTradeRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[118]
+ 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_QueryValidateWrappedTokenForTradeRequest_messageType fastReflection_QueryValidateWrappedTokenForTradeRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryValidateWrappedTokenForTradeRequest_messageType{}
+
+type fastReflection_QueryValidateWrappedTokenForTradeRequest_messageType struct{}
+
+func (x fastReflection_QueryValidateWrappedTokenForTradeRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryValidateWrappedTokenForTradeRequest)(nil)
+}
+func (x fastReflection_QueryValidateWrappedTokenForTradeRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryValidateWrappedTokenForTradeRequest)
+}
+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_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_QueryValidateWrappedTokenForTradeRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryValidateWrappedTokenForTradeRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryValidateWrappedTokenForTradeRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryValidateWrappedTokenForTradeRequest)(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_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
+ }
+ }
+}
+
+// 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_QueryValidateWrappedTokenForTradeRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryValidateWrappedTokenForTradeRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryValidateWrappedTokenForTradeRequest 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_QueryValidateWrappedTokenForTradeRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryValidateWrappedTokenForTradeRequest.contract_address":
+ x.ContractAddress = ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateWrappedTokenForTradeRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryValidateWrappedTokenForTradeRequest 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_QueryValidateWrappedTokenForTradeRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ 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.QueryValidateWrappedTokenForTradeRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryValidateWrappedTokenForTradeRequest 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_QueryValidateWrappedTokenForTradeRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ 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.QueryValidateWrappedTokenForTradeRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryValidateWrappedTokenForTradeRequest 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_QueryValidateWrappedTokenForTradeRequest) 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"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateWrappedTokenForTradeRequest"))
+ }
+ 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_QueryValidateWrappedTokenForTradeRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryValidateWrappedTokenForTradeRequest"))
+ }
+ 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_QueryValidateWrappedTokenForTradeRequest) 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("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_QueryValidateWrappedTokenForTradeRequest) 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_QueryValidateWrappedTokenForTradeRequest) 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_QueryValidateWrappedTokenForTradeRequest) 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_QueryValidateWrappedTokenForTradeRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryValidateWrappedTokenForTradeRequest)
+ 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.ContractAddress)
+ 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().(*QueryValidateWrappedTokenForTradeRequest)
+ 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.ContractAddress) > 0 {
+ i -= len(x.ContractAddress)
+ copy(dAtA[i:], x.ContractAddress)
+ i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ContractAddress)))
+ 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().(*QueryValidateWrappedTokenForTradeRequest)
+ 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: QueryValidateWrappedTokenForTradeRequest: 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)
+ }
+ 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)
+ }
+ 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
+ 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_QueryValidateWrappedTokenForTradeResponse protoreflect.MessageDescriptor
+ fd_QueryValidateWrappedTokenForTradeResponse_is_valid 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryValidateWrappedTokenForTradeResponse)(nil)
+
+type fastReflection_QueryValidateWrappedTokenForTradeResponse QueryValidateWrappedTokenForTradeResponse
+
+func (x *QueryValidateWrappedTokenForTradeResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryValidateWrappedTokenForTradeResponse)(x)
+}
+
+func (x *QueryValidateWrappedTokenForTradeResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[119]
+ 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_QueryValidateWrappedTokenForTradeResponse_messageType fastReflection_QueryValidateWrappedTokenForTradeResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryValidateWrappedTokenForTradeResponse_messageType{}
+
+type fastReflection_QueryValidateWrappedTokenForTradeResponse_messageType struct{}
+
+func (x fastReflection_QueryValidateWrappedTokenForTradeResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryValidateWrappedTokenForTradeResponse)(nil)
+}
+func (x fastReflection_QueryValidateWrappedTokenForTradeResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryValidateWrappedTokenForTradeResponse)
+}
+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_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_QueryValidateWrappedTokenForTradeResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryValidateWrappedTokenForTradeResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryValidateWrappedTokenForTradeResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryValidateWrappedTokenForTradeResponse)(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_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) {
+ 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_QueryValidateWrappedTokenForTradeResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryValidateWrappedTokenForTradeResponse.is_valid":
+ return x.IsValid_ != false
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateWrappedTokenForTradeResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryValidateWrappedTokenForTradeResponse 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_QueryValidateWrappedTokenForTradeResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryValidateWrappedTokenForTradeResponse.is_valid":
+ x.IsValid_ = false
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateWrappedTokenForTradeResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryValidateWrappedTokenForTradeResponse 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_QueryValidateWrappedTokenForTradeResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryValidateWrappedTokenForTradeResponse.is_valid":
+ value := x.IsValid_
+ return protoreflect.ValueOfBool(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateWrappedTokenForTradeResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryValidateWrappedTokenForTradeResponse 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_QueryValidateWrappedTokenForTradeResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryValidateWrappedTokenForTradeResponse.is_valid":
+ x.IsValid_ = value.Bool()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateWrappedTokenForTradeResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryValidateWrappedTokenForTradeResponse 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_QueryValidateWrappedTokenForTradeResponse) 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"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateWrappedTokenForTradeResponse"))
+ }
+ 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_QueryValidateWrappedTokenForTradeResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryValidateWrappedTokenForTradeResponse.is_valid":
+ return protoreflect.ValueOfBool(false)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateWrappedTokenForTradeResponse"))
+ }
+ 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_QueryValidateWrappedTokenForTradeResponse) 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("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_QueryValidateWrappedTokenForTradeResponse) 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_QueryValidateWrappedTokenForTradeResponse) 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_QueryValidateWrappedTokenForTradeResponse) 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_QueryValidateWrappedTokenForTradeResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryValidateWrappedTokenForTradeResponse)
+ 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.IsValid_ {
+ 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().(*QueryValidateWrappedTokenForTradeResponse)
+ 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.IsValid_ {
+ i--
+ if x.IsValid_ {
+ 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().(*QueryValidateWrappedTokenForTradeResponse)
+ 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: QueryValidateWrappedTokenForTradeResponse: 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)
+ }
+ 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)
+ }
+ 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.IsValid_ = 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_QueryLiquidityPoolRequest protoreflect.MessageDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryLiquidityPoolRequest = File_inference_inference_query_proto.Messages().ByName("QueryLiquidityPoolRequest")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryLiquidityPoolRequest)(nil)
+
+type fastReflection_QueryLiquidityPoolRequest QueryLiquidityPoolRequest
+
+func (x *QueryLiquidityPoolRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryLiquidityPoolRequest)(x)
+}
+
+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))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryLiquidityPoolRequest_messageType fastReflection_QueryLiquidityPoolRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryLiquidityPoolRequest_messageType{}
+
+type fastReflection_QueryLiquidityPoolRequest_messageType struct{}
+
+func (x fastReflection_QueryLiquidityPoolRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryLiquidityPoolRequest)(nil)
+}
+func (x fastReflection_QueryLiquidityPoolRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryLiquidityPoolRequest)
+}
+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_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_QueryLiquidityPoolRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryLiquidityPoolRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryLiquidityPoolRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryLiquidityPoolRequest)(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_QueryLiquidityPoolRequest) 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_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.QueryLiquidityPoolRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryLiquidityPoolRequest 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_QueryLiquidityPoolRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryLiquidityPoolRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryLiquidityPoolRequest 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_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.QueryLiquidityPoolRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryLiquidityPoolRequest 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_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.QueryLiquidityPoolRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryLiquidityPoolRequest 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_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.QueryLiquidityPoolRequest"))
+ }
+ 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_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.QueryLiquidityPoolRequest"))
+ }
+ 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_QueryLiquidityPoolRequest) 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("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_QueryLiquidityPoolRequest) 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_QueryLiquidityPoolRequest) 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_QueryLiquidityPoolRequest) 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_QueryLiquidityPoolRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryLiquidityPoolRequest)
+ 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().(*QueryLiquidityPoolRequest)
+ 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().(*QueryLiquidityPoolRequest)
+ 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: QueryLiquidityPoolRequest: 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)
+ }
+ 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 (
+ 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_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_QueryLiquidityPoolResponse)(nil)
+
+type fastReflection_QueryLiquidityPoolResponse QueryLiquidityPoolResponse
+
+func (x *QueryLiquidityPoolResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryLiquidityPoolResponse)(x)
+}
+
+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))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryLiquidityPoolResponse_messageType fastReflection_QueryLiquidityPoolResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryLiquidityPoolResponse_messageType{}
+
+type fastReflection_QueryLiquidityPoolResponse_messageType struct{}
+
+func (x fastReflection_QueryLiquidityPoolResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryLiquidityPoolResponse)(nil)
+}
+func (x fastReflection_QueryLiquidityPoolResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryLiquidityPoolResponse)
+}
+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_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_QueryLiquidityPoolResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryLiquidityPoolResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryLiquidityPoolResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryLiquidityPoolResponse)(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_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) {
+ return
+ }
+ }
+ if x.BlockHeight != uint64(0) {
+ value := protoreflect.ValueOfUint64(x.BlockHeight)
+ if !f(fd_QueryLiquidityPoolResponse_block_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_QueryLiquidityPoolResponse) 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)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryLiquidityPoolResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryLiquidityPoolResponse 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_QueryLiquidityPoolResponse) 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)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryLiquidityPoolResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryLiquidityPoolResponse 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_QueryLiquidityPoolResponse) 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)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryLiquidityPoolResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryLiquidityPoolResponse 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_QueryLiquidityPoolResponse) 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()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryLiquidityPoolResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryLiquidityPoolResponse 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_QueryLiquidityPoolResponse) 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"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryLiquidityPoolResponse"))
+ }
+ 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_QueryLiquidityPoolResponse) 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))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryLiquidityPoolResponse"))
+ }
+ 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_QueryLiquidityPoolResponse) 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("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_QueryLiquidityPoolResponse) 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_QueryLiquidityPoolResponse) 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_QueryLiquidityPoolResponse) 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_QueryLiquidityPoolResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryLiquidityPoolResponse)
+ 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.Address)
+ if l > 0 {
+ n += 1 + l + runtime.Sov(uint64(l))
+ }
+ if x.CodeId != 0 {
+ n += 1 + runtime.Sov(uint64(x.CodeId))
+ }
+ if x.BlockHeight != 0 {
+ n += 1 + runtime.Sov(uint64(x.BlockHeight))
+ }
+ 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().(*QueryLiquidityPoolResponse)
+ 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.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))
+ 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)))
+ 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().(*QueryLiquidityPoolResponse)
+ 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: QueryLiquidityPoolResponse: 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)
+ }
+ 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)
+ }
+ x.CodeId = 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.CodeId |= 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 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 |= 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_QueryEpochInfoRequest protoreflect.MessageDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryEpochInfoRequest = File_inference_inference_query_proto.Messages().ByName("QueryEpochInfoRequest")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryEpochInfoRequest)(nil)
+
+type fastReflection_QueryEpochInfoRequest QueryEpochInfoRequest
+
+func (x *QueryEpochInfoRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryEpochInfoRequest)(x)
+}
+
+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))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryEpochInfoRequest_messageType fastReflection_QueryEpochInfoRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryEpochInfoRequest_messageType{}
+
+type fastReflection_QueryEpochInfoRequest_messageType struct{}
+
+func (x fastReflection_QueryEpochInfoRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryEpochInfoRequest)(nil)
+}
+func (x fastReflection_QueryEpochInfoRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryEpochInfoRequest)
+}
+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_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_QueryEpochInfoRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryEpochInfoRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_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_QueryEpochInfoRequest) 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_QueryEpochInfoRequest) 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("message inference.inference.QueryEpochInfoRequest 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_QueryEpochInfoRequest) 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("message inference.inference.QueryEpochInfoRequest 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_QueryEpochInfoRequest) 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("message inference.inference.QueryEpochInfoRequest 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_QueryEpochInfoRequest) 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("message inference.inference.QueryEpochInfoRequest 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_QueryEpochInfoRequest) 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("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_QueryEpochInfoRequest) 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("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_QueryEpochInfoRequest) 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("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_QueryEpochInfoRequest) 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_QueryEpochInfoRequest) 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_QueryEpochInfoRequest) 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_QueryEpochInfoRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryEpochInfoRequest)
+ 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().(*QueryEpochInfoRequest)
+ 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().(*QueryEpochInfoRequest)
+ 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: QueryEpochInfoRequest: 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)
+ }
+ 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 (
+ 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_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_QueryEpochInfoResponse)(nil)
+
+type fastReflection_QueryEpochInfoResponse QueryEpochInfoResponse
+
+func (x *QueryEpochInfoResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryEpochInfoResponse)(x)
+}
+
+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))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryEpochInfoResponse_messageType fastReflection_QueryEpochInfoResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryEpochInfoResponse_messageType{}
+
+type fastReflection_QueryEpochInfoResponse_messageType struct{}
+
+func (x fastReflection_QueryEpochInfoResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryEpochInfoResponse)(nil)
+}
+func (x fastReflection_QueryEpochInfoResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryEpochInfoResponse)
+}
+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_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_QueryEpochInfoResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryEpochInfoResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryEpochInfoResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryEpochInfoResponse)(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_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
+ }
+ }
+}
+
+// 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_QueryEpochInfoResponse) 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
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochInfoResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryEpochInfoResponse 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_QueryEpochInfoResponse) 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
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochInfoResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryEpochInfoResponse 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_QueryEpochInfoResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ 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.QueryEpochInfoResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryEpochInfoResponse 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_QueryEpochInfoResponse) 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)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochInfoResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryEpochInfoResponse 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_QueryEpochInfoResponse) 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"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochInfoResponse"))
+ }
+ 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_QueryEpochInfoResponse) 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())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochInfoResponse"))
+ }
+ 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_QueryEpochInfoResponse) 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("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_QueryEpochInfoResponse) 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_QueryEpochInfoResponse) 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_QueryEpochInfoResponse) 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_QueryEpochInfoResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryEpochInfoResponse)
+ 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.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)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*QueryEpochInfoResponse)
+ 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.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
+ }
+ 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().(*QueryEpochInfoResponse)
+ 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: QueryEpochInfoResponse: 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)
+ }
+ 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)
+ }
+ 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.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
+ }
+ 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,
+ CheckInitialized: nil,
+ }
+}
+
+var (
+ md_QueryCountPoCbatchesAtHeightRequest protoreflect.MessageDescriptor
+ fd_QueryCountPoCbatchesAtHeightRequest_blockHeight protoreflect.FieldDescriptor
+)
+
+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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryCountPoCbatchesAtHeightRequest)(nil)
+
+type fastReflection_QueryCountPoCbatchesAtHeightRequest QueryCountPoCbatchesAtHeightRequest
+
+func (x *QueryCountPoCbatchesAtHeightRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryCountPoCbatchesAtHeightRequest)(x)
+}
+
+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))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryCountPoCbatchesAtHeightRequest_messageType fastReflection_QueryCountPoCbatchesAtHeightRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryCountPoCbatchesAtHeightRequest_messageType{}
+
+type fastReflection_QueryCountPoCbatchesAtHeightRequest_messageType struct{}
+
+func (x fastReflection_QueryCountPoCbatchesAtHeightRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryCountPoCbatchesAtHeightRequest)(nil)
+}
+func (x fastReflection_QueryCountPoCbatchesAtHeightRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryCountPoCbatchesAtHeightRequest)
+}
+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_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_QueryCountPoCbatchesAtHeightRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryCountPoCbatchesAtHeightRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryCountPoCbatchesAtHeightRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryCountPoCbatchesAtHeightRequest)(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
+ }
+ }
+}
+
+// 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_QueryCountPoCbatchesAtHeightRequest) 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("message inference.inference.QueryCountPoCbatchesAtHeightRequest 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_QueryCountPoCbatchesAtHeightRequest) 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("message inference.inference.QueryCountPoCbatchesAtHeightRequest 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_QueryCountPoCbatchesAtHeightRequest) 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("message inference.inference.QueryCountPoCbatchesAtHeightRequest 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_QueryCountPoCbatchesAtHeightRequest) 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("message inference.inference.QueryCountPoCbatchesAtHeightRequest 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_QueryCountPoCbatchesAtHeightRequest) 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("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_QueryCountPoCbatchesAtHeightRequest) 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("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_QueryCountPoCbatchesAtHeightRequest) 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("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_QueryCountPoCbatchesAtHeightRequest) 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_QueryCountPoCbatchesAtHeightRequest) 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_QueryCountPoCbatchesAtHeightRequest) 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_QueryCountPoCbatchesAtHeightRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryCountPoCbatchesAtHeightRequest)
+ 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.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().(*QueryCountPoCbatchesAtHeightRequest)
+ 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.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().(*QueryCountPoCbatchesAtHeightRequest)
+ 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: QueryCountPoCbatchesAtHeightRequest: 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)
+ }
+ 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:])
+ 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_QueryCountPoCbatchesAtHeightResponse protoreflect.MessageDescriptor
+ fd_QueryCountPoCbatchesAtHeightResponse_count 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryCountPoCbatchesAtHeightResponse)(nil)
+
+type fastReflection_QueryCountPoCbatchesAtHeightResponse QueryCountPoCbatchesAtHeightResponse
+
+func (x *QueryCountPoCbatchesAtHeightResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryCountPoCbatchesAtHeightResponse)(x)
+}
+
+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))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryCountPoCbatchesAtHeightResponse_messageType fastReflection_QueryCountPoCbatchesAtHeightResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryCountPoCbatchesAtHeightResponse_messageType{}
+
+type fastReflection_QueryCountPoCbatchesAtHeightResponse_messageType struct{}
+
+func (x fastReflection_QueryCountPoCbatchesAtHeightResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryCountPoCbatchesAtHeightResponse)(nil)
+}
+func (x fastReflection_QueryCountPoCbatchesAtHeightResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryCountPoCbatchesAtHeightResponse)
+}
+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_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_QueryCountPoCbatchesAtHeightResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryCountPoCbatchesAtHeightResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryCountPoCbatchesAtHeightResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryCountPoCbatchesAtHeightResponse)(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_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) {
+ 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_QueryCountPoCbatchesAtHeightResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryCountPoCbatchesAtHeightResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryCountPoCbatchesAtHeightResponse 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_QueryCountPoCbatchesAtHeightResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ 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.QueryCountPoCbatchesAtHeightResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryCountPoCbatchesAtHeightResponse 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_QueryCountPoCbatchesAtHeightResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ 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.QueryCountPoCbatchesAtHeightResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryCountPoCbatchesAtHeightResponse 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_QueryCountPoCbatchesAtHeightResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ 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.QueryCountPoCbatchesAtHeightResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryCountPoCbatchesAtHeightResponse 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_QueryCountPoCbatchesAtHeightResponse) 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"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCbatchesAtHeightResponse"))
+ }
+ 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_QueryCountPoCbatchesAtHeightResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryCountPoCbatchesAtHeightResponse"))
+ }
+ 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_QueryCountPoCbatchesAtHeightResponse) 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("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_QueryCountPoCbatchesAtHeightResponse) 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_QueryCountPoCbatchesAtHeightResponse) 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_QueryCountPoCbatchesAtHeightResponse) 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_QueryCountPoCbatchesAtHeightResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryCountPoCbatchesAtHeightResponse)
+ 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.Count != 0 {
+ n += 1 + runtime.Sov(uint64(x.Count))
+ }
+ 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().(*QueryCountPoCbatchesAtHeightResponse)
+ 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.Count != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.Count))
+ 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().(*QueryCountPoCbatchesAtHeightResponse)
+ 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: QueryCountPoCbatchesAtHeightResponse: 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)
+ }
+ 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 |= 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_QueryCountPoCvalidationsAtHeightRequest protoreflect.MessageDescriptor
+ fd_QueryCountPoCvalidationsAtHeightRequest_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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryCountPoCvalidationsAtHeightRequest)(nil)
+
+type fastReflection_QueryCountPoCvalidationsAtHeightRequest QueryCountPoCvalidationsAtHeightRequest
+
+func (x *QueryCountPoCvalidationsAtHeightRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryCountPoCvalidationsAtHeightRequest)(x)
+}
+
+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))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryCountPoCvalidationsAtHeightRequest_messageType fastReflection_QueryCountPoCvalidationsAtHeightRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryCountPoCvalidationsAtHeightRequest_messageType{}
+
+type fastReflection_QueryCountPoCvalidationsAtHeightRequest_messageType struct{}
+
+func (x fastReflection_QueryCountPoCvalidationsAtHeightRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryCountPoCvalidationsAtHeightRequest)(nil)
+}
+func (x fastReflection_QueryCountPoCvalidationsAtHeightRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryCountPoCvalidationsAtHeightRequest)
+}
+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_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_QueryCountPoCvalidationsAtHeightRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryCountPoCvalidationsAtHeightRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryCountPoCvalidationsAtHeightRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryCountPoCvalidationsAtHeightRequest)(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_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.
+//
+// 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_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.QueryCountPoCvalidationsAtHeightRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryCountPoCvalidationsAtHeightRequest 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_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.QueryCountPoCvalidationsAtHeightRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryCountPoCvalidationsAtHeightRequest 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_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.QueryCountPoCvalidationsAtHeightRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryCountPoCvalidationsAtHeightRequest 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_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.QueryCountPoCvalidationsAtHeightRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryCountPoCvalidationsAtHeightRequest 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_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.QueryCountPoCvalidationsAtHeightRequest"))
+ }
+ 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_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.QueryCountPoCvalidationsAtHeightRequest"))
+ }
+ 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_QueryCountPoCvalidationsAtHeightRequest) 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("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_QueryCountPoCvalidationsAtHeightRequest) 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_QueryCountPoCvalidationsAtHeightRequest) 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_QueryCountPoCvalidationsAtHeightRequest) 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_QueryCountPoCvalidationsAtHeightRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryCountPoCvalidationsAtHeightRequest)
+ 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.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().(*QueryCountPoCvalidationsAtHeightRequest)
+ 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.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().(*QueryCountPoCvalidationsAtHeightRequest)
+ 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: QueryCountPoCvalidationsAtHeightRequest: 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)
+ }
+ 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:])
+ 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_QueryCountPoCvalidationsAtHeightResponse protoreflect.MessageDescriptor
+ fd_QueryCountPoCvalidationsAtHeightResponse_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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryCountPoCvalidationsAtHeightResponse)(nil)
+
+type fastReflection_QueryCountPoCvalidationsAtHeightResponse QueryCountPoCvalidationsAtHeightResponse
+
+func (x *QueryCountPoCvalidationsAtHeightResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryCountPoCvalidationsAtHeightResponse)(x)
+}
+
+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))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryCountPoCvalidationsAtHeightResponse_messageType fastReflection_QueryCountPoCvalidationsAtHeightResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryCountPoCvalidationsAtHeightResponse_messageType{}
+
+type fastReflection_QueryCountPoCvalidationsAtHeightResponse_messageType struct{}
+
+func (x fastReflection_QueryCountPoCvalidationsAtHeightResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryCountPoCvalidationsAtHeightResponse)(nil)
+}
+func (x fastReflection_QueryCountPoCvalidationsAtHeightResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryCountPoCvalidationsAtHeightResponse)
+}
+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_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_QueryCountPoCvalidationsAtHeightResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryCountPoCvalidationsAtHeightResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryCountPoCvalidationsAtHeightResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryCountPoCvalidationsAtHeightResponse)(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_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
+ }
+ }
+}
+
+// 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_QueryCountPoCvalidationsAtHeightResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryCountPoCvalidationsAtHeightResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryCountPoCvalidationsAtHeightResponse 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_QueryCountPoCvalidationsAtHeightResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ 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.QueryCountPoCvalidationsAtHeightResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryCountPoCvalidationsAtHeightResponse 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_QueryCountPoCvalidationsAtHeightResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ 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.QueryCountPoCvalidationsAtHeightResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryCountPoCvalidationsAtHeightResponse 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_QueryCountPoCvalidationsAtHeightResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ 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.QueryCountPoCvalidationsAtHeightResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryCountPoCvalidationsAtHeightResponse 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_QueryCountPoCvalidationsAtHeightResponse) 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"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCvalidationsAtHeightResponse"))
+ }
+ 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_QueryCountPoCvalidationsAtHeightResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryCountPoCvalidationsAtHeightResponse"))
+ }
+ 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_QueryCountPoCvalidationsAtHeightResponse) 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("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_QueryCountPoCvalidationsAtHeightResponse) 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_QueryCountPoCvalidationsAtHeightResponse) 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_QueryCountPoCvalidationsAtHeightResponse) 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_QueryCountPoCvalidationsAtHeightResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryCountPoCvalidationsAtHeightResponse)
+ 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.Count != 0 {
+ n += 1 + runtime.Sov(uint64(x.Count))
+ }
+ 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().(*QueryCountPoCvalidationsAtHeightResponse)
+ 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.Count != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.Count))
+ 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().(*QueryCountPoCvalidationsAtHeightResponse)
+ 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: QueryCountPoCvalidationsAtHeightResponse: 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)
+ }
+ 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 |= 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_QueryApprovedTokensForTradeRequest protoreflect.MessageDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryApprovedTokensForTradeRequest = File_inference_inference_query_proto.Messages().ByName("QueryApprovedTokensForTradeRequest")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryApprovedTokensForTradeRequest)(nil)
+
+type fastReflection_QueryApprovedTokensForTradeRequest QueryApprovedTokensForTradeRequest
+
+func (x *QueryApprovedTokensForTradeRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryApprovedTokensForTradeRequest)(x)
+}
+
+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))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryApprovedTokensForTradeRequest_messageType fastReflection_QueryApprovedTokensForTradeRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryApprovedTokensForTradeRequest_messageType{}
+
+type fastReflection_QueryApprovedTokensForTradeRequest_messageType struct{}
+
+func (x fastReflection_QueryApprovedTokensForTradeRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryApprovedTokensForTradeRequest)(nil)
+}
+func (x fastReflection_QueryApprovedTokensForTradeRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryApprovedTokensForTradeRequest)
+}
+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_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_QueryApprovedTokensForTradeRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryApprovedTokensForTradeRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryApprovedTokensForTradeRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryApprovedTokensForTradeRequest)(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_QueryApprovedTokensForTradeRequest) 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_QueryApprovedTokensForTradeRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryApprovedTokensForTradeRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryApprovedTokensForTradeRequest 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_QueryApprovedTokensForTradeRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryApprovedTokensForTradeRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryApprovedTokensForTradeRequest 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_QueryApprovedTokensForTradeRequest) 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.QueryApprovedTokensForTradeRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryApprovedTokensForTradeRequest 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_QueryApprovedTokensForTradeRequest) 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.QueryApprovedTokensForTradeRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryApprovedTokensForTradeRequest 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_QueryApprovedTokensForTradeRequest) 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.QueryApprovedTokensForTradeRequest"))
+ }
+ 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_QueryApprovedTokensForTradeRequest) 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.QueryApprovedTokensForTradeRequest"))
+ }
+ 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_QueryApprovedTokensForTradeRequest) 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("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_QueryApprovedTokensForTradeRequest) 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_QueryApprovedTokensForTradeRequest) 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_QueryApprovedTokensForTradeRequest) 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_QueryApprovedTokensForTradeRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryApprovedTokensForTradeRequest)
+ 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().(*QueryApprovedTokensForTradeRequest)
+ 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().(*QueryApprovedTokensForTradeRequest)
+ 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: QueryApprovedTokensForTradeRequest: 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)
+ }
+ 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 = (*_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
+)
+
+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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryApprovedTokensForTradeResponse)(nil)
+
+type fastReflection_QueryApprovedTokensForTradeResponse QueryApprovedTokensForTradeResponse
+
+func (x *QueryApprovedTokensForTradeResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryApprovedTokensForTradeResponse)(x)
+}
+
+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))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryApprovedTokensForTradeResponse_messageType fastReflection_QueryApprovedTokensForTradeResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryApprovedTokensForTradeResponse_messageType{}
+
+type fastReflection_QueryApprovedTokensForTradeResponse_messageType struct{}
+
+func (x fastReflection_QueryApprovedTokensForTradeResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryApprovedTokensForTradeResponse)(nil)
+}
+func (x fastReflection_QueryApprovedTokensForTradeResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryApprovedTokensForTradeResponse)
+}
+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_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_QueryApprovedTokensForTradeResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryApprovedTokensForTradeResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryApprovedTokensForTradeResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryApprovedTokensForTradeResponse)(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_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
+ }
+ }
+}
+
+// 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_QueryApprovedTokensForTradeResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryApprovedTokensForTradeResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryApprovedTokensForTradeResponse 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_QueryApprovedTokensForTradeResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ 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.QueryApprovedTokensForTradeResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryApprovedTokensForTradeResponse 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_QueryApprovedTokensForTradeResponse) 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)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryApprovedTokensForTradeResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryApprovedTokensForTradeResponse 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_QueryApprovedTokensForTradeResponse) 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
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryApprovedTokensForTradeResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryApprovedTokensForTradeResponse 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_QueryApprovedTokensForTradeResponse) 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)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryApprovedTokensForTradeResponse"))
+ }
+ 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_QueryApprovedTokensForTradeResponse) 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})
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryApprovedTokensForTradeResponse"))
+ }
+ 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_QueryApprovedTokensForTradeResponse) 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("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_QueryApprovedTokensForTradeResponse) 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_QueryApprovedTokensForTradeResponse) 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_QueryApprovedTokensForTradeResponse) 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_QueryApprovedTokensForTradeResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryApprovedTokensForTradeResponse)
+ 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.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)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*QueryApprovedTokensForTradeResponse)
+ 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.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 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().(*QueryApprovedTokensForTradeResponse)
+ 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: QueryApprovedTokensForTradeResponse: 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)
+ }
+ 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)
+ }
+ 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.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:])
+ 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_QueryGetModelPerTokenPriceRequest protoreflect.MessageDescriptor
+ fd_QueryGetModelPerTokenPriceRequest_model_id protoreflect.FieldDescriptor
+)
+
+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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetModelPerTokenPriceRequest)(nil)
+
+type fastReflection_QueryGetModelPerTokenPriceRequest QueryGetModelPerTokenPriceRequest
+
+func (x *QueryGetModelPerTokenPriceRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetModelPerTokenPriceRequest)(x)
+}
+
+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))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryGetModelPerTokenPriceRequest_messageType fastReflection_QueryGetModelPerTokenPriceRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetModelPerTokenPriceRequest_messageType{}
+
+type fastReflection_QueryGetModelPerTokenPriceRequest_messageType struct{}
+
+func (x fastReflection_QueryGetModelPerTokenPriceRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetModelPerTokenPriceRequest)(nil)
+}
+func (x fastReflection_QueryGetModelPerTokenPriceRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetModelPerTokenPriceRequest)
+}
+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_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_QueryGetModelPerTokenPriceRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetModelPerTokenPriceRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryGetModelPerTokenPriceRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetModelPerTokenPriceRequest)(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_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.
+//
+// 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_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.QueryGetModelPerTokenPriceRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetModelPerTokenPriceRequest 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_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.QueryGetModelPerTokenPriceRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetModelPerTokenPriceRequest 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_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.QueryGetModelPerTokenPriceRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetModelPerTokenPriceRequest 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_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.QueryGetModelPerTokenPriceRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetModelPerTokenPriceRequest 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_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.QueryGetModelPerTokenPriceRequest"))
+ }
+ 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_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.QueryGetModelPerTokenPriceRequest"))
+ }
+ 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_QueryGetModelPerTokenPriceRequest) 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("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_QueryGetModelPerTokenPriceRequest) 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_QueryGetModelPerTokenPriceRequest) 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_QueryGetModelPerTokenPriceRequest) 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_QueryGetModelPerTokenPriceRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetModelPerTokenPriceRequest)
+ 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))
+ }
+ 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().(*QueryGetModelPerTokenPriceRequest)
+ 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.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().(*QueryGetModelPerTokenPriceRequest)
+ 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: QueryGetModelPerTokenPriceRequest: 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)
+ }
+ 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:])
+ 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_QueryGetModelPerTokenPriceResponse protoreflect.MessageDescriptor
+ fd_QueryGetModelPerTokenPriceResponse_price protoreflect.FieldDescriptor
+ fd_QueryGetModelPerTokenPriceResponse_found 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetModelPerTokenPriceResponse)(nil)
+
+type fastReflection_QueryGetModelPerTokenPriceResponse QueryGetModelPerTokenPriceResponse
+
+func (x *QueryGetModelPerTokenPriceResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetModelPerTokenPriceResponse)(x)
+}
+
+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))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryGetModelPerTokenPriceResponse_messageType fastReflection_QueryGetModelPerTokenPriceResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetModelPerTokenPriceResponse_messageType{}
+
+type fastReflection_QueryGetModelPerTokenPriceResponse_messageType struct{}
+
+func (x fastReflection_QueryGetModelPerTokenPriceResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetModelPerTokenPriceResponse)(nil)
+}
+func (x fastReflection_QueryGetModelPerTokenPriceResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetModelPerTokenPriceResponse)
+}
+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_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_QueryGetModelPerTokenPriceResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetModelPerTokenPriceResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryGetModelPerTokenPriceResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetModelPerTokenPriceResponse)(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_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) {
+ 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_QueryGetModelPerTokenPriceResponse) 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
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelPerTokenPriceResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetModelPerTokenPriceResponse 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_QueryGetModelPerTokenPriceResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ 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.QueryGetModelPerTokenPriceResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetModelPerTokenPriceResponse 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_QueryGetModelPerTokenPriceResponse) 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)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelPerTokenPriceResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetModelPerTokenPriceResponse 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_QueryGetModelPerTokenPriceResponse) 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()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelPerTokenPriceResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetModelPerTokenPriceResponse 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_QueryGetModelPerTokenPriceResponse) 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"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelPerTokenPriceResponse"))
+ }
+ 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_QueryGetModelPerTokenPriceResponse) 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)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelPerTokenPriceResponse"))
+ }
+ 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_QueryGetModelPerTokenPriceResponse) 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("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_QueryGetModelPerTokenPriceResponse) 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_QueryGetModelPerTokenPriceResponse) 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_QueryGetModelPerTokenPriceResponse) 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_QueryGetModelPerTokenPriceResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetModelPerTokenPriceResponse)
+ 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.Price != 0 {
+ n += 1 + runtime.Sov(uint64(x.Price))
+ }
+ 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().(*QueryGetModelPerTokenPriceResponse)
+ 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.Price != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.Price))
+ 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().(*QueryGetModelPerTokenPriceResponse)
+ 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: QueryGetModelPerTokenPriceResponse: 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)
+ }
+ 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)
+ }
+ 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
+ }
+ }
+ 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_QueryGetAllModelPerTokenPricesRequest protoreflect.MessageDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryGetAllModelPerTokenPricesRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetAllModelPerTokenPricesRequest")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetAllModelPerTokenPricesRequest)(nil)
+
+type fastReflection_QueryGetAllModelPerTokenPricesRequest QueryGetAllModelPerTokenPricesRequest
+
+func (x *QueryGetAllModelPerTokenPricesRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetAllModelPerTokenPricesRequest)(x)
+}
+
+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))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryGetAllModelPerTokenPricesRequest_messageType fastReflection_QueryGetAllModelPerTokenPricesRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetAllModelPerTokenPricesRequest_messageType{}
+
+type fastReflection_QueryGetAllModelPerTokenPricesRequest_messageType struct{}
+
+func (x fastReflection_QueryGetAllModelPerTokenPricesRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetAllModelPerTokenPricesRequest)(nil)
+}
+func (x fastReflection_QueryGetAllModelPerTokenPricesRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetAllModelPerTokenPricesRequest)
+}
+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_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_QueryGetAllModelPerTokenPricesRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetAllModelPerTokenPricesRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryGetAllModelPerTokenPricesRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetAllModelPerTokenPricesRequest)(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_QueryGetAllModelPerTokenPricesRequest) 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_QueryGetAllModelPerTokenPricesRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelPerTokenPricesRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetAllModelPerTokenPricesRequest 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_QueryGetAllModelPerTokenPricesRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelPerTokenPricesRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetAllModelPerTokenPricesRequest 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_QueryGetAllModelPerTokenPricesRequest) 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.QueryGetAllModelPerTokenPricesRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetAllModelPerTokenPricesRequest 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_QueryGetAllModelPerTokenPricesRequest) 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.QueryGetAllModelPerTokenPricesRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetAllModelPerTokenPricesRequest 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_QueryGetAllModelPerTokenPricesRequest) 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.QueryGetAllModelPerTokenPricesRequest"))
+ }
+ 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_QueryGetAllModelPerTokenPricesRequest) 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.QueryGetAllModelPerTokenPricesRequest"))
+ }
+ 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_QueryGetAllModelPerTokenPricesRequest) 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("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_QueryGetAllModelPerTokenPricesRequest) 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_QueryGetAllModelPerTokenPricesRequest) 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_QueryGetAllModelPerTokenPricesRequest) 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_QueryGetAllModelPerTokenPricesRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetAllModelPerTokenPricesRequest)
+ 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().(*QueryGetAllModelPerTokenPricesRequest)
+ 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().(*QueryGetAllModelPerTokenPricesRequest)
+ 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: QueryGetAllModelPerTokenPricesRequest: 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)
+ }
+ 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 (
+ md_ModelPrice protoreflect.MessageDescriptor
+ fd_ModelPrice_model_id protoreflect.FieldDescriptor
+ fd_ModelPrice_price 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_ModelPrice)(nil)
+
+type fastReflection_ModelPrice ModelPrice
+
+func (x *ModelPrice) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_ModelPrice)(x)
+}
+
+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))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_ModelPrice_messageType fastReflection_ModelPrice_messageType
+var _ protoreflect.MessageType = fastReflection_ModelPrice_messageType{}
+
+type fastReflection_ModelPrice_messageType struct{}
+
+func (x fastReflection_ModelPrice_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_ModelPrice)(nil)
+}
+func (x fastReflection_ModelPrice_messageType) New() protoreflect.Message {
+ return new(fastReflection_ModelPrice)
+}
+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_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_ModelPrice) Type() protoreflect.MessageType {
+ return _fastReflection_ModelPrice_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_ModelPrice) Interface() protoreflect.ProtoMessage {
+ return (*ModelPrice)(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_ModelPrice) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.ModelId != "" {
+ value := protoreflect.ValueOfString(x.ModelId)
+ 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
+ }
+ }
+}
+
+// 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_ModelPrice) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.ModelPrice"))
+ }
+ panic(fmt.Errorf("message inference.inference.ModelPrice 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_ModelPrice) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ 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.ModelPrice"))
+ }
+ panic(fmt.Errorf("message inference.inference.ModelPrice 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_ModelPrice) 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":
+ value := x.Price
+ return protoreflect.ValueOfUint64(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelPrice"))
+ }
+ panic(fmt.Errorf("message inference.inference.ModelPrice 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_ModelPrice) 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":
+ x.Price = value.Uint()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelPrice"))
+ }
+ panic(fmt.Errorf("message inference.inference.ModelPrice 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_ModelPrice) 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"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelPrice"))
+ }
+ 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_ModelPrice) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.ModelPrice"))
+ }
+ 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_ModelPrice) 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("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_ModelPrice) 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_ModelPrice) 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_ModelPrice) 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_ModelPrice) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*ModelPrice)
+ 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))
+ }
+ if x.Price != 0 {
+ n += 1 + runtime.Sov(uint64(x.Price))
+ }
+ 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().(*ModelPrice)
+ 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.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)
+ 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().(*ModelPrice)
+ 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: ModelPrice: 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)
+ }
+ 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 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:])
+ 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 = (*_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
+)
+
+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_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_QueryGetAllModelPerTokenPricesResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetAllModelPerTokenPricesResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryGetAllModelPerTokenPricesResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetAllModelPerTokenPricesResponse)(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_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
+ }
+ }
+}
+
+// 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_QueryGetAllModelPerTokenPricesResponse) 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("message inference.inference.QueryGetAllModelPerTokenPricesResponse 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_QueryGetAllModelPerTokenPricesResponse) 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("message inference.inference.QueryGetAllModelPerTokenPricesResponse 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_QueryGetAllModelPerTokenPricesResponse) 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("message inference.inference.QueryGetAllModelPerTokenPricesResponse 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_QueryGetAllModelPerTokenPricesResponse) 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("message inference.inference.QueryGetAllModelPerTokenPricesResponse 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_QueryGetAllModelPerTokenPricesResponse) 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("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_QueryGetAllModelPerTokenPricesResponse) 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("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_QueryGetAllModelPerTokenPricesResponse) 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("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_QueryGetAllModelPerTokenPricesResponse) 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_QueryGetAllModelPerTokenPricesResponse) 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_QueryGetAllModelPerTokenPricesResponse) 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_QueryGetAllModelPerTokenPricesResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetAllModelPerTokenPricesResponse)
+ 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.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)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*QueryGetAllModelPerTokenPricesResponse)
+ 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.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 {
+ 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().(*QueryGetAllModelPerTokenPricesResponse)
+ 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: QueryGetAllModelPerTokenPricesResponse: 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)
+ }
+ 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:])
+ 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_QueryGetModelCapacityRequest protoreflect.MessageDescriptor
+ fd_QueryGetModelCapacityRequest_model_id 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetModelCapacityRequest)(nil)
+
+type fastReflection_QueryGetModelCapacityRequest QueryGetModelCapacityRequest
+
+func (x *QueryGetModelCapacityRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetModelCapacityRequest)(x)
+}
+
+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))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryGetModelCapacityRequest_messageType fastReflection_QueryGetModelCapacityRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetModelCapacityRequest_messageType{}
+
+type fastReflection_QueryGetModelCapacityRequest_messageType struct{}
+
+func (x fastReflection_QueryGetModelCapacityRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetModelCapacityRequest)(nil)
+}
+func (x fastReflection_QueryGetModelCapacityRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetModelCapacityRequest)
+}
+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_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_QueryGetModelCapacityRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetModelCapacityRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryGetModelCapacityRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetModelCapacityRequest)(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_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.
+//
+// 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_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.QueryGetModelCapacityRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetModelCapacityRequest 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_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.QueryGetModelCapacityRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetModelCapacityRequest 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_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.QueryGetModelCapacityRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetModelCapacityRequest 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_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.QueryGetModelCapacityRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetModelCapacityRequest 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_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.QueryGetModelCapacityRequest"))
+ }
+ 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_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.QueryGetModelCapacityRequest"))
+ }
+ 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_QueryGetModelCapacityRequest) 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("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_QueryGetModelCapacityRequest) 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_QueryGetModelCapacityRequest) 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_QueryGetModelCapacityRequest) 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_QueryGetModelCapacityRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetModelCapacityRequest)
+ 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))
+ }
+ 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().(*QueryGetModelCapacityRequest)
+ 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.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().(*QueryGetModelCapacityRequest)
+ 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: QueryGetModelCapacityRequest: 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)
+ }
+ 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:])
+ 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_QueryGetModelCapacityResponse protoreflect.MessageDescriptor
+ fd_QueryGetModelCapacityResponse_capacity protoreflect.FieldDescriptor
+ fd_QueryGetModelCapacityResponse_found protoreflect.FieldDescriptor
+)
+
+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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetModelCapacityResponse)(nil)
+
+type fastReflection_QueryGetModelCapacityResponse QueryGetModelCapacityResponse
+
+func (x *QueryGetModelCapacityResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetModelCapacityResponse)(x)
+}
+
+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)
+}
+
+var _fastReflection_QueryGetModelCapacityResponse_messageType fastReflection_QueryGetModelCapacityResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetModelCapacityResponse_messageType{}
+
+type fastReflection_QueryGetModelCapacityResponse_messageType struct{}
+
+func (x fastReflection_QueryGetModelCapacityResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetModelCapacityResponse)(nil)
+}
+func (x fastReflection_QueryGetModelCapacityResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetModelCapacityResponse)
+}
+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_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_QueryGetModelCapacityResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetModelCapacityResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryGetModelCapacityResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetModelCapacityResponse)(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_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
+ }
+ }
+}
+
+// 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_QueryGetModelCapacityResponse) 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
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelCapacityResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetModelCapacityResponse 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_QueryGetModelCapacityResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ 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.QueryGetModelCapacityResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetModelCapacityResponse 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_QueryGetModelCapacityResponse) 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)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelCapacityResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetModelCapacityResponse 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_QueryGetModelCapacityResponse) 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()
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelCapacityResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetModelCapacityResponse 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_QueryGetModelCapacityResponse) 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"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelCapacityResponse"))
+ }
+ 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_QueryGetModelCapacityResponse) 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)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelCapacityResponse"))
+ }
+ 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_QueryGetModelCapacityResponse) 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("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_QueryGetModelCapacityResponse) 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_QueryGetModelCapacityResponse) 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_QueryGetModelCapacityResponse) 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_QueryGetModelCapacityResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetModelCapacityResponse)
+ 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.Capacity != 0 {
+ n += 1 + runtime.Sov(uint64(x.Capacity))
+ }
+ 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().(*QueryGetModelCapacityResponse)
+ 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.Capacity != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.Capacity))
+ 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().(*QueryGetModelCapacityResponse)
+ 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: QueryGetModelCapacityResponse: 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)
+ }
+ 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)
+ }
+ 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
+ }
+ }
+ 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_QueryGetAllModelCapacitiesRequest protoreflect.MessageDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryGetAllModelCapacitiesRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetAllModelCapacitiesRequest")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetAllModelCapacitiesRequest)(nil)
+
+type fastReflection_QueryGetAllModelCapacitiesRequest QueryGetAllModelCapacitiesRequest
+
+func (x *QueryGetAllModelCapacitiesRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetAllModelCapacitiesRequest)(x)
+}
+
+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))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryGetAllModelCapacitiesRequest_messageType fastReflection_QueryGetAllModelCapacitiesRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetAllModelCapacitiesRequest_messageType{}
+
+type fastReflection_QueryGetAllModelCapacitiesRequest_messageType struct{}
+
+func (x fastReflection_QueryGetAllModelCapacitiesRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetAllModelCapacitiesRequest)(nil)
+}
+func (x fastReflection_QueryGetAllModelCapacitiesRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetAllModelCapacitiesRequest)
+}
+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_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_QueryGetAllModelCapacitiesRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetAllModelCapacitiesRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryGetAllModelCapacitiesRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetAllModelCapacitiesRequest)(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_QueryGetAllModelCapacitiesRequest) 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_QueryGetAllModelCapacitiesRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelCapacitiesRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetAllModelCapacitiesRequest 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_QueryGetAllModelCapacitiesRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelCapacitiesRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetAllModelCapacitiesRequest 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_QueryGetAllModelCapacitiesRequest) 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.QueryGetAllModelCapacitiesRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetAllModelCapacitiesRequest 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_QueryGetAllModelCapacitiesRequest) 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.QueryGetAllModelCapacitiesRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetAllModelCapacitiesRequest 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_QueryGetAllModelCapacitiesRequest) 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.QueryGetAllModelCapacitiesRequest"))
+ }
+ 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_QueryGetAllModelCapacitiesRequest) 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.QueryGetAllModelCapacitiesRequest"))
+ }
+ 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_QueryGetAllModelCapacitiesRequest) 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("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_QueryGetAllModelCapacitiesRequest) 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_QueryGetAllModelCapacitiesRequest) 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_QueryGetAllModelCapacitiesRequest) 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_QueryGetAllModelCapacitiesRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetAllModelCapacitiesRequest)
+ 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().(*QueryGetAllModelCapacitiesRequest)
+ 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().(*QueryGetAllModelCapacitiesRequest)
+ 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: QueryGetAllModelCapacitiesRequest: 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)
+ }
+ 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 = (*_QueryGetAllModelCapacitiesResponse_1_list)(nil)
+
+type _QueryGetAllModelCapacitiesResponse_1_list struct {
+ list *[]*ModelCapacity
+}
+
+func (x *_QueryGetAllModelCapacitiesResponse_1_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_QueryGetAllModelCapacitiesResponse_1_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryGetAllModelCapacitiesResponse_1_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.Message()
+ concreteValue := valueUnwrapped.Interface().(*ModelCapacity)
+ (*x.list)[i] = concreteValue
+}
+
+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)
+ }
+ 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
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+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_QueryGetAllModelCapacitiesResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetAllModelCapacitiesResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryGetAllModelCapacitiesResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetAllModelCapacitiesResponse)(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_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
+ }
+ }
+}
+
+// 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_QueryGetAllModelCapacitiesResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryGetAllModelCapacitiesResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetAllModelCapacitiesResponse 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_QueryGetAllModelCapacitiesResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ 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.QueryGetAllModelCapacitiesResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetAllModelCapacitiesResponse 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_QueryGetAllModelCapacitiesResponse) 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)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelCapacitiesResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetAllModelCapacitiesResponse 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_QueryGetAllModelCapacitiesResponse) 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
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelCapacitiesResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetAllModelCapacitiesResponse 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_QueryGetAllModelCapacitiesResponse) 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)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelCapacitiesResponse"))
+ }
+ 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_QueryGetAllModelCapacitiesResponse) 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})
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelCapacitiesResponse"))
+ }
+ 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_QueryGetAllModelCapacitiesResponse) 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("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_QueryGetAllModelCapacitiesResponse) 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_QueryGetAllModelCapacitiesResponse) 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_QueryGetAllModelCapacitiesResponse) 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_QueryGetAllModelCapacitiesResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetAllModelCapacitiesResponse)
+ 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.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)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*QueryGetAllModelCapacitiesResponse)
+ 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.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...)
+ } 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().(*QueryGetAllModelCapacitiesResponse)
+ 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: QueryGetAllModelCapacitiesResponse: 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)
+ }
+ 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)
+ }
+ 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.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
+ }
+ 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_ModelCapacity protoreflect.MessageDescriptor
+ fd_ModelCapacity_model_id protoreflect.FieldDescriptor
+ fd_ModelCapacity_capacity protoreflect.FieldDescriptor
+)
+
+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")
+}
+
+var _ protoreflect.Message = (*fastReflection_ModelCapacity)(nil)
+
+type fastReflection_ModelCapacity ModelCapacity
+
+func (x *ModelCapacity) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_ModelCapacity)(x)
+}
+
+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))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_ModelCapacity_messageType fastReflection_ModelCapacity_messageType
+var _ protoreflect.MessageType = fastReflection_ModelCapacity_messageType{}
+
+type fastReflection_ModelCapacity_messageType struct{}
+
+func (x fastReflection_ModelCapacity_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_ModelCapacity)(nil)
+}
+func (x fastReflection_ModelCapacity_messageType) New() protoreflect.Message {
+ return new(fastReflection_ModelCapacity)
+}
+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_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_ModelCapacity) Type() protoreflect.MessageType {
+ return _fastReflection_ModelCapacity_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_ModelCapacity) Interface() protoreflect.ProtoMessage {
+ return (*ModelCapacity)(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_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
+ }
+ }
+}
+
+// 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_ModelCapacity) 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("message inference.inference.ModelCapacity 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_ModelCapacity) 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("message inference.inference.ModelCapacity 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_ModelCapacity) 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("message inference.inference.ModelCapacity 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_ModelCapacity) 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("message inference.inference.ModelCapacity 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_ModelCapacity) 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("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_ModelCapacity) 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("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_ModelCapacity) 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("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_ModelCapacity) 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_ModelCapacity) 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_ModelCapacity) 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_ModelCapacity) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*ModelCapacity)
+ 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))
+ }
+ if x.Capacity != 0 {
+ n += 1 + runtime.Sov(uint64(x.Capacity))
+ }
+ 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().(*ModelCapacity)
+ 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.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 {
+ 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().(*ModelCapacity)
+ 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: ModelCapacity: 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)
+ }
+ 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:])
+ 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_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_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_QueryGranteesByMessageTypeRequest)(nil)
+
+type fastReflection_QueryGranteesByMessageTypeRequest QueryGranteesByMessageTypeRequest
+
+func (x *QueryGranteesByMessageTypeRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGranteesByMessageTypeRequest)(x)
+}
+
+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))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryGranteesByMessageTypeRequest_messageType fastReflection_QueryGranteesByMessageTypeRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGranteesByMessageTypeRequest_messageType{}
+
+type fastReflection_QueryGranteesByMessageTypeRequest_messageType struct{}
+
+func (x fastReflection_QueryGranteesByMessageTypeRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGranteesByMessageTypeRequest)(nil)
+}
+func (x fastReflection_QueryGranteesByMessageTypeRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGranteesByMessageTypeRequest)
+}
+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_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_QueryGranteesByMessageTypeRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGranteesByMessageTypeRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryGranteesByMessageTypeRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryGranteesByMessageTypeRequest)(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_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
+ }
+ }
+}
+
+// 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_QueryGranteesByMessageTypeRequest) 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 != ""
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGranteesByMessageTypeRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGranteesByMessageTypeRequest 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_QueryGranteesByMessageTypeRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ 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.QueryGranteesByMessageTypeRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGranteesByMessageTypeRequest 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_QueryGranteesByMessageTypeRequest) 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)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGranteesByMessageTypeRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGranteesByMessageTypeRequest 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_QueryGranteesByMessageTypeRequest) 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)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGranteesByMessageTypeRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGranteesByMessageTypeRequest 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_QueryGranteesByMessageTypeRequest) 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"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGranteesByMessageTypeRequest"))
+ }
+ 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_QueryGranteesByMessageTypeRequest) 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("")
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGranteesByMessageTypeRequest"))
+ }
+ 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_QueryGranteesByMessageTypeRequest) 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("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_QueryGranteesByMessageTypeRequest) 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_QueryGranteesByMessageTypeRequest) 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_QueryGranteesByMessageTypeRequest) 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_QueryGranteesByMessageTypeRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGranteesByMessageTypeRequest)
+ 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.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)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*QueryGranteesByMessageTypeRequest)
+ 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.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...)
+ } 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().(*QueryGranteesByMessageTypeRequest)
+ 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: QueryGranteesByMessageTypeRequest: 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)
+ }
+ 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)
+ }
+ 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.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
+ 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_Grantee protoreflect.MessageDescriptor
+ fd_Grantee_address protoreflect.FieldDescriptor
+ fd_Grantee_pub_key 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_Grantee)(nil)
+
+type fastReflection_Grantee Grantee
+
+func (x *Grantee) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_Grantee)(x)
+}
+
+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))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_Grantee_messageType fastReflection_Grantee_messageType
+var _ protoreflect.MessageType = fastReflection_Grantee_messageType{}
+
+type fastReflection_Grantee_messageType struct{}
+
+func (x fastReflection_Grantee_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_Grantee)(nil)
+}
+func (x fastReflection_Grantee_messageType) New() protoreflect.Message {
+ return new(fastReflection_Grantee)
+}
+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_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_Grantee) Type() protoreflect.MessageType {
+ return _fastReflection_Grantee_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_Grantee) Interface() protoreflect.ProtoMessage {
+ return (*Grantee)(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_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.
+//
+// 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_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.Grantee"))
+ }
+ panic(fmt.Errorf("message inference.inference.Grantee 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_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.Grantee"))
+ }
+ panic(fmt.Errorf("message inference.inference.Grantee 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_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.Grantee"))
+ }
+ panic(fmt.Errorf("message inference.inference.Grantee 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_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.Grantee"))
+ }
+ panic(fmt.Errorf("message inference.inference.Grantee 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_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.Grantee"))
+ }
+ 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_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.Grantee"))
+ }
+ 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_Grantee) 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("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_Grantee) 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_Grantee) 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_Grantee) 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_Grantee) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*Grantee)
+ 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.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)
+ }
+ return protoiface.SizeOutput{
+ NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+ Size: n,
+ }
+ }
+
+ marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+ x := input.Message.Interface().(*Grantee)
+ 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.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 {
+ 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().(*Grantee)
+ 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: Grantee: 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)
+ }
+ 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 != 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
+ }
+ 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 = (*_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
+)
+
+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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGranteesByMessageTypeResponse)(nil)
+
+type fastReflection_QueryGranteesByMessageTypeResponse QueryGranteesByMessageTypeResponse
+
+func (x *QueryGranteesByMessageTypeResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGranteesByMessageTypeResponse)(x)
+}
+
+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))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryGranteesByMessageTypeResponse_messageType fastReflection_QueryGranteesByMessageTypeResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGranteesByMessageTypeResponse_messageType{}
+
+type fastReflection_QueryGranteesByMessageTypeResponse_messageType struct{}
+
+func (x fastReflection_QueryGranteesByMessageTypeResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGranteesByMessageTypeResponse)(nil)
+}
+func (x fastReflection_QueryGranteesByMessageTypeResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGranteesByMessageTypeResponse)
+}
+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_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_QueryGranteesByMessageTypeResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGranteesByMessageTypeResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryGranteesByMessageTypeResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryGranteesByMessageTypeResponse)(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_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
+ }
+ }
+}
+
+// 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_QueryGranteesByMessageTypeResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryGranteesByMessageTypeResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGranteesByMessageTypeResponse 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_QueryGranteesByMessageTypeResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryGranteesByMessageTypeResponse.grantees":
+ x.Grantees = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGranteesByMessageTypeResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGranteesByMessageTypeResponse 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_QueryGranteesByMessageTypeResponse) 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)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGranteesByMessageTypeResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGranteesByMessageTypeResponse 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_QueryGranteesByMessageTypeResponse) 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
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGranteesByMessageTypeResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGranteesByMessageTypeResponse 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_QueryGranteesByMessageTypeResponse) 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)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGranteesByMessageTypeResponse"))
+ }
+ 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_QueryGranteesByMessageTypeResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryGranteesByMessageTypeResponse"))
+ }
+ 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_QueryGranteesByMessageTypeResponse) 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("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_QueryGranteesByMessageTypeResponse) 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_QueryGranteesByMessageTypeResponse) 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_QueryGranteesByMessageTypeResponse) 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_QueryGranteesByMessageTypeResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGranteesByMessageTypeResponse)
+ 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.Grantees) > 0 {
+ for _, e := range x.Grantees {
+ 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().(*QueryGranteesByMessageTypeResponse)
+ 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.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 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().(*QueryGranteesByMessageTypeResponse)
+ 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: QueryGranteesByMessageTypeResponse: 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)
+ }
+ 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)
+ }
+ 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.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
+ 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_QueryTrainingAllowListRequest protoreflect.MessageDescriptor
+ fd_QueryTrainingAllowListRequest_role protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryTrainingAllowListRequest = File_inference_inference_query_proto.Messages().ByName("QueryTrainingAllowListRequest")
+ fd_QueryTrainingAllowListRequest_role = md_QueryTrainingAllowListRequest.Fields().ByName("role")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryTrainingAllowListRequest)(nil)
+
+type fastReflection_QueryTrainingAllowListRequest QueryTrainingAllowListRequest
+
+func (x *QueryTrainingAllowListRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryTrainingAllowListRequest)(x)
+}
+
+func (x *QueryTrainingAllowListRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[143]
+ 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_QueryTrainingAllowListRequest_messageType fastReflection_QueryTrainingAllowListRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryTrainingAllowListRequest_messageType{}
+
+type fastReflection_QueryTrainingAllowListRequest_messageType struct{}
+
+func (x fastReflection_QueryTrainingAllowListRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryTrainingAllowListRequest)(nil)
+}
+func (x fastReflection_QueryTrainingAllowListRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryTrainingAllowListRequest)
+}
+func (x fastReflection_QueryTrainingAllowListRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryTrainingAllowListRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryTrainingAllowListRequest) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryTrainingAllowListRequest
+}
+
+// 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_QueryTrainingAllowListRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryTrainingAllowListRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryTrainingAllowListRequest) New() protoreflect.Message {
+ return new(fastReflection_QueryTrainingAllowListRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryTrainingAllowListRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryTrainingAllowListRequest)(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_QueryTrainingAllowListRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if x.Role != int32(0) {
+ value := protoreflect.ValueOfInt32(x.Role)
+ if !f(fd_QueryTrainingAllowListRequest_role, 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_QueryTrainingAllowListRequest) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingAllowListRequest.role":
+ return x.Role != int32(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingAllowListRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingAllowListRequest 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_QueryTrainingAllowListRequest) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingAllowListRequest.role":
+ x.Role = int32(0)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingAllowListRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingAllowListRequest 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_QueryTrainingAllowListRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryTrainingAllowListRequest.role":
+ value := x.Role
+ return protoreflect.ValueOfInt32(value)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingAllowListRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingAllowListRequest 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_QueryTrainingAllowListRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingAllowListRequest.role":
+ x.Role = int32(value.Int())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingAllowListRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingAllowListRequest 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_QueryTrainingAllowListRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingAllowListRequest.role":
+ panic(fmt.Errorf("field role of message inference.inference.QueryTrainingAllowListRequest is not mutable"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingAllowListRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingAllowListRequest 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_QueryTrainingAllowListRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingAllowListRequest.role":
+ return protoreflect.ValueOfInt32(int32(0))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingAllowListRequest"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingAllowListRequest 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_QueryTrainingAllowListRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryTrainingAllowListRequest", 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_QueryTrainingAllowListRequest) 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_QueryTrainingAllowListRequest) 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_QueryTrainingAllowListRequest) 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_QueryTrainingAllowListRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryTrainingAllowListRequest)
+ 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.Role != 0 {
+ n += 1 + runtime.Sov(uint64(x.Role))
+ }
+ 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().(*QueryTrainingAllowListRequest)
+ 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.Role != 0 {
+ i = runtime.EncodeVarint(dAtA, i, uint64(x.Role))
+ 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().(*QueryTrainingAllowListRequest)
+ 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: QueryTrainingAllowListRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryTrainingAllowListRequest: 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 Role", wireType)
+ }
+ x.Role = 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.Role |= 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,
+ Size: size,
+ Marshal: marshal,
+ Unmarshal: unmarshal,
+ Merge: nil,
+ CheckInitialized: nil,
+ }
+}
+
+var _ protoreflect.List = (*_QueryTrainingAllowListResponse_1_list)(nil)
+
+type _QueryTrainingAllowListResponse_1_list struct {
+ list *[]string
+}
+
+func (x *_QueryTrainingAllowListResponse_1_list) Len() int {
+ if x.list == nil {
+ return 0
+ }
+ return len(*x.list)
+}
+
+func (x *_QueryTrainingAllowListResponse_1_list) Get(i int) protoreflect.Value {
+ return protoreflect.ValueOfString((*x.list)[i])
+}
+
+func (x *_QueryTrainingAllowListResponse_1_list) Set(i int, value protoreflect.Value) {
+ valueUnwrapped := value.String()
+ concreteValue := valueUnwrapped
+ (*x.list)[i] = concreteValue
+}
+
+func (x *_QueryTrainingAllowListResponse_1_list) Append(value protoreflect.Value) {
+ valueUnwrapped := value.String()
+ concreteValue := valueUnwrapped
+ *x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryTrainingAllowListResponse_1_list) AppendMutable() protoreflect.Value {
+ panic(fmt.Errorf("AppendMutable can not be called on message QueryTrainingAllowListResponse at list field Addresses as it is not of Message kind"))
+}
+
+func (x *_QueryTrainingAllowListResponse_1_list) Truncate(n int) {
+ *x.list = (*x.list)[:n]
+}
+
+func (x *_QueryTrainingAllowListResponse_1_list) NewElement() protoreflect.Value {
+ v := ""
+ return protoreflect.ValueOfString(v)
+}
+
+func (x *_QueryTrainingAllowListResponse_1_list) IsValid() bool {
+ return x.list != nil
+}
+
+var (
+ md_QueryTrainingAllowListResponse protoreflect.MessageDescriptor
+ fd_QueryTrainingAllowListResponse_addresses protoreflect.FieldDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryTrainingAllowListResponse = File_inference_inference_query_proto.Messages().ByName("QueryTrainingAllowListResponse")
+ fd_QueryTrainingAllowListResponse_addresses = md_QueryTrainingAllowListResponse.Fields().ByName("addresses")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryTrainingAllowListResponse)(nil)
+
+type fastReflection_QueryTrainingAllowListResponse QueryTrainingAllowListResponse
+
+func (x *QueryTrainingAllowListResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryTrainingAllowListResponse)(x)
+}
+
+func (x *QueryTrainingAllowListResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[144]
+ 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_QueryTrainingAllowListResponse_messageType fastReflection_QueryTrainingAllowListResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryTrainingAllowListResponse_messageType{}
+
+type fastReflection_QueryTrainingAllowListResponse_messageType struct{}
+
+func (x fastReflection_QueryTrainingAllowListResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryTrainingAllowListResponse)(nil)
+}
+func (x fastReflection_QueryTrainingAllowListResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryTrainingAllowListResponse)
+}
+func (x fastReflection_QueryTrainingAllowListResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryTrainingAllowListResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryTrainingAllowListResponse) Descriptor() protoreflect.MessageDescriptor {
+ return md_QueryTrainingAllowListResponse
+}
+
+// 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_QueryTrainingAllowListResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryTrainingAllowListResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryTrainingAllowListResponse) New() protoreflect.Message {
+ return new(fastReflection_QueryTrainingAllowListResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryTrainingAllowListResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryTrainingAllowListResponse)(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_QueryTrainingAllowListResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+ if len(x.Addresses) != 0 {
+ value := protoreflect.ValueOfList(&_QueryTrainingAllowListResponse_1_list{list: &x.Addresses})
+ if !f(fd_QueryTrainingAllowListResponse_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_QueryTrainingAllowListResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingAllowListResponse.addresses":
+ return len(x.Addresses) != 0
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingAllowListResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingAllowListResponse 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_QueryTrainingAllowListResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingAllowListResponse.addresses":
+ x.Addresses = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingAllowListResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingAllowListResponse 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_QueryTrainingAllowListResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ case "inference.inference.QueryTrainingAllowListResponse.addresses":
+ if len(x.Addresses) == 0 {
+ return protoreflect.ValueOfList(&_QueryTrainingAllowListResponse_1_list{})
+ }
+ listValue := &_QueryTrainingAllowListResponse_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.QueryTrainingAllowListResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingAllowListResponse 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_QueryTrainingAllowListResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingAllowListResponse.addresses":
+ lv := value.List()
+ clv := lv.(*_QueryTrainingAllowListResponse_1_list)
+ x.Addresses = *clv.list
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingAllowListResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingAllowListResponse 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_QueryTrainingAllowListResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingAllowListResponse.addresses":
+ if x.Addresses == nil {
+ x.Addresses = []string{}
+ }
+ value := &_QueryTrainingAllowListResponse_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.QueryTrainingAllowListResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingAllowListResponse 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_QueryTrainingAllowListResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryTrainingAllowListResponse.addresses":
+ list := []string{}
+ return protoreflect.ValueOfList(&_QueryTrainingAllowListResponse_1_list{list: &list})
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryTrainingAllowListResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryTrainingAllowListResponse 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_QueryTrainingAllowListResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+ switch d.FullName() {
+ default:
+ panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryTrainingAllowListResponse", 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_QueryTrainingAllowListResponse) 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_QueryTrainingAllowListResponse) 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_QueryTrainingAllowListResponse) 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_QueryTrainingAllowListResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryTrainingAllowListResponse)
+ 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.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().(*QueryTrainingAllowListResponse)
+ 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] = 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().(*QueryTrainingAllowListResponse)
+ 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: QueryTrainingAllowListResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryTrainingAllowListResponse: 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)
+ }
+ 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_QueryGetMLNodeVersionRequest protoreflect.MessageDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryGetMLNodeVersionRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetMLNodeVersionRequest")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetMLNodeVersionRequest)(nil)
+
+type fastReflection_QueryGetMLNodeVersionRequest QueryGetMLNodeVersionRequest
+
+func (x *QueryGetMLNodeVersionRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetMLNodeVersionRequest)(x)
+}
+
+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))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryGetMLNodeVersionRequest_messageType fastReflection_QueryGetMLNodeVersionRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetMLNodeVersionRequest_messageType{}
+
+type fastReflection_QueryGetMLNodeVersionRequest_messageType struct{}
+
+func (x fastReflection_QueryGetMLNodeVersionRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetMLNodeVersionRequest)(nil)
+}
+func (x fastReflection_QueryGetMLNodeVersionRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetMLNodeVersionRequest)
+}
+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_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_QueryGetMLNodeVersionRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetMLNodeVersionRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryGetMLNodeVersionRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetMLNodeVersionRequest)(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_QueryGetMLNodeVersionRequest) 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_QueryGetMLNodeVersionRequest) 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("message inference.inference.QueryGetMLNodeVersionRequest 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_QueryGetMLNodeVersionRequest) 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("message inference.inference.QueryGetMLNodeVersionRequest 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_QueryGetMLNodeVersionRequest) 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("message inference.inference.QueryGetMLNodeVersionRequest 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_QueryGetMLNodeVersionRequest) 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("message inference.inference.QueryGetMLNodeVersionRequest 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_QueryGetMLNodeVersionRequest) 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("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_QueryGetMLNodeVersionRequest) 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("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_QueryGetMLNodeVersionRequest) 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("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_QueryGetMLNodeVersionRequest) 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_QueryGetMLNodeVersionRequest) 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_QueryGetMLNodeVersionRequest) 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_QueryGetMLNodeVersionRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetMLNodeVersionRequest)
+ 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().(*QueryGetMLNodeVersionRequest)
+ 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().(*QueryGetMLNodeVersionRequest)
+ 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: QueryGetMLNodeVersionRequest: 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)
+ }
+ 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 (
+ md_QueryGetMLNodeVersionResponse protoreflect.MessageDescriptor
+ fd_QueryGetMLNodeVersionResponse_mlnode_version 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetMLNodeVersionResponse)(nil)
+
+type fastReflection_QueryGetMLNodeVersionResponse QueryGetMLNodeVersionResponse
+
+func (x *QueryGetMLNodeVersionResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryGetMLNodeVersionResponse)(x)
+}
+
+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))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryGetMLNodeVersionResponse_messageType fastReflection_QueryGetMLNodeVersionResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetMLNodeVersionResponse_messageType{}
+
+type fastReflection_QueryGetMLNodeVersionResponse_messageType struct{}
+
+func (x fastReflection_QueryGetMLNodeVersionResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryGetMLNodeVersionResponse)(nil)
+}
+func (x fastReflection_QueryGetMLNodeVersionResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryGetMLNodeVersionResponse)
+}
+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_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_QueryGetMLNodeVersionResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryGetMLNodeVersionResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryGetMLNodeVersionResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryGetMLNodeVersionResponse)(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_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
+ }
+ }
+}
+
+// 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_QueryGetMLNodeVersionResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryGetMLNodeVersionResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetMLNodeVersionResponse 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_QueryGetMLNodeVersionResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ 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.QueryGetMLNodeVersionResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetMLNodeVersionResponse 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_QueryGetMLNodeVersionResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ 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.QueryGetMLNodeVersionResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetMLNodeVersionResponse 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_QueryGetMLNodeVersionResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+ switch fd.FullName() {
+ 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.QueryGetMLNodeVersionResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryGetMLNodeVersionResponse 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_QueryGetMLNodeVersionResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryGetMLNodeVersionResponse.mlnode_version":
+ if x.MlnodeVersion == nil {
+ x.MlnodeVersion = new(MLNodeVersion)
+ }
+ return protoreflect.ValueOfMessage(x.MlnodeVersion.ProtoReflect())
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMLNodeVersionResponse"))
+ }
+ 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_QueryGetMLNodeVersionResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryGetMLNodeVersionResponse"))
+ }
+ 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_QueryGetMLNodeVersionResponse) 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("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_QueryGetMLNodeVersionResponse) 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_QueryGetMLNodeVersionResponse) 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_QueryGetMLNodeVersionResponse) 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_QueryGetMLNodeVersionResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryGetMLNodeVersionResponse)
+ 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.MlnodeVersion != nil {
+ l = options.Size(x.MlnodeVersion)
+ 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().(*QueryGetMLNodeVersionResponse)
+ 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.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...)
+ } 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().(*QueryGetMLNodeVersionResponse)
+ 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: QueryGetMLNodeVersionResponse: 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)
+ }
+ 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)
+ }
+ 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.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
+ 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_QueryExcludedParticipantsRequest protoreflect.MessageDescriptor
+ fd_QueryExcludedParticipantsRequest_epoch_index protoreflect.FieldDescriptor
+)
+
+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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryExcludedParticipantsRequest)(nil)
+
+type fastReflection_QueryExcludedParticipantsRequest QueryExcludedParticipantsRequest
+
+func (x *QueryExcludedParticipantsRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryExcludedParticipantsRequest)(x)
+}
+
+func (x *QueryExcludedParticipantsRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[147]
+ 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_QueryExcludedParticipantsRequest_messageType fastReflection_QueryExcludedParticipantsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryExcludedParticipantsRequest_messageType{}
+
+type fastReflection_QueryExcludedParticipantsRequest_messageType struct{}
+
+func (x fastReflection_QueryExcludedParticipantsRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryExcludedParticipantsRequest)(nil)
+}
+func (x fastReflection_QueryExcludedParticipantsRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryExcludedParticipantsRequest)
+}
+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_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_QueryExcludedParticipantsRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryExcludedParticipantsRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryExcludedParticipantsRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryExcludedParticipantsRequest)(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_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
+ }
+ }
+}
+
+// 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_QueryExcludedParticipantsRequest) 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("message inference.inference.QueryExcludedParticipantsRequest 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_QueryExcludedParticipantsRequest) 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("message inference.inference.QueryExcludedParticipantsRequest 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_QueryExcludedParticipantsRequest) 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("message inference.inference.QueryExcludedParticipantsRequest 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_QueryExcludedParticipantsRequest) 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("message inference.inference.QueryExcludedParticipantsRequest 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_QueryExcludedParticipantsRequest) 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("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_QueryExcludedParticipantsRequest) 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("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_QueryExcludedParticipantsRequest) 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("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_QueryExcludedParticipantsRequest) 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_QueryExcludedParticipantsRequest) 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_QueryExcludedParticipantsRequest) 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_QueryExcludedParticipantsRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryExcludedParticipantsRequest)
+ 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 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().(*QueryExcludedParticipantsRequest)
+ 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.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().(*QueryExcludedParticipantsRequest)
+ 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: QueryExcludedParticipantsRequest: 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)
+ }
+ 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:])
+ 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 = (*_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
+)
+
+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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryExcludedParticipantsResponse)(nil)
+
+type fastReflection_QueryExcludedParticipantsResponse QueryExcludedParticipantsResponse
+
+func (x *QueryExcludedParticipantsResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryExcludedParticipantsResponse)(x)
+}
+
+func (x *QueryExcludedParticipantsResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[148]
+ 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_QueryExcludedParticipantsResponse_messageType fastReflection_QueryExcludedParticipantsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryExcludedParticipantsResponse_messageType{}
+
+type fastReflection_QueryExcludedParticipantsResponse_messageType struct{}
+
+func (x fastReflection_QueryExcludedParticipantsResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryExcludedParticipantsResponse)(nil)
+}
+func (x fastReflection_QueryExcludedParticipantsResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryExcludedParticipantsResponse)
+}
+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_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_QueryExcludedParticipantsResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryExcludedParticipantsResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryExcludedParticipantsResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryExcludedParticipantsResponse)(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_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
+ }
+ }
+}
+
+// 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_QueryExcludedParticipantsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+ switch fd.FullName() {
+ 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.QueryExcludedParticipantsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryExcludedParticipantsResponse 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_QueryExcludedParticipantsResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ case "inference.inference.QueryExcludedParticipantsResponse.items":
+ x.Items = nil
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryExcludedParticipantsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryExcludedParticipantsResponse 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_QueryExcludedParticipantsResponse) 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)
+ default:
+ if descriptor.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryExcludedParticipantsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryExcludedParticipantsResponse 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_QueryExcludedParticipantsResponse) 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
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryExcludedParticipantsResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryExcludedParticipantsResponse 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_QueryExcludedParticipantsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ case "inference.inference.QueryExcludedParticipantsResponse.items":
+ if x.Items == nil {
+ x.Items = []*ExcludedParticipant{}
+ }
+ 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.QueryExcludedParticipantsResponse"))
+ }
+ 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_QueryExcludedParticipantsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryExcludedParticipantsResponse"))
+ }
+ 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_QueryExcludedParticipantsResponse) 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("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_QueryExcludedParticipantsResponse) 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_QueryExcludedParticipantsResponse) 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_QueryExcludedParticipantsResponse) 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_QueryExcludedParticipantsResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryExcludedParticipantsResponse)
+ 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.Items) > 0 {
+ for _, e := range x.Items {
+ 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().(*QueryExcludedParticipantsResponse)
+ 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.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 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().(*QueryExcludedParticipantsResponse)
+ 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: QueryExcludedParticipantsResponse: 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)
+ }
+ 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)
+ }
+ 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.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
+ 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_QueryActiveConfirmationPoCEventRequest protoreflect.MessageDescriptor
+)
+
+func init() {
+ file_inference_inference_query_proto_init()
+ md_QueryActiveConfirmationPoCEventRequest = File_inference_inference_query_proto.Messages().ByName("QueryActiveConfirmationPoCEventRequest")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryActiveConfirmationPoCEventRequest)(nil)
+
+type fastReflection_QueryActiveConfirmationPoCEventRequest QueryActiveConfirmationPoCEventRequest
+
+func (x *QueryActiveConfirmationPoCEventRequest) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryActiveConfirmationPoCEventRequest)(x)
+}
+
+func (x *QueryActiveConfirmationPoCEventRequest) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[149]
+ 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_QueryActiveConfirmationPoCEventRequest_messageType fastReflection_QueryActiveConfirmationPoCEventRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryActiveConfirmationPoCEventRequest_messageType{}
+
+type fastReflection_QueryActiveConfirmationPoCEventRequest_messageType struct{}
+
+func (x fastReflection_QueryActiveConfirmationPoCEventRequest_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryActiveConfirmationPoCEventRequest)(nil)
+}
+func (x fastReflection_QueryActiveConfirmationPoCEventRequest_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryActiveConfirmationPoCEventRequest)
+}
+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_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_QueryActiveConfirmationPoCEventRequest) Type() protoreflect.MessageType {
+ return _fastReflection_QueryActiveConfirmationPoCEventRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryActiveConfirmationPoCEventRequest) Interface() protoreflect.ProtoMessage {
+ return (*QueryActiveConfirmationPoCEventRequest)(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_QueryActiveConfirmationPoCEventRequest) 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_QueryActiveConfirmationPoCEventRequest) 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("message inference.inference.QueryActiveConfirmationPoCEventRequest 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_QueryActiveConfirmationPoCEventRequest) 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("message inference.inference.QueryActiveConfirmationPoCEventRequest 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_QueryActiveConfirmationPoCEventRequest) 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("message inference.inference.QueryActiveConfirmationPoCEventRequest 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_QueryActiveConfirmationPoCEventRequest) 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("message inference.inference.QueryActiveConfirmationPoCEventRequest 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_QueryActiveConfirmationPoCEventRequest) 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("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_QueryActiveConfirmationPoCEventRequest) 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("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_QueryActiveConfirmationPoCEventRequest) 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("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_QueryActiveConfirmationPoCEventRequest) 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_QueryActiveConfirmationPoCEventRequest) 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_QueryActiveConfirmationPoCEventRequest) 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_QueryActiveConfirmationPoCEventRequest) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryActiveConfirmationPoCEventRequest)
+ 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().(*QueryActiveConfirmationPoCEventRequest)
+ 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().(*QueryActiveConfirmationPoCEventRequest)
+ 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: QueryActiveConfirmationPoCEventRequest: 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)
+ }
+ 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 (
+ md_QueryActiveConfirmationPoCEventResponse protoreflect.MessageDescriptor
+ fd_QueryActiveConfirmationPoCEventResponse_is_active protoreflect.FieldDescriptor
+ fd_QueryActiveConfirmationPoCEventResponse_event 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")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryActiveConfirmationPoCEventResponse)(nil)
+
+type fastReflection_QueryActiveConfirmationPoCEventResponse QueryActiveConfirmationPoCEventResponse
+
+func (x *QueryActiveConfirmationPoCEventResponse) ProtoReflect() protoreflect.Message {
+ return (*fastReflection_QueryActiveConfirmationPoCEventResponse)(x)
+}
+
+func (x *QueryActiveConfirmationPoCEventResponse) slowProtoReflect() protoreflect.Message {
+ mi := &file_inference_inference_query_proto_msgTypes[150]
+ 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_QueryActiveConfirmationPoCEventResponse_messageType fastReflection_QueryActiveConfirmationPoCEventResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryActiveConfirmationPoCEventResponse_messageType{}
+
+type fastReflection_QueryActiveConfirmationPoCEventResponse_messageType struct{}
+
+func (x fastReflection_QueryActiveConfirmationPoCEventResponse_messageType) Zero() protoreflect.Message {
+ return (*fastReflection_QueryActiveConfirmationPoCEventResponse)(nil)
+}
+func (x fastReflection_QueryActiveConfirmationPoCEventResponse_messageType) New() protoreflect.Message {
+ return new(fastReflection_QueryActiveConfirmationPoCEventResponse)
+}
+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_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_QueryActiveConfirmationPoCEventResponse) Type() protoreflect.MessageType {
+ return _fastReflection_QueryActiveConfirmationPoCEventResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+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_QueryActiveConfirmationPoCEventResponse) Interface() protoreflect.ProtoMessage {
+ return (*QueryActiveConfirmationPoCEventResponse)(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_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
+ }
+ }
+}
+
+// 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_QueryActiveConfirmationPoCEventResponse) 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
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryActiveConfirmationPoCEventResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryActiveConfirmationPoCEventResponse 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_QueryActiveConfirmationPoCEventResponse) Clear(fd protoreflect.FieldDescriptor) {
+ switch fd.FullName() {
+ 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.QueryActiveConfirmationPoCEventResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryActiveConfirmationPoCEventResponse 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_QueryActiveConfirmationPoCEventResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+ switch descriptor.FullName() {
+ 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.QueryActiveConfirmationPoCEventResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryActiveConfirmationPoCEventResponse 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_QueryActiveConfirmationPoCEventResponse) 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)
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryActiveConfirmationPoCEventResponse"))
+ }
+ panic(fmt.Errorf("message inference.inference.QueryActiveConfirmationPoCEventResponse 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_QueryActiveConfirmationPoCEventResponse) 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"))
+ default:
+ if fd.IsExtension() {
+ panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryActiveConfirmationPoCEventResponse"))
+ }
+ 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_QueryActiveConfirmationPoCEventResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+ switch fd.FullName() {
+ 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.QueryActiveConfirmationPoCEventResponse"))
+ }
+ 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_QueryActiveConfirmationPoCEventResponse) 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("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_QueryActiveConfirmationPoCEventResponse) 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_QueryActiveConfirmationPoCEventResponse) 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_QueryActiveConfirmationPoCEventResponse) 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_QueryActiveConfirmationPoCEventResponse) ProtoMethods() *protoiface.Methods {
+ size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+ x := input.Message.Interface().(*QueryActiveConfirmationPoCEventResponse)
+ 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.IsActive {
+ n += 2
+ }
+ if x.Event != nil {
+ l = options.Size(x.Event)
+ 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().(*QueryActiveConfirmationPoCEventResponse)
+ 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.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 {
+ 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...)
+ } 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().(*QueryActiveConfirmationPoCEventResponse)
+ 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: QueryActiveConfirmationPoCEventResponse: 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)
+ }
+ 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 Event", 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.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
+ 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) <