add script to check emissions for HK (opentensor#515)

MichaelTrestman · Michael Trestman · web-flow · commit 10193d525528 · 2025-02-23T11:55:22.000-08:00
* wip

* wip

* wip

---------

Co-authored-by: Michael Trestman &lt;michaeltrestman@mac.mynetworksettings.com&gt;
diff --git a/docs/dynamic-tao/sdk-cheat-sheet.md b/docs/dynamic-tao/sdk-cheat-sheet.md
@@ -78,7 +78,7 @@ class DynamicInfo:
 ## Viewing subnets
 Subnets evolve substantially in Dynamic TAO! Each subnet has its own currency, known as its alpha token, and an internal economy comprising a currency reserve of TAO, a reserve of its own alpha token, and a ledger of staked balances, to keep track of all of its stakers&mdash;those who have put TAO into its reserve in exchange for alpha.
 
-### `all_subnets`
+#### `all_subnets`
 ```python
 all_subnets(
     block_number: Optional[int] = None
@@ -90,7 +90,7 @@ Description: Fetches information about all subnets at a certain block height (or
 
 Returns: A list of DynamicInfo objects (detailed below).
 
-### `get_netuids`
+#### `get_netuids`
 ```python
 get_netuids(self, block: Optional[int] = None) -> list[int]
 
@@ -104,7 +104,7 @@ Returns:
 - `list`[int]: A list of network UIDs representing each active subnet.
 
 
-### `subnet`
+#### `subnet`
 ```python
 subnet(
     netuid: int, 
@@ -117,7 +117,7 @@ Fetches information about a single subnet identified by netuid.
 Returns a DynamicInfo object describing the subnet’s current state.
 
 
-### `metagraph`
+#### `metagraph`
 ```python
 metagraph(
     netuid: int, 
@@ -128,15 +128,15 @@ metagraph(
 
 Returns the metagraph for a specified subnet netuid. The metagraph includes detailed data on the neurons in the subnet.
 
-## Calculating exchange rates
+## Exchange rates
 You can query the DynamicInfo object for the exchange rates between TAO and alpha tokens.
 You can use `all_subnets` or `subnet` to get the DynamicInfo object.
 
 ```python
 subnet = sub.subnet(netuid=1)
 ```
-
-### `tao_to_alpha`
+### Calculate exhange rates
+#### `tao_to_alpha`
 
 ```python
 tao_to_alpha(self, tao: Union[Balance, float, int]) -> Balance:
@@ -146,15 +146,15 @@ Description: Returns an 'ideal' estimate of how much Alpha a staker would receiv
 Parameters:
     `tao`: Amount of TAO to stake.
 
-### `alpha_to_tao`
+#### `alpha_to_tao`
 ```python
 alpha_to_tao(self, alpha: Union[Balance, float, int]) -> Balance:
 ```
 Description: Returns an 'ideal' estimate of how much TAO would be yielded by unstaking at the current price, *ignoring slippage*.
 Parameters:
     `alpha`: Amount of Alpha to unstake.
 
-### `tao_to_alpha_with_slippage`
+#### `tao_to_alpha_with_slippage`
 ```python
 tao_to_alpha_with_slippage(tao: Union[Balance, float, int], percentage: bool = False) -> Union[tuple[Balance, Balance], float]:
 ```
@@ -171,7 +171,7 @@ Returns:
     OR
     Percentage of the slippage as a float
 
-### `alpha_to_tao_with_slippage`
+#### `alpha_to_tao_with_slippage`
 ```python
 alpha_to_tao_with_slippage(alpha: Union[Balance, float, int], percentage: bool = False) -> Union[tuple[Balance, Balance], float]:
 ```
@@ -188,7 +188,7 @@ Returns:
     OR
     Percentage of the slippage as a float
 
-### Example: Viewing exchange rates
+### Display current exchange rates
 
 The following script displays exchange rates for a subnet alpha token, with and without slippage.
 
@@ -210,7 +210,7 @@ print("alpha_to_tao", subnet.alpha_to_tao(100))
 
 ## Managing stake
 
-### `get_stake`
+#### `get_stake`
 ```python
 get_stake(
     hotkey_ss58: str, 
@@ -228,7 +228,7 @@ Parameters:
 
 
 
-### `add_stake`
+#### `add_stake`
 
 ```python
 async add_stake(
@@ -246,7 +246,7 @@ Parameters:
 - netuid: Unique ID of the subnet on which you want to stake.
 - tao_amount: Amount to stake, can be a float, integer, or bittensor.Balance object.
 
-### `unstake`
+#### `unstake`
 ```python
 unstake(
     wallet, 
@@ -266,7 +266,7 @@ Parameters:
 - amount: Amount to unstake.
 
 
-### `get_balance`
+#### `get_balance`
 ```python
 get_balance(
     address: str, 
@@ -282,13 +282,13 @@ Parameters:
 - block: Optional block number at which to fetch the balance. Uses the latest block if None.
 
 
-### `get_current_block`
+#### `get_current_block`
 ```python
 get_current_block() -> int
 
 ```
 Description: Returns the current chain block number.
-### `wait_for_block`
+#### `wait_for_block`
 ```python
 wait_for_block(
 block: Optional[int] = None
@@ -302,9 +302,8 @@ Update: we have added proper nonce protection allowing you to run gather operati
 scatter_stake = await asyncio.gather(*[ sub.add_stake( hotkey, coldkey, netuid, amount ) for netuid in range(64) ] )
 ```
 
-### Example: staking and unstaking
 
-#### Staking
+### Staking
 The following script incrementally stakes 3 TAO into several subnets over many blocks:
 
 ```python
@@ -360,7 +359,7 @@ netuid 5 price τ0.001784484 stake ε11.208213619
 ...
 
 ```
-#### Unstaking
+### Unstaking
 
 The below script will reverse the effects of the above, by incrementally unstaking alpha tokens from the list of subnets to yield TAO.
 
@@ -418,11 +417,13 @@ netuid 5 price τ0.001785179 stake ε33.619312896
 
 ```
 
-## Register on a subnet
+## Subnet registration
+
+### Register
 
 You can register your hotkey on a subnet using the `burned_register` method. This is necessary for staking, mining or validating.
 
-### `burned_register`
+#### `burned_register`
 ```python
 burned_register(
     wallet, 
@@ -454,9 +455,9 @@ reg = sub.burned_register(wallet=wallet, netuid=3)
 ```
 
 
-## View your registered subnets
+### View registered subnets
 
-### `get_netuids_for_hotkey`
+#### `get_netuids_for_hotkey`
 ```python
 get_netuids_for_hotkey(
     hotkey: str, 
@@ -482,7 +483,7 @@ netuids = sub.get_netuids_for_hotkey(wallet.hotkey.ss58_address)
 print(netuids)
 ```
 
-### `btcli wallet overview`
+#### `btcli wallet overview`
 You can also use the `btcli` to check subnet registrations using `btcli wallet overview`.
 This displays the registrations to subnets by hotkeys controlled by the wallet:
 
@@ -517,3 +518,65 @@ Subnet: 119: vidac Ⲃ
                                     1                   268.38 Ⲃ       0.0094       1.0000       0.0093       0.0094       0.0000     ρ3470929       0.0000
 
 ```
+
+
+## View a hotkey's emissions
+
+This script displays the last day's emissions for a specified hotkey on all subnets on which the hotkey is registered.
+
+This could be useful for a miner to see how much they've been extracting from the different subnets, if they've been mining on several.
+
+Be aware that daily emissions can fluctuate widely. See [Emissions](../emissions.md).
+
+```python
+from bittensor.core.async_subtensor import AsyncSubtensor
+import sys
+import asyncio
+
+# This is the validator HK for Opentensor Foundation, substitute with the hotkey of the miner/validator you wish to inspect
+HOTKEY = "5F4tQyWrhfGVcNhoqeiNsR6KjD4wMZ2kfhLj4oHYuyHbZAc3"
+
+# Speicfy which subnets you wish to inspect, by UID
+NETUIDS = range(0,64)
+BLOCKTIME = 12
+
+subtensor_address = "finney"  # or "test" or locally with "ws://127.0.0.1:9944"
+
+async def main():
+    async with AsyncSubtensor(f"{subtensor_address}") as subtensor:
+        all_sn_dynamic_info_list = await subtensor.all_subnets()
+
+        all_sn_dynamic_info = {info.netuid: info for info in all_sn_dynamic_info_list}
+        daily_blocks = (60 * 60 * 24) / BLOCKTIME  # Number of blocks per day
+        
+
+        print(f"Hotkey: {HOTKEY}")
+
+        subnets = await asyncio.gather(*[subtensor.subnet_exists(netuid) for netuid in range(1, 8)])
+        metagraphs = await asyncio.gather(*[ subtensor.metagraph(netuid=id) for id in NETUIDS])
+        for id in NETUIDS:
+            print(f"UID: {id}")
+            
+            metagraph = metagraphs[id]
+            tempo_multiplier = daily_blocks / metagraph.tempo
+            
+            subnet_info = all_sn_dynamic_info.get(id)
+
+            uid = metagraph.hotkeys.index(HOTKEY) if HOTKEY in metagraph.hotkeys else None
+
+            if uid is None:
+                print(f"Hotkey {HOTKEY} not found in the metagraph")
+            else:
+                daily_rewards_alpha = float(metagraph.emission[uid] * tempo_multiplier)
+                daily_rewards_tao = float(daily_rewards_alpha * subnet_info.price.tao)
+                alpha_to_tao_with_slippage, slippage = subnet_info.alpha_to_tao_with_slippage(
+                    alpha=daily_rewards_alpha
+                )
+
+                print(f"Daily Rewards Alpha: {daily_rewards_alpha}")
+                print(f"Daily Rewards Tao: {daily_rewards_tao}")
+                print(f"Alpha to Tao with Slippage: {alpha_to_tao_with_slippage}")
+
+asyncio.run(main())
+
+```
