Add layer enum for tick index bitmap

Author: ales-otf

pallets/swap/src/lib.rs

@@ -9,7 +9,7 @@ use safe_math::*;
 use sp_arithmetic::helpers_128bit::sqrt;
 use substrate_fixed::types::U64F64;
 
-use self::tick::{Tick, TickIndex, TickIndexBitmap};
+use self::tick::{Layer, Tick, TickIndex, TickIndexBitmap};
 
 pub mod pallet;
 mod tick;
@@ -1127,22 +1127,26 @@ where
         let bitmap = TickIndexBitmap::from(index);
 
         // Update layer words
-        let mut word0_value = self.state_ops.get_layer0_word(bitmap.word_at(0));
-        let mut word1_value = self.state_ops.get_layer1_word(bitmap.word_at(1));
-        let mut word2_value = self.state_ops.get_layer2_word(bitmap.word_at(2));
+        let mut word0_value = self.state_ops.get_layer0_word(bitmap.word_at(Layer::Top));
+        let mut word1_value = self
+            .state_ops
+            .get_layer1_word(bitmap.word_at(Layer::Middle));
+        let mut word2_value = self
+            .state_ops
+            .get_layer2_word(bitmap.word_at(Layer::Bottom));
 
         // Set bits in each layer
-        word0_value |= bitmap.bit_mask(0);
-        word1_value |= bitmap.bit_mask(1);
-        word2_value |= bitmap.bit_mask(2);
+        word0_value |= bitmap.bit_mask(Layer::Top);
+        word1_value |= bitmap.bit_mask(Layer::Middle);
+        word2_value |= bitmap.bit_mask(Layer::Bottom);
 
         // Update the storage
         self.state_ops
-            .set_layer0_word(bitmap.word_at(0), word0_value);
+            .set_layer0_word(bitmap.word_at(Layer::Top), word0_value);
         self.state_ops
-            .set_layer1_word(bitmap.word_at(1), word1_value);
+            .set_layer1_word(bitmap.word_at(Layer::Middle), word1_value);
         self.state_ops
-            .set_layer2_word(bitmap.word_at(2), word2_value);
+            .set_layer2_word(bitmap.word_at(Layer::Bottom), word2_value);
     }
 
     pub fn remove_active_tick(&mut self, index: TickIndex) {
@@ -1155,25 +1159,29 @@ where
         let bitmap = TickIndexBitmap::from(index);
 
         // Update layer words
-        let mut word0_value = self.state_ops.get_layer0_word(bitmap.word_at(0));
-        let mut word1_value = self.state_ops.get_layer1_word(bitmap.word_at(1));
-        let mut word2_value = self.state_ops.get_layer2_word(bitmap.word_at(2));
+        let mut word0_value = self.state_ops.get_layer0_word(bitmap.word_at(Layer::Top));
+        let mut word1_value = self
+            .state_ops
+            .get_layer1_word(bitmap.word_at(Layer::Middle));
+        let mut word2_value = self
+            .state_ops
+            .get_layer2_word(bitmap.word_at(Layer::Bottom));
 
         // Turn the bit off (& !bit) and save as needed
-        word2_value &= !bitmap.bit_mask(2);
+        word2_value &= !bitmap.bit_mask(Layer::Bottom);
         self.state_ops
-            .set_layer2_word(bitmap.word_at(2), word2_value);
+            .set_layer2_word(bitmap.word_at(Layer::Bottom), word2_value);
 
         if word2_value == 0 {
-            word1_value &= !bitmap.bit_mask(1);
+            word1_value &= !bitmap.bit_mask(Layer::Middle);
             self.state_ops
-                .set_layer1_word(bitmap.word_at(1), word1_value);
+                .set_layer1_word(bitmap.word_at(Layer::Middle), word1_value);
         }
 
         if word1_value == 0 {
-            word0_value &= !bitmap.bit_mask(0);
+            word0_value &= !bitmap.bit_mask(Layer::Top);
             self.state_ops
-                .set_layer0_word(bitmap.word_at(0), word0_value);
+                .set_layer0_word(bitmap.word_at(Layer::Top), word0_value);
         }
     }
 
