create pool keys collection and get pools message

src/contracts/collections/mod.rs

@@ -1,9 +1,11 @@
 pub mod fee_tiers;
+pub mod pool_keys;
 pub mod pools;
 pub mod positions;
 pub mod ticks;
 
 pub use fee_tiers::*;
+pub use pool_keys::*;
 pub use pools::*;
 pub use positions::*;
 pub use ticks::*;

src/contracts/collections/pool_keys.rs

@@ -0,0 +1,110 @@
+use crate::{contracts::PoolKey, InvariantError};
+use alloc::vec::Vec;
+
+#[ink::storage_item]
+#[derive(Debug, Default)]
+pub struct PoolKeys {
+    pool_keys: Vec<PoolKey>,
+}
+
+impl PoolKeys {
+    pub fn add(&mut self, pool_key: PoolKey) -> Result<(), InvariantError> {
+        if self.contains(pool_key) {
+            return Err(InvariantError::PoolKeyAlreadyExist);
+        }
+
+        self.pool_keys.push(pool_key);
+        Ok(())
+    }
+
+    pub fn remove(&mut self, pool_key: PoolKey) -> Result<(), InvariantError> {
+        let index = self
+            .pool_keys
+            .iter()
+            .position(|vec_pool_key| *vec_pool_key == pool_key)
+            .ok_or(InvariantError::PoolKeyNotFound)?;
+
+        let length = self.pool_keys.len();
+
+        self.pool_keys.swap(index, length - 1);
+        self.pool_keys.pop();
+
+        Ok(())
+    }
+
+    pub fn contains(&self, fee_tier_key: PoolKey) -> bool {
+        self.pool_keys
+            .iter()
+            .any(|vec_fee_tier_key| *vec_fee_tier_key == fee_tier_key)
+    }
+
+    pub fn get_all(&self) -> Vec<PoolKey> {
+        self.pool_keys.clone()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{contracts::FeeTier, math::percentage::Percentage};
+    use decimal::*;
+    use ink::primitives::AccountId;
+
+    #[ink::test]
+    fn test_add() {
+        let pool_keys = &mut PoolKeys::default();
+        let pool_key = PoolKey::default();
+        let token_x = AccountId::from([1; 32]);
+        let token_y = AccountId::from([2; 32]);
+        let fee_tier = FeeTier {
+            fee: Percentage::new(0),
+            tick_spacing: 1,
+        };
+        let new_pool_key = PoolKey::new(token_x, token_y, fee_tier).unwrap();
+
+        pool_keys.add(pool_key).unwrap();
+        assert_eq!(pool_keys.contains(pool_key), true);
+        assert_eq!(pool_keys.contains(new_pool_key), false);
+
+        let result = pool_keys.add(pool_key);
+        assert_eq!(result, Err(InvariantError::PoolKeyAlreadyExist));
+    }
+
+    #[ink::test]
+    fn test_remove() {
+        let pool_keys = &mut PoolKeys::default();
+        let pool_key = PoolKey::default();
+
+        pool_keys.add(pool_key).unwrap();
+
+        pool_keys.remove(pool_key).unwrap();
+        assert_eq!(pool_keys.contains(pool_key), false);
+
+        let result = pool_keys.remove(pool_key);
+        assert_eq!(result, Err(InvariantError::PoolKeyNotFound));
+    }
+
+    #[ink::test]
+    fn test_get_all() {
+        let pool_keys = &mut PoolKeys::default();
+        let pool_key = PoolKey::default();
+        let token_x = AccountId::from([1; 32]);
+        let token_y = AccountId::from([2; 32]);
+        let fee_tier = FeeTier {
+            fee: Percentage::new(0),
+            tick_spacing: 1,
+        };
+        let new_pool_key = PoolKey::new(token_x, token_y, fee_tier).unwrap();
+
+        let result = pool_keys.get_all();
+        assert_eq!(result, vec![]);
+        assert_eq!(result.len(), 0);
+
+        pool_keys.add(pool_key).unwrap();
+        pool_keys.add(new_pool_key).unwrap();
+
+        let result = pool_keys.get_all();
+        assert_eq!(result, vec![pool_key, new_pool_key]);
+        assert_eq!(result.len(), 2);
+    }
+}

src/contracts/entrypoints.rs

@@ -124,6 +124,9 @@ pub trait Invariant {
         fee_tier: FeeTier,
     ) -> Result<Pool, InvariantError>;
 
+    #[ink(message)]
+    fn get_pools(&self) -> Vec<PoolKey>;
+
     #[ink(message)]
     fn get_tick(&self, key: PoolKey, index: i32) -> Result<Tick, InvariantError>;
 

src/lib.rs

@@ -15,12 +15,14 @@
     PositionNotFound,
     TickNotFound,
     FeeTierNotFound,
+    PoolKeyNotFound,
     AmountIsZero,
     WrongLimit,
     PriceLimitReached,
     NoGainSwap,
     InvalidTickSpacing,
     FeeTierAlreadyExist,
+    PoolKeyAlreadyExist,
     UnauthorizedFeeReceiver,
     ZeroLiquidity,
     TransferError,
@@ -35,6 +37,7 @@
     use crate::contracts::FeeTierKey;
     use crate::contracts::Invariant;
     use crate::contracts::Pool;
+    use crate::contracts::PoolKeys;
     use crate::contracts::Tick;
     use crate::contracts::Tickmap;
     use crate::contracts::{FeeTier, FeeTiers, PoolKey, Pools, Position, Positions, Ticks}; //
@@ -131,7 +134,7 @@
         tickmap: Tickmap,
         ticks: Ticks,
         fee_tier_keys: Vec<FeeTierKey>,
-        pool_keys: Vec<PoolKey>,
+        pool_keys: PoolKeys,
         state: State,
     }
 
