Merge pull request #3354 from latent-to/release/10.3.2

Release/10.3.2

Author: thewhaleking

CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 10.3.2 /2026-05-15
+
+## What's Changed
+* Fix `--help` hijacking on import bittensor by @basfroman in https://github.com/latent-to/bittensor/pull/3347
+* Hopefully, this is a fix for the flaky e2e test by @basfroman in https://github.com/latent-to/bittensor/pull/3348
+* fix(axon): narrow preprocess exception handling and chain causes by @RUNECTZ33 in https://github.com/latent-to/bittensor/pull/3346
+* run do_take_checks at pool validation by @thewhaleking in https://github.com/latent-to/bittensor/pull/3350
+* Mev Shield Nonce Increment Fix by @thewhaleking in https://github.com/latent-to/bittensor/pull/3349
+* Test Fixes by @thewhaleking in https://github.com/latent-to/bittensor/pull/3352
+* Use the public API for clearing nonce cache by @thewhaleking in https://github.com/latent-to/bittensor/pull/3351
+
+## New Contributors
+* @RUNECTZ33 made their first contribution in https://github.com/latent-to/bittensor/pull/3346
+
+**Full Changelog**: https://github.com/latent-to/bittensor/compare/v10.3.1...v10.3.2
+
 ## 10.3.1 /2026-05-06
 
 ## What's Changed

bittensor/core/async_subtensor.py

@@ -48,7 +48,11 @@
     decode_revealed_commitment_with_hotkey,
 )
 from bittensor.core.config import Config
