bittensor-cli 9.7.1__py3-none-any.whl → 9.8.1__py3-none-any.whl

bittensor_cli/src/commands/liquidity/utils.py

@@ -0,0 +1,200 @@
+"""
+This module provides utilities for managing liquidity positions and price conversions in the Bittensor network. The
+module handles conversions between TAO and Alpha tokens while maintaining precise calculations for liquidity
+provisioning and fee distribution.
+"""
+
+import math
+from dataclasses import dataclass
+from typing import Any
+
+from rich.prompt import IntPrompt, FloatPrompt
+
+from bittensor_cli.src.bittensor.balances import Balance, fixed_to_float
+from bittensor_cli.src.bittensor.utils import (
+    console,
+)
+
+# These three constants are unchangeable at the level of Uniswap math
+MIN_TICK = -887272
+MAX_TICK = 887272
+PRICE_STEP = 1.0001
+
+
+@dataclass
+class LiquidityPosition:
+    id: int
+    price_low: Balance  # RAO
+    price_high: Balance  # RAO
+    liquidity: Balance  # TAO + ALPHA (sqrt by TAO balance * Alpha Balance -> math under the hood)
+    fees_tao: Balance  # RAO
+    fees_alpha: Balance  # RAO
+    netuid: int
+
+    def to_token_amounts(
+        self, current_subnet_price: Balance
+    ) -> tuple[Balance, Balance]:
+        """Convert a position to token amounts.
+
+        Arguments:
+            current_subnet_price: current subnet price in Alpha.
+
+        Returns:
+            tuple[int, int]:
+                Amount of Alpha in liquidity
+                Amount of TAO in liquidity
+
+        Liquidity is a combination of TAO and Alpha depending on the price of the subnet at the moment.
+        """
+        sqrt_price_low = math.sqrt(self.price_low)
+        sqrt_price_high = math.sqrt(self.price_high)
+        sqrt_current_subnet_price = math.sqrt(current_subnet_price)
+
+        if sqrt_current_subnet_price < sqrt_price_low:
+            amount_alpha = self.liquidity * (1 / sqrt_price_low - 1 / sqrt_price_high)
+            amount_tao = 0
+        elif sqrt_current_subnet_price > sqrt_price_high:
+            amount_alpha = 0
+            amount_tao = self.liquidity * (sqrt_price_high - sqrt_price_low)
+        else:
+            amount_alpha = self.liquidity * (
+                1 / sqrt_current_subnet_price - 1 / sqrt_price_high
+            )
+            amount_tao = self.liquidity * (sqrt_current_subnet_price - sqrt_price_low)
+        return Balance.from_rao(int(amount_alpha)).set_unit(
+            self.netuid
+        ), Balance.from_rao(int(amount_tao))
+
+
+def price_to_tick(price: float) -> int:
+    """Converts a float price to the nearest Uniswap V3 tick index."""
+    if price <= 0:
+        raise ValueError(f"Price must be positive, got `{price}`.")
+
+    tick = int(math.log(price) / math.log(PRICE_STEP))
+
+    if not (MIN_TICK <= tick <= MAX_TICK):
+        raise ValueError(
+            f"Resulting tick {tick} is out of allowed range ({MIN_TICK} to {MAX_TICK})"
+        )
+    return tick
+
+
+def tick_to_price(tick: int) -> float:
+    """Convert an integer Uniswap V3 tick index to float price."""
+    if not (MIN_TICK <= tick <= MAX_TICK):
+        raise ValueError("Tick is out of allowed range")
+    return PRICE_STEP**tick
+
+
+def get_fees(
+    current_tick: int,
+    tick: dict,
+    tick_index: int,
+    quote: bool,
+    global_fees_tao: float,
+    global_fees_alpha: float,
+    above: bool,
+) -> float:
+    """Returns the liquidity fee."""
+    tick_fee_key = "fees_out_tao" if quote else "fees_out_alpha"
+    tick_fee_value = fixed_to_float(tick.get(tick_fee_key))
+    global_fee_value = global_fees_tao if quote else global_fees_alpha
+
+    if above:
+        return (
+            global_fee_value - tick_fee_value
+            if tick_index <= current_tick
+            else tick_fee_value
+        )
+    return (
+        tick_fee_value
+        if tick_index <= current_tick
+        else global_fee_value - tick_fee_value
+    )
+
+
+def get_fees_in_range(
+    quote: bool,
+    global_fees_tao: float,
+    global_fees_alpha: float,
+    fees_below_low: float,
+    fees_above_high: float,
+) -> float:
+    """Returns the liquidity fee value in a range."""
+    global_fees = global_fees_tao if quote else global_fees_alpha
+    return global_fees - fees_below_low - fees_above_high
+
+
+# Calculate fees for a position
+def calculate_fees(
+    position: dict[str, Any],
+    global_fees_tao: float,
+    global_fees_alpha: float,
+    tao_fees_below_low: float,
+    tao_fees_above_high: float,
+    alpha_fees_below_low: float,
+    alpha_fees_above_high: float,
+    netuid: int,
+) -> tuple[Balance, Balance]:
+    fee_tao_agg = get_fees_in_range(
+        quote=True,
+        global_fees_tao=global_fees_tao,
+        global_fees_alpha=global_fees_alpha,
+        fees_below_low=tao_fees_below_low,
+        fees_above_high=tao_fees_above_high,
+    )
+
+    fee_alpha_agg = get_fees_in_range(
+        quote=False,
+        global_fees_tao=global_fees_tao,
+        global_fees_alpha=global_fees_alpha,
+        fees_below_low=alpha_fees_below_low,
+        fees_above_high=alpha_fees_above_high,
+    )
+
+    fee_tao = fee_tao_agg - fixed_to_float(position["fees_tao"])
+    fee_alpha = fee_alpha_agg - fixed_to_float(position["fees_alpha"])
+    liquidity_frac = position["liquidity"]
+
+    fee_tao = liquidity_frac * fee_tao
+    fee_alpha = liquidity_frac * fee_alpha
+
+    return Balance.from_rao(int(fee_tao)), Balance.from_rao(int(fee_alpha)).set_unit(
+        netuid
+    )
+
+
+def prompt_liquidity(prompt: str, negative_allowed: bool = False) -> Balance:
+    """Prompt the user for the amount of liquidity.
+
+    Arguments:
+        prompt: Prompt to display to the user.
+        negative_allowed: Whether negative amounts are allowed.
+
+    Returns:
+        Balance converted from input to TAO.
+    """
+    while True:
+        amount = FloatPrompt.ask(prompt)
+        try:
+            if amount <= 0 and not negative_allowed:
+                console.print("[red]Amount must be greater than 0[/red].")
+                continue
+            return Balance.from_tao(amount)
+        except ValueError:
+            console.print("[red]Please enter a valid number[/red].")
+
+
+def prompt_position_id() -> int:
+    """Ask the user for the ID of the liquidity position to remove."""
+    while True:
+        position_id = IntPrompt.ask("Enter the [blue]liquidity position ID[/blue]")
+
+        try:
+            if position_id <= 1:
+                console.print("[red]Position ID must be greater than 1[/red].")
+                continue
+            return position_id
+        except ValueError:
+            console.print("[red]Please enter a valid number[/red].")

