Merge pull request #2856 from opentensor/feat/roman/cleanup

Cleanup, refactoring, small fix, improvement

Author: basfroman

bittensor/core/async_subtensor.py

@@ -58,12 +58,12 @@
     publish_metadata,
     get_metadata,
 )
-from bittensor.core.extrinsics.asyncex.start_call import start_call_extrinsic
 from bittensor.core.extrinsics.asyncex.serving import serve_axon_extrinsic
 from bittensor.core.extrinsics.asyncex.staking import (
     add_stake_extrinsic,
     add_stake_multiple_extrinsic,
 )
+from bittensor.core.extrinsics.asyncex.start_call import start_call_extrinsic
 from bittensor.core.extrinsics.asyncex.take import (
     decrease_take_extrinsic,
     increase_take_extrinsic,
@@ -135,7 +135,6 @@ def __init__(
         self.chain_endpoint, self.network = AsyncSubtensor.setup_config(
             network, self._config
         )
-        self._mock = _mock
 
         self.log_verbose = log_verbose
         self._check_and_log_network_settings()
@@ -229,7 +228,7 @@ async def encode_params(
         call_definition: dict[str, list["ParamWithTypes"]],
         params: Union[list[Any], dict[str, Any]],
     ) -> str:
-        """Returns a hex encoded string of the params using their types."""
+        """Returns a hex-encoded string of the params using their types."""
         param_data = scalecodec.ScaleBytes(b"")
 
         for i, param in enumerate(call_definition["params"]):

bittensor/core/extrinsics/utils.py

@@ -2,106 +2,19 @@
 
 from typing import TYPE_CHECKING
 
-from async_substrate_interface.errors import SubstrateRequestException
-
-from bittensor.utils import format_error_message
 from bittensor.utils.balance import Balance
-from bittensor.utils.btlogging import logging
 
 if TYPE_CHECKING:
     from bittensor_wallet import Wallet
-    from bittensor.core.async_subtensor import AsyncSubtensor
-    from async_substrate_interface import (
-        AsyncExtrinsicReceipt,
-        ExtrinsicReceipt,
-    )
-    from bittensor.core.subtensor import Subtensor
     from bittensor.core.chain_data import StakeInfo
-    from scalecodec.types import GenericExtrinsic
-
-
-def submit_extrinsic(
-    subtensor: "Subtensor",
-    extrinsic: "GenericExtrinsic",
-    wait_for_inclusion: bool,
-    wait_for_finalization: bool,
-) -> "ExtrinsicReceipt":
-    """
-    Submits an extrinsic to the substrate blockchain and handles potential exceptions.
-
-    This function attempts to submit an extrinsic to the substrate blockchain with specified options
-    for waiting for inclusion in a block and/or finalization. If an exception occurs during submission,
-    it logs the error and re-raises the exception.
-
-    Args:
-        subtensor: The Subtensor instance used to interact with the blockchain.
-        extrinsic (scalecodec.types.GenericExtrinsic): The extrinsic to be submitted to the blockchain.
-        wait_for_inclusion (bool): Whether to wait for the extrinsic to be included in a block.
-        wait_for_finalization (bool): Whether to wait for the extrinsic to be finalized on the blockchain.
-
-    Returns:
-        response: The response from the substrate after submitting the extrinsic.
-
-    Raises:
-        SubstrateRequestException: If the submission of the extrinsic fails, the error is logged and re-raised.
-    """
-    try:
-        return subtensor.substrate.submit_extrinsic(
-            extrinsic,
-            wait_for_inclusion=wait_for_inclusion,
-            wait_for_finalization=wait_for_finalization,
-        )
-    except SubstrateRequestException as e:
-        logging.error(format_error_message(e.args[0]))
-        # Re-raise the exception for retrying of the extrinsic call. If we remove the retry logic,
-        # the raise will need to be removed.
-        raise
-
-
-async def async_submit_extrinsic(
-    subtensor: "AsyncSubtensor",
-    extrinsic: "GenericExtrinsic",
-    wait_for_inclusion: bool,
-    wait_for_finalization: bool,
-) -> "AsyncExtrinsicReceipt":
-    """
-    Submits an extrinsic to the substrate blockchain and handles potential exceptions.
-
-    This function attempts to submit an extrinsic to the substrate blockchain with specified options
-    for waiting for inclusion in a block and/or finalization. If an exception occurs during submission,
-    it logs the error and re-raises the exception.
-
-    Args:
-        subtensor: The AsyncSubtensor instance used to interact with the blockchain.
-        extrinsic: The extrinsic to be submitted to the blockchain.
-        wait_for_inclusion: Whether to wait for the extrinsic to be included in a block.
-        wait_for_finalization: Whether to wait for the extrinsic to be finalized on the blockchain.
-
-    Returns:
-        response: The response from the substrate after submitting the extrinsic.
-
-    Raises:
-        SubstrateRequestException: If the submission of the extrinsic fails, the error is logged and re-raised.
-    """
-    try:
-        return await subtensor.substrate.submit_extrinsic(
-            extrinsic,
-            wait_for_inclusion=wait_for_inclusion,
-            wait_for_finalization=wait_for_finalization,
-        )
-    except SubstrateRequestException as e:
-        logging.error(format_error_message(e.args[0]))
-        # Re-raise the exception for retrying of the extrinsic call. If we remove the retry logic,
-        # the raise will need to be removed.
-        raise
 
 
 def get_old_stakes(
     wallet: "Wallet",
     hotkey_ss58s: list[str],
     netuids: list[int],
     all_stakes: list["StakeInfo"],
-) -> list[Balance]:
+) -> list["Balance"]:
     """
     Retrieve the previous staking balances for a wallet's hotkeys across given netuids.
 
@@ -110,10 +23,10 @@ def get_old_stakes(
     is found for a particular hotkey and netuid combination, a default balance of zero is returned.
 
     Args:
-        wallet (Wallet): The wallet containing the coldkey to compare with stake data.
-        hotkey_ss58s (list[str]): List of hotkey SS58 addresses for which stakes are retrieved.
-        netuids (list[int]): List of network unique identifiers (netuids) corresponding to the hotkeys.
-        all_stakes (list[StakeInfo]): A collection of all staking information to search through.
+        wallet: The wallet containing the coldkey to compare with stake data.
+        hotkey_ss58s: List of hotkey SS58 addresses for which stakes are retrieved.
+        netuids: List of network unique identifiers (netuids) corresponding to the hotkeys.
+        all_stakes: A collection of all staking information to search through.
 
     Returns:
         list[Balance]: A list of Balances, each representing the stake for a given hotkey and netuid.

bittensor/core/subtensor.py

@@ -61,12 +61,12 @@
     get_metadata,
     serve_axon_extrinsic,
 )
-from bittensor.core.extrinsics.start_call import start_call_extrinsic
 from bittensor.core.extrinsics.set_weights import set_weights_extrinsic
 from bittensor.core.extrinsics.staking import (
     add_stake_extrinsic,
     add_stake_multiple_extrinsic,
 )
+from bittensor.core.extrinsics.start_call import start_call_extrinsic
 from bittensor.core.extrinsics.take import (
     decrease_take_extrinsic,
     increase_take_extrinsic,
@@ -110,7 +110,7 @@
 
 
 class Subtensor(SubtensorMixin):
-    """Thin layer for interacting with Substrate Interface. Mostly a collection of frequently-used calls."""
+    """Thin layer for interacting with Substrate Interface. Mostly a collection of frequently used calls."""
 
     def __init__(
         self,
@@ -135,7 +135,6 @@ def __init__(
             config = self.config()
         self._config = copy.deepcopy(config)
         self.chain_endpoint, self.network = self.setup_config(network, self._config)
-        self._mock = _mock
 
         self.log_verbose = log_verbose
         self._check_and_log_network_settings()

bittensor/utils/__init__.py

@@ -248,7 +248,7 @@ def format_error_message(error_message: Union[dict, Exception]) -> str:
             err_type = error_message.get("type", err_type)
             err_name = error_message.get("name", err_name)
             err_docs = error_message.get("docs", [err_description])
-            err_description = err_docs[0] if err_docs else err_description
+            err_description = " ".join(err_docs)
 
         elif error_message.get("code") and error_message.get("message"):
             err_type = error_message.get("code", err_name)

tests/unit_tests/extrinsics/test__init__.py

@@ -4,26 +4,31 @@
 
 
 def test_format_error_message_with_right_error_message():
-    """Verify that error message from extrinsic response parses correctly."""
+    """Verify that an error message from extrinsic response parses correctly."""
     # Prep
     fake_error_message = {
         "type": "SomeType",
         "name": "SomeErrorName",
-        "docs": ["Some error description."],
+        "docs": [
+            "Some error description.",
+            "I'm second part.",
+            "Hah, I'm the last one.",
+        ],
     }
 
     # Call
     result = format_error_message(fake_error_message)
 
     # Assertions
 
-    assert "SomeType" in result
-    assert "SomeErrorName" in result
-    assert "Some error description." in result
+    assert (
+        result
+        == "Subtensor returned `SomeErrorName(SomeType)` error. This means: `Some error description. I'm second part. Hah, I'm the last one.`."
+    )
 
 
 def test_format_error_message_with_empty_error_message():
-    """Verify that empty error message from extrinsic response parses correctly."""
+    """Verify that an empty error message from extrinsic response parses correctly."""
     # Prep
     fake_error_message = {}
 

tests/unit_tests/extrinsics/test_utils.py

@@ -1,26 +1,31 @@
-from unittest.mock import MagicMock
-
-import pytest
-from scalecodec.types import GenericExtrinsic
-
+from bittensor.core.chain_data import StakeInfo
 from bittensor.core.extrinsics import utils
-from bittensor.core.subtensor import Subtensor
-
-
-@pytest.fixture
-def mock_subtensor(mock_substrate):
-    mock_subtensor = MagicMock(autospec=Subtensor)
-    mock_subtensor.substrate = mock_substrate
-    yield mock_subtensor
-
-
-@pytest.fixture
-def starting_block():
-    yield {"header": {"number": 1, "hash": "0x0100"}}
-
-
-def test_submit_extrinsic_success(mock_subtensor):
-    mock_subtensor.substrate.submit_extrinsic.return_value = True
-    mock_extrinsic = MagicMock(autospec=GenericExtrinsic)
-    result = utils.submit_extrinsic(mock_subtensor, mock_extrinsic, True, True)
-    assert result is True
+from bittensor.utils.balance import Balance
+
+
+def test_old_stake(subtensor, mocker):
+    wallet = mocker.Mock(
+        hotkey=mocker.Mock(ss58_address="HK1"),
+        coldkeypub=mocker.Mock(ss58_address="CK1"),
+    )
+
+    expected_stake = Balance.from_tao(100)
+
+    hotkey_ss58s = ["HK1", "HK2"]
+    netuids = [3, 4]
+    all_stakes = [
+        StakeInfo(
+            hotkey_ss58="HK1",
+            coldkey_ss58="CK1",
+            netuid=3,
+            stake=expected_stake,
+            locked=Balance.from_tao(10),
+            emission=Balance.from_tao(1),
+            drain=0,
+            is_registered=True,
+        ),
+    ]
+
+    result = utils.get_old_stakes(wallet, hotkey_ss58s, netuids, all_stakes)
+
+    assert result == [expected_stake, Balance.from_tao(0)]