Fix new swap's API integration issues

Author: ales-otf

pallets/admin-utils/src/tests/mock.rs

@@ -344,6 +344,8 @@ impl pallet_subtensor_swap::Config for Test {
     type SubnetInfo = SubtensorModule;
     type BalanceOps = SubtensorModule;
     type ProtocolId = SwapProtocolId;
+    type TaoReserve = pallet_subtensor::TaoCurrencyReserve<Self>;
+    type AlphaReserve = pallet_subtensor::AlphaCurrencyReserve<Self>;
     type MaxFeeRate = SwapMaxFeeRate;
     type MaxPositions = SwapMaxPositions;
     type MinimumLiquidity = SwapMinimumLiquidity;

pallets/subtensor/src/coinbase/block_emission.rs

@@ -6,7 +6,7 @@ use substrate_fixed::{
     types::{I96F32, U96F32},
 };
 use subtensor_runtime_common::{NetUid, TaoCurrency};
-use subtensor_swap_interface::SwapExt;
+use subtensor_swap_interface::SwapHandler;
 
 impl<T: Config> Pallet<T> {
     /// Calculates the dynamic TAO emission for a given subnet.
@@ -40,7 +40,7 @@ impl<T: Config> Pallet<T> {
         let float_alpha_block_emission: U96F32 = U96F32::saturating_from_num(alpha_block_emission);
 
         // Get alpha price for subnet.
-        let alpha_price = T::SwapExt::current_alpha_price(netuid.into());
+        let alpha_price = T::SwapInterface::current_alpha_price(netuid.into());
         log::debug!("{netuid:?} - alpha_price: {alpha_price:?}");
 
         // Get initial alpha_in

pallets/subtensor/src/coinbase/root.rs

@@ -22,7 +22,7 @@ use safe_math::*;
 use sp_core::Get;
 use substrate_fixed::types::{I64F64, U96F32};
 use subtensor_runtime_common::{AlphaCurrency, Currency, NetUid, NetUidStorageIndex, TaoCurrency};
-use subtensor_swap_interface::SwapExt;
+use subtensor_swap_interface::SwapHandler;
 
 impl<T: Config> Pallet<T> {
     /// Fetches the total count of root network validators
@@ -373,9 +373,9 @@ impl<T: Config> Pallet<T> {
         );
 
         // 2. --- Perform the cleanup before removing the network.
-        T::SwapExt::dissolve_all_liquidity_providers(netuid)?;
+        T::SwapInterface::dissolve_all_liquidity_providers(netuid)?;
         Self::destroy_alpha_in_out_stakes(netuid)?;
-        T::SwapExt::clear_protocol_liquidity(netuid)?;
+        T::SwapInterface::clear_protocol_liquidity(netuid)?;
         T::CommitmentsInterface::purge_netuid(netuid);
 
         // 3. --- Remove the network

pallets/subtensor/src/coinbase/run_coinbase.rs

@@ -3,7 +3,7 @@ use alloc::collections::BTreeMap;
 use safe_math::*;
 use substrate_fixed::types::U96F32;
 use subtensor_runtime_common::{AlphaCurrency, Currency, NetUid, TaoCurrency};
-use subtensor_swap_interface::SwapExt;
+use subtensor_swap_interface::SwapHandler;
 
 // Distribute dividends to each hotkey
 macro_rules! asfloat {
@@ -58,7 +58,7 @@ impl<T: Config> Pallet<T> {
         // Only calculate for subnets that we are emitting to.
         for netuid_i in subnets_to_emit_to.iter() {
             // Get subnet price.
-            let price_i = T::SwapExt::current_alpha_price((*netuid_i).into());
+            let price_i = T::SwapInterface::current_alpha_price((*netuid_i).into());
             log::debug!("price_i: {price_i:?}");
             // Get subnet TAO.
             let moving_price_i: U96F32 = Self::get_moving_alpha_price(*netuid_i);
@@ -91,7 +91,7 @@ impl<T: Config> Pallet<T> {
                 let buy_swap_result = Self::swap_tao_for_alpha(
                     *netuid_i,
                     tou64!(difference_tao).into(),
-                    T::SwapExt::max_price(),
+                    T::SwapInterface::max_price(),
                     true,
                 );
                 if let Ok(buy_swap_result_ok) = buy_swap_result {
@@ -159,7 +159,7 @@ impl<T: Config> Pallet<T> {
                 *total = total.saturating_add(tao_in_i.into());
             });
             // Adjust protocol liquidity based on new reserves
-            T::SwapExt::adjust_protocol_liquidity(*netuid_i, tao_in_i, alpha_in_i);
+            T::SwapInterface::adjust_protocol_liquidity(*netuid_i, tao_in_i, alpha_in_i);
         }
 
         // --- 5. Compute owner cuts and remove them from alpha_out remaining.
@@ -220,7 +220,7 @@ impl<T: Config> Pallet<T> {
                 let swap_result = Self::swap_alpha_for_tao(
                     *netuid_i,
                     tou64!(root_alpha).into(),
-                    T::SwapExt::min_price(),
+                    T::SwapInterface::min_price(),
                     true,
                 );
                 if let Ok(ok_result) = swap_result {

pallets/subtensor/src/macros/config.rs

@@ -6,9 +6,9 @@ use frame_support::pallet_macros::pallet_section;
 #[pallet_section]
 mod config {
 
-    use crate::CommitmentsInterface;
+    use crate::{CommitmentsInterface, GetAlphaForTao, GetTaoForAlpha};
     use pallet_commitments::GetCommitments;
-    use subtensor_swap_interface::{Order as OrderT, SwapEngine, SwapExt};
+    use subtensor_swap_interface::{SwapEngine, SwapHandler};
 
     /// Configure the pallet by specifying the parameters and types on which it depends.
     #[pallet::config]
@@ -54,11 +54,10 @@ mod config {
         /// the preimage to store the call data.
         type Preimages: QueryPreimage<H = Self::Hashing> + StorePreimage;
 
-        /// Implementor of `SwapExt` interface from `subtensor_swap_interface`
-        type SwapExt: SwapExt;
-
-        /// Implementor of `SwapEngine` interface from `subtensor_swap_interface`
-        type SwapEngine<Order: OrderT>: SwapEngine<Order>;
+        /// Implementor of `SwapHandler` interface from `subtensor_swap_interface`
+        type SwapInterface: SwapHandler
+            + SwapEngine<GetAlphaForTao<Self>>
+            + SwapEngine<GetTaoForAlpha<Self>>;
 
         /// Interface to allow interacting with the proxy pallet.
         type ProxyInterface: crate::ProxyInterface<Self::AccountId>;

pallets/subtensor/src/rpc_info/stake_info.rs

@@ -3,7 +3,7 @@ extern crate alloc;
 use codec::Compact;
 use frame_support::pallet_prelude::{Decode, Encode};
 use subtensor_runtime_common::{AlphaCurrency, Currency, NetUid, TaoCurrency};
-use subtensor_swap_interface::SwapExt;
+use subtensor_swap_interface::SwapHandler;
 
 use super::*;
 
@@ -128,7 +128,7 @@ impl<T: Config> Pallet<T> {
             0_u64
         } else {
             let netuid = destination.or(origin).map(|v| v.1).unwrap_or_default();
-            T::SwapExt::approx_fee_amount(netuid.into(), TaoCurrency::from(amount)).to_u64()
+            T::SwapInterface::approx_fee_amount(netuid.into(), TaoCurrency::from(amount)).to_u64()
         }
     }
 }

pallets/subtensor/src/staking/add_stake.rs

@@ -1,6 +1,6 @@
 use substrate_fixed::types::I96F32;
 use subtensor_runtime_common::{NetUid, TaoCurrency};
-use subtensor_swap_interface::{Order, SwapEngine, SwapExt};
+use subtensor_swap_interface::{Order, SwapHandler};
 
 use super::*;
 
@@ -74,7 +74,7 @@ impl<T: Config> Pallet<T> {
             &coldkey,
             netuid,
             tao_staked.saturating_to_num::<u64>().into(),
-            T::SwapExt::max_price(),
+            T::SwapInterface::max_price(),
             true,
             false,
         )?;
@@ -194,7 +194,7 @@ impl<T: Config> Pallet<T> {
 
         // Use reverting swap to estimate max limit amount
         let order = GetAlphaForTao::<T>::with_amount(u64::MAX);
-        let result = T::SwapEngine::swap(netuid.into(), order, limit_price, false, true)
+        let result = T::SwapInterface::swap(netuid.into(), order, limit_price, false, true)
             .map(|r| r.amount_paid_in.saturating_add(r.fee_paid))
             .map_err(|_| Error::ZeroMaxStakeAmount)?;
 

pallets/subtensor/src/staking/helpers.rs

@@ -8,7 +8,7 @@ use frame_support::traits::{
 use safe_math::*;
 use substrate_fixed::types::U96F32;
 use subtensor_runtime_common::{NetUid, TaoCurrency};
-use subtensor_swap_interface::{Order, SwapEngine, SwapExt};
+use subtensor_swap_interface::{Order, SwapHandler};
 
 use super::*;
 
@@ -51,8 +51,9 @@ impl<T: Config> Pallet<T> {
                 let alpha = U96F32::saturating_from_num(Self::get_stake_for_hotkey_on_subnet(
                     hotkey, netuid,
                 ));
-                let alpha_price =
-                    U96F32::saturating_from_num(T::SwapExt::current_alpha_price(netuid.into()));
+                let alpha_price = U96F32::saturating_from_num(
+                    T::SwapInterface::current_alpha_price(netuid.into()),
+                );
                 alpha.saturating_mul(alpha_price)
             })
             .sum::<U96F32>()
@@ -73,10 +74,12 @@ impl<T: Config> Pallet<T> {
                             hotkey, coldkey, netuid,
                         );
                         let order = GetTaoForAlpha::<T>::with_amount(alpha_stake);
-                        T::SwapEngine::sim_swap(netuid.into(), order)
+                        T::SwapInterface::sim_swap(netuid.into(), order)
                             .map(|r| {
                                 let fee: u64 = U96F32::saturating_from_num(r.fee_paid)
-                                    .saturating_mul(T::SwapExt::current_alpha_price(netuid.into()))
+                                    .saturating_mul(T::SwapInterface::current_alpha_price(
+                                        netuid.into(),
+                                    ))
                                     .saturating_to_num();
                                 r.amount_paid_out.to_u64().saturating_add(fee)
                             })
@@ -184,7 +187,7 @@ impl<T: Config> Pallet<T> {
                 Self::get_stake_for_hotkey_and_coldkey_on_subnet(hotkey, coldkey, netuid);
             let min_alpha_stake =
                 U96F32::saturating_from_num(Self::get_nominator_min_required_stake())
-                    .safe_div(T::SwapExt::current_alpha_price(netuid))
+                    .safe_div(T::SwapInterface::current_alpha_price(netuid))
                     .saturating_to_num::<u64>();
             if alpha_stake > 0.into() && alpha_stake < min_alpha_stake.into() {
                 // Log the clearing of a small nomination
@@ -196,7 +199,7 @@ impl<T: Config> Pallet<T> {
                     coldkey,
                     netuid,
                     alpha_stake,
-                    T::SwapExt::min_price(),
+                    T::SwapInterface::min_price(),
                     false,
                 );
 
@@ -313,7 +316,7 @@ impl<T: Config> Pallet<T> {
     }
 
     pub fn is_user_liquidity_enabled(netuid: NetUid) -> bool {
-        T::SwapExt::is_user_liquidity_enabled(netuid)
+        T::SwapInterface::is_user_liquidity_enabled(netuid)
     }
 
     pub fn recycle_subnet_alpha(netuid: NetUid, amount: AlphaCurrency) {

pallets/subtensor/src/staking/move_stake.rs

@@ -3,7 +3,7 @@ use safe_math::*;
 use sp_core::Get;
 use substrate_fixed::types::U64F64;
 use subtensor_runtime_common::{AlphaCurrency, Currency, NetUid, TaoCurrency};
-use subtensor_swap_interface::SwapExt;
+use subtensor_swap_interface::SwapHandler;
 
 impl<T: Config> Pallet<T> {
     /// Moves stake from one hotkey to another across subnets.
@@ -360,7 +360,7 @@ impl<T: Config> Pallet<T> {
                 origin_coldkey,
                 origin_netuid,
                 move_amount,
-                T::SwapExt::min_price(),
+                T::SwapInterface::min_price(),
                 drop_fee_origin,
             )?;
 
@@ -378,7 +378,7 @@ impl<T: Config> Pallet<T> {
                     destination_coldkey,
                     destination_netuid,
                     tao_unstaked,
-                    T::SwapExt::max_price(),
+                    T::SwapInterface::max_price(),
                     set_limit,
                     drop_fee_destination,
                 )?;
@@ -499,8 +499,9 @@ impl<T: Config> Pallet<T> {
         let limit_price_float: U64F64 = U64F64::saturating_from_num(limit_price)
             .checked_div(U64F64::saturating_from_num(1_000_000_000))
             .unwrap_or(U64F64::saturating_from_num(0));
-        let current_price = T::SwapExt::current_alpha_price(origin_netuid.into())
-            .safe_div(T::SwapExt::current_alpha_price(destination_netuid.into()));
+        let current_price = T::SwapInterface::current_alpha_price(origin_netuid.into()).safe_div(
+            T::SwapInterface::current_alpha_price(destination_netuid.into()),
+        );
         if limit_price_float > current_price {
             return Err(Error::ZeroMaxStakeAmount);
         }

pallets/subtensor/src/staking/remove_stake.rs

@@ -1,9 +1,7 @@
-use subtensor_swap_interface::{SwapEngine, SwapExt};
-
 use super::*;
 use substrate_fixed::types::U96F32;
 use subtensor_runtime_common::{AlphaCurrency, Currency, NetUid, TaoCurrency};
-use subtensor_swap_interface::Order;
+use subtensor_swap_interface::{Order, SwapHandler};
 
 impl<T: Config> Pallet<T> {
     /// ---- The implementation for the extrinsic remove_stake: Removes stake from a hotkey account and adds it onto a coldkey.
@@ -74,7 +72,7 @@ impl<T: Config> Pallet<T> {
             &coldkey,
             netuid,
             alpha_unstaked,
-            T::SwapExt::min_price(),
+            T::SwapInterface::min_price(),
             false,
         )?;
 
@@ -169,7 +167,7 @@ impl<T: Config> Pallet<T> {
                     &coldkey,
                     netuid,
                     alpha_unstaked,
-                    T::SwapExt::min_price(),
+                    T::SwapInterface::min_price(),
                     false,
                 )?;
 
@@ -262,7 +260,7 @@ impl<T: Config> Pallet<T> {
                         &coldkey,
                         netuid,
                         alpha_unstaked,
-                        T::SwapExt::min_price(),
+                        T::SwapInterface::min_price(),
                         false,
                     )?;
 
@@ -281,7 +279,7 @@ impl<T: Config> Pallet<T> {
             &coldkey,
             NetUid::ROOT,
             total_tao_unstaked,
-            T::SwapExt::max_price(),
+            T::SwapInterface::max_price(),
             false, // no limit for Root subnet
             false,
         )?;
@@ -407,7 +405,7 @@ impl<T: Config> Pallet<T> {
 
         // Use reverting swap to estimate max limit amount
         let order = GetTaoForAlpha::<T>::with_amount(u64::MAX);
-        let result = T::SwapEngine::swap(netuid.into(), order, limit_price.into(), false, true)
+        let result = T::SwapInterface::swap(netuid.into(), order, limit_price.into(), false, true)
             .map(|r| r.amount_paid_in.saturating_add(r.fee_paid))
             .map_err(|_| Error::ZeroMaxStakeAmount)?;
 
@@ -465,13 +463,13 @@ impl<T: Config> Pallet<T> {
 
         let owner_emission_tao: TaoCurrency = if owner_alpha_u64 > 0 {
             let order = GetTaoForAlpha::<T>::with_amount(owner_alpha_u64);
-            match T::SwapEngine::sim_swap(netuid.into(), order) {
+            match T::SwapInterface::sim_swap(netuid.into(), order) {
                 Ok(sim) => sim.amount_paid_out,
                 Err(e) => {
                     log::debug!(
                         "destroy_alpha_in_out_stakes: sim_swap owner α→τ failed (netuid={netuid:?}, alpha={owner_alpha_u64}, err={e:?}); falling back to price multiply.",
                     );
-                    let cur_price: U96F32 = T::SwapExt::current_alpha_price(netuid.into());
+                    let cur_price: U96F32 = T::SwapInterface::current_alpha_price(netuid.into());
                     let val_u64: u64 = U96F32::from_num(owner_alpha_u64)
                         .saturating_mul(cur_price)
                         .floor()