bittensor_cli/src/commands/stake/add.py

@@ -245,12 +245,12 @@ async def stake_add(
     # Get subnet data and stake information for coldkey
     chain_head = await subtensor.substrate.get_chain_head()
     _all_subnets, _stake_info, current_wallet_balance = await asyncio.gather(
-        subtensor.all_subnets(),
+        subtensor.all_subnets(block_hash=chain_head),
         subtensor.get_stake_for_coldkey(
             coldkey_ss58=wallet.coldkeypub.ss58_address,
             block_hash=chain_head,
         ),
-        subtensor.get_balance(wallet.coldkeypub.ss58_address),
+        subtensor.get_balance(wallet.coldkeypub.ss58_address, block_hash=chain_head),
     )
     all_subnets = {di.netuid: di for di in _all_subnets}
 
@@ -307,6 +307,7 @@ async def stake_add(
                 return False
             remaining_wallet_balance -= amount_to_stake
 
+            # TODO this should be asyncio gathered before the for loop
             stake_fee = await subtensor.get_stake_fee(
                 origin_hotkey_ss58=None,
                 origin_netuid=None,
@@ -318,14 +319,20 @@ async def stake_add(
             )
 
             # Calculate slippage
-            try:
-                received_amount, slippage_pct, slippage_pct_float, rate = (
-                    _calculate_slippage(subnet_info, amount_to_stake, stake_fee)
-                )
-            except ValueError:
-                return False
-
-            max_slippage = max(slippage_pct_float, max_slippage)
+            # TODO: Update for V3, slippage calculation is significantly different in v3
+            # try:
+            #     received_amount, slippage_pct, slippage_pct_float, rate = (
+            #         _calculate_slippage(subnet_info, amount_to_stake, stake_fee)
+            #     )
+            # except ValueError:
+            #     return False
+            #
+            # max_slippage = max(slippage_pct_float, max_slippage)
+
+            # Temporary workaround - calculations without slippage
+            current_price_float = float(subnet_info.price.tao)
+            rate = 1.0 / current_price_float
+            received_amount = rate * amount_to_stake
 
             # Add rows for the table
             base_row = [
@@ -336,20 +343,20 @@ async def stake_add(
                 + f" {Balance.get_unit(netuid)}/{Balance.get_unit(0)} ",  # rate
                 str(received_amount.set_unit(netuid)),  # received
                 str(stake_fee),  # fee
-                str(slippage_pct),  # slippage
+                # str(slippage_pct),  # slippage
             ]
 
             # If we are staking safe, add price tolerance
             if safe_staking:
                 if subnet_info.is_dynamic:
-                    rate = 1 / subnet_info.price.tao or 1
-                    _rate_with_tolerance = rate * (
-                        1 + rate_tolerance
+                    price_with_tolerance = current_price_float * (1 + rate_tolerance)
+                    _rate_with_tolerance = (
+                        1.0 / price_with_tolerance
                     )  # Rate only for display
                     rate_with_tolerance = f"{_rate_with_tolerance:.4f}"
-                    price_with_tolerance = subnet_info.price.rao * (
-                        1 + rate_tolerance
-                    )  # Actual price to pass to extrinsic
+                    price_with_tolerance = Balance.from_tao(
+                        price_with_tolerance
+                    ).rao  # Actual price to pass to extrinsic
                 else:
                     rate_with_tolerance = "1"
                     price_with_tolerance = Balance.from_rao(1)
@@ -581,9 +588,10 @@ def _define_stake_table(
         justify="center",
         style=COLOR_PALETTE["STAKE"]["STAKE_AMOUNT"],
     )
-    table.add_column(
-        "Slippage", justify="center", style=COLOR_PALETTE["STAKE"]["SLIPPAGE_PERCENT"]
-    )
+    # TODO: Uncomment when slippage is reimplemented for v3
+    # table.add_column(
+    #     "Slippage", justify="center", style=COLOR_PALETTE["STAKE"]["SLIPPAGE_PERCENT"]
+    # )
 
     if safe_staking:
         table.add_column(
@@ -628,8 +636,8 @@ The columns are as follows:
     - [bold white]Hotkey[/bold white]: The ss58 address of the hotkey you are staking to. 
     - [bold white]Amount[/bold white]: The TAO you are staking into this subnet onto this hotkey.
     - [bold white]Rate[/bold white]: The rate of exchange between your TAO and the subnet's stake.
-    - [bold white]Received[/bold white]: The amount of stake you will receive on this subnet after slippage.
-    - [bold white]Slippage[/bold white]: The slippage percentage of the stake operation. (0% if the subnet is not dynamic i.e. root)."""
+    - [bold white]Received[/bold white]: The amount of stake you will receive on this subnet after slippage."""
+    # - [bold white]Slippage[/bold white]: The slippage percentage of the stake operation. (0% if the subnet is not dynamic i.e. root)."""
 
     safe_staking_description = """
     - [bold white]Rate Tolerance[/bold white]: Maximum acceptable alpha rate. If the rate exceeds this tolerance, the transaction will be limited or rejected.
@@ -654,6 +662,9 @@ def _calculate_slippage(
         - slippage_str: Formatted slippage percentage string
         - slippage_float: Raw slippage percentage value
         - rate: Exchange rate string
+
+    TODO: Update to v3. This method only works for protocol-liquidity-only
+          mode (user liquidity disabled)
     """
     amount_after_fee = amount - stake_fee
 
@@ -670,6 +681,7 @@ def _calculate_slippage(
         slippage_str = f"{slippage_pct_float:.4f} %"
         rate = f"{(1 / subnet_info.price.tao or 1):.4f}"
     else:
+        # TODO: Fix this. Slippage is always zero for static networks.
         slippage_pct_float = (
             100 * float(stake_fee.tao) / float(amount.tao) if amount.tao != 0 else 0
         )

bittensor_cli/src/commands/stake/list.py

@@ -111,15 +111,15 @@ async def stake_list(
             style=COLOR_PALETTE["POOLS"]["RATE"],
             justify="center",
         )
-        defined_table.add_column(
-            f"[white]Swap ({Balance.get_unit(1)} -> {Balance.unit})",
-            footer_style="overline white",
-            style=COLOR_PALETTE["STAKE"]["STAKE_SWAP"],
-            justify="right",
-            footer=f"τ {millify_tao(total_swapped_tao_value_.tao)}"
-            if not verbose
-            else f"{total_swapped_tao_value_}",
-        )
+        # defined_table.add_column(
+        #     f"[white]Swap ({Balance.get_unit(1)} -> {Balance.unit})",
+        #     footer_style="overline white",
+        #     style=COLOR_PALETTE["STAKE"]["STAKE_SWAP"],
+        #     justify="right",
+        #     footer=f"τ {millify_tao(total_swapped_tao_value_.tao)}"
+        #     if not verbose
+        #     else f"{total_swapped_tao_value_}",
+        # )
         defined_table.add_column(
             "[white]Registered",
             style=COLOR_PALETTE["STAKE"]["STAKE_ALPHA"],
@@ -168,25 +168,17 @@ async def stake_list(
             tao_value_ = pool.alpha_to_tao(alpha_value)
             total_tao_value_ += tao_value_
 
-            # Swapped TAO value and slippage cell
-            swapped_tao_value_, _, slippage_percentage_ = (
-                pool.alpha_to_tao_with_slippage(substake_.stake)
-            )
-            total_swapped_tao_value_ += swapped_tao_value_
-
-            # Slippage percentage cell
-            if pool.is_dynamic:
-                slippage_percentage = f"[{COLOR_PALETTE['STAKE']['SLIPPAGE_PERCENT']}]{slippage_percentage_:.3f}%[/{COLOR_PALETTE['STAKE']['SLIPPAGE_PERCENT']}]"
-            else:
-                slippage_percentage = f"[{COLOR_PALETTE['STAKE']['SLIPPAGE_PERCENT']}]0.000%[/{COLOR_PALETTE['STAKE']['SLIPPAGE_PERCENT']}]"
+            # TAO value cell
+            tao_value_ = pool.alpha_to_tao(substake_.stake)
+            total_swapped_tao_value_ += tao_value_
 
             if netuid == 0:
-                swap_value = f"[{COLOR_PALETTE['STAKE']['NOT_REGISTERED']}]N/A[/{COLOR_PALETTE['STAKE']['NOT_REGISTERED']}] ({slippage_percentage})"
+                swap_value = f"[{COLOR_PALETTE['STAKE']['NOT_REGISTERED']}]N/A[/{COLOR_PALETTE['STAKE']['NOT_REGISTERED']}]"
             else:
                 swap_value = (
-                    f"τ {millify_tao(swapped_tao_value_.tao)} ({slippage_percentage})"
+                    f"τ {millify_tao(tao_value_.tao)}"
                     if not verbose
-                    else f"{swapped_tao_value_} ({slippage_percentage})"
+                    else f"{tao_value_}"
                 )
 
             # Per block emission cell
@@ -214,7 +206,7 @@ async def stake_list(
                         else f"{symbol} {stake_value}",  # Stake (a)
                         f"{pool.price.tao:.4f} τ/{symbol}",  # Rate (t/a)
                         # f"τ {millify_tao(tao_ownership.tao)}" if not verbose else f"{tao_ownership}",  # TAO equiv
-                        swap_value,  # Swap(α) -> τ
+                        # swap_value,  # Swap(α) -> τ
                         "YES"
                         if substake_.is_registered
                         else f"[{COLOR_PALETTE['STAKE']['NOT_REGISTERED']}]NO",  # Registered
@@ -232,7 +224,7 @@ async def stake_list(
                         "value": tao_value_.tao,
                         "stake_value": substake_.stake.tao,
                         "rate": pool.price.tao,
-                        "swap_value": swap_value,
+                        # "swap_value": swap_value,
                         "registered": True if substake_.is_registered else False,
                         "emission": {
                             "alpha": per_block_emission,
@@ -317,9 +309,7 @@ async def stake_list(
             alpha_value = Balance.from_rao(int(substake_.stake.rao)).set_unit(netuid)
             tao_value_ = pool.alpha_to_tao(alpha_value)
             total_tao_value_ += tao_value_
-            swapped_tao_value_, slippage, slippage_pct = (
-                pool.alpha_to_tao_with_slippage(substake_.stake)
-            )
+            swapped_tao_value_ = pool.alpha_to_tao(substake_.stake)
             total_swapped_tao_value_ += swapped_tao_value_
 
             # Store current values for future delta tracking
@@ -364,19 +354,16 @@ async def stake_list(
             )
 
             if netuid != 0:
-                swap_cell = (
-                    format_cell(
-                        swapped_tao_value_.tao,
-                        prev.get("swapped_value"),
-                        unit="τ",
-                        unit_first_=True,
-                        precision=4,
-                        millify=True if not verbose else False,
-                    )
-                    + f" ({slippage_pct:.2f}%)"
+                swap_cell = format_cell(
+                    swapped_tao_value_.tao,
+                    prev.get("swapped_value"),
+                    unit="τ",
+                    unit_first_=True,
+                    precision=4,
+                    millify=True if not verbose else False,
                 )
             else:
-                swap_cell = f"[{COLOR_PALETTE['STAKE']['NOT_REGISTERED']}]N/A[/{COLOR_PALETTE['STAKE']['NOT_REGISTERED']}] ({slippage_pct}%)"
+                swap_cell = f"[{COLOR_PALETTE['STAKE']['NOT_REGISTERED']}]N/A[/{COLOR_PALETTE['STAKE']['NOT_REGISTERED']}]"
 
             emission_value = substake_.emission.tao / (pool.tempo or 1)
             emission_cell = format_cell(
@@ -408,7 +395,7 @@ async def stake_list(
                     exchange_cell,  # Exchange value
                     stake_cell,  # Stake amount
                     rate_cell,  # Rate
-                    swap_cell,  # Swap value with slippage
+                    # swap_cell,  # Swap value
                     "YES"
                     if substake_.is_registered
                     else f"[{COLOR_PALETTE['STAKE']['NOT_REGISTERED']}]NO",  # Registration status
@@ -591,12 +578,12 @@ async def stake_list(
             f"Wallet:\n"
             f"  Coldkey SS58: [{COLOR_PALETTE['GENERAL']['COLDKEY']}]{coldkey_address}[/{COLOR_PALETTE['GENERAL']['COLDKEY']}]\n"
             f"  Free Balance: [{COLOR_PALETTE['GENERAL']['BALANCE']}]{balance}[/{COLOR_PALETTE['GENERAL']['BALANCE']}]\n"
-            f"  Total TAO Value ({Balance.unit}): [{COLOR_PALETTE['GENERAL']['BALANCE']}]{total_tao_value}[/{COLOR_PALETTE['GENERAL']['BALANCE']}]\n"
-            f"  Total TAO Swapped Value ({Balance.unit}): [{COLOR_PALETTE['GENERAL']['BALANCE']}]{total_swapped_tao_value}[/{COLOR_PALETTE['GENERAL']['BALANCE']}]"
+            f"  Total TAO Value ({Balance.unit}): [{COLOR_PALETTE['GENERAL']['BALANCE']}]{total_tao_value}[/{COLOR_PALETTE['GENERAL']['BALANCE']}]"
+            # f"\n  Total TAO Swapped Value ({Balance.unit}): [{COLOR_PALETTE['GENERAL']['BALANCE']}]{total_swapped_tao_value}[/{COLOR_PALETTE['GENERAL']['BALANCE']}]"
         )
         dict_output["free_balance"] = balance.tao
         dict_output["total_tao_value"] = all_hks_tao_value.tao
-        dict_output["total_swapped_tao_value"] = all_hks_swapped_tao_value.tao
+        # dict_output["total_swapped_tao_value"] = all_hks_swapped_tao_value.tao
         if json_output:
             json_console.print(json.dumps(dict_output))
         if not sub_stakes:
@@ -658,12 +645,12 @@ async def stake_list(
                     ),
                     (
                         "[bold tan]Exchange Value (α x τ/α)[/bold tan]",
-                        "This is the potential τ you will receive, without considering slippage, if you unstake from this hotkey now on this subnet. See Swap(α → τ) column description. Note: The TAO Equiv(τ_in x α/α_out) indicates validator stake weight while this Exchange Value shows τ you will receive if you unstake now. This can change every block. \nFor more, see [blue]https://docs.bittensor.com/dynamic-tao/dtao-guide#exchange-value-%CE%B1-x-%CF%84%CE%B1[/blue].",
-                    ),
-                    (
-                        "[bold tan]Swap (α → τ)[/bold tan]",
-                        "This is the actual τ you will receive, after factoring in the slippage charge, if you unstake from this hotkey now on this subnet. The slippage is calculated as 1 - (Swap(α → τ)/Exchange Value(α x τ/α)), and is displayed in brackets. This can change every block. \nFor more, see [blue]https://docs.bittensor.com/dynamic-tao/dtao-guide#swap-%CE%B1--%CF%84[/blue].",
+                        "This is the potential τ you will receive if you unstake from this hotkey now on this subnet. Note: The TAO Equiv(τ_in x α/α_out) indicates validator stake weight while this Exchange Value shows τ you will receive if you unstake now. This can change every block. \nFor more, see [blue]https://docs.bittensor.com/dynamic-tao/dtao-guide#exchange-value-%CE%B1-x-%CF%84%CE%B1[/blue].",
                     ),
+                    # (
+                    #     "[bold tan]Swap (α → τ)[/bold tan]",
+                    #     "This is the τ you will receive if you unstake from this hotkey now on this subnet. This can change every block. \nFor more, see [blue]https://docs.bittensor.com/dynamic-tao/dtao-guide#swap-%CE%B1--%CF%84[/blue].",
+                    # ),
                     (
                         "[bold tan]Registered[/bold tan]",
                         "Indicates if the hotkey is registered in this subnet or not. \nFor more, see [blue]https://docs.bittensor.com/learn/anatomy-of-incentive-mechanism#tempo[/blue].",

bittensor_cli/src/commands/stake/move.py

@@ -33,8 +33,8 @@ async def display_stake_movement_cross_subnets(
     destination_hotkey: str,
     amount_to_move: Balance,
     stake_fee: Balance,
-) -> tuple[Balance, float, str, str]:
-    """Calculate and display slippage information"""
+) -> tuple[Balance, str]:
+    """Calculate and display stake movement information"""
 
     if origin_netuid == destination_netuid:
         subnet = await subtensor.subnet(origin_netuid)
@@ -46,45 +46,32 @@ async def display_stake_movement_cross_subnets(
             raise ValueError
 
         received_amount = subnet.tao_to_alpha(received_amount_tao)
-        slippage_pct_float = (
-            100 * float(stake_fee) / float(stake_fee + received_amount_tao)
-            if received_amount_tao != 0
-            else 0
-        )
-        slippage_pct = f"{slippage_pct_float:.4f}%"
-        price = Balance.from_tao(1).set_unit(origin_netuid)
+        price = subnet.price.tao
         price_str = (
-            str(float(price.tao))
-            + f"{Balance.get_unit(origin_netuid)}/{Balance.get_unit(origin_netuid)}"
+            str(float(price))
+            + f"({Balance.get_unit(0)}/{Balance.get_unit(origin_netuid)})"
         )
     else:
         dynamic_origin, dynamic_destination = await asyncio.gather(
             subtensor.subnet(origin_netuid),
             subtensor.subnet(destination_netuid),
         )
-        price = (
-            float(dynamic_origin.price) * 1 / (float(dynamic_destination.price) or 1)
-        )
-        received_amount_tao, _, _ = dynamic_origin.alpha_to_tao_with_slippage(
-            amount_to_move
-        )
+        price_origin = dynamic_origin.price.tao
+        price_destination = dynamic_destination.price.tao
+        rate = price_origin / (price_destination or 1)
+
+        received_amount_tao = dynamic_origin.alpha_to_tao(amount_to_move)
         received_amount_tao -= stake_fee
-        received_amount, _, _ = dynamic_destination.tao_to_alpha_with_slippage(
-            received_amount_tao
-        )
+        received_amount = dynamic_destination.tao_to_alpha(received_amount_tao)
         received_amount.set_unit(destination_netuid)
 
         if received_amount < Balance.from_tao(0):
             print_error("Not enough Alpha to pay the transaction fee.")
             raise ValueError
 
-        ideal_amount = amount_to_move * price
-        total_slippage = ideal_amount - received_amount
-        slippage_pct_float = 100 * (total_slippage.tao / ideal_amount.tao)
-        slippage_pct = f"{slippage_pct_float:.4f} %"
         price_str = (
-            f"{price:.5f}"
-            + f"{Balance.get_unit(destination_netuid)}/{Balance.get_unit(origin_netuid)}"
+            f"{rate:.5f}"
+            + f"({Balance.get_unit(destination_netuid)}/{Balance.get_unit(origin_netuid)})"
         )
 
     # Create and display table
@@ -141,11 +128,6 @@ async def display_stake_movement_cross_subnets(
         justify="center",
         style=COLOR_PALETTE["STAKE"]["STAKE_AMOUNT"],
     )
-    table.add_column(
-        "slippage",
-        justify="center",
-        style=COLOR_PALETTE["STAKE"]["SLIPPAGE_PERCENT"],
-    )
 
     table.add_row(
         f"{Balance.get_unit(origin_netuid)}({origin_netuid})",
@@ -156,19 +138,11 @@ async def display_stake_movement_cross_subnets(
         price_str,
         str(received_amount),
         str(stake_fee),
-        str(slippage_pct),
     )
 
     console.print(table)
 
-    # Display slippage warning if necessary
-    if slippage_pct_float > 5:
-        message = f"[{COLOR_PALETTE['STAKE']['SLIPPAGE_TEXT']}]-------------------------------------------------------------------------------------------------------------------\n"
-        message += f"[bold]WARNING:\tSlippage is high: [{COLOR_PALETTE['STAKE']['SLIPPAGE_PERCENT']}]{slippage_pct}[/{COLOR_PALETTE['STAKE']['SLIPPAGE_PERCENT']}], this may result in a loss of funds.[/bold] \n"
-        message += "-------------------------------------------------------------------------------------------------------------------\n"
-        console.print(message)
-
-    return received_amount, slippage_pct_float, slippage_pct, price_str
+    return received_amount, price_str
 
 
 def prompt_stake_amount(
@@ -414,7 +388,7 @@ async def stake_swap_selection(
     origin_stake = hotkey_stakes[origin_netuid]["stake"]
 
     # Ask for amount to swap
-    amount, all_balance = prompt_stake_amount(origin_stake, origin_netuid, "swap")
+    amount, _ = prompt_stake_amount(origin_stake, origin_netuid, "swap")
 
     all_netuids = sorted(await subtensor.get_all_subnet_netuids())
     destination_choices = [
@@ -530,7 +504,7 @@ async def move_stake(
         amount=amount_to_move_as_balance.rao,
     )
 
-    # Slippage warning
+    # Display stake movement details
     if prompt:
         try:
             await display_stake_movement_cross_subnets(
@@ -714,7 +688,7 @@ async def transfer_stake(
         amount=amount_to_transfer.rao,
     )
 
-    # Slippage warning
+    # Display stake movement details
     if prompt:
         try:
             await display_stake_movement_cross_subnets(
@@ -883,7 +857,7 @@ async def swap_stake(
         amount=amount_to_swap.rao,
     )
 
-    # Slippage warning
+    # Display stake movement details
     if prompt:
         try:
             await display_stake_movement_cross_subnets(