Release/10.1.0

.github/workflows/monitor_requirements_size_master.yml

@@ -12,6 +12,7 @@ on:
 permissions:
   pull-requests: write
   contents: read
+  issues: write
 
 jobs:
   read-python-versions:

.gitignore

@@ -213,4 +213,5 @@ replicate.yaml
 # Notebooks
 *.ipynb
 
-tests/zombienet/bin/**/*
+tests/zombienet/bin/**/*
+myscripts/

CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 10.1.0 /2026-01-15
+
+## What's Changed
+* Fix for async metagraph initialization by @basfroman in https://github.com/opentensor/bittensor/pull/3236
+* Clarify return ordering and units for `get_revealed_commitment_by_hotkey` by @Dairus01 in https://github.com/opentensor/bittensor/pull/3231
+* Skips user liquidity e2e test pending the rework by @basfroman in https://github.com/opentensor/bittensor/pull/3239
+* chore: fix incorrect Optional type annotation in utils by @Olexandr88 in https://github.com/opentensor/bittensor/pull/3238
+* chore: remove unused test helper by @Olexandr88 in https://github.com/opentensor/bittensor/pull/3241
+* Add `start_call_delay_hyperparameter` support by @basfroman in https://github.com/opentensor/bittensor/pull/3234
+* Improve `is_fast_blocks` by @basfroman in https://github.com/opentensor/bittensor/pull/3243
+* Adds note about block 5611654 decoding by @thewhaleking in https://github.com/opentensor/bittensor/pull/3246
+
+## New Contributors
+* @Dairus01 made their first contribution in https://github.com/opentensor/bittensor/pull/3231
+* @Olexandr88 made their first contribution in https://github.com/opentensor/bittensor/pull/3238
+
+**Full Changelog**: https://github.com/opentensor/bittensor/compare/v10.1.0...v10.0.2
+
 ## 10.0.1 /2025-12-22
 
 ## What's Changed

bittensor/core/async_subtensor.py

@@ -8,6 +8,7 @@
 import scalecodec
 from async_substrate_interface import AsyncSubstrateInterface
 from async_substrate_interface.substrate_addons import RetryAsyncSubstrate
+from async_substrate_interface.types import ScaleObj
 from async_substrate_interface.utils.storage import StorageKey
 from bittensor_drand import get_encrypted_commitment
 from bittensor_wallet.utils import SS58_FORMAT
@@ -165,7 +166,6 @@
 
 if TYPE_CHECKING:
     from async_substrate_interface import AsyncQueryMapResult
-    from async_substrate_interface.types import ScaleObj
     from bittensor_wallet import Keypair, Wallet
 
     from bittensor.core.axon import Axon
@@ -4306,6 +4306,35 @@ async def get_stake_weight(
         )
         return [u16_normalized_float(w) for w in result]
 
