Add ActiveTickIndexManager

Author: ales-otf

pallets/swap/src/lib.rs

@@ -10,7 +10,7 @@ use safe_math::*;
 use substrate_fixed::types::U64F64;
 use uuid::Uuid;
 
-use self::tick::{Layer, Tick, TickIndex, TickIndexBitmap};
+use self::tick::{LayerLevel, Tick, TickIndex, TickIndexBitmap};
 use crate::pallet::{Config, Error};
 
 pub mod pallet;
@@ -28,7 +28,6 @@ pub struct RemoveLiquidityResult {
     fee_alpha: u64,
 }
 
-
 #[derive(
     Clone, Copy, Decode, Default, Encode, Eq, MaxEncodedLen, PartialEq, RuntimeDebug, TypeInfo,
 )]

pallets/swap/src/pallet/impls.rs

@@ -107,6 +107,7 @@ impl<T: Config> Pallet<T> {
         // New position
         let position = Position {
             id: PositionId::new(),
+            netuid,
             tick_low,
             tick_high,
             liquidity,
@@ -184,7 +185,7 @@ impl<T: Config> Pallet<T> {
         let current_tick_index = CurrentTickIndex::<T>::get(netuid);
 
         // Collect fees and get tao and alpha amounts
-        // let (fee_tao, fee_alpha) = self.collect_fees(&mut pos);
+        let (fee_tao, fee_alpha) = pos.collect_fees::<T>();
         //     let current_price: SqrtPrice = self.state_ops.get_alpha_sqrt_price();
         //     let (tao, alpha) = pos.to_token_amounts(current_price)?;
 

pallets/swap/src/pallet/mod.rs

@@ -6,7 +6,7 @@ use substrate_fixed::types::U64F64;
 use crate::{
     NetUid,
     position::{Position, PositionId},
-    tick::{Tick, TickIndex},
+    tick::{LayerLevel, Tick, TickIndex},
 };
 
 pub use pallet::*;
@@ -76,7 +76,6 @@ mod pallet {
     /// Storage for user positions, using subnet ID and account ID as keys
     /// The value is a bounded vector of Position structs with details about the liquidity positions
     #[pallet::storage]
-    #[pallet::getter(fn positions)]
     pub type Positions<T: Config> = StorageNMap<
         _,
         (
@@ -88,6 +87,27 @@ mod pallet {
         OptionQuery,
     >;
 
+    // Global accrued fees in tao per subnet
+    #[pallet::storage]
+    pub type FeeGlobalTao<T> = StorageMap<_, Twox64Concat, NetUid, U64F64>;
+
+    // Global accrued fees in alpha per subnet
+    #[pallet::storage]
+    pub type FeeGlobalAlpha<T> = StorageMap<_, Twox64Concat, NetUid, U64F64>;
+
+    /// Tick index bitmap words storage
+    #[pallet::storage]
+    pub type TickIndexBitmapWords<T: Config> = StorageNMap<
+        _,
+        (
+            NMapKey<Twox64Concat, NetUid>,     // Subnet ID
+            NMapKey<Twox64Concat, LayerLevel>, // Layer level
+            NMapKey<Twox64Concat, u32>,        // word index
+        ),
+        u128,
+        ValueQuery,
+    >;
+
     #[pallet::event]
     #[pallet::generate_deposit(pub(super) fn deposit_event)]
     pub enum Event<T: Config> {

pallets/swap/src/position.rs

@@ -4,9 +4,9 @@ use safe_math::*;
 use substrate_fixed::types::U64F64;
 use uuid::Uuid;
 
-use crate::SqrtPrice;
-use crate::pallet::{Config, Error};
+use crate::pallet::{Config, Error, FeeGlobalAlpha, FeeGlobalTao};
 use crate::tick::TickIndex;
+use crate::{NetUid, SqrtPrice};
 
 /// Position designates one liquidity position.
 ///
@@ -21,6 +21,7 @@ use crate::tick::TickIndex;
 #[derive(Clone, Encode, Decode, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen, Default)]
 pub struct Position {
     pub id: PositionId,
+    pub netuid: NetUid,
     pub tick_low: TickIndex,
     pub tick_high: TickIndex,
     pub liquidity: u64,
@@ -88,6 +89,38 @@ impl Position {
             )
         })
     }
+
+    /// Collect fees for a position
+    /// Updates the position
+    pub fn collect_fees<T: Config>(&mut self) -> (u64, u64) {
+        let mut fee_tao = self.fees_in_range::<T>(true);
+        let mut fee_alpha = self.fees_in_range::<T>(false);
+
+        fee_tao = fee_tao.saturating_sub(self.fees_tao);
+        fee_alpha = fee_alpha.saturating_sub(self.fees_alpha);
+
+        self.fees_tao = fee_tao;
+        self.fees_alpha = fee_alpha;
+
+        fee_tao = self.liquidity.saturating_mul(fee_tao);
+        fee_alpha = self.liquidity.saturating_mul(fee_alpha);
+
+        (fee_tao, fee_alpha)
+    }
+
+    /// Get fees in a position's range
+    ///
+    /// If quote flag is true, Tao is returned, otherwise alpha.
+    fn fees_in_range<T: Config>(&self, quote: bool) -> u64 {
+        if quote {
+            FeeGlobalTao::<T>::get(self.netuid).unwrap_or_default()
+        } else {
+            FeeGlobalAlpha::<T>::get(self.netuid).unwrap_or_default()
+        }
+        .saturating_sub(self.tick_low.fees_below::<T>(self.netuid, quote))
+        .saturating_sub(self.tick_high.fees_above::<T>(self.netuid, quote))
+        .saturating_to_num::<u64>()
+    }
 }
 
 #[derive(