Merge pull request #126 from Kenlachy/feat/52-single-pool-pause

feat: add single-pool pausing capability for incident response (#52)

Author: AlAfiz

contracts/lending_pool/src/lib.rs

@@ -22,8 +22,9 @@ pub enum Error {
     CannotLiquidateHealthyLoan = 8,
     Unauthorized = 9,
     MathOverflow = 10,
-    EmptyPool = 11,
-    TradeSizeTooLarge = 12,
+    PoolIsPaused = 11,
+    EmptyPool = 12,
+    TradeSizeTooLarge = 13,
 }
 
 #[contracttype]
@@ -166,7 +167,9 @@ impl LendingPool {
 
     // 3. SWAP / BORROW: Withdraw/Borrow against an invoice (Simplified with max trade protection)
     pub fn swap(env: Env, user: Address, amount_in: i128) -> Result<(), Error> {
-        Self::check_paused(&env);
+        if env.storage().instance().get(&DataKey::Paused).unwrap_or(false) {
+            return Err(Error::PoolIsPaused);
+        }
         user.require_auth();
 
         // 1. Check total pool reserves

lib.rs

@@ -1,13 +1,22 @@
 #![no_std]
 
-use soroban_sdk::{contract, contractimpl, contracttype, symbol_short, Address, Bytes, BytesN, Env, Map};
+use soroban_sdk::{contract, contractimpl, contracttype, symbol_short, Address, Bytes, BytesN, Env, Map, Symbol, vec};
 
 mod tests;
 
+#[contracttype]
+#[derive(Clone)]
+pub struct Pool {
+    pub address: Address,
+    pub token_a: Address,
+    pub token_b: Address,
+    pub paused: bool,
+}
+
 #[contracttype]
 pub enum DataKey {
     FeeTo, // The address that receives protocol fees
-    Pools, // Map of (TokenA, TokenB) -> PoolAddress
+    Pools, // Map of (TokenA, TokenB) -> Pool
     PoolWasmHash, // The Wasm hash of the Pool contract to deploy
     Admin, // The address of the factory admin
 }
@@ -49,10 +58,10 @@ impl FactoryContract {
     /// Returns the address of the liquidity pool for a given pair of tokens.
     pub fn get_pool(env: Env, token_a: Address, token_b: Address) -> Option<Address> {
         let sorted_tokens = Self::sort_tokens(token_a, token_b);
-        let pools: Map<(Address, Address), Address> =
+        let pools: Map<(Address, Address), Pool> =
             env.storage().instance().get(&DataKey::Pools).unwrap_or_else(|| Map::new(&env));
 
-        pools.get(sorted_tokens)
+        pools.get(sorted_tokens).map(|p| p.address)
     }
 
     /// Deploys a new liquidity pool for the given token pair.
@@ -71,7 +80,7 @@ impl FactoryContract {
 
         let (token_0, token_1) = Self::sort_tokens(token_a, token_b);
 
-        let mut pools: Map<(Address, Address), Address> =
+        let mut pools: Map<(Address, Address), Pool> =
             env.storage().instance().get(&DataKey::Pools).unwrap_or(Map::new(&env));
 
         if pools.contains_key((token_0.clone(), token_1.clone())) {
@@ -92,7 +101,14 @@ impl FactoryContract {
         let pool_address = env.deployer().with_current_contract(salt).deploy(wasm_hash);
 
         // Store the new pool
-        pools.set((token_0, token_1), pool_address.clone());
+        let pool = Pool {
+            address: pool_address.clone(),
+            token_a: token_0.clone(),
+            token_b: token_1.clone(),
+            paused: false,
+        };
+
+        pools.set((token_0, token_1), pool);
         env.storage().instance().set(&DataKey::Pools, &pools);
 
         pool_address
@@ -125,22 +141,29 @@ impl FactoryContract {
     /// * `token_a` - The first token of the pair.
     /// * `token_b` - The second token of the pair.
     /// * `status` - The new status (e.g., 0 = Paused, 1 = Active).
-    pub fn toggle_pool_status(env: Env, token_a: Address, token_b: Address, status: u32) {
+    pub fn toggle_pool_status(env: Env, token_a: Address, token_b: Address) {
         let admin: Address = env.storage().instance().get(&DataKey::Admin).expect("Not initialized");
         admin.require_auth();
 
-        // Verify pool exists
-        let pool_addr = Self::get_pool(env.clone(), token_a.clone(), token_b.clone());
-        if pool_addr.is_none() {
-            panic!("Pool does not exist");
-        }
+        let sorted_tokens = Self::sort_tokens(token_a.clone(), token_b.clone());
+        let mut pools: Map<(Address, Address), Pool> =
+            env.storage().instance().get(&DataKey::Pools).unwrap_or_else(|| Map::new(&env));
+
+        let mut pool = pools.get(sorted_tokens.clone()).expect("Pool does not exist");
+        
+        // Toggle the paused state
+        pool.paused = !pool.paused;
+        
+        // Invoke the pool contract to update its internal pause state
+        let args = vec![&env, pool.paused.into()];
+        env.invoke_contract::<()>(&pool.address, &Symbol::new(&env, "set_paused"), args);
+
+        pools.set(sorted_tokens, pool.clone());
+        env.storage().instance().set(&DataKey::Pools, &pools);
 
-        // Emit event: ("Admin", "PoolStatus", token_a, token_b) -> status
-        // Note: The factory doesn't store the status locally in this implementation,
-        // but emits the event for indexers and transparency.
         env.events().publish(
             (symbol_short!("Admin"), symbol_short!("PoolStatus"), token_a, token_b),
-            status
+            pool.paused
         );
     }
 }