Merge pull request #13 from SorellaLabs/feat/l2-factory

feat: l2 factory

Author: Will-Smith11

.github/workflows/ci.yml

@@ -134,6 +134,6 @@ jobs:
           ${{ runner.os }}-cargo-
 
     - name: Run integration tests
-      run: cargo test --features integration
+      run: cargo test -p uni-v4
       env:
         SKIP_INTEGRATION_TESTS: false

crates/uni-v4-structure/src/fee_config.rs

@@ -24,7 +24,9 @@ pub struct L2FeeConfiguration {
     pub protocol_tax_fee_e6:    u32,
     pub creator_swap_fee_e6:    u32,
     pub protocol_swap_fee_e6:   u32,
-    pub priority_fee_tax_floor: u128
+    pub priority_fee_tax_floor: u128,
+    pub jit_tax_enabled:        bool,
+    pub withdraw_only:          bool
 }
 
 pub trait FeeConfig:
@@ -49,6 +51,10 @@ pub trait FeeConfig:
     /// - L2: swap_fee (0) + protocol_fee (creator + protocol swap fees)
     fn fee(&self, bundle: bool) -> u32;
 
+    fn priority_fee_tax_floor(&self) -> u128 {
+        0
+    }
+
     fn update_fees(&mut self, update: Self::Update);
 
     /// Calculate MEV tax given a priority fee in wei.
@@ -110,21 +116,26 @@ impl FeeConfig for L2FeeConfiguration {
         self.swap_fee() + self.protocol_fee()
     }
 
