refactor: add tests for dispute resolution and withdrawal rounding edge cases

Author: armandocodecr

contracts/escrow/src/tests/dispute.rs

@@ -1,6 +1,6 @@
 extern crate std;
 
-use crate::storage::types::{Escrow, Flags, Milestone, Roles, Trustline};
+use crate::storage::types::{Escrow, Flags, Milestone, MilestoneUpdate, Roles, Trustline};
 use soroban_sdk::{testutils::Address as _, vec, Address, Env, Map, String};
 
 use super::helpers::{create_escrow_contract, create_usdc_token};
@@ -578,3 +578,240 @@ fn test_change_dispute_flag_authorized_and_unauthorized() {
         "Unauthorized user should not be able to change dispute flag"
     );
 }
+
+#[test]
+fn test_resolve_dispute_rounding_edge_case() {
+    let env = Env::default();
+    env.mock_all_auths();
+
+    let admin = Address::generate(&env);
+    let approver = Address::generate(&env);
+    let service_provider = Address::generate(&env);
+    let platform = Address::generate(&env);
+    let release_signer = Address::generate(&env);
+    let dispute_resolver = Address::generate(&env);
+    let trustless_work_address = Address::generate(&env);
+
+    let usdc_token = create_usdc_token(&env, &admin);
+
+    // Use values where floor division rounding causes a mismatch:
+    // total = 100_003, TW fee (30 bps) = floor(100_003 * 30 / 10000) = 300,
+    // platform fee (300 bps) = floor(100_003 * 300 / 10000) = 3000,
+    // total_fees = 3300.
+    // Per-recipient floor shares: floor(50_001 * 3300 / 100_003) = 1649, floor(50_002 * 3300 / 100_003) = 1650
+    // sum(fee_shares) = 3299 < 3300, so the old code would over-distribute by 1.
+    let total: i128 = 100_003;
+    let platform_fee: u32 = 300; // 3%
+
+    let roles = Roles {
+        approver: approver.clone(),
+        service_provider: service_provider.clone(),
+        platform: platform.clone(),
+        release_signer: release_signer.clone(),
+        dispute_resolver: dispute_resolver.clone(),
+    };
+
+    let flags = Flags {
+        disputed: false,
+        released: false,
+        resolved: false,
+        approved: false,
+    };
+
+    let milestones = vec![
+        &env,
+        Milestone {
+            description: String::from_str(&env, "Milestone"),
+            status: String::from_str(&env, "Pending"),
+            evidence: String::from_str(&env, ""),
+            amount: total,
+            flags: flags.clone(),
+            receiver: service_provider.clone(),
+        },
+    ];
+
+    let escrow_properties = Escrow {
+        engagement_id: String::from_str(&env, "rounding_resolve"),
+        title: String::from_str(&env, "Rounding Test"),
+        description: String::from_str(&env, "Test floor division rounding in resolve_dispute"),
+        roles,
+        platform_fee,
+        milestones,
+        trustline: Trustline {
+            address: usdc_token.0.address.clone(),
+        },
+        receiver_memo: 0,
+    };
+
+    let test_data = create_escrow_contract(&env);
+    let client = test_data.client;
+
+    client.initialize_escrow(&escrow_properties);
+
+    // Fund the escrow with exactly total
+    usdc_token.1.mint(&client.address, &total);
+
+    // Put milestone in dispute
+    client.dispute_milestone(&0, &approver);
+
+    // Distributions that trigger the rounding mismatch
+    let mut distributions = Map::new(&env);
+    distributions.set(approver.clone(), 50_001);
+    distributions.set(service_provider.clone(), 50_002);
+
+    // This must NOT revert (old code would fail here due to insufficient balance)
+    let result = client.try_resolve_milestone_dispute(
+        &dispute_resolver,
+        &0,
+        &trustless_work_address,
+        &distributions,
+    );
+    assert!(result.is_ok(), "resolve_milestone_dispute should handle fee rounding correctly");
+
+    // Verify contract has no negative balance and all funds were distributed
+    let final_balance = usdc_token.0.balance(&client.address);
+    assert!(final_balance >= 0, "Contract balance must be non-negative");
+
+    // Verify the total outflows equal exactly the initial balance
+    let tw_balance = usdc_token.0.balance(&trustless_work_address);
+    let platform_balance = usdc_token.0.balance(&platform);
+    let approver_balance = usdc_token.0.balance(&approver);
+    let sp_balance = usdc_token.0.balance(&service_provider);
+
+    let total_outflow = tw_balance + platform_balance + approver_balance + sp_balance;
+    assert_eq!(
+        total_outflow + final_balance,
+        total,
+        "Sum of all outflows plus remaining balance must equal the original total"
+    );
+
+    // Verify dispute was resolved
+    let escrow = client.get_escrow();
+    let milestone = escrow.milestones.get(0).unwrap();
+    assert!(milestone.flags.resolved);
+    assert!(!milestone.flags.disputed);
+}
+
+#[test]
+fn test_withdraw_remaining_funds_rounding_edge_case() {
+    let env = Env::default();
+    env.mock_all_auths();
+
+    let admin = Address::generate(&env);
+    let approver = Address::generate(&env);
+    let service_provider = Address::generate(&env);
+    let platform = Address::generate(&env);
+    let release_signer = Address::generate(&env);
+    let dispute_resolver = Address::generate(&env);
+    let trustless_work_address = Address::generate(&env);
+    let recipient_a = Address::generate(&env);
+    let recipient_b = Address::generate(&env);
+
+    let usdc_token = create_usdc_token(&env, &admin);
+
+    let milestone_amount: i128 = 1_000_000;
+    let platform_fee: u32 = 300; // 3%
+
+    let roles = Roles {
+        approver: approver.clone(),
+        service_provider: service_provider.clone(),
+        platform: platform.clone(),
+        release_signer: release_signer.clone(),
+        dispute_resolver: dispute_resolver.clone(),
+    };
+
+    let flags = Flags {
+        disputed: false,
+        released: false,
+        resolved: false,
+        approved: false,
+    };
+
+    let milestones = vec![
+        &env,
+        Milestone {
+            description: String::from_str(&env, "Milestone"),
+            status: String::from_str(&env, "Pending"),
+            evidence: String::from_str(&env, ""),
+            amount: milestone_amount,
+            flags: flags.clone(),
+            receiver: service_provider.clone(),
+        },
+    ];
+
+    let escrow_properties = Escrow {
+        engagement_id: String::from_str(&env, "rounding_withdraw"),
+        title: String::from_str(&env, "Rounding Withdraw Test"),
+        description: String::from_str(&env, "Test floor division rounding in withdraw"),
+        roles,
+        platform_fee,
+        milestones: milestones.clone(),
+        trustline: Trustline {
+            address: usdc_token.0.address.clone(),
+        },
+        receiver_memo: 0,
+    };
+
+    let test_data = create_escrow_contract(&env);
+    let client = test_data.client;
+
+    client.initialize_escrow(&escrow_properties);
+
+    // Fund and go through the full release flow so withdraw_remaining_funds is allowed
+    usdc_token.1.mint(&client.address, &milestone_amount);
+
+    let milestone_updates = vec![
+        &env,
+        MilestoneUpdate {
+            index: 0,
+            status: String::from_str(&env, "Completed"),
+            evidence: Some(String::from_str(&env, "Done")),
+        },
+    ];
+    client.change_milestone_status(&milestone_updates, &service_provider);
+
+    client.approve_milestone(&0, &approver);
+
+    client.release_milestone_funds(&release_signer, &trustless_work_address, &0);
+
+    // Simulate remaining funds (e.g. from overfunding or rounding leftovers)
+    let remaining: i128 = 100_003;
+    usdc_token.1.mint(&client.address, &remaining);
+
+    let balance_before = usdc_token.0.balance(&client.address);
+
+    // Record initial balances
+    let tw_before = usdc_token.0.balance(&trustless_work_address);
+    let platform_before = usdc_token.0.balance(&platform);
+    let a_before = usdc_token.0.balance(&recipient_a);
+    let b_before = usdc_token.0.balance(&recipient_b);
+
+    // Distributions that trigger rounding mismatch
+    let mut distributions = Map::new(&env);
+    distributions.set(recipient_a.clone(), 50_001);
+    distributions.set(recipient_b.clone(), 50_002);
+
+    let result = client.try_withdraw_remaining_funds(
+        &dispute_resolver,
+        &trustless_work_address,
+        &distributions,
+    );
+    assert!(result.is_ok(), "withdraw_remaining_funds should handle fee rounding correctly");
+
+    // Verify the contract didn't underflow
+    let final_balance = usdc_token.0.balance(&client.address);
+    assert!(final_balance >= 0, "Contract balance must be non-negative");
+
+    // Verify total outflows from the withdraw operation
+    let tw_delta = usdc_token.0.balance(&trustless_work_address) - tw_before;
+    let platform_delta = usdc_token.0.balance(&platform) - platform_before;
+    let a_delta = usdc_token.0.balance(&recipient_a) - a_before;
+    let b_delta = usdc_token.0.balance(&recipient_b) - b_before;
+
+    let total_withdrawn = tw_delta + platform_delta + a_delta + b_delta;
+    let balance_used = balance_before - final_balance;
+    assert_eq!(
+        total_withdrawn, balance_used,
+        "Total withdrawn must equal the contract balance decrease"
+    );
+}