Release/9.0.3

CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## 9.0.3 /2025-02-26
+
+## What's Changed
+* Release/9.0.2 by @ibraheem-opentensor in https://github.com/opentensor/bittensor/pull/2696
+* fix: typos in config test by @EricHasegawa in https://github.com/opentensor/bittensor/pull/2693
+* Removes limits in async + unstake_multiple by @ibraheem-opentensor in https://github.com/opentensor/bittensor/pull/2701
+* Fixes get_all_commitments, adds tests. by @thewhaleking in https://github.com/opentensor/bittensor/pull/2699
+* Use `.value` in e2e test by @thewhaleking in https://github.com/opentensor/bittensor/pull/2700
+* Fix e2e test setup by @thewhaleking in https://github.com/opentensor/bittensor/pull/2681
+* Dendrite `__del__` method fix by @thewhaleking in https://github.com/opentensor/bittensor/pull/2702
+* Fix E2E test_set_weights by @zyzniewski-reef in https://github.com/opentensor/bittensor/pull/2703
+* Updates test incentive by @ibraheem-opentensor in https://github.com/opentensor/bittensor/pull/2688
+* Add `get_timestamp` method by @thewhaleking in https://github.com/opentensor/bittensor/pull/2704
+* fix: async get_delegated by @zyzniewski-reef in https://github.com/opentensor/bittensor/pull/2706
+* Properly mock data_chain class methods by @zyzniewski-reef in https://github.com/opentensor/bittensor/pull/2705
+* Install btcli from install sh by @thewhaleking in https://github.com/opentensor/bittensor/pull/2708
+* Bumps dependencies of async substrate + btwallet by @ibraheem-opentensor in https://github.com/opentensor/bittensor/pull/2710
+* Backmerge/main to staging 902 by @ibraheem-opentensor in https://github.com/opentensor/bittensor/pull/2711
+
+## New Contributors
+* @EricHasegawa made their first contribution in https://github.com/opentensor/bittensor/pull/2693
+
+**Full Changelog**: https://github.com/opentensor/bittensor/compare/v9.0.2...v9.0.3
+
 ## 9.0.2 /2025-02-24
 
 ## What's Changed

VERSION

@@ -1 +1 @@
-9.0.2
+9.0.3

bittensor/core/async_subtensor.py

@@ -1,5 +1,6 @@
 import asyncio
 import copy
+from datetime import datetime, timezone
 import ssl
 from functools import partial
 from typing import Optional, Any, Union, Iterable, TYPE_CHECKING
@@ -27,6 +28,7 @@
     decode_account_id,
     DynamicInfo,
 )
+from bittensor.core.chain_data.delegate_info import DelegatedInfo
 from bittensor.core.chain_data.utils import decode_metadata
 from bittensor.core.config import Config
 from bittensor.core.errors import SubstrateRequestException
@@ -999,7 +1001,7 @@ async def get_all_commitments(
         )
         result = {}
         async for id_, value in query:
