Merge pull request #118 from tx-cyber/main

feat: trigger escrow freeze on dispute and implement arbitrator resolution controls

Author: Tybravo

contracts/dispute_resolution_contract/lib.rs

@@ -134,6 +134,10 @@ impl DisputeResolutionContract {
             }
         }
 
+        let escrow_addr = Self::get_escrow_contract(env.clone());
+        let escrow_client = escrow_contract::EscrowContractClient::new(&env, &escrow_addr);
+        escrow_client.freeze_funds(&u64::from(delivery_id));
+
         let dispute_key = DataKey::Dispute(delivery_id);
         if env.storage().persistent().has(&dispute_key) {
             panic_with_error!(&env, SwiftChainError::DuplicateDelivery);
@@ -284,6 +288,47 @@ impl DisputeResolutionContract {
         );
     }
 
+    pub fn resolve_dispute_pay_driver(env: Env, caller: Address, delivery_id: DeliveryId) {
+        caller.require_auth();
+        if !Self::is_admin(env.clone(), caller.clone()) {
+            panic_with_error!(&env, SwiftChainError::Unauthorized);
+        }
+
+        let dispute_key = DataKey::Dispute(delivery_id);
+        let mut dispute: DisputeCase = env
+            .storage()
+            .persistent()
+            .get(&dispute_key)
+            .unwrap_or_else(|| panic_with_error!(&env, SwiftChainError::DeliveryNotFound));
+
+        if dispute.status != DisputeStatus::Open {
+            panic_with_error!(&env, SwiftChainError::InvalidState);
+        }
+
+        dispute.status = DisputeStatus::ResolvedPayout;
+        env.storage().persistent().set(&dispute_key, &dispute);
+        env.storage().persistent().extend_ttl(&dispute_key, 518400, 518400);
+
+        let escrow_addr = Self::get_escrow_contract(env.clone());
+        
+        use soroban_sdk::IntoVal;
+        let _: () = env.invoke_contract(
+            &escrow_addr,
+            &Symbol::new(&env, "resolve_dispute"),
+            soroban_sdk::vec![
+                &env,
+                caller.into_val(&env),
+                u64::from(delivery_id).into_val(&env),
+                true.into_val(&env),
+            ],
+        );
+
+        env.events().publish(
+            (Symbol::new(&env, "dispute_resolved_payout"), delivery_id),
+            (caller, delivery_id),
+        );
+    }
+
     pub fn get_dispute(env: Env, delivery_id: DeliveryId) -> DisputeCase {
         let dispute_key = DataKey::Dispute(delivery_id);
         env.storage()

contracts/dispute_resolution_contract/test.rs

@@ -77,6 +77,15 @@ impl MockEscrowContract {
             env.storage().instance().set(&delivery_id, &record);
         }
     }
+
+    pub fn freeze_funds(env: Env, delivery_id: u64) {
+        if env.storage().instance().has(&delivery_id) {
+            let mut record: shared_types::EscrowRecord =
+                env.storage().instance().get(&delivery_id).unwrap();
+            record.status = shared_types::EscrowStatus::Paused;
+            env.storage().instance().set(&delivery_id, &record);
+        }
+    }
 }
 
 fn setup_test() -> (
@@ -250,6 +259,10 @@ fn test_raise_dispute_active_delivery() {
     let delivery = MockDeliveryContractClient::new(&env, &delivery_id).get_delivery(&did(1));
     assert_eq!(delivery.status, delivery_contract::DeliveryStatus::Disputed);
 
+    // Verify escrow status changed to Paused in MockEscrowContract
+    let escrow = MockEscrowContractClient::new(&env, &escrow_id).get_escrow(&1);
+    assert_eq!(escrow.status, shared_types::EscrowStatus::Paused);
+
     // Verify local dispute case in DisputeResolutionContract
     let case = dispute_client.get_dispute(&did(1));
     assert_eq!(case.delivery_id, did(1));
@@ -472,3 +485,49 @@ fn test_integration_resolve_dispute_split_funds() {
     assert_eq!(sender_balance, 600); // 60% of 1000 refunded
     assert_eq!(driver_balance, 400); // 40% of 1000 paid to driver
 }
+
+#[test]
+fn test_resolve_dispute_pay_driver_by_admin() {
+    let (env, admin, sender, recipient, driver, delivery_id, escrow_id, dispute_client) = setup_test();
+
+    // Setup mock delivery
+    let delivery_record = create_mock_delivery_record(&env, did(8), sender.clone(), recipient.clone(), delivery_contract::DeliveryStatus::Active, None);
+    set_mock_delivery(&env, &delivery_id, did(8), &delivery_record);
+
+    // Setup mock escrow as Paused (representing escrow paused after dispute raised)
+    let token = Address::generate(&env);
+    let escrow_record = create_mock_escrow_record(sender.clone(), recipient.clone(), driver.clone(), token, shared_types::EscrowStatus::Paused);
+    set_mock_escrow(&env, &escrow_id, 8, &escrow_record);
+
+    // Raise dispute to initialize local dispute case
+    dispute_client.raise_dispute(&sender, &did(8));
+
+    // Resolve dispute
+    dispute_client.resolve_dispute_pay_driver(&admin, &did(8));
+
+    // Verify local dispute status is ResolvedPayout
+    let case = dispute_client.get_dispute(&did(8));
+    assert_eq!(case.status, DisputeStatus::ResolvedPayout);
+
+    // Verify mock escrow status updated to Released
+    let escrow = MockEscrowContractClient::new(&env, &escrow_id).get_escrow(&8);
+    assert_eq!(escrow.status, shared_types::EscrowStatus::Released);
+}
+
+#[test]
+#[should_panic(expected = "HostError: Error(Contract, #1)")] // SwiftChainError::Unauthorized
+fn test_unauthorized_resolve_pay_driver_fails() {
+    let (env, _admin, sender, recipient, driver, delivery_id, escrow_id, dispute_client) = setup_test();
+
+    let delivery_record = create_mock_delivery_record(&env, did(9), sender.clone(), recipient.clone(), delivery_contract::DeliveryStatus::Active, None);
+    set_mock_delivery(&env, &delivery_id, did(9), &delivery_record);
+
+    let token = Address::generate(&env);
+    let escrow_record = create_mock_escrow_record(sender.clone(), recipient.clone(), driver.clone(), token, shared_types::EscrowStatus::Paused);
+    set_mock_escrow(&env, &escrow_id, 9, &escrow_record);
+
+    dispute_client.raise_dispute(&sender, &did(9));
+
+    // Attacker (sender) tries to resolve dispute pay driver
+    dispute_client.resolve_dispute_pay_driver(&sender, &did(9));
+}

contracts/escrow_contract/lib.rs

@@ -495,6 +495,15 @@ impl EscrowContract {
         }
         load_escrow(&env, delivery_id)
     }
+
+    pub fn freeze_funds(env: Env, delivery_id: u64) {
+        let mut record = load_escrow(&env, delivery_id);
+        if record.status == EscrowStatus::Locked {
+            record.status = EscrowStatus::Paused;
+            record.disputed_at = Some(env.ledger().timestamp());
+            save_escrow(&env, delivery_id, &record);
+        }
+    }
 }
 
 #[cfg(test)]