code refactoring

Author: Cosmodude

contracts/script/LiqManager.s.sol

@@ -17,3 +17,8 @@ contract LiqManagerScript is Script {
         vm.stopBroadcast();
     }
 }
+
+// forge script script/LiqManager.s.sol:LiqManagerScript \
+//   --rpc-url https://rpc.berachain.com \
+//   --account DEV \
+//   --broadcast

src/liquidity_provider.rs

@@ -26,7 +26,7 @@ impl<P: JsonRpcClient + Clone + 'static> LiquidityProvider<P> {
     }
 
     pub async fn provide_liquidity(&self, amount_a: U256, amount_b: U256) -> Result<()> {
-        let (current_price, current_tick) = self.pool.get_adjusted_current_price_and_tick(&self.provider).await?;
+        let (current_price, current_tick) = self.pool.get_adjusted_current_price_and_tick().await?;
         let (bottom_tick, top_tick) = self.pool.get_tick_range(current_tick, self.num_ticks).await;
 
         info!("Providing liquidity at price {:.6}, tick range [{}, {}]", 

src/main.rs

@@ -39,9 +39,7 @@ async fn main() -> Result<()> {
     let liquidity_manager: Address = liquidity_manager.parse()?;
 
     // Create pool instance
-    let pool = Pool::new(pool_address, token_a, token_b, tick_spacing, Arc::new(provider.clone())).await?;
-    let mut pool = Arc::new(pool);
-    Arc::get_mut(&mut pool).unwrap().set_provider(provider.clone());
+    let pool = Arc::new(Pool::new(pool_address, Arc::new(provider.clone()), token_a, token_b, tick_spacing).await?);
 
     // Create liquidity provider
     let liquidity_provider = Arc::new(LiquidityProvider::new(

src/pool.rs

@@ -13,32 +13,26 @@ pub struct Pool<P> {
     token_b_decimals: u8,
     tick_spacing: i32,
     contract: Option<BullaPool<Arc<Provider<P>>>>,
-    provider: Option<Arc<Provider<P>>>,
 }
 
 impl<P: JsonRpcClient + 'static> Pool<P> {
-    pub async fn new(address: Address, token_a: Address, token_b: Address, tick_spacing: i32, provider: Arc<Provider<P>>) -> Result<Self> {
+    pub async fn new(address: Address, provider: Arc<Provider<P>>, token_a: Address, token_b: Address, tick_spacing: i32) -> Result<Self> {
         let token_a_decimals = Self::get_decimals(provider.clone(), token_a).await?;
         let token_b_decimals = Self::get_decimals(provider.clone(), token_b).await?;
+        let contract = BullaPool::new(address, provider.clone());
+        println!("Provider set for pool at {:?}", address);
         Ok(Self {
             address,
             token_a,
             token_b,
             token_a_decimals,
             token_b_decimals,
             tick_spacing,
-            contract: None,
-            provider: Some(provider),
+            contract: Some(contract),
         })
     }
 
-    pub fn set_provider(&mut self, provider: Provider<P>) {
-        let contract = BullaPool::new(self.address, Arc::new(provider));
-        self.contract = Some(contract);
-        println!("Provider set for pool at {:?}", self.address);
-    }
-
-    pub async fn get_adjusted_current_price_and_tick(&self, provider: &Provider<P>) -> Result<(f64, i32)> {
+    pub async fn get_adjusted_current_price_and_tick(&self) -> Result<(f64, i32)> {
         if let Some(contract) = &self.contract {
             let state = contract.get_state_of_amm().await?;
             let sqrt_price = state.sqrt_price;
@@ -48,7 +42,7 @@ impl<P: JsonRpcClient + 'static> Pool<P> {
             let adjusted_price = price * (10.0_f64.powi(self.token_a_decimals as i32 - self.token_b_decimals as i32));
             Ok((adjusted_price, state.tick))
         } else {
-            anyhow::bail!("Provider not set for pool")
+            anyhow::bail!("Contract not set for pool")
         }
     }
 

src/price_tracker.rs

@@ -42,7 +42,7 @@ impl<P: JsonRpcClient + 'static> PriceTracker<P> {
     }
 
     async fn update_price(&self) -> Result<(f64, i32, u64)> {
-        let (price, tick) = self.pool.get_adjusted_current_price_and_tick(&self.provider).await?;
+        let (price, tick) = self.pool.get_adjusted_current_price_and_tick().await?;
         let timestamp = std::time::SystemTime::now()
             .duration_since(std::time::UNIX_EPOCH)?
             .as_secs();