-    fn update_fees(&mut self, update: Self::Update) {
-        let Self::Update { protocol_tax_fee_e6, protocol_swap_fee_e6, priority_fee_tax_floor } =
-            update;
+    fn priority_fee_tax_floor(&self) -> u128 {
+        self.priority_fee_tax_floor
+    }
 
-        if let Some(fee) = protocol_tax_fee_e6 {
+    fn update_fees(&mut self, update: Self::Update) {
+        if let Some(fee) = update.protocol_tax_fee_e6 {
             self.protocol_tax_fee_e6 = fee;
         }
-
-        if let Some(fee) = protocol_swap_fee_e6 {
+        if let Some(fee) = update.protocol_swap_fee_e6 {
             self.protocol_swap_fee_e6 = fee;
         }
-
-        if let Some(floor) = priority_fee_tax_floor {
+        if let Some(floor) = update.priority_fee_tax_floor {
             self.priority_fee_tax_floor = floor;
         }
+        if let Some(enabled) = update.jit_tax_enabled {
+            self.jit_tax_enabled = enabled;
+        }
+        if let Some(wo) = update.withdraw_only {
+            self.withdraw_only = wo;
+        }
     }
 
     fn mev_tax(&self, priority_fee_wei: u128) -> u128 {
@@ -148,7 +159,9 @@ pub struct L1FeeUpdate {
 pub struct L2FeeUpdate {
     pub protocol_tax_fee_e6:    Option<u32>,
     pub protocol_swap_fee_e6:   Option<u32>,
-    pub priority_fee_tax_floor: Option<u128>
+    pub priority_fee_tax_floor: Option<u128>,
+    pub jit_tax_enabled:        Option<bool>,
+    pub withdraw_only:          Option<bool>
 }
 
 #[cfg(test)]
@@ -162,7 +175,9 @@ mod tests {
             protocol_tax_fee_e6:    2000,
             creator_swap_fee_e6:    3000,
             protocol_swap_fee_e6:   4000,
-            priority_fee_tax_floor: floor
+            priority_fee_tax_floor: floor,
+            jit_tax_enabled:        false,
+            withdraw_only:          false
         }
     }
 
@@ -210,7 +225,9 @@ mod tests {
         cfg.update_fees(L2FeeUpdate {
             protocol_tax_fee_e6:    None,
             protocol_swap_fee_e6:   None,
-            priority_fee_tax_floor: Some(42)
+            priority_fee_tax_floor: Some(42),
+            jit_tax_enabled:        None,
+            withdraw_only:          None
         });
         assert_eq!(cfg.priority_fee_tax_floor, 42);
     }
@@ -221,7 +238,9 @@ mod tests {
         cfg.update_fees(L2FeeUpdate {
             protocol_tax_fee_e6:    Some(9999),
             protocol_swap_fee_e6:   None,
-            priority_fee_tax_floor: None
+            priority_fee_tax_floor: None,
+            jit_tax_enabled:        None,
+            withdraw_only:          None
         });
         assert_eq!(cfg.priority_fee_tax_floor, 100);
         assert_eq!(cfg.protocol_tax_fee_e6, 9999);
@@ -233,10 +252,14 @@ mod tests {
         cfg.update_fees(L2FeeUpdate {
             protocol_tax_fee_e6:    Some(111),
             protocol_swap_fee_e6:   Some(222),
-            priority_fee_tax_floor: Some(333)
+            priority_fee_tax_floor: Some(333),
+            jit_tax_enabled:        Some(true),
+            withdraw_only:          Some(true)
         });
         assert_eq!(cfg.protocol_tax_fee_e6, 111);
         assert_eq!(cfg.protocol_swap_fee_e6, 222);
         assert_eq!(cfg.priority_fee_tax_floor, 333);
+        assert!(cfg.jit_tax_enabled);
+        assert!(cfg.withdraw_only);
     }
 }

crates/uni-v4-structure/src/l2/pool_updates.rs

@@ -17,7 +17,9 @@ pub enum L2PoolUpdate {
         tick_spacing:           i32,
         hook:                   Address,
         block:                  u64,
-        priority_fee_tax_floor: u128
+        priority_fee_tax_floor: u128,
+        jit_tax_enabled:        bool,
+        withdraw_only:          bool
     }
 }
 

crates/uni-v4-upkeeper/src/l2/pool_manager_service.rs

@@ -1,10 +1,11 @@
+use alloy_primitives::aliases::{I24, U24};
 use alloy_provider::Provider;
 use futures::Stream;
 use op_alloy_network::Optimism;
 use uni_v4_common::PoolUpdate;
 use uni_v4_structure::{
-    L2FeeConfiguration, PoolId, l2_structure::pool_updates::L2PoolUpdate,
-    pool_registry::PoolRegistry, pool_updates::Slot0Update
+    L2FeeConfiguration, PoolId, PoolKey, l2_structure::pool_updates::L2PoolUpdate,
+    pool_updates::Slot0Update
 };
 
 use crate::{
@@ -26,32 +27,41 @@ where
         match update {
             L2PoolUpdate::NewPool {
                 pool_id,
+                token0,
+                token1,
+                hook,
+                hook_fee,
+                tick_spacing,
                 block,
                 creator_tax_fee_e6,
                 protocol_tax_fee_e6,
                 creator_swap_fee_e6,
                 protocol_swap_fee_e6,
                 priority_fee_tax_floor,
+                jit_tax_enabled,
+                withdraw_only,
                 ..
             } => {
                 if self.auto_pool_creation {
+                    let pool_key = PoolKey {
+                        currency0:   *token0,
+                        currency1:   *token1,
+                        fee:         U24::from(*hook_fee),
+                        tickSpacing: I24::unchecked_from(*tick_spacing),
+                        hooks:       *hook
+                    };
                     let fee_cfg = L2FeeConfiguration {
                         is_initialized:         true,
                         creator_tax_fee_e6:     *creator_tax_fee_e6,
                         protocol_tax_fee_e6:    *protocol_tax_fee_e6,
                         creator_swap_fee_e6:    *creator_swap_fee_e6,
                         protocol_swap_fee_e6:   *protocol_swap_fee_e6,
-                        priority_fee_tax_floor: *priority_fee_tax_floor
+                        priority_fee_tax_floor: *priority_fee_tax_floor,
+                        jit_tax_enabled:        *jit_tax_enabled,
+                        withdraw_only:          *withdraw_only
                     };
-                    // Reconstruct pool_key from the NewPool data
-                    // We need to get the pool_key from the registry
-                    if let Some(pool_key) = self.factory.registry().get(pool_id) {
-                        self.handle_new_pool(*pool_key, *block, fee_cfg);
-
-                        tracing::info!("Pool configured: {pool_id:?}:\n{fee_cfg:?}",);
-                    } else {
-                        tracing::warn!("Pool {:?} not found in registry", pool_id);
-                    }
+                    self.handle_new_pool(pool_key, *block, fee_cfg);
+                    tracing::info!("Pool configured: {pool_id:?}:\n{fee_cfg:?}");
                 } else {
                     tracing::info!(
                         "Ignoring pool configured event (auto creation disabled): {:?}",