+    async def get_start_call_delay(
+        self,
+        block: Optional[int] = None,
+        block_hash: Optional[str] = None,
+        reuse_block: bool = False,
+    ) -> int:
+        """
+        Retrieves the start call delay in blocks.
+
+        Parameters:
+            block: The blockchain block number for the query.
+            block_hash: The blockchain block_hash of the block id.
+            reuse_block: Whether to reuse the last-used block hash.
+
+        Return:
+            Amount of blocks after the start call can be executed.
+        """
+        return cast(
+            int,
+            (
+                await self.query_subtensor(
+                    name="StartCallDelay",
+                    block=block,
+                    block_hash=block_hash,
+                    reuse_block=reuse_block,
+                )
+            ),
+        )
+
     async def get_subnet_burn_cost(
         self,
         block: Optional[int] = None,
@@ -4985,19 +5014,20 @@ async def is_in_admin_freeze_window(
     async def is_fast_blocks(self) -> bool:
         """Checks if the node is running with fast blocks enabled.
 
-        Fast blocks have a block time of 10 seconds, compared to the standard 12-second block time. This affects
+        Fast blocks have a block time of 0.25 seconds, compared to the standard 12-second block time. This affects
         transaction timing and network synchronization.
 
         Returns:
-            `True` if fast blocks are enabled (10-second block time), `False` otherwise (12-second block time).
+            `True` if fast blocks are enabled, `False` otherwise.
 
         Notes:
             - <https://docs.learnbittensor.org/resources/glossary#fast-blocks>
 
         """
-        return (
-            await self.query_constant("SubtensorModule", "DurationOfStartCall")
-        ) == 10
+        slot_duration_obj = cast(
+            ScaleObj, await self.query_constant("Aura", "SlotDuration")
+        )
+        return slot_duration_obj.value == 250
 
     async def is_hotkey_delegate(
         self,

bittensor/core/metagraph.py

@@ -1391,7 +1391,7 @@ async def sync(
         await self._apply_extra_info(block=block)
 
     async def _initialize_subtensor(
-        self, subtensor: "AsyncSubtensor"
+        self, subtensor: Optional["AsyncSubtensor"]
     ) -> "AsyncSubtensor":
         """
         Initializes the subtensor to be used for syncing the metagraph.
@@ -1422,8 +1422,8 @@ async def _initialize_subtensor(
             # Lazy import due to circular import (subtensor -> metagraph, metagraph -> subtensor)
             from bittensor.core.async_subtensor import AsyncSubtensor
 
-            self.subtensor = AsyncSubtensor(network=self.chain_endpoint)
-            await self.subtensor.initialize()
+            subtensor = AsyncSubtensor(network=self.chain_endpoint)
+            await subtensor.initialize()
             self.subtensor = subtensor
         return subtensor
 
@@ -1720,7 +1720,7 @@ def sync(
         # apply MetagraphInfo data to instance
         self._apply_extra_info(block=block)
 
-    def _initialize_subtensor(self, subtensor: "Subtensor") -> "Subtensor":
+    def _initialize_subtensor(self, subtensor: Optional["Subtensor"]) -> "Subtensor":
         """
         Initializes the subtensor to be used for syncing the metagraph.
 
@@ -1939,6 +1939,17 @@ async def async_metagraph(
 ) -> "AsyncMetagraph":
     """
     Factory function to create an instantiated AsyncMetagraph, mainly for the ability to use sync at instantiation.
+
+    Parameters:
+        netuid: The netuid of the subnet for which to create the AsyncMetagraph.
+        mechid: The mechid of the subnet for which to create the AsyncMetagraph.
+        network: The network to use for the AsyncMetagraph.
+        lite: Whether to use a lite version of the AsyncMetagraph.
+        sync: Whether to sync the AsyncMetagraph.
+        subtensor: The subtensor to use for the AsyncMetagraph.
+
+    Returns:
+        AsyncMetagraph: The instantiated AsyncMetagraph.
     """
     metagraph_ = AsyncMetagraph(
         netuid=netuid,

bittensor/core/subtensor.py

@@ -3540,6 +3540,24 @@ def get_stake_weight(self, netuid: int, block: Optional[int] = None) -> list[flo
         )
         return [u16_normalized_float(w) for w in result]
 
+    def get_start_call_delay(self, block: Optional[int] = None) -> int:
+        """
+        Retrieves the start call delay in blocks.
+
+        Parameters:
+            block: The blockchain block number for the query.
+
+        Return:
+            Amount of blocks after the start call can be executed.
+        """
+        return cast(
+            int,
+            self.query_subtensor(
+                name="StartCallDelay",
+                block=block,
+            ),
+        )
+
     def get_subnet_burn_cost(self, block: Optional[int] = None) -> Optional[Balance]:
         """
         Retrieves the burn cost for registering a new subnet within the Bittensor network. This cost represents the
@@ -4075,17 +4093,18 @@ def is_in_admin_freeze_window(
     def is_fast_blocks(self) -> bool:
         """Checks if the node is running with fast blocks enabled.
 
-        Fast blocks have a block time of 10 seconds, compared to the standard 12-second block time. This affects
+        Fast blocks have a block time of 0.25 seconds, compared to the standard 12-second block time. This affects
         transaction timing and network synchronization.
 
         Returns:
-            `True` if fast blocks are enabled (10-second block time), `False` otherwise (12-second block time).
+            `True` if fast blocks are enabled, `False` otherwise.
 
         Notes:
             - <https://docs.learnbittensor.org/resources/glossary#fast-blocks>
 
         """
-        return self.query_constant("SubtensorModule", "DurationOfStartCall") == 10
+        slot_duration_obj = cast(ScaleObj, self.query_constant("Aura", "SlotDuration"))
+        return slot_duration_obj.value == 250
 
     def is_hotkey_delegate(self, hotkey_ss58: str, block: Optional[int] = None) -> bool:
         """

bittensor/extras/dev_framework/calls/non_sudo_calls.py

@@ -11,7 +11,7 @@
 
 Note:
     Any manual changes will be overwritten the next time the generator is run.
-    Subtensor spec version: 331
+    Subtensor spec version: 365
 """
 
 from collections import namedtuple
@@ -42,6 +42,9 @@
 ANNOUNCE = namedtuple(
     "ANNOUNCE", ["wallet", "pallet", "real", "call_hash"]
 )  # args: [real: AccountIdLookupOf<T>, call_hash: CallHashOf<T>]  | Pallet: Proxy
+ANNOUNCE_NEXT_KEY = namedtuple(
+    "ANNOUNCE_NEXT_KEY", ["wallet", "pallet", "public_key"]
+)  # args: [public_key: BoundedVec<u8, ConstU32<2048>>]  | Pallet: MevShield
 APPLY_AUTHORIZED_UPGRADE = namedtuple(
     "APPLY_AUTHORIZED_UPGRADE", ["wallet", "pallet", "code"]
 )  # args: [code: Vec<u8>]  | Pallet: System
@@ -118,6 +121,10 @@
 BURN_ALPHA = namedtuple(
     "BURN_ALPHA", ["wallet", "pallet", "hotkey", "amount", "netuid"]
 )  # args: [hotkey: T::AccountId, amount: AlphaCurrency, netuid: NetUid]  | Pallet: SubtensorModule
+CALL = namedtuple(
+    "CALL",
+    ["wallet", "pallet", "dest", "value", "gas_limit", "storage_deposit_limit", "data"],
+)  # args: [dest: AccountIdLookupOf<T>, value: BalanceOf<T>, gas_limit: Weight, storage_deposit_limit: Option<<BalanceOf<T> as codec::HasCompact>::Type>, data: Vec<u8>]  | Pallet: Contracts
 CALL = namedtuple(
     "CALL",
     [
@@ -135,6 +142,10 @@
         "authorization_list",
     ],
 )  # args: [source: H160, target: H160, input: Vec<u8>, value: U256, gas_limit: u64, max_fee_per_gas: U256, max_priority_fee_per_gas: Option<U256>, nonce: Option<U256>, access_list: Vec<(H160, Vec<H256>)>, authorization_list: AuthorizationList]  | Pallet: EVM
+CALL_OLD_WEIGHT = namedtuple(
+    "CALL_OLD_WEIGHT",
+    ["wallet", "pallet", "dest", "value", "gas_limit", "storage_deposit_limit", "data"],
+)  # args: [dest: AccountIdLookupOf<T>, value: BalanceOf<T>, gas_limit: OldWeight, storage_deposit_limit: Option<<BalanceOf<T> as codec::HasCompact>::Type>, data: Vec<u8>]  | Pallet: Contracts
 CANCEL = namedtuple(
     "CANCEL", ["wallet", "pallet", "when", "index"]
 )  # args: [when: BlockNumberFor<T>, index: u32]  | Pallet: Scheduler
@@ -152,12 +163,8 @@
     "CANCEL_RETRY_NAMED", ["wallet", "pallet", "id"]
 )  # args: [id: TaskName]  | Pallet: Scheduler
 CLAIM_ROOT = namedtuple(
-    "CLAIM_ROOT",
-    [
-        "wallet",
-        "pallet",
-    ],
-)  # args: []  | Pallet: SubtensorModule
+    "CLAIM_ROOT", ["wallet", "pallet", "subnets"]
+)  # args: [subnets: BTreeSet<NetUid>]  | Pallet: SubtensorModule
 CLEAR_IDENTITY = namedtuple(
     "CLEAR_IDENTITY", ["wallet", "pallet", "identified"]
 )  # args: [identified: T::AccountId]  | Pallet: Registry
@@ -242,6 +249,13 @@
 DECREASE_TAKE = namedtuple(
     "DECREASE_TAKE", ["wallet", "pallet", "hotkey", "take"]
 )  # args: [hotkey: T::AccountId, take: u16]  | Pallet: SubtensorModule
+DISABLE_LP = namedtuple(
+    "DISABLE_LP",
+    [
+        "wallet",
+        "pallet",
+    ],
+)  # args: []  | Pallet: Swap
 DISABLE_WHITELIST = namedtuple(
     "DISABLE_WHITELIST", ["wallet", "pallet", "disabled"]
 )  # args: [disabled: bool]  | Pallet: EVM
@@ -328,6 +342,58 @@
 INCREASE_TAKE = namedtuple(
     "INCREASE_TAKE", ["wallet", "pallet", "hotkey", "take"]
 )  # args: [hotkey: T::AccountId, take: u16]  | Pallet: SubtensorModule
+INSTANTIATE = namedtuple(
+    "INSTANTIATE",
+    [
+        "wallet",
+        "pallet",
+        "value",
+        "gas_limit",
+        "storage_deposit_limit",
+        "code_hash",
+        "data",
+        "salt",
+    ],
+)  # args: [value: BalanceOf<T>, gas_limit: Weight, storage_deposit_limit: Option<<BalanceOf<T> as codec::HasCompact>::Type>, code_hash: CodeHash<T>, data: Vec<u8>, salt: Vec<u8>]  | Pallet: Contracts
+INSTANTIATE_OLD_WEIGHT = namedtuple(
+    "INSTANTIATE_OLD_WEIGHT",
+    [
+        "wallet",
+        "pallet",
+        "value",
+        "gas_limit",
+        "storage_deposit_limit",
+        "code_hash",
+        "data",
+        "salt",
+    ],
+)  # args: [value: BalanceOf<T>, gas_limit: OldWeight, storage_deposit_limit: Option<<BalanceOf<T> as codec::HasCompact>::Type>, code_hash: CodeHash<T>, data: Vec<u8>, salt: Vec<u8>]  | Pallet: Contracts
+INSTANTIATE_WITH_CODE = namedtuple(
+    "INSTANTIATE_WITH_CODE",
+    [
+        "wallet",
+        "pallet",
+        "value",
+        "gas_limit",
+        "storage_deposit_limit",
+        "code",
+        "data",
+        "salt",
+    ],
+)  # args: [value: BalanceOf<T>, gas_limit: Weight, storage_deposit_limit: Option<<BalanceOf<T> as codec::HasCompact>::Type>, code: Vec<u8>, data: Vec<u8>, salt: Vec<u8>]  | Pallet: Contracts
+INSTANTIATE_WITH_CODE_OLD_WEIGHT = namedtuple(
+    "INSTANTIATE_WITH_CODE_OLD_WEIGHT",
+    [
+        "wallet",
+        "pallet",
+        "value",
+        "gas_limit",
+        "storage_deposit_limit",
+        "code",
+        "data",
+        "salt",
+    ],
+)  # args: [value: BalanceOf<T>, gas_limit: OldWeight, storage_deposit_limit: Option<<BalanceOf<T> as codec::HasCompact>::Type>, code: Vec<u8>, data: Vec<u8>, salt: Vec<u8>]  | Pallet: Contracts
 KILL_PREFIX = namedtuple(
     "KILL_PREFIX", ["wallet", "pallet", "prefix", "subkeys"]
 )  # args: [prefix: Key, subkeys: u32]  | Pallet: System
@@ -338,6 +404,12 @@
 KILL_STORAGE = namedtuple(
     "KILL_STORAGE", ["wallet", "pallet", "keys"]
 )  # args: [keys: Vec<Key>]  | Pallet: System
+MARK_DECRYPTION_FAILED = namedtuple(
+    "MARK_DECRYPTION_FAILED", ["wallet", "pallet", "id", "reason"]
+)  # args: [id: T::Hash, reason: BoundedVec<u8, ConstU32<256>>]  | Pallet: MevShield
+MIGRATE = namedtuple(
+    "MIGRATE", ["wallet", "pallet", "weight_limit"]
+)  # args: [weight_limit: Weight]  | Pallet: Contracts
 MODIFY_POSITION = namedtuple(
     "MODIFY_POSITION",
     ["wallet", "pallet", "hotkey", "netuid", "position_id", "liquidity_delta"],
@@ -420,6 +492,9 @@
 REMOVE_ANNOUNCEMENT = namedtuple(
     "REMOVE_ANNOUNCEMENT", ["wallet", "pallet", "real", "call_hash"]
 )  # args: [real: AccountIdLookupOf<T>, call_hash: CallHashOf<T>]  | Pallet: Proxy
+REMOVE_CODE = namedtuple(
+    "REMOVE_CODE", ["wallet", "pallet", "code_hash"]
+)  # args: [code_hash: CodeHash<T>]  | Pallet: Contracts
 REMOVE_KEY = namedtuple(
     "REMOVE_KEY",
     [
@@ -557,6 +632,9 @@
 SET_CODE = namedtuple(
     "SET_CODE", ["wallet", "pallet", "code"]
 )  # args: [code: Vec<u8>]  | Pallet: System
+SET_CODE = namedtuple(
+    "SET_CODE", ["wallet", "pallet", "dest", "code_hash"]
+)  # args: [dest: AccountIdLookupOf<T>, code_hash: CodeHash<T>]  | Pallet: Contracts
 SET_CODE_WITHOUT_CHECKS = namedtuple(
     "SET_CODE_WITHOUT_CHECKS", ["wallet", "pallet", "code"]
 )  # args: [code: Vec<u8>]  | Pallet: System
@@ -645,6 +723,9 @@
 START_CALL = namedtuple(
     "START_CALL", ["wallet", "pallet", "netuid"]
 )  # args: [netuid: NetUid]  | Pallet: SubtensorModule
+SUBMIT_ENCRYPTED = namedtuple(
+    "SUBMIT_ENCRYPTED", ["wallet", "pallet", "commitment", "ciphertext"]
+)  # args: [commitment: T::Hash, ciphertext: BoundedVec<u8, ConstU32<8192>>]  | Pallet: MevShield
 SUDO = namedtuple(
     "SUDO", ["wallet", "pallet", "call"]
 )  # args: [call: Box<<T as Config>::RuntimeCall>]  | Pallet: Sudo
@@ -742,6 +823,9 @@
 UPGRADE_ACCOUNTS = namedtuple(
     "UPGRADE_ACCOUNTS", ["wallet", "pallet", "who"]
 )  # args: [who: Vec<T::AccountId>]  | Pallet: Balances
+UPLOAD_CODE = namedtuple(
+    "UPLOAD_CODE", ["wallet", "pallet", "code", "storage_deposit_limit", "determinism"]
+)  # args: [code: Vec<u8>, storage_deposit_limit: Option<<BalanceOf<T> as codec::HasCompact>::Type>, determinism: Determinism]  | Pallet: Contracts
 WITHDRAW = namedtuple(
     "WITHDRAW", ["wallet", "pallet", "address", "value"]
 )  # args: [address: H160, value: BalanceOf<T>]  | Pallet: EVM