-from bittensor.core.errors import ChainError, SubstrateRequestException
+from bittensor.core.errors import (
+    ChainError,
+    SubstrateRequestException,
+    chain_error_from_substrate_exception,
+)
 from bittensor.core.extrinsics.asyncex.children import (
     root_set_pending_childkey_cooldown_extrinsic,
     set_children_extrinsic,
@@ -6145,8 +6149,15 @@ async def sign_and_send_extrinsic(
             return extrinsic_response
 
         except SubstrateRequestException as error:
+            # The extrinsic was rejected before inclusion (pool validation, dropped,
+            # invalid, etc.), so the nonce was not consumed on-chain. Clear the cached
+            # next-index so the next call refetches the true on-chain value.
+            self.substrate.clear_nonce_cache_for_account(signing_keypair.ss58_address)
+            typed = chain_error_from_substrate_exception(error)
+            if typed is not None:
+                error = typed
             if raise_error:
-                raise
+                raise error from None
 
             extrinsic_response.success = False
             extrinsic_response.message = format_error_message(error)

bittensor/core/axon.py

@@ -15,6 +15,7 @@
 from typing import Any, Awaitable, Callable, Optional, Tuple
 
 from async_substrate_interface.utils import json
+from pydantic import ValidationError
 import uvicorn
 from bittensor_wallet import Wallet, Keypair
 from fastapi import APIRouter, Depends, FastAPI
@@ -1233,13 +1234,17 @@ async def preprocess(self, request: "Request") -> "Synapse":
         This method sets the foundation for the subsequent steps in the request handling process,
         ensuring that all necessary information is encapsulated within the Synapse object.
         """
-        # Extracts the request name from the URL path.
+        # Extracts the request name from the URL path. `split("/")[1]` can
+        # only realistically fail with `IndexError` (empty path) or
+        # `AttributeError` (malformed/mocked request without a `url`); a bare
+        # `except Exception` here would swallow `MemoryError`, real bugs from
+        # `starlette`, etc., and relabel them as malformed-request errors.
         try:
             request_name = request.url.path.split("/")[1]
-        except Exception:
+        except (IndexError, AttributeError) as e:
             raise InvalidRequestNameError(
                 f"Improperly formatted request. Could not parser request {request.url.path}."
-            )
+            ) from e
 
         # Creates a synapse instance from the headers using the appropriate forward class type
         # based on the request name obtained from the URL path.
@@ -1249,12 +1254,17 @@ async def preprocess(self, request: "Request") -> "Synapse":
                 f"Synapse name '{request_name}' not found. Available synapses {list(self.axon.forward_class_types.keys())}"
             )
 
+        # `from_headers` constructs a pydantic model from header inputs; the
+        # realistic failure modes are `ValidationError` (field-level),
+        # `TypeError` (bad kwarg types), and `ValueError` (custom validators).
+        # Narrowing keeps unrelated infrastructure failures visible instead of
+        # relabeling them as malformed-request errors.
         try:
             synapse = request_synapse.from_headers(request.headers)  # type: ignore
-        except Exception:
+        except (ValidationError, TypeError, ValueError) as e:
             raise SynapseParsingError(
                 f"Improperly formatted request. Could not parse headers {request.headers} into synapse of type {request_name}."
-            )
+            ) from e
         synapse.name = request_name
 
         # Fills the local axon information into the synapse.

bittensor/core/config.py

@@ -21,9 +21,11 @@
 import sys
 from copy import deepcopy
 from typing import Any, Optional
-from bittensor.core.settings import DEFAULTS
+
 import yaml
 
+from bittensor.core.settings import DEFAULTS, no_parse_cli
+
 
 class DefaultMunch(dict):
     """
@@ -130,12 +132,6 @@ def __init__(
         strict: bool = False,
         default: Any = DEFAULTS,
     ) -> None:
-        no_parse_cli = os.getenv("BT_NO_PARSE_CLI_ARGS", "").lower() in (
-            "1",
-            "true",
-            "yes",
-            "on",
-        )
 
         # Fallback to defaults if not provided
         default = deepcopy(default or DEFAULTS)
@@ -153,7 +149,7 @@ def __init__(
         self.__is_set = {}
 
         # If CLI parsing disabled, stop here
-        if no_parse_cli or parser is None:
+        if no_parse_cli() or parser is None:
             return
 
         self._add_default_arguments(parser)

bittensor/core/errors.py

@@ -1,3 +1,4 @@
+import ast
 from typing import Optional, TYPE_CHECKING
 
 from async_substrate_interface.errors import (
@@ -58,6 +59,7 @@
     "UnknownSynapseError",
     "UnstakeError",
     "SHIELD_VALIDATION_ERRORS",
+    "chain_error_from_substrate_exception",
     "map_shield_error",
 ]
 
@@ -278,6 +280,57 @@ def __init__(
 }
 
 
+_CUSTOM_ERROR_CODE_TO_EXCEPTION: dict[int, type["ChainError"]] = {
+    3: SubnetNotExists,
+    4: HotKeyAccountNotExists,
+    6: TxRateLimitExceeded,
+    25: NonAssociatedColdKey,
+}
+
+
+def _extract_custom_error_code(error: Exception) -> Optional[int]:
+    """Walk a SubstrateRequestException's args looking for a transaction-pool
+    validity error like ``{'error': {'code': 1010, ..., 'data': 'Custom error: N'}}``
+    and return ``N``. Returns ``None`` if the shape doesn't match."""
+    for arg in getattr(error, "args", ()):
+        parsed = arg
+        if isinstance(parsed, str):
+            try:
+                parsed = ast.literal_eval(parsed)
+            except (ValueError, SyntaxError, MemoryError, RecursionError, TypeError):
+                continue
+        if not isinstance(parsed, dict):
+            continue
+        inner = parsed.get("error", parsed)
+        if not isinstance(inner, dict):
+            continue
+        data = inner.get("data")
+        if isinstance(data, str) and data.startswith("Custom error:"):
+            try:
+                return int(data.split(":", 1)[1].strip())
+            except ValueError:
+                continue
+    return None
+
+
+def chain_error_from_substrate_exception(
+    error: SubstrateRequestException,
+) -> Optional["ChainError"]:
+    """Translate a transaction-pool validation error into a typed
+    :class:`ChainError`. Returns ``None`` when the exception doesn't carry a
+    recognised ``Custom error: N`` code from subtensor's
+    ``CustomTransactionError`` enum, so callers can keep the original."""
+    if isinstance(error, ChainError):
+        return None
+    code = _extract_custom_error_code(error)
+    if code is None:
+        return None
+    exc_cls = _CUSTOM_ERROR_CODE_TO_EXCEPTION.get(code)
+    if exc_cls is None:
+        return None
+    return exc_cls(*error.args)
+
+
 def map_shield_error(raw_message: str) -> str:
     """Map a raw shield validation error to a human-readable description.
 

bittensor/core/extrinsics/asyncex/coldkey_swap.py

@@ -392,6 +392,13 @@ async def swap_coldkey_announced_extrinsic(
             )
 
         if response.success:
+            # The swap may reap the old coldkey's account on chain (resetting its
+            # nonce). Drop the in-process nonce cache entry so the next extrinsic
+            # signed by this ss58 re-fetches from the chain instead of incrementing
+            # a stale value.
+            subtensor.substrate.clear_nonce_cache_for_account(
+                wallet.coldkeypub.ss58_address
+            )
             logging.debug("[green]Coldkey swap executed successfully.[/green]")
         else:
             logging.error(f"[red]{response.message}[/red]")

bittensor/core/extrinsics/asyncex/sudo.py

@@ -93,7 +93,7 @@ async def swap_coldkey_extrinsic(
     Notes:
         - This function can only called by root.
     """
-    return await sudo_call_extrinsic(
+    response = await sudo_call_extrinsic(
         subtensor=subtensor,
         wallet=wallet,
         call_module="SubtensorModule",
@@ -108,6 +108,13 @@ async def swap_coldkey_extrinsic(
         wait_for_inclusion=wait_for_inclusion,
         wait_for_finalization=wait_for_finalization,
     )
+    if response.success:
+        # The swap may reap the old coldkey's account on chain (resetting its
+        # nonce). Drop the in-process nonce cache entry so the next extrinsic
+        # signed by this ss58 re-fetches from the chain instead of incrementing
+        # a stale value.
+        subtensor.substrate.clear_nonce_cache_for_account(old_coldkey_ss58)
+    return response
 
 
 async def sudo_set_admin_freeze_window_extrinsic(

bittensor/core/settings.py

@@ -166,3 +166,13 @@ class wallet:
     e * (_version_int_base**i) for i, e in enumerate(reversed(_version_info))
 )
 assert version_as_int < 2**31  # fits in int32
+
+
+# used for backwards compatibility in config.py and loggingmachine.py
+def no_parse_cli():
+    return not os.getenv("BT_NO_PARSE_CLI_ARGS", "true").lower() in (
+        "0",
+        "false",
+        "no",
+        "off",
+    )

bittensor/core/subtensor.py

@@ -48,7 +48,7 @@
     decode_revealed_commitment_with_hotkey,
 )
 from bittensor.core.config import Config
-from bittensor.core.errors import ChainError
+from bittensor.core.errors import ChainError, chain_error_from_substrate_exception
 from bittensor.core.extrinsics.children import (
     root_set_pending_childkey_cooldown_extrinsic,
     set_children_extrinsic,
@@ -5012,8 +5012,11 @@ def sign_and_send_extrinsic(
             return extrinsic_response
 
         except SubstrateRequestException as error:
+            typed = chain_error_from_substrate_exception(error)
+            if typed is not None:
+                error = typed
             if raise_error:
-                raise
+                raise error from None
 
             extrinsic_response.success = False
             extrinsic_response.message = format_error_message(error)

bittensor/utils/btlogging/loggingmachine.py

@@ -17,7 +17,7 @@
 from statemachine import State, StateMachine
 
 from bittensor.core.config import Config
-from bittensor.core.settings import DEFAULTS
+from bittensor.core.settings import DEFAULTS, no_parse_cli
 from bittensor.utils.btlogging.console import BittensorConsole
 from .defines import (
     BITTENSOR_LOGGER_NAME,
@@ -686,6 +686,8 @@ def config(cls) -> "Config":
         Return:
             Configuration object with settings from command-line arguments.
         """
+        if no_parse_cli():
+            return Config()
         parser = argparse.ArgumentParser()
         cls.add_args(parser)
         return Config(parser)