@@ -188,7 +191,7 @@
                 {
                     return Err(InvariantError::WrongLimit);
                 }
             } else {
                 if pool.sqrt_price >= sqrt_price_limit
                     || sqrt_price_limit < SqrtPrice::new(MIN_SQRT_PRICE)
                 {
@@ -910,8 +913,7 @@
             let pool_key = PoolKey::new(token_0, token_1, fee_tier)?;
             let pool = Pool::create(init_tick, current_timestamp, self.state.admin);
             self.pools.add(pool_key, &pool)?;
-
-            self.pool_keys.push(pool_key);
+            self.pool_keys.add(pool_key)?;
 
             Ok(())
         }
@@ -929,16 +931,6 @@
             Ok(pool)
         }
 
-        fn remove_pool(&mut self, key: PoolKey) {
-            self.pools.remove(key);
-            self.pool_keys.retain(|&x| x != key);
-        }
-
-        // Ticks
-        fn add_tick(&mut self, key: PoolKey, index: i32, tick: Tick) {
-            self.ticks.add(key, index, &tick);
-        }
-
         #[ink(message)]
         fn get_tick(&self, key: PoolKey, index: i32) -> Result<Tick, InvariantError> {
             self.ticks.get(key, index)
@@ -948,117 +940,10 @@
         fn get_tickmap_bit(&self, key: PoolKey, index: i32) -> bool {
             self.tickmap.get(index, key.fee_tier.tick_spacing, key)
         }
-        fn remove_tick(&mut self, key: PoolKey, index: i32) {
-            self.ticks.remove(key, index);
-        }
 
-        fn emit_swap_event(
-            &self,
-            address: AccountId,
-            pool: PoolKey,
-            amount_in: TokenAmount,
-            amount_out: TokenAmount,
-            fee: TokenAmount,
-            start_sqrt_price: SqrtPrice,
-            target_sqrt_price: SqrtPrice,
-            x_to_y: bool,
-        ) {
-            let timestamp = self.get_timestamp();
-            ink::codegen::EmitEvent::<Contract>::emit_event(
-                self.env(),
-                SwapEvent {
-                    timestamp,
-                    address,
-                    pool,
-                    amount_in,
-                    amount_out,
-                    fee,
-                    start_sqrt_price,
-                    target_sqrt_price,
-                    x_to_y,
-                },
-            );
-        }
-        fn emit_create_position_event(
-            &self,
-            address: AccountId,
-            pool: PoolKey,
-            liquidity: Liquidity,
-            lower_tick: i32,
-            upper_tick: i32,
-            current_sqrt_price: SqrtPrice,
-        ) {
-            let timestamp = self.get_timestamp();
-            ink::codegen::EmitEvent::<Contract>::emit_event(
-                self.env(),
-                CreatePositionEvent {
-                    timestamp,
-                    address,
-                    pool,
-                    liquidity,
-                    lower_tick,
-                    upper_tick,
-                    current_sqrt_price,
-                },
-            );
-        }
-        fn emit_remove_position_event(
-            &self,
-            address: AccountId,
-            pool: PoolKey,
-            liquidity: Liquidity,
-            lower_tick: i32,
-            upper_tick: i32,
-            current_sqrt_price: SqrtPrice,
-        ) {
-            let timestamp = self.get_timestamp();
-            ink::codegen::EmitEvent::<Contract>::emit_event(
-                self.env(),
-                RemovePositionEvent {
-                    timestamp,
-                    address,
-                    pool,
-                    liquidity,
-                    lower_tick,
-                    upper_tick,
-                    current_sqrt_price,
-                },
-            );
-        }
-        fn emit_cross_tick_event(&self, address: AccountId, pool: PoolKey, index: i32) {
-            let timestamp = self.get_timestamp();
-            ink::codegen::EmitEvent::<Contract>::emit_event(
-                self.env(),
-                CrossTickEvent {
-                    timestamp,
-                    address,
-                    pool,
-                    index,
-                },
-            );
-        }
-
-        fn get_timestamp(&self) -> u64 {
-            self.env().block_timestamp()
-        }
-
-        fn _order_tokens(
-            &self,
-            token_0: AccountId,
-            token_1: AccountId,
-            balance_0: Balance,
-            balance_1: Balance,
-        ) -> OrderPair {
-            match token_0.lt(&token_1) {
-                true => OrderPair {
-                    x: (token_0, balance_0),
-                    y: (token_1, balance_1),
-                },
-                false => OrderPair {
-                    x: (token_1, balance_1),
-                    y: (token_0, balance_0),
-                },
-            }
+        #[ink(message)]
+        fn get_pools(&self) -> Vec<PoolKey> {
+            self.pool_keys.get_all()
         }
     }