Upgrade Rust Edition to 2024

Cargo.toml

@@ -5,7 +5,7 @@ authors = [
     "Mahmoud Salem <moody@ekubo.org>",
     "Die Herdplatte <die.herdplatte@gmail.com>",
 ]
-edition = "2021"
+edition = "2024"
 license = "LGPL-2.1"
 description = "Types for interacting with Ekubo Protocol on Starknet & EVM chains"
 homepage = "https://ekubo.org"

justfile

@@ -3,3 +3,5 @@ test:
 
 check:
     cargo check --features serde,evm,starknet
+    cargo clippy --features evm,starknet,serde  --workspace -- -D warnings
+    cargo fmt --check

src/chain/evm.rs

@@ -1,5 +1,5 @@
-use crate::alloy_primitives::{aliases::B32, fixed_bytes, Address, FixedBytes, B256, U256};
-use crate::alloy_primitives::{uint, Keccak256};
+use crate::alloy_primitives::{Address, B256, FixedBytes, U256, aliases::B32, fixed_bytes};
+use crate::alloy_primitives::{Keccak256, uint};
 use derive_more::From;
 use num_traits::Zero as _;
 use thiserror::Error;

src/math/delta.rs

@@ -1,7 +1,7 @@
 use core::ops::Not;
 
 use crate::math::{
-    muldiv::{muldiv, MuldivError},
+    muldiv::{MuldivError, muldiv},
     sqrt_ratio::SQRT_RATIO_ONE,
 };
 use num_traits::Zero;