@@ -1193,12 +1201,12 @@ where
         let mut result: u32 = 0;
 
         // Layer positions from bitmap
-        let layer0_word = bitmap.word_at(0);
-        let layer0_bit = bitmap.bit_at(0);
-        let layer1_word = bitmap.word_at(1);
-        let layer1_bit = bitmap.bit_at(1);
-        let layer2_word = bitmap.word_at(2);
-        let layer2_bit = bitmap.bit_at(2);
+        let layer0_word = bitmap.word_at(Layer::Top);
+        let layer0_bit = bitmap.bit_at(Layer::Top);
+        let layer1_word = bitmap.word_at(Layer::Middle);
+        let layer1_bit = bitmap.bit_at(Layer::Middle);
+        let layer2_word = bitmap.word_at(Layer::Bottom);
+        let layer2_bit = bitmap.bit_at(Layer::Bottom);
 
         // Find the closest active bits in layer 0, then 1, then 2
 

pallets/swap/src/tick.rs

@@ -10,7 +10,7 @@ use frame_support::pallet_prelude::*;
 use safe_math::*;
 use substrate_fixed::types::U64F64;
 
-use crate::{SqrtPrice, SwapDataOperations};
+use crate::SqrtPrice;
 
 const U256_1: U256 = U256::from_limbs([1, 0, 0, 0]);
 const U256_2: U256 = U256::from_limbs([2, 0, 0, 0]);
@@ -375,6 +375,17 @@ impl TickIndex {
     }
 }
 
+/// Represents the three layers in the Uniswap V3 bitmap structure
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Layer {
+    /// Top layer (highest level of the hierarchy)
+    Top = 0,
+    /// Middle layer
+    Middle = 1,
+    /// Bottom layer (contains the actual ticks)
+    Bottom = 2,
+}
+
 /// A bitmap representation of a tick index position across the three-layer structure
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct TickIndexBitmap {
@@ -405,32 +416,29 @@ impl TickIndexBitmap {
     }
 
     /// Get the mask for a bit in the specified layer
-    pub fn bit_mask(&self, layer: u8) -> u128 {
+    pub fn bit_mask(&self, layer: Layer) -> u128 {
         match layer {
-            0 => 1u128 << self.layer0.1,
-            1 => 1u128 << self.layer1.1,
-            2 => 1u128 << self.layer2.1,
-            _ => panic!("Invalid layer: must be 0, 1, or 2"),
+            Layer::Top => 1u128 << self.layer0.1,
+            Layer::Middle => 1u128 << self.layer1.1,
+            Layer::Bottom => 1u128 << self.layer2.1,
         }
     }
 
     /// Get the word for the specified layer
-    pub fn word_at(&self, layer: u8) -> u32 {
+    pub fn word_at(&self, layer: Layer) -> u32 {
         match layer {
-            0 => self.layer0.0,
-            1 => self.layer1.0,
-            2 => self.layer2.0,
-            _ => panic!("Invalid layer: must be 0, 1, or 2"),
+            Layer::Top => self.layer0.0,
+            Layer::Middle => self.layer1.0,
+            Layer::Bottom => self.layer2.0,
         }
     }
 
     /// Get the bit for the specified layer
-    pub fn bit_at(&self, layer: u8) -> u32 {
+    pub fn bit_at(&self, layer: Layer) -> u32 {
         match layer {
-            0 => self.layer0.1,
-            1 => self.layer1.1,
-            2 => self.layer2.1,
-            _ => panic!("Invalid layer: must be 0, 1, or 2"),
+            Layer::Top => self.layer0.1,
+            Layer::Middle => self.layer1.1,
+            Layer::Bottom => self.layer2.1,
         }
     }