liqudiity manager g=functionality moved to separate module

Author: Cosmodude

src/liquidity_provider.rs

@@ -3,23 +3,26 @@ use ethers::prelude::*;
 use std::sync::Arc;
 use crate::pool::Pool;
 use crate::onchain::erc20::ERC20Token;
+use crate::onchain::liquidity_manager::LiquidityManager;
 use log::info;
 
 pub struct LiquidityProvider<P> {
     pool: Arc<Pool<P>>,
     provider: Provider<P>,
     num_ticks: u32,
-    liquidity_manager_contract: Address,
+    liquidity_manager: LiquidityManager<P>,
 }
 
 impl<P: JsonRpcClient + Clone + 'static> LiquidityProvider<P> {
-    pub fn new(pool: Arc<Pool<P>>, provider: Provider<P>, num_ticks: u32, liquidity_manager_contract: Address) -> Self {
-        Self {
+    pub fn new(pool: Arc<Pool<P>>, provider: Provider<P>, num_ticks: u32, liquidity_manager_contract: Address) -> Result<Self> {
+        let liquidity_manager = LiquidityManager::new(provider.clone(), liquidity_manager_contract)?;
+        
+        Ok(Self {
             pool,
             provider,
             num_ticks,
-            liquidity_manager_contract,
-        }
+            liquidity_manager,
+        })
     }
 
     pub async fn provide_liquidity(&self, amount_a: U256, amount_b: U256) -> Result<()> {
@@ -37,79 +40,35 @@ impl<P: JsonRpcClient + Clone + 'static> LiquidityProvider<P> {
         let token_b_contract = ERC20Token::new(token_b, provider.clone());
 
         // Approve tokens
-        token_a_contract.approve(self.liquidity_manager_contract, amount_a).await?;
-        token_b_contract.approve(self.liquidity_manager_contract, amount_b).await?;
-
-        let liq_manager_abi: ethers::abi::Abi = serde_json::from_str(include_str!("../contracts/out/LiqManager.sol/LiquidityManager.json"))?;
-        let liq_manager_contract = Contract::new(
-            self.liquidity_manager_contract,
-            liq_manager_abi,
-            provider
-        );
-
-        let sqrt_lower = Self::tick_to_sqrt_price(bottom_tick);
-        let sqrt_upper = Self::tick_to_sqrt_price(top_tick);
-        let sqrt_current = Self::tick_to_sqrt_price(current_tick);
-      
-        let liquidity_from_token0 = (amount_a.as_u128() as f64) * (sqrt_lower * sqrt_upper) / (sqrt_upper - sqrt_lower);
-        let liquidity_from_token1 = (amount_b.as_u128() as f64) / (sqrt_upper - sqrt_lower);
-        let liquidity = if sqrt_current <= sqrt_lower {
-            liquidity_from_token0
-        } else if sqrt_current >= sqrt_upper {
-            liquidity_from_token1
-        } else {
-            liquidity_from_token0.min(liquidity_from_token1)
-        };
-        let liquidity_desired = U128::from(liquidity as u128);
-        let data = Vec::<u8>::new();
+        token_a_contract.approve(self.liquidity_manager.address, amount_a).await?;
+        token_b_contract.approve(self.liquidity_manager.address, amount_b).await?;
 
-        let provide_call = liq_manager_contract
-            .method::<_, H256>(
-                "provideLiquidity",
-                (
-                    self.liquidity_manager_contract,
-                    bottom_tick,
-                    top_tick,
-                    liquidity_desired,
-                    data,
-                ),
-            )?;
-        let tx = provide_call.send().await?;
+        self.liquidity_manager.provide_liquidity(
+            bottom_tick,
+            top_tick,
+            amount_a,
+            amount_b,
+            current_tick,
+        ).await?;
 
-        info!("Liquidity provided successfully. Transaction hash: {:?}", tx.tx_hash());
         Ok(())
     }
 
     pub async fn remove_liquidity(&self, position_id: U256) -> Result<()> {
-        let liq_manager_abi: ethers::abi::Abi = serde_json::from_str(include_str!("../contracts/out/LiqManager.sol/LiquidityManager.json"))?;
-        let provider = Arc::new(self.provider.clone());
-        let liq_manager_contract = Contract::new(
-            self.liquidity_manager_contract,
-            liq_manager_abi,
-            provider
-        );
-
         let bottom_tick = -100;
         let top_tick = 100;
         let amount = U128::from(position_id.as_u128());
         let amount0_min = U256::from(0);
         let amount1_min = U256::from(0);
 
-        let withdraw_call = liq_manager_contract
-            .method::<_, H256>(
-                "withdrawLiquidity",
-                (
-                    self.liquidity_manager_contract,
-                    bottom_tick,
-                    top_tick,
-                    amount,
-                    amount0_min,
-                    amount1_min,
-                ),
-            )?;
-        let tx = withdraw_call.send().await?;
+        self.liquidity_manager.withdraw_liquidity(
+            bottom_tick,
+            top_tick,
+            amount,
+            amount0_min,
+            amount1_min,
+        ).await?;
 
-        info!("Liquidity removed successfully. Transaction hash: {:?}", tx.tx_hash());
         Ok(())
     }
 

src/onchain/liquidity_manager.rs

@@ -0,0 +1,100 @@
+use anyhow::Result;
+use ethers::prelude::*;
+use std::sync::Arc;
+use log::info;
+
+pub struct LiquidityManager<P> {
+    contract: Contract<Arc<Arc<Provider<P>>>>,
+    pub address: Address,
+}
+
+impl<P: JsonRpcClient + Clone + 'static> LiquidityManager<P> {
+    pub fn new(provider: Provider<P>, address: Address) -> Result<Self> {
+        let abi: ethers::abi::Abi = serde_json::from_str(include_str!("../../contracts/out/LiqManager.sol/LiquidityManager.json"))?;
+        let contract = Contract::new(address, abi, Arc::new(Arc::new(Arc::new(provider))));
+        
+        Ok(Self {
+            contract,
+            address,
+        })
+    }
+
+    fn calculate_liquidity(
+        amount_a: U256,
+        amount_b: U256,
+        bottom_tick: i32,
+        top_tick: i32,
+        current_tick: i32,
+    ) -> U128 {
+        let sqrt_lower = Self::tick_to_sqrt_price(bottom_tick);
+        let sqrt_upper = Self::tick_to_sqrt_price(top_tick);
+        let sqrt_current = Self::tick_to_sqrt_price(current_tick);
+      
+        let liquidity_from_token0 = (amount_a.as_u128() as f64) * (sqrt_lower * sqrt_upper) / (sqrt_upper - sqrt_lower);
+        let liquidity_from_token1 = (amount_b.as_u128() as f64) / (sqrt_upper - sqrt_lower);
+        let liquidity = if sqrt_current <= sqrt_lower {
+            liquidity_from_token0
+        } else if sqrt_current >= sqrt_upper {
+            liquidity_from_token1
+        } else {
+            liquidity_from_token0.min(liquidity_from_token1)
+        };
+        U128::from(liquidity as u128)
+    }
+
+    fn tick_to_sqrt_price(tick: i32) -> f64 {
+        1.0001_f64.powf(tick as f64 / 2.0)
+    }
+
+    pub async fn provide_liquidity(
+        &self,
+        bottom_tick: i32,
+        top_tick: i32,
+        amount_a: U256,
+        amount_b: U256,
+        current_tick: i32,
+    ) -> Result<H256> {
+        let liquidity_desired = Self::calculate_liquidity(amount_a, amount_b, bottom_tick, top_tick, current_tick);
+        let data = Vec::<u8>::new();
+
+        let provide_call = self.contract
+            .method::<_, H256>(
+                "provideLiquidity",
+                (
+                    self.address,
+                    bottom_tick,
+                    top_tick,
+                    liquidity_desired,
+                    data,
+                ),
+            )?;
+        let tx = provide_call.send().await?;
+        info!("Liquidity provided successfully. Transaction hash: {:?}", tx.tx_hash());
+        Ok(tx.tx_hash())
+    }
+
+    pub async fn withdraw_liquidity(
+        &self,
+        bottom_tick: i32,
+        top_tick: i32,
+        amount: U128,
+        amount0_min: U256,
+        amount1_min: U256,
+    ) -> Result<H256> {
+        let withdraw_call = self.contract
+            .method::<_, H256>(
+                "withdrawLiquidity",
+                (
+                    self.address,
+                    bottom_tick,
+                    top_tick,
+                    amount,
+                    amount0_min,
+                    amount1_min,
+                ),
+            )?;
+        let tx = withdraw_call.send().await?;
+        info!("Liquidity removed successfully. Transaction hash: {:?}", tx.tx_hash());
+        Ok(tx.tx_hash())
+    }
+} 

src/onchain/mod.rs

@@ -1,2 +1,3 @@
 pub mod erc20;
-pub mod bulla_pool;
+pub mod bulla_pool;
+pub mod liquidity_manager;