-            result[decode_account_id(id_[0])] = decode_account_id(value)
+            result[decode_account_id(id_[0])] = decode_metadata(value)
         return result
 
     async def get_current_weight_commit_info(
@@ -1219,7 +1221,7 @@ async def get_delegated(
         if not result:
             return []
 
-        return DelegateInfo.delegated_list_from_dicts(result)
+        return DelegatedInfo.list_from_dicts(result)
 
     async def get_delegates(
         self,
@@ -2744,6 +2746,36 @@ async def weights_rate_limit(
         )
         return None if call is None else int(call)
 
+    async def get_timestamp(
+        self,
+        block: Optional[int] = None,
+        block_hash: Optional[str] = None,
+        reuse_block: bool = False,
+    ) -> datetime:
+        """
+        Retrieves the datetime timestamp for a given block
+
+        Arguments:
+            block: The blockchain block number for the query. Do not specify if specifying block_hash or reuse_block.
+            block_hash: The blockchain block_hash representation of the block id. Do not specify if specifying block
+                or reuse_block.
+            reuse_block: Whether to reuse the last-used blockchain block hash. Do not specify if specifying block or
+                block_hash.
+
+        Returns:
+            datetime object for the timestamp of the block
+        """
+        unix = (
+            await self.query_module(
+                "Timestamp",
+                "Now",
+                block=block,
+                block_hash=block_hash,
+                reuse_block=reuse_block,
+            )
+        ).value
+        return datetime.fromtimestamp(unix / 1000, tz=timezone.utc)
+
     # Extrinsics helper ================================================================================================
 
     async def sign_and_send_extrinsic(

bittensor/core/dendrite.py

@@ -877,7 +877,14 @@ def __del__(self):
             # ... some operations ...
             del dendrite  # This will implicitly invoke the __del__ method and close the session.
         """
-        self.close_session()
+        try:
+            self.close_session()
+        except RuntimeError:
+            if self._session:
+                logging.debug(
+                    "A Dendrite session was unable to be closed during garbage-collection of the Dendrite object. This "
+                    "usually indicates that you were not using the async context manager."
+                )
 
 
 # For back-compatibility with torch

bittensor/core/extrinsics/asyncex/staking.py

@@ -314,20 +314,6 @@ async def add_stake_multiple_extrinsic(
             if staking_response is True:  # If we successfully staked.
                 # We only wait here if we expect finalization.
 
-                if idx < len(hotkey_ss58s) - 1:
-                    # Wait for tx rate limit.
-                    tx_query = await subtensor.substrate.query(
-                        module="SubtensorModule", storage_function="TxRateLimit"
-                    )
-                    tx_rate_limit_blocks: int = getattr(tx_query, "value", 0)
-                    if tx_rate_limit_blocks > 0:
-                        logging.error(
-                            f":hourglass: [yellow]Waiting for tx rate limit: [white]{tx_rate_limit_blocks}[/white] "
-                            f"blocks[/yellow]"
-                        )
-                        # 12 seconds per block
-                        await asyncio.sleep(tx_rate_limit_blocks * 12)
-
                 if not wait_for_finalization and not wait_for_inclusion:
                     old_balance -= staking_balance
                     successful_stakes += 1

bittensor/core/extrinsics/asyncex/unstaking.py

@@ -281,18 +281,6 @@ async def unstake_multiple_extrinsic(
             if staking_response is True:  # If we successfully unstaked.
                 # We only wait here if we expect finalization.
 
-                if idx < len(hotkey_ss58s) - 1:
-                    # Wait for tx rate limit.
-                    tx_rate_limit_blocks = await subtensor.tx_rate_limit()
-                    if tx_rate_limit_blocks > 0:
-                        logging.info(
-                            f":hourglass: [yellow]Waiting for tx rate limit: "
-                            f"[white]{tx_rate_limit_blocks}[/white] blocks[/yellow]"
-                        )
-                        await asyncio.sleep(
-                            tx_rate_limit_blocks * 12
-                        )  # 12 seconds per block
-
                 if not wait_for_finalization and not wait_for_inclusion:
                     successful_unstakes += 1
                     continue

bittensor/core/extrinsics/unstaking.py

@@ -1,4 +1,3 @@
-import time
 from typing import Optional, TYPE_CHECKING
 
 from bittensor.core.errors import StakeError, NotRegisteredError
@@ -266,16 +265,6 @@ def unstake_multiple_extrinsic(
             if staking_response is True:  # If we successfully unstaked.
                 # We only wait here if we expect finalization.
 
-                if idx < len(hotkey_ss58s) - 1:
-                    # Wait for tx rate limit.
-                    tx_rate_limit_blocks = subtensor.tx_rate_limit()
-                    if tx_rate_limit_blocks > 0:
-                        logging.info(
-                            f":hourglass: [yellow]Waiting for tx rate limit: "
-                            f"[white]{tx_rate_limit_blocks}[/white] blocks[/yellow]"
-                        )
-                        time.sleep(tx_rate_limit_blocks * 12)  # 12 seconds per block
-
                 if not wait_for_finalization and not wait_for_inclusion:
                     successful_unstakes += 1
                     continue

bittensor/core/settings.py

@@ -1,4 +1,4 @@
-__version__ = "9.0.2"
+__version__ = "9.0.3"
 
 import os
 import re

bittensor/core/subtensor.py

@@ -1,4 +1,6 @@
 import copy
+from datetime import datetime, timezone
+
 from functools import lru_cache
 from typing import TYPE_CHECKING, Any, Iterable, Optional, Union, cast
 
@@ -754,7 +756,7 @@ def get_all_commitments(
         )
         result = {}
         for id_, value in query:
-            result[decode_account_id(id_[0])] = decode_account_id(value)
+            result[decode_account_id(id_[0])] = decode_metadata(value)
         return result
 
     def get_current_weight_commit_info(
@@ -2070,6 +2072,19 @@ def weights_rate_limit(
         )
         return None if call is None else int(call)
 
+    def get_timestamp(self, block: Optional[int] = None) -> datetime:
+        """
+        Retrieves the datetime timestamp for a given block
+
+        Arguments:
+            block: The blockchain block number for the query.
+
+        Returns:
+            datetime object for the timestamp of the block
+        """
+        unix = cast(ScaleObj, self.query_module("Timestamp", "Now", block=block)).value
+        return datetime.fromtimestamp(unix / 1000, tz=timezone.utc)
+
     # Extrinsics helper ================================================================================================
 
     def sign_and_send_extrinsic(

scripts/install.sh

@@ -105,6 +105,7 @@ linux_install_bittensor() {
     git clone https://github.com/opentensor/bittensor.git ~/.bittensor/bittensor/ 2> /dev/null || (cd ~/.bittensor/bittensor/ ; git fetch origin master ; git checkout master ; git pull --ff-only ; git reset --hard ; git clean -xdf)
     ohai "Installing bittensor"
     $python -m pip install -e ~/.bittensor/bittensor/
+    $python -m pip install -U bittensor-cli
     exit_on_error $? 
 }
 
@@ -163,10 +164,11 @@ mac_update_pip() {
 }
 
 mac_install_bittensor() {
-    ohai "Cloning bittensor@text_prompting into ~/.bittensor/bittensor"
+    ohai "Cloning bittensor into ~/.bittensor/bittensor"
     git clone https://github.com/opentensor/bittensor.git ~/.bittensor/bittensor/ 2> /dev/null || (cd ~/.bittensor/bittensor/ ; git fetch origin master ; git checkout master ; git pull --ff-only ; git reset --hard; git clean -xdf)
     ohai "Installing bittensor"
     $python -m pip install -e ~/.bittensor/bittensor/
+    $python -m pip install -U bittensor-cli
     exit_on_error $? 
     deactivate
 }

tests/e2e_tests/conftest.py

@@ -8,8 +8,9 @@
 
 import pytest
 from async_substrate_interface import SubstrateInterface
-from bittensor.core.subtensor import Subtensor
 
+from bittensor.core.async_subtensor import AsyncSubtensor
+from bittensor.core.subtensor import Subtensor
 from bittensor.utils.btlogging import logging
 from tests.e2e_tests.utils.e2e_test_utils import (
     Templates,
@@ -101,6 +102,11 @@ def subtensor(local_chain):
     return Subtensor(network="ws://localhost:9944")
 
 
+@pytest.fixture
+def async_subtensor(local_chain):
+    return AsyncSubtensor(network="ws://localhost:9944")
+
+
 @pytest.fixture
 def alice_wallet():
     keypair, wallet = setup_wallet("//Alice")

tests/e2e_tests/test_commit_weights.py

@@ -267,7 +267,7 @@ async def test_commit_weights_uses_next_nonce(local_chain, subtensor, alice_wall
     assert success is True
 
     # Wait a few blocks
-    await asyncio.sleep(2)  # Wait for the txs to be included in the chain
+    await asyncio.sleep(10)  # Wait for the txs to be included in the chain
 
     # Query the WeightCommits storage map for all three salts
     weight_commits = subtensor.query_module(

tests/e2e_tests/test_commitment.py

@@ -51,3 +51,61 @@ def test_commitment(subtensor, alice_wallet):
         netuid=1,
         uid=uid,
     )
+
+    assert (
+        subtensor.get_all_commitments(netuid=1)[alice_wallet.hotkey.ss58_address]
+        == "Hello World!"
+    )
+
+
+@pytest.mark.asyncio
+async def test_commitment_async(async_subtensor, alice_wallet):
+    async with async_subtensor as sub:
+        with pytest.raises(SubstrateRequestException, match="AccountNotAllowedCommit"):
+            await sub.set_commitment(
+                alice_wallet,
+                netuid=1,
+                data="Hello World!",
+            )
+
+        assert await sub.burned_register(
+            alice_wallet,
+            netuid=1,
+        )
+
+        uid = await sub.get_uid_for_hotkey_on_subnet(
+            alice_wallet.hotkey.ss58_address,
+            netuid=1,
+        )
+
+        assert uid is not None
+
+        assert "" == await sub.get_commitment(
+            netuid=1,
+            uid=uid,
+        )
+
+        assert await sub.set_commitment(
+            alice_wallet,
+            netuid=1,
+            data="Hello World!",
+        )
+
+        with pytest.raises(
+            SubstrateRequestException,
+            match="CommitmentSetRateLimitExceeded",
+        ):
+            await sub.set_commitment(
+                alice_wallet,
+                netuid=1,
+                data="Hello World!",
+            )
+
+        assert "Hello World!" == await sub.get_commitment(
+            netuid=1,
+            uid=uid,
+        )
+
+        assert (await sub.get_all_commitments(netuid=1))[
+            alice_wallet.hotkey.ss58_address
+        ] == "Hello World!"

tests/e2e_tests/test_cross_subtensor_compatibility.py

@@ -0,0 +1,18 @@
+from datetime import datetime
+import pytest
+
+
+@pytest.mark.asyncio
+async def test_get_timestamp(subtensor, async_subtensor, local_chain):
+    with subtensor:
+        block_number = subtensor.get_current_block()
+        assert isinstance(
+            subtensor.get_timestamp(), datetime
+        )  # verify it works with no block number specified
+        sync_result = subtensor.get_timestamp(
+            block=block_number
+        )  # verify it works with block number specified
+    async with async_subtensor:
+        assert isinstance(await async_subtensor.get_timestamp(), datetime)
+        async_result = await async_subtensor.get_timestamp(block=block_number)
+    assert sync_result == async_result