Expose more useful bitmap resources & rename base pool to concentrated pool

src/chain/evm.rs

@@ -11,10 +11,6 @@ type U96 = ruint::Uint<96, 2>;
 #[cfg(feature = "evm-alloy-1")]
 use crate::alloy_primitives::aliases::U96;
 use crate::private;
-use crate::quoting::pools::base::{
-    BasePool, BasePoolConfig, BasePoolConstructionError, BasePoolKey, BasePoolQuoteError,
-    BasePoolResources, BasePoolState, BasePoolTypeConfig, TickSpacing,
-};
 use crate::quoting::pools::boosted_fees::concentrated::{
     BoostedFeesConcentratedPool, BoostedFeesConcentratedPoolConfig,
     BoostedFeesConcentratedPoolConstructionError, BoostedFeesConcentratedPoolKey,
@@ -34,6 +30,11 @@ use crate::quoting::pools::boosted_fees::stableswap::{
     BoostedFeesStableswapPoolQuoteError, BoostedFeesStableswapPoolResources,
     BoostedFeesStableswapPoolState, BoostedFeesStableswapPoolTypeConfig,
 };
+use crate::quoting::pools::concentrated::{
+    ConcentratedPool, ConcentratedPoolConfig, ConcentratedPoolConstructionError,
+    ConcentratedPoolKey, ConcentratedPoolQuoteError, ConcentratedPoolResources,
+    ConcentratedPoolState, ConcentratedPoolTypeConfig, TickSpacing,
+};
 use crate::quoting::pools::full_range::{
     FullRangePool, FullRangePoolConfig, FullRangePoolConstructionError, FullRangePoolKey,
     FullRangePoolQuoteError, FullRangePoolResources, FullRangePoolState, FullRangePoolTypeConfig,
@@ -59,14 +60,14 @@ use crate::quoting::pools::twamm::{
 use crate::quoting::types::{PoolConfig, PoolKey, TokenAmount};
 
 // Re-export pool types for ergonomic, chain-scoped usage.
-pub type EvmBasePool = BasePool<Evm>;
-pub type EvmBasePoolConstructionError = BasePoolConstructionError;
-pub type EvmBasePoolConfig = BasePoolConfig<Evm>;
-pub type EvmBasePoolKey = BasePoolKey<Evm>;
-pub type EvmBasePoolQuoteError = BasePoolQuoteError;
-pub type EvmBasePoolResources = BasePoolResources;
-pub type EvmBasePoolState = BasePoolState;
-pub type EvmBasePoolTypeConfig = BasePoolTypeConfig;
+pub type EvmConcentratedPool = ConcentratedPool<Evm>;
+pub type EvmConcentratedPoolConstructionError = ConcentratedPoolConstructionError;
+pub type EvmConcentratedPoolConfig = ConcentratedPoolConfig<Evm>;
+pub type EvmConcentratedPoolKey = ConcentratedPoolKey<Evm>;
+pub type EvmConcentratedPoolQuoteError = ConcentratedPoolQuoteError;
+pub type EvmConcentratedPoolResources = ConcentratedPoolResources;
+pub type EvmConcentratedPoolState = ConcentratedPoolState;
+pub type EvmConcentratedPoolTypeConfig = ConcentratedPoolTypeConfig;
 
 pub type EvmFullRangePool = FullRangePool;
 pub type EvmFullRangePoolConstructionError = FullRangePoolConstructionError;
@@ -90,7 +91,7 @@ pub type EvmMevCapturePool = MevCapturePool;
 pub type EvmMevCapturePoolConstructionError = MevCapturePoolConstructionError;
 pub type EvmMevCapturePoolConfig = MevCapturePoolConfig;
 pub type EvmMevCapturePoolKey = MevCapturePoolKey;
-pub type EvmMevCapturePoolQuoteError = BasePoolQuoteError;
+pub type EvmMevCapturePoolQuoteError = ConcentratedPoolQuoteError;
 pub type EvmMevCapturePoolResources = MevCapturePoolResources;
 pub type EvmMevCaptureStandalonePoolResources = MevCaptureStandalonePoolResources;
 pub type EvmMevCapturePoolState = MevCapturePoolState;
@@ -190,7 +191,7 @@ pub enum EvmPoolTypeConfig {
     /// Stableswap config for pegged assets.
     Stableswap(StableswapPoolTypeConfig),
     /// Concentrated liquidity config (tick spacing).
-    Concentrated(BasePoolTypeConfig),
+    Concentrated(ConcentratedPoolTypeConfig),
 }
 
 #[cfg(feature = "evm-alloy-1")]

src/chain/mod.rs

@@ -1,6 +1,6 @@
 use crate::{
     private,
-    quoting::{pools::base::TickSpacing, types::Pool},
+    quoting::{pools::concentrated::TickSpacing, types::Pool},
 };
 use core::hash::Hash;
 use core::{

src/chain/starknet.rs

@@ -6,9 +6,10 @@ use thiserror::Error;
 
 use crate::chain::Chain;
 use crate::private;
-use crate::quoting::pools::base::{
-    BasePool, BasePoolConfig, BasePoolConstructionError, BasePoolKey, BasePoolQuoteError,
-    BasePoolResources, BasePoolState, BasePoolTypeConfig, TickSpacing,
+use crate::quoting::pools::concentrated::{
+    ConcentratedPool, ConcentratedPoolConfig, ConcentratedPoolConstructionError,
+    ConcentratedPoolKey, ConcentratedPoolQuoteError, ConcentratedPoolResources,
+    ConcentratedPoolState, ConcentratedPoolTypeConfig, TickSpacing,
 };
 use crate::quoting::pools::limit_order::{
     LimitOrderPool, LimitOrderPoolConfig, LimitOrderPoolConstructionError, LimitOrderPoolKey,
@@ -29,20 +30,20 @@ use crate::quoting::pools::twamm::{
 use crate::quoting::types::{PoolConfig, PoolKey, Tick, TokenAmount};
 
 // Re-export pool types for ergonomic, chain-scoped usage.
-pub type StarknetBasePool = BasePool<Starknet>;
-pub type StarknetBasePoolConstructionError = BasePoolConstructionError;
-pub type StarknetBasePoolConfig = BasePoolConfig<Starknet>;
-pub type StarknetBasePoolKey = BasePoolKey<Starknet>;
-pub type StarknetBasePoolQuoteError = BasePoolQuoteError;
-pub type StarknetBasePoolResources = BasePoolResources;
-pub type StarknetBasePoolState = BasePoolState;
-pub type StarknetBasePoolTypeConfig = BasePoolTypeConfig;
+pub type StarknetConcentratedPool = ConcentratedPool<Starknet>;
+pub type StarknetConcentratedPoolConstructionError = ConcentratedPoolConstructionError;
+pub type StarknetConcentratedPoolConfig = ConcentratedPoolConfig<Starknet>;
+pub type StarknetConcentratedPoolKey = ConcentratedPoolKey<Starknet>;
+pub type StarknetConcentratedPoolQuoteError = ConcentratedPoolQuoteError;
+pub type StarknetConcentratedPoolResources = ConcentratedPoolResources;
+pub type StarknetConcentratedPoolState = ConcentratedPoolState;
+pub type StarknetConcentratedPoolTypeConfig = ConcentratedPoolTypeConfig;
 
 pub type StarknetLimitOrderPool = LimitOrderPool;
 pub type StarknetLimitOrderPoolConstructionError = LimitOrderPoolConstructionError;
 pub type StarknetLimitOrderPoolConfig = LimitOrderPoolConfig;
 pub type StarknetLimitOrderPoolKey = LimitOrderPoolKey;
-pub type StarknetLimitOrderPoolQuoteError = BasePoolQuoteError;
+pub type StarknetLimitOrderPoolQuoteError = ConcentratedPoolQuoteError;
 pub type StarknetLimitOrderPoolResources = LimitOrderPoolResources;
 pub type StarknetLimitOrderStandalonePoolResources = LimitOrderStandalonePoolResources;
 pub type StarknetLimitOrderPoolState = LimitOrderPoolState;
@@ -52,14 +53,14 @@ pub type StarknetOraclePoolConstructionError =
     OraclePoolConstructionError<FullRangePoolConstructionError>;
 pub type StarknetOraclePoolConfig = OraclePoolConfig<Starknet>;
 pub type StarknetOraclePoolKey = OraclePoolKey<Starknet>;
-pub type StarknetOraclePoolQuoteError = BasePoolQuoteError;
-pub type StarknetOraclePoolResources = OraclePoolResources<BasePoolResources>;
+pub type StarknetOraclePoolQuoteError = ConcentratedPoolQuoteError;
+pub type StarknetOraclePoolResources = OraclePoolResources<ConcentratedPoolResources>;
 pub type StarknetOracleStandalonePoolResources = OracleStandalonePoolResources;
-pub type StarknetOraclePoolState = OraclePoolState<BasePoolState>;
+pub type StarknetOraclePoolState = OraclePoolState<ConcentratedPoolState>;
 pub type StarknetOraclePoolTypeConfig = OraclePoolTypeConfig<Starknet>;
 
 pub type StarknetSplinePool = SplinePool;
-pub type StarknetSplinePoolConstructionError = BasePoolConstructionError;
+pub type StarknetSplinePoolConstructionError = ConcentratedPoolConstructionError;
 pub type StarknetSplinePoolConfig = SplinePoolConfig;
 pub type StarknetSplinePoolKey = SplinePoolKey;
 pub type StarknetSplinePoolResources = SplinePoolResources;
@@ -71,10 +72,10 @@ pub type StarknetTwammPoolConstructionError =
     TwammPoolConstructionError<FullRangePoolConstructionError>;
 pub type StarknetTwammPoolConfig = TwammPoolConfig<Starknet>;
 pub type StarknetTwammPoolKey = TwammPoolKey<Starknet>;
-pub type StarknetTwammPoolQuoteError = TwammPoolQuoteError<BasePoolQuoteError>;
-pub type StarknetTwammPoolResources = TwammPoolResources<BasePoolResources>;
+pub type StarknetTwammPoolQuoteError = TwammPoolQuoteError<ConcentratedPoolQuoteError>;
+pub type StarknetTwammPoolResources = TwammPoolResources<ConcentratedPoolResources>;
 pub type StarknetTwammStandalonePoolResources = TwammStandalonePoolResources;
-pub type StarknetTwammPoolState = TwammPoolState<BasePoolState>;
+pub type StarknetTwammPoolState = TwammPoolState<ConcentratedPoolState>;
 pub type StarknetTwammPoolTypeConfig = TwammPoolTypeConfig<Starknet>;
 
 pub const STARKNET_MAX_TICK_SPACING: TickSpacing = TickSpacing(354892);
@@ -121,16 +122,16 @@ pub type StarknetTokenAmount = TokenAmount<<Starknet as Chain>::Address>;
 /// Errors constructing a Starknet full range pool from inputs.
 #[derive(Debug, PartialEq, Eq, Clone, Copy, Hash, Error)]
 pub enum FullRangePoolConstructionError {
-    #[error("base pool error")]
-    BasePoolConstructionError(#[from] BasePoolConstructionError),
+    #[error("concentrated pool error")]
+    ConcentratedPoolConstructionError(#[from] ConcentratedPoolConstructionError),
     #[error("active liquidity does not fit into signed integer")]
     ActiveLiquidityDoesNotFitSignedInteger,
 }
 
 impl Chain for Starknet {
     type Fee = u128;
 
-    type FullRangePool = BasePool<Self>;
+    type FullRangePool = ConcentratedPool<Self>;
     type FullRangePoolConstructionError = FullRangePoolConstructionError;
 
     fn max_tick_spacing() -> TickSpacing {
@@ -218,20 +219,20 @@ impl Chain for Starknet {
             extension,
         };
 
-        BasePool::new(
+        ConcentratedPool::new(
             PoolKey {
                 token0,
                 token1,
                 config,
             },
-            BasePoolState {
+            ConcentratedPoolState {
                 sqrt_ratio,
                 liquidity,
                 active_tick_index,
             },
             sorted_ticks,
         )
-        .map_err(FullRangePoolConstructionError::BasePoolConstructionError)
+        .map_err(FullRangePoolConstructionError::ConcentratedPoolConstructionError)
     }
 
     type Address = Felt;

src/math/facade.rs

@@ -1,16 +1,5 @@
 //! Thin facades over std/libm so float operations work in `no_std` mode.
 use ruint::aliases::U256;
-#[inline]
-pub fn ln(value: f64) -> f64 {
-    #[cfg(feature = "std")]
-    {
-        value.ln()
-    }
-    #[cfg(feature = "no_std")]
-    {
-        libm::log(value)
-    }
-}
 
 #[inline]
 pub fn log_base(value: f64, base: f64) -> f64 {
@@ -20,7 +9,7 @@ pub fn log_base(value: f64, base: f64) -> f64 {
     }
     #[cfg(feature = "no_std")]
     {
-        ln(value) / ln(base)
+        libm::log(value) / libm::log(base)
     }
 }
 

src/math/uint.rs

@@ -8,3 +8,37 @@ pub fn u256_to_float_base_x128(x128: U256) -> f64 {
         + l2 as f64
         + (l3 as f64 * 18446744073709551616f64)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn u256_to_fraction() {
+        assert_eq!(
+            u256_to_float_base_x128(U256::from_limbs([
+                16403144882676588163,
+                1525053501570699700,
+                35,
+                0
+            ])),
+            35.08267331597798
+        );
+        assert_eq!(
+            u256_to_float_base_x128(U256::from_limbs([123456, 0, 0, 0])),
+            3.628045764377908e-34
+        );
+        assert_eq!(
+            u256_to_float_base_x128(U256::from_limbs([0, 123456, 0, 0])),
+            6.692563170318522e-15
+        );
+        assert_eq!(
+            u256_to_float_base_x128(U256::from_limbs([0, 0, 123456, 0])),
+            123456.0
+        );
+        assert_eq!(
+            u256_to_float_base_x128(U256::from_limbs([0, 0, 0, 123456])),
+            2.2773612363638864e24
+        );
+    }
+}