@@ -83,10 +83,10 @@ fn sort_ratios(sqrt_ratio_a: U256, sqrt_ratio_b: U256) -> Option<(U256, U256)> {
 mod tests {
     use super::*;
     use crate::chain::{
+        Chain,
         evm::Evm,
         starknet::Starknet,
-        tests::{ChainEnum, CHAINS},
-        Chain,
+        tests::{CHAINS, ChainEnum},
     };
     use ruint::uint;
 

src/math/muldiv.rs

@@ -1,6 +1,6 @@
 use ruint::{
-    aliases::{U256, U512},
     UintTryFrom,
+    aliases::{U256, U512},
 };
 use thiserror::Error;
 

src/math/sqrt_ratio.rs

@@ -1,4 +1,4 @@
-use crate::math::muldiv::{muldiv, MuldivError};
+use crate::math::muldiv::{MuldivError, muldiv};
 use num_traits::Zero;
 use ruint::aliases::U256;
 use thiserror::Error;

src/math/swap.rs

@@ -1,7 +1,7 @@
 use crate::math::sqrt_ratio::{next_sqrt_ratio_from_amount0, next_sqrt_ratio_from_amount1};
 use crate::{
     chain::Chain,
-    math::delta::{amount0_delta, amount1_delta, AmountDeltaError},
+    math::delta::{AmountDeltaError, amount0_delta, amount1_delta},
 };
 use num_traits::Zero;
 use ruint::aliases::U256;
@@ -200,7 +200,7 @@ mod tests {
         chain::{
             evm::Evm,
             starknet::Starknet,
-            tests::{ChainEnum, CHAINS},
+            tests::{CHAINS, ChainEnum},
         },
         math::sqrt_ratio::SQRT_RATIO_ONE,
     };

src/math/tick.rs

@@ -78,7 +78,7 @@ mod tests {
     use crate::chain::{
         evm::Evm,
         starknet::Starknet,
-        tests::{ChainEnum, CHAINS},
+        tests::{CHAINS, ChainEnum},
     };
 
     mod to_sqrt_ratio {

src/quoting/pools/concentrated.rs

@@ -1,15 +1,15 @@
 use crate::private;
 use crate::quoting::pools::{
-    ensure_valid_token_order, is_token1, CommonPoolConstructionError, CommonPoolQuoteError,
+    CommonPoolConstructionError, CommonPoolQuoteError, ensure_valid_token_order, is_token1,
 };
 use crate::quoting::types::{Pool, PoolConfig, PoolKey, Quote, QuoteParams, Tick};
 use crate::quoting::util::{
-    approximate_extra_distinct_tick_bitmap_lookups, construct_sorted_ticks,
-    ConstructSortedTicksError,
+    ConstructSortedTicksError, approximate_extra_distinct_tick_bitmap_lookups,
+    construct_sorted_ticks,
 };
 use crate::{
     chain::Chain,
-    math::swap::{compute_step, is_price_increasing, ComputeStepError},
+    math::swap::{ComputeStepError, compute_step, is_price_increasing},
 };
 use crate::{math::tick::to_sqrt_ratio, quoting::types::PoolState};
 use alloc::vec::Vec;
@@ -228,10 +228,10 @@ impl<C: Chain> ConcentratedPool<C> {
 
         for (i, tick) in sorted_ticks.iter().enumerate() {
             // Verify ticks are sorted
-            if let Some(last) = last_tick {
-                if tick.index <= last {
-                    return Err(ConcentratedPoolConstructionError::TicksNotSorted);
-                }
+            if let Some(last) = last_tick
+                && tick.index <= last
+            {
+                return Err(ConcentratedPoolConstructionError::TicksNotSorted);
             }
 
             // Verify ticks are multiples of tick_spacing
@@ -250,12 +250,12 @@ impl<C: Chain> ConcentratedPool<C> {
                 .ok_or(ConcentratedPoolConstructionError::ActiveLiquidityOverflow)?;
 
             // Calculate active liquidity
-            if let Some(active_index) = state.active_tick_index {
-                if i <= active_index {
-                    active_liquidity = active_liquidity
-                        .checked_add_signed(tick.liquidity_delta)
-                        .ok_or(ConcentratedPoolConstructionError::ActiveLiquidityOverflow)?;
-                }
+            if let Some(active_index) = state.active_tick_index
+                && i <= active_index
+            {
+                active_liquidity = active_liquidity
+                    .checked_add_signed(tick.liquidity_delta)
+                    .ok_or(ConcentratedPoolConstructionError::ActiveLiquidityOverflow)?;
             }
         }
 
@@ -520,7 +520,7 @@ mod tests {
     use crate::{
         chain::{
             starknet::Starknet,
-            tests::{run_for_all_chains, ChainTest},
+            tests::{ChainTest, run_for_all_chains},
         },
         math::sqrt_ratio::SQRT_RATIO_ONE,
         quoting::types::{PoolConfig, TokenAmount},

src/quoting/pools/full_range.rs

@@ -1,14 +1,14 @@
-use crate::{
-    chain::evm::Evm,
-    math::swap::{compute_step, is_price_increasing, ComputeStepError},
-};
 use crate::{
     chain::Chain,
     quoting::pools::{
-        ensure_valid_token_order, is_token1, CommonPoolConstructionError, CommonPoolQuoteError,
+        CommonPoolConstructionError, CommonPoolQuoteError, ensure_valid_token_order, is_token1,
     },
     quoting::types::{Pool, PoolConfig, PoolKey, Quote, QuoteParams},
 };
+use crate::{
+    chain::evm::Evm,
+    math::swap::{ComputeStepError, compute_step, is_price_increasing},
+};
 use crate::{private, quoting::types::PoolState};
 use derive_more::{Add, AddAssign, Sub, SubAssign};
 use num_traits::Zero;

src/quoting/pools/limit_order.rs

@@ -7,8 +7,8 @@ use crate::quoting::{
     pools::concentrated::{ConcentratedPoolResources, ConcentratedPoolTypeConfig},
     types::PoolState,
 };
-use crate::{chain::starknet::Starknet, math::swap::is_price_increasing};
 use crate::{chain::Chain, quoting::pools::concentrated::ConcentratedPoolState};
+use crate::{chain::starknet::Starknet, math::swap::is_price_increasing};
 use crate::{math::tick::to_sqrt_ratio, quoting::types::PoolConfig};
 use crate::{
     private,

src/quoting/pools/mev_capture.rs

@@ -4,7 +4,11 @@ use ruint::aliases::U256;
 use thiserror::Error;
 
 use crate::{
-    chain::evm::{Evm, EVM_FULL_RANGE_TICK_SPACING},
+    chain::Chain,
+    quoting::types::{BlockTimestamp, Pool, PoolConfig, PoolKey, Quote, QuoteParams},
+};
+use crate::{
+    chain::evm::{EVM_FULL_RANGE_TICK_SPACING, Evm},
     math::{
         facade::round_f64,
         swap::{amount_before_fee, compute_fee},
@@ -15,10 +19,6 @@ use crate::{
         ConcentratedPoolState, ConcentratedPoolTypeConfig, TickSpacing,
     },
 };
-use crate::{
-    chain::Chain,
-    quoting::types::{BlockTimestamp, Pool, PoolConfig, PoolKey, Quote, QuoteParams},
-};
 use crate::{math::tick::approximate_sqrt_ratio_to_tick, quoting::types::PoolState};
 
 /// MEV-capture pool that wraps a concentrated liquidity pool with time-aware fees.
@@ -110,20 +110,20 @@ impl MevCapturePool {
         // validates that the current tick is between the active tick and the active tick index + 1
         if let Some(i) = concentrated_pool.state().active_tick_index {
             let sorted_ticks = concentrated_pool.ticks();
-            if let Some(t) = sorted_ticks.get(i) {
-                if t.index > tick {
-                    return Err(MevCapturePoolConstructionError::InvalidCurrentTick);
-                }
-            }
-            if let Some(t) = sorted_ticks.get(i + 1) {
-                if t.index <= tick {
-                    return Err(MevCapturePoolConstructionError::InvalidCurrentTick);
-                }
+            if let Some(t) = sorted_ticks.get(i)
+                && t.index > tick
+            {
+                return Err(MevCapturePoolConstructionError::InvalidCurrentTick);
             }
-        } else if let Some(t) = concentrated_pool.ticks().first() {
-            if t.index <= tick {
+            if let Some(t) = sorted_ticks.get(i + 1)
+                && t.index <= tick
+            {
                 return Err(MevCapturePoolConstructionError::InvalidCurrentTick);
             }
+        } else if let Some(t) = concentrated_pool.ticks().first()
+            && t.index <= tick
+        {
+            return Err(MevCapturePoolConstructionError::InvalidCurrentTick);
         }
 
         Ok(Self {

src/quoting/pools/oracle.rs

@@ -197,13 +197,13 @@ mod tests {
     use super::*;
     use crate::{
         chain::{
+            Chain,
             starknet::{
-                Starknet, STARKNET_MAX_SQRT_RATIO_AT_MAX_TICK_SPACING,
-                STARKNET_MAX_TICK_AT_MAX_TICK_SPACING, STARKNET_MIN_SQRT_RATIO_AT_MAX_TICK_SPACING,
-                STARKNET_MIN_TICK_AT_MAX_TICK_SPACING,
+                STARKNET_MAX_SQRT_RATIO_AT_MAX_TICK_SPACING, STARKNET_MAX_TICK_AT_MAX_TICK_SPACING,
+                STARKNET_MIN_SQRT_RATIO_AT_MAX_TICK_SPACING, STARKNET_MIN_TICK_AT_MAX_TICK_SPACING,
+                Starknet,
             },
-            tests::{chain_test, ChainTest},
-            Chain,
+            tests::{ChainTest, chain_test},
         },
         math::tick::to_sqrt_ratio,
         quoting::types::{Pool, PoolState, QuoteParams, TokenAmount},

src/quoting/pools/spline.rs

@@ -1,5 +1,5 @@
 use crate::{
-    chain::{starknet::Starknet, Chain},
+    chain::{Chain, starknet::Starknet},
     quoting::pools::concentrated::{
         ConcentratedPool, ConcentratedPoolConstructionError, ConcentratedPoolKey,
         ConcentratedPoolQuoteError, ConcentratedPoolResources, ConcentratedPoolState,

src/quoting/pools/stableswap.rs

@@ -1,17 +1,17 @@
-use crate::{
-    chain::evm::{Evm, EVM_MAX_STABLESWAP_AMPLIFICATION_FACTOR},
-    math::swap::{compute_step, is_price_increasing, ComputeStepError},
-    private,
-    quoting::pools::full_range::FullRangePoolState,
-};
 use crate::{
     chain::Chain,
     math::tick::to_sqrt_ratio,
     quoting::pools::{
-        ensure_valid_token_order, is_token1, CommonPoolConstructionError, CommonPoolQuoteError,
+        CommonPoolConstructionError, CommonPoolQuoteError, ensure_valid_token_order, is_token1,
     },
     quoting::types::{Pool, PoolConfig, PoolKey, Quote, QuoteParams, TokenAmount},
 };
+use crate::{
+    chain::evm::{EVM_MAX_STABLESWAP_AMPLIFICATION_FACTOR, Evm},
+    math::swap::{ComputeStepError, compute_step, is_price_increasing},
+    private,
+    quoting::pools::full_range::FullRangePoolState,
+};
 use derive_more::{Add, AddAssign, Sub, SubAssign};
 use ruint::aliases::U256;
 use thiserror::Error;

src/quoting/pools/twamm.rs

@@ -416,7 +416,7 @@ mod tests {
     use crate::{
         chain::{
             evm::Evm,
-            tests::{run_for_all_chains, ChainEnum, ChainTest},
+            tests::{ChainEnum, ChainTest, run_for_all_chains},
         },
         math::tick::to_sqrt_ratio,
         quoting::types::{Pool, QuoteParams, TokenAmount},

src/quoting/util.rs

@@ -194,7 +194,7 @@ pub fn real_last_time(current: u64, stored: u32) -> u64 {
 mod tests {
     use super::*;
     use crate::{
-        chain::{tests::run_for_all_chains, Chain},
+        chain::{Chain, tests::run_for_all_chains},
         math::tick::to_sqrt_ratio,
         quoting::types::Tick,
     };