Improves all apis

Author: ibraheem-abe

bittensor/core/async_subtensor.py

@@ -1575,71 +1575,116 @@ async def get_stake(
 
         return Balance.from_rao(int(stake)).set_unit(netuid=netuid)
 
-    async def get_stake_fee(
+    async def get_stake_add_fee(
         self,
-        origin_hotkey_ss58: Optional[str],
-        origin_netuid: Optional[int],
-        origin_coldkey_ss58: str,
-        destination_hotkey_ss58: Optional[str],
-        destination_netuid: Optional[int],
-        destination_coldkey_ss58: str,
-        amount: int,
-        block_hash: Optional[str] = None,
+        amount: Balance,
+        netuid: int,
+        coldkey_ss58: str,
+        hotkey_ss58: str,
+        block: Optional[int] = None,
     ) -> Balance:
         """
-        Calculates the fee for a staking operation.
-
-        :param origin_hotkey_ss58: SS58 address of source hotkey (None for new stake)
-        :param origin_netuid: Netuid of source subnet (None for new stake)
-        :param origin_coldkey_ss58: SS58 address of source coldkey
-        :param destination_hotkey_ss58: SS58 address of destination hotkey (None for removing stake)
-        :param destination_netuid: Netuid of destination subnet (None for removing stake)
-        :param destination_coldkey_ss58: SS58 address of destination coldkey
-        :param amount: Amount of stake to transfer in RAO
-        :param block_hash: Optional block hash at which to perform the calculation
+        Calculates the fee for adding new stake to a hotkey.
 
-        :return: The calculated stake fee as a Balance object
+        Args:
+            amount: Amount of stake to add in TAO
+            netuid: Netuid of subnet
+            coldkey_ss58: SS58 address of source coldkey
+            hotkey_ss58: SS58 address of destination hotkey
+            block: Block number at which to perform the calculation
 
-        When to use None:
+        Returns:
+            The calculated stake fee as a Balance object
+        """
+        result = await self.query_runtime_api(
+            runtime_api="StakeInfoRuntimeApi",
+            method="get_stake_fee",
+            params=[
+                None,
+                coldkey_ss58,
+                (hotkey_ss58, netuid),
+                coldkey_ss58,
+                amount.rao,
+            ],
+            block=block,
+        )
+        return Balance.from_rao(result)
 
-        1. Adding new stake (default fee):
-        - origin_hotkey_ss58 = None
-        - origin_netuid = None
-        - All other fields required
+    async def get_unstake_fee(
+        self,
+        amount: Balance,
+        netuid: int,
+        coldkey_ss58: str,
+        hotkey_ss58: str,
+        block: Optional[int] = None,
+    ) -> Balance:
+        """
+        Calculates the fee for unstaking from a hotkey.
 
-        2. Removing stake (default fee):
-        - destination_hotkey_ss58 = None
-        - destination_netuid = None
-        - All other fields required
+        Args:
+            amount: Amount of stake to unstake in TAO
+            netuid: Netuid of subnet
+            coldkey_ss58: SS58 address of source coldkey
+            hotkey_ss58: SS58 address of destination hotkey
+            block: Block number at which to perform the calculation
 
-        For all other operations, no None values - provide all parameters:
-        3. Moving between subnets
-        4. Moving between hotkeys
-        5. Moving between coldkeys
+        Returns:
+            The calculated stake fee as a Balance object
         """
+        result = await self.query_runtime_api(
+            runtime_api="StakeInfoRuntimeApi",
+            method="get_stake_fee",
+            params=[
+                None,
+                coldkey_ss58,
+                (hotkey_ss58, netuid),
+                coldkey_ss58,
+                amount.rao,
+            ],
+            block=block,
+        )
+        return Balance.from_rao(result)
 
-        origin = None
-        if origin_hotkey_ss58 is not None and origin_netuid is not None:
-            origin = (origin_hotkey_ss58, origin_netuid)
+    async def get_stake_movement_fee(
+        self,
+        amount: Balance,
+        origin_netuid: int,
+        origin_hotkey_ss58: str,
+        origin_coldkey_ss58: str,
+        destination_netuid: int,
+        destination_hotkey_ss58: str,
+        destination_coldkey_ss58: str,
+        block: Optional[int] = None,
+    ) -> Balance:
+        """
+        Calculates the fee for moving stake between hotkeys/subnets/coldkeys.
 
-        destination = None
-        if destination_hotkey_ss58 is not None and destination_netuid is not None:
-            destination = (destination_hotkey_ss58, destination_netuid)
+        Args:
+            amount: Amount of stake to move in TAO
+            origin_netuid: Netuid of source subnet
+            origin_hotkey_ss58: SS58 address of source hotkey
+            origin_coldkey_ss58: SS58 address of source coldkey
+            destination_netuid: Netuid of destination subnet
+            destination_hotkey_ss58: SS58 address of destination hotkey
+            destination_coldkey_ss58: SS58 address of destination coldkey
+            block: Block number at which to perform the calculation
 
+        Returns:
+            The calculated stake fee as a Balance object
+        """
         result = await self.query_runtime_api(
             runtime_api="StakeInfoRuntimeApi",
             method="get_stake_fee",
             params=[
-                origin,
+                (origin_hotkey_ss58, origin_netuid),
                 origin_coldkey_ss58,
-                destination,
+                (destination_hotkey_ss58, destination_netuid),
                 destination_coldkey_ss58,
-                amount,
+                amount.rao,
             ],
-            block_hash=block_hash,
+            block=block,
         )
-
-        return Balance.from_rao(result if result is not None else 0)
+        return Balance.from_rao(result)
 
     async def get_stake_for_coldkey_and_hotkey(
         self,

bittensor/core/subtensor.py

@@ -1210,67 +1210,115 @@ def get_stake(
 
         return Balance.from_rao(int(stake)).set_unit(netuid=netuid)
 
-    def get_stake_fee(
+    def get_stake_add_fee(
         self,
-        origin_hotkey_ss58: Optional[str],
-        origin_netuid: Optional[int],
+        amount: Balance,
+        netuid: int,
+        coldkey_ss58: str,
+        hotkey_ss58: str,
+        block: Optional[int] = None,
+    ) -> Balance:
+        """
+        Calculates the fee for adding new stake to a hotkey.
+
+        Args:
+            amount: Amount of stake to add in TAO
+            netuid: Netuid of subnet
+            coldkey_ss58: SS58 address of coldkey
+            hotkey_ss58: SS58 address of hotkey
+            block: Block number at which to perform the calculation
+
+        Returns:
+            The calculated stake fee as a Balance object
+        """
+        result = self.query_runtime_api(
+            runtime_api="StakeInfoRuntimeApi",
+            method="get_stake_fee",
+            params=[
+                None,
+                coldkey_ss58,
+                (hotkey_ss58, netuid),
+                coldkey_ss58,
+                amount.rao,
+            ],
+            block=block,
+        )
+        return Balance.from_rao(result)
+
+    def get_unstake_fee(
+        self,
+        amount: Balance,
+        netuid: int,
+        coldkey_ss58: str,
+        hotkey_ss58: str,
+        block: Optional[int] = None,
+    ) -> Balance:
+        """
+        Calculates the fee for unstaking from a hotkey.
+
+        Args:
+            amount: Amount of stake to unstake in TAO
+            netuid: Netuid of subnet
+            coldkey_ss58: SS58 address of coldkey
+            hotkey_ss58: SS58 address of hotkey
+            block: Block number at which to perform the calculation
+
+        Returns:
+            The calculated stake fee as a Balance object
+        """
+        result = self.query_runtime_api(
+            runtime_api="StakeInfoRuntimeApi",
+            method="get_stake_fee",
+            params=[
+                (hotkey_ss58, netuid),
+                coldkey_ss58,
+                None,
+                coldkey_ss58,
+                amount.rao,
+            ],
+            block=block,
+        )
+        return Balance.from_rao(result)
+
+    def get_stake_movement_fee(
+        self,
+        amount: Balance,
+        origin_netuid: int,
+        origin_hotkey_ss58: str,
         origin_coldkey_ss58: str,
-        destination_hotkey_ss58: Optional[str],
-        destination_netuid: Optional[int],
+        destination_netuid: int,
+        destination_hotkey_ss58: str,
         destination_coldkey_ss58: str,
-        amount: Balance,
         block: Optional[int] = None,
     ) -> Balance:
         """
-        Calculates the fee for a staking operation.
-        :param origin_hotkey_ss58: SS58 address of source hotkey (None for new stake)
-        :param origin_netuid: Netuid of source subnet (None for new stake)
-        :param origin_coldkey_ss58: SS58 address of source coldkey
-        :param destination_hotkey_ss58: SS58 address of destination hotkey (None for removing stake)
-        :param destination_netuid: Netuid of destination subnet (None for removing stake)
-        :param destination_coldkey_ss58: SS58 address of destination coldkey
-        :param amount: Amount of stake to transfer in RAO
-        :param block_hash: Optional block hash at which to perform the calculation
-        :return: The calculated stake fee as a Balance object
-        When to use None:
-        1. Adding new stake (default fee):
-        - origin_hotkey_ss58 = None
-        - origin_netuid = None
-        - All other fields required
-        2. Removing stake (default fee):
-        - destination_hotkey_ss58 = None
-        - destination_netuid = None
-        - All other fields required
-        For all other operations, no None values - provide all parameters:
-        3. Moving between subnets
-        4. Moving between hotkeys
-        5. Moving between coldkeys
-        """
-
-        origin = None
-        if origin_hotkey_ss58 is not None and origin_netuid is not None:
-            origin = (origin_hotkey_ss58, origin_netuid)
-
-        destination = None
-        if destination_hotkey_ss58 is not None and destination_netuid is not None:
-            destination = (destination_hotkey_ss58, destination_netuid)
+        Calculates the fee for moving stake between hotkeys/subnets/coldkeys.
 
+        Args:
+            amount: Amount of stake to move in TAO
+            origin_netuid: Netuid of origin subnet
+            origin_hotkey_ss58: SS58 address of origin hotkey
+            origin_coldkey_ss58: SS58 address of origin coldkey
+            destination_netuid: Netuid of destination subnet
+            destination_hotkey_ss58: SS58 address of destination hotkey
+            destination_coldkey_ss58: SS58 address of destination coldkey
+            block: Block number at which to perform the calculation
+
+        Returns:
+            The calculated stake fee as a Balance object
+        """
         result = self.query_runtime_api(
             runtime_api="StakeInfoRuntimeApi",
             method="get_stake_fee",
             params=[
-                origin,
+                (origin_hotkey_ss58, origin_netuid),
                 origin_coldkey_ss58,
-                destination,
+                (destination_hotkey_ss58, destination_netuid),
                 destination_coldkey_ss58,
-                amount,
+                amount.rao,
             ],
             block=block,
         )
-
-        if result is None:
-            raise Exception("Unable to retrieve stake fee.")
-
         return Balance.from_rao(result)
 
     def get_stake_for_coldkey_and_hotkey(