Merge pull request #2828 from opentensor/feat/roman/start-call-extrinsic

Add `start_call` extrinsic to the sdk

Author: basfroman

bittensor/core/async_subtensor.py

@@ -57,6 +57,7 @@
     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,
@@ -3986,6 +3987,36 @@ async def serve_axon(
             certificate=certificate,
         )
 
+    async def start_call(
+        self,
+        wallet: "Wallet",
+        netuid: int,
+        wait_for_inclusion: bool = True,
+        wait_for_finalization: bool = False,
+    ) -> tuple[bool, str]:
+        """
+        Submits a start_call extrinsic to the blockchain, to trigger the start call process for a subnet (used to start a
+        new subnet's emission mechanism).
+
+        Args:
+            wallet (Wallet): The wallet used to sign the extrinsic (must be unlocked).
+            netuid (int): The UID of the target subnet for which the call is being initiated.
+            wait_for_inclusion (bool, optional): Whether to wait for the extrinsic to be included in a block. Defaults to True.
+            wait_for_finalization (bool, optional): Whether to wait for finalization of the extrinsic. Defaults to False.
+
+        Returns:
+            Tuple[bool, str]:
+                - True and a success message if the extrinsic is successfully submitted or processed.
+                - False and an error message if the submission fails or the wallet cannot be unlocked.
+        """
+        return await start_call_extrinsic(
+            subtensor=self,
+            wallet=wallet,
+            netuid=netuid,
+            wait_for_inclusion=wait_for_inclusion,
+            wait_for_finalization=wait_for_finalization,
+        )
+
     async def swap_stake(
         self,
         wallet: "Wallet",

bittensor/core/extrinsics/asyncex/start_call.py

@@ -0,0 +1,61 @@
+from typing import TYPE_CHECKING
+
+from bittensor.utils import unlock_key
+from bittensor.utils.btlogging import logging
+
+if TYPE_CHECKING:
+    from bittensor_wallet import Wallet
+    from bittensor.core.async_subtensor import AsyncSubtensor
+
+
+async def start_call_extrinsic(
+    subtensor: "AsyncSubtensor",
+    wallet: "Wallet",
+    netuid: int,
+    wait_for_inclusion: bool = True,
+    wait_for_finalization: bool = False,
+) -> tuple[bool, str]:
+    """
+    Submits a start_call extrinsic to the blockchain, to trigger the start call process for a subnet (used to start a
+    new subnet's emission mechanism).
+
+    Args:
+        subtensor (Subtensor): The Subtensor client instance used for blockchain interaction.
+        wallet (Wallet): The wallet used to sign the extrinsic (must be unlocked).
+        netuid (int): The UID of the target subnet for which the call is being initiated.
+        wait_for_inclusion (bool, optional): Whether to wait for the extrinsic to be included in a block. Defaults to True.
+        wait_for_finalization (bool, optional): Whether to wait for finalization of the extrinsic. Defaults to False.
+
+    Returns:
+        Tuple[bool, str]:
+            - True and a success message if the extrinsic is successfully submitted or processed.
+            - False and an error message if the submission fails or the wallet cannot be unlocked.
+    """
+    if not (unlock := unlock_key(wallet)).success:
+        logging.error(unlock.message)
+        return False, unlock.message
+
+    async with subtensor.substrate as substrate:
+        start_call = await substrate.compose_call(
+            call_module="SubtensorModule",
+            call_function="start_call",
+            call_params={"netuid": netuid},
+        )
+        signed_ext = await substrate.create_signed_extrinsic(
+            call=start_call,
+            keypair=wallet.coldkey,
+        )
+
+        response = await substrate.submit_extrinsic(
+            extrinsic=signed_ext,
+            wait_for_inclusion=wait_for_inclusion,
+            wait_for_finalization=wait_for_finalization,
+        )
+
+        if not wait_for_finalization and not wait_for_inclusion:
+            return True, "Not waiting for finalization or inclusion."
+
+        if await response.is_success:
+            return True, "Success with `start_call` response."
+
+        return False, await response.error_message

bittensor/core/extrinsics/start_call.py

@@ -0,0 +1,62 @@
+from typing import TYPE_CHECKING
+
+from bittensor.utils import unlock_key
+from bittensor.utils.btlogging import logging
+
+if TYPE_CHECKING:
+    from bittensor_wallet import Wallet
+    from bittensor.core.subtensor import Subtensor
+
+
+def start_call_extrinsic(
+    subtensor: "Subtensor",
+    wallet: "Wallet",
+    netuid: int,
+    wait_for_inclusion: bool = True,
+    wait_for_finalization: bool = False,
+) -> tuple[bool, str]:
+    """
+    Submits a start_call extrinsic to the blockchain, to trigger the start call process for a subnet (used to start a
+    new subnet's emission mechanism).
+
+    Args:
+        subtensor (Subtensor): The Subtensor client instance used for blockchain interaction.
+        wallet (Wallet): The wallet used to sign the extrinsic (must be unlocked).
+        netuid (int): The UID of the target subnet for which the call is being initiated.
+        wait_for_inclusion (bool, optional): Whether to wait for the extrinsic to be included in a block. Defaults to True.
+        wait_for_finalization (bool, optional): Whether to wait for finalization of the extrinsic. Defaults to False.
+
+    Returns:
+        Tuple[bool, str]:
+            - True and a success message if the extrinsic is successfully submitted or processed.
+            - False and an error message if the submission fails or the wallet cannot be unlocked.
+    """
+    if not (unlock := unlock_key(wallet)).success:
+        logging.error(unlock.message)
+        return False, unlock.message
+
+    with subtensor.substrate as substrate:
+        start_call = substrate.compose_call(
+            call_module="SubtensorModule",
+            call_function="start_call",
+            call_params={"netuid": netuid},
+        )
+
+        signed_ext = substrate.create_signed_extrinsic(
+            call=start_call,
+            keypair=wallet.coldkey,
+        )
+
+        response = substrate.submit_extrinsic(
+            extrinsic=signed_ext,
+            wait_for_inclusion=wait_for_inclusion,
+            wait_for_finalization=wait_for_finalization,
+        )
+
+        if not wait_for_finalization and not wait_for_inclusion:
+            return True, "Not waiting for finalization or inclusion."
+
+        if response.is_success:
+            return True, "Success with `start_call` response."
+
+        return False, response.error_message

bittensor/core/subtensor.py

@@ -60,6 +60,7 @@
     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,
@@ -3252,6 +3253,36 @@ def serve_axon(
             certificate=certificate,
         )
 
+    def start_call(
+        self,
+        wallet: "Wallet",
+        netuid: int,
+        wait_for_inclusion: bool = True,
+        wait_for_finalization: bool = False,
+    ) -> tuple[bool, str]:
+        """
+        Submits a start_call extrinsic to the blockchain, to trigger the start call process for a subnet (used to start a
+        new subnet's emission mechanism).
+
+        Args:
+            wallet (Wallet): The wallet used to sign the extrinsic (must be unlocked).
+            netuid (int): The UID of the target subnet for which the call is being initiated.
+            wait_for_inclusion (bool, optional): Whether to wait for the extrinsic to be included in a block. Defaults to True.
+            wait_for_finalization (bool, optional): Whether to wait for finalization of the extrinsic. Defaults to False.
+
+        Returns:
+            Tuple[bool, str]:
+                - True and a success message if the extrinsic is successfully submitted or processed.
+                - False and an error message if the submission fails or the wallet cannot be unlocked.
+        """
+        return start_call_extrinsic(
+            subtensor=self,
+            wallet=wallet,
+            netuid=netuid,
+            wait_for_inclusion=wait_for_inclusion,
+            wait_for_finalization=wait_for_finalization,
+        )
+
     def swap_stake(
         self,
         wallet: "Wallet",

tests/e2e_tests/test_incentive.py

@@ -3,12 +3,10 @@
 import pytest
 
 from bittensor.utils.btlogging import logging
-
 from tests.e2e_tests.utils.chain_interactions import (
     root_set_subtensor_hyperparameter_values,
     sudo_set_admin_utils,
     wait_epoch,
-    wait_interval,
 )
 
 DURATION_OF_START_CALL = 10
@@ -70,15 +68,8 @@ async def test_incentive(local_chain, subtensor, templates, alice_wallet, bob_wa
 
     subtensor.wait_for_block(DURATION_OF_START_CALL)
 
-    # Subnet "Start Call" https://github.com/opentensor/bits/pull/13
-    status, error = await root_set_subtensor_hyperparameter_values(
-        local_chain,
-        alice_wallet,
-        call_function="start_call",
-        call_params={
-            "netuid": netuid,
-        },
-    )
+    # # Subnet "Start Call" https://github.com/opentensor/bits/pull/13
+    status, error = subtensor.start_call(wallet=alice_wallet, netuid=netuid)
 
     assert status is True, error
 

tests/unit_tests/extrinsics/asyncex/test_start_call.py

@@ -0,0 +1,48 @@
+from bittensor.core.extrinsics.asyncex import start_call
+import pytest
+
+
+@pytest.mark.asyncio
+async def test_start_call_extrinsics(subtensor, mocker, fake_wallet):
+    """Test that start_call_extrinsic correctly constructs and submits the extrinsic."""
+
+    # Preps
+    netuid = 123
+    wallet = fake_wallet
+    wallet.name = "fake_wallet"
+    wallet.coldkey = "fake_coldkey"
+
+    substrate = subtensor.substrate.__aenter__.return_value
+    substrate.compose_call.return_value = "mock_call"
+    substrate.create_signed_extrinsic.return_value = "signed_ext"
+    substrate.submit_extrinsic.return_value = mocker.MagicMock(
+        is_success=mocker.AsyncMock(return_value=True)(), error_message=""
+    )
+
+    # Call
+    success, message = await start_call.start_call_extrinsic(
+        subtensor=subtensor,
+        wallet=wallet,
+        netuid=netuid,
+    )
+
+    # Assertions
+    substrate.compose_call.assert_awaited_once_with(
+        call_module="SubtensorModule",
+        call_function="start_call",
+        call_params={"netuid": netuid},
+    )
+
+    substrate.create_signed_extrinsic.assert_awaited_once_with(
+        call="mock_call",
+        keypair=wallet.coldkey,
+    )
+
+    substrate.submit_extrinsic.assert_awaited_once_with(
+        extrinsic="signed_ext",
+        wait_for_inclusion=True,
+        wait_for_finalization=False,
+    )
+
+    assert success is True
+    assert "Success" in message

tests/unit_tests/extrinsics/test_start_call.py

@@ -0,0 +1,46 @@
+from bittensor.core.extrinsics import start_call
+
+
+def test_start_call_extrinsics(subtensor, mocker, fake_wallet):
+    """Test that start_call_extrinsic correctly constructs and submits the extrinsic."""
+
+    # Preps
+    netuid = 123
+    wallet = fake_wallet
+    wallet.name = "fake_wallet"
+    wallet.coldkey = "fake_coldkey"
+
+    substrate = subtensor.substrate.__enter__.return_value
+    substrate.compose_call.return_value = "mock_call"
+    substrate.create_signed_extrinsic.return_value = "signed_ext"
+    substrate.submit_extrinsic.return_value = mocker.MagicMock(
+        is_success=True, error_message=""
+    )
+
+    # Call
+    success, message = start_call.start_call_extrinsic(
+        subtensor=subtensor,
+        wallet=wallet,
+        netuid=netuid,
+    )
+
+    # Assertions
+    substrate.compose_call.assert_called_once_with(
+        call_module="SubtensorModule",
+        call_function="start_call",
+        call_params={"netuid": netuid},
+    )
+
+    substrate.create_signed_extrinsic.assert_called_once_with(
+        call="mock_call",
+        keypair=wallet.coldkey,
+    )
+
+    substrate.submit_extrinsic.assert_called_once_with(
+        extrinsic="signed_ext",
+        wait_for_inclusion=True,
+        wait_for_finalization=False,
+    )
+
+    assert success is True
+    assert "Success" in message

tests/unit_tests/test_async_subtensor.py

@@ -3013,3 +3013,25 @@ async def test_get_owned_hotkeys_return_empty(subtensor, mocker):
         reuse_block_hash=False,
     )
     assert result == []
+
+
+@pytest.mark.asyncio
+async def test_start_call(subtensor, mocker):
+    """Test start_call extrinsic calls properly."""
+    # preps
+    wallet_name = mocker.Mock(spec=Wallet)
+    netuid = 123
+    mocked_extrinsic = mocker.patch.object(async_subtensor, "start_call_extrinsic")
+
+    # Call
+    result = await subtensor.start_call(wallet_name, netuid)
+
+    # Asserts
+    mocked_extrinsic.assert_awaited_once_with(
+        subtensor=subtensor,
+        wallet=wallet_name,
+        netuid=netuid,
+        wait_for_inclusion=True,
+        wait_for_finalization=False,
+    )
+    assert result == mocked_extrinsic.return_value

tests/unit_tests/test_subtensor.py

@@ -3388,3 +3388,24 @@ def test_get_owned_hotkeys_return_empty(subtensor, mocker):
         reuse_block_hash=False,
     )
     assert result == []
+
+
+def test_start_call(subtensor, mocker):
+    """Test start_call extrinsic calls properly."""
+    # preps
+    wallet_name = mocker.Mock(spec=Wallet)
+    netuid = 123
+    mocked_extrinsic = mocker.patch.object(subtensor_module, "start_call_extrinsic")
+
+    # Call
+    result = subtensor.start_call(wallet_name, netuid)
+
+    # Asserts
+    mocked_extrinsic.assert_called_once_with(
+        subtensor=subtensor,
+        wallet=wallet_name,
+        netuid=netuid,
+        wait_for_inclusion=True,
+        wait_for_finalization=False,
+    )
+    assert result == mocked_extrinsic.return_value