Merge pull request #293 from Abdullahi130/feat/batch-trade-operations

feat: harden batch trade ops (parity, fees, duplicate IDs)

Author: Mystery-CLI

src/errors.rs

@@ -33,4 +33,5 @@ pub enum ContractError {
     InsufficientAllowance = 27,
     TradeExpired = 28,
     NotExpiredYet = 29,
+    DuplicateTradeInBatch = 30,
 }

src/lib.rs

@@ -539,7 +539,9 @@ impl StellarEscrowContract {
         let fee_bps = tiers::effective_fee_bps(&env, &seller, base_fee_bps);
         let mut trade_ids = soroban_sdk::Vec::new(&env);
         let mut total_amount: u64 = 0;
+        let mut total_fees: u64 = 0;
         let now = env.ledger().sequence();
+        let currency = types::Currency::Usdc;
         for (buyer, amount, arbitrator) in trades.iter() {
             if amount == 0 { return Err(ContractError::InvalidAmount); }
             if let Some(ref arb) = arbitrator {
@@ -552,14 +554,21 @@ impl StellarEscrowContract {
                 id: trade_id, seller: seller.clone(), buyer: buyer.clone(),
                 amount, fee, arbitrator, status: TradeStatus::Created,
                 created_at: now, updated_at: now, metadata: None,
-                currency: types::Currency::Usdc, expiry_time: None,
+                currency: currency.clone(), expiry_time: None,
             };
             save_trade(&env, trade_id, &trade);
             index_trade_for_address(&env, &seller, trade_id);
             index_trade_for_address(&env, &buyer, trade_id);
+            append_timeline_entry(&env, trade_id, TimelineEntry { status: TradeStatus::Created, ledger: now });
+            users::record_trade_created(&env, &seller, &buyer, amount);
+            admin::on_trade_created(&env, amount);
             trade_ids.push_back(trade_id);
             total_amount = total_amount.checked_add(amount).ok_or(ContractError::Overflow)?;
+            total_fees = total_fees.checked_add(fee).ok_or(ContractError::Overflow)?;
         }
+        let current_fees = get_accumulated_fees(&env)?;
+        set_accumulated_fees(&env, current_fees.checked_add(total_fees).ok_or(ContractError::Overflow)?);
+        add_currency_fees(&env, &currency, total_fees)?;
         events::emit_batch_trades_created(&env, trade_ids.len() as u32, total_amount);
         Ok(trade_ids)
     }
@@ -577,10 +586,21 @@ impl StellarEscrowContract {
         let token = get_usdc_token(&env)?;
         let token_client = TokenClient::new(&env, &token);
         let mut total_amount: u64 = 0;
+        let mut seen: soroban_sdk::Map<u64, bool> = soroban_sdk::Map::new(&env);
+        let now_ts = env.ledger().timestamp();
         for trade_id in trade_ids.iter() {
+            if seen.get(trade_id).is_some() {
+                return Err(ContractError::DuplicateTradeInBatch);
+            }
+            seen.set(trade_id, true);
             let trade = get_trade(&env, trade_id)?;
             if trade.status != TradeStatus::Created { return Err(ContractError::InvalidStatus); }
             if trade.buyer != buyer { return Err(ContractError::Unauthorized); }
+            if let Some(expiry) = trade.expiry_time {
+                if now_ts >= expiry {
+                    return Err(ContractError::TradeExpired);
+                }
+            }
             total_amount = total_amount.checked_add(trade.amount).ok_or(ContractError::Overflow)?;
         }
         token_client.transfer(&buyer, &env.current_contract_address(), &(total_amount as i128));
@@ -590,6 +610,7 @@ impl StellarEscrowContract {
             trade.status = TradeStatus::Funded;
             trade.updated_at = now;
             save_trade(&env, trade_id, &trade);
+            append_timeline_entry(&env, trade_id, TimelineEntry { status: TradeStatus::Funded, ledger: now });
         }
         events::emit_batch_trades_funded(&env, trade_ids.len() as u32, total_amount);
         Ok(())
@@ -610,7 +631,12 @@ impl StellarEscrowContract {
         let mut total_payout: u64 = 0;
         let mut total_fees: u64 = 0;
         let mut seller_payouts: soroban_sdk::Map<Address, u64> = soroban_sdk::Map::new(&env);
+        let mut seen: soroban_sdk::Map<u64, bool> = soroban_sdk::Map::new(&env);
         for trade_id in trade_ids.iter() {
+            if seen.get(trade_id).is_some() {
+                return Err(ContractError::DuplicateTradeInBatch);
+            }
+            seen.set(trade_id, true);
             let trade = get_trade(&env, trade_id)?;
             if trade.status != TradeStatus::Completed { return Err(ContractError::InvalidStatus); }
             if trade.buyer != buyer { return Err(ContractError::Unauthorized); }
@@ -629,6 +655,8 @@ impl StellarEscrowContract {
             let trade = get_trade(&env, trade_id)?;
             tiers::record_volume(&env, &trade.seller, trade.amount)?;
             tiers::record_volume(&env, &trade.buyer, trade.amount)?;
+            users::record_trade_completed(&env, &trade.seller, &trade.buyer);
+            admin::on_trade_completed(&env, trade.fee);
         }
         events::emit_batch_trades_confirmed(&env, trade_ids.len() as u32, total_payout, total_fees);
         Ok(())

src/test.rs

@@ -977,6 +977,32 @@ fn test_batch_create_rejects_empty_and_oversized_batches() {
     assert_eq!(oversized_result, Err(Ok(ContractError::BatchLimitExceeded)));
 }
 
+#[test]
+fn test_batch_fund_and_confirm_reject_duplicate_trade_ids() {
+    let (env, client, _, seller, buyer) = setup();
+    let mut batch = soroban_sdk::Vec::new(&env);
+    batch.push_back((buyer.clone(), 1_000u64, None));
+    let trade_ids = client.batch_create_trades(&seller, &batch);
+    let id = trade_ids.get(0).unwrap();
+
+    let mut dup_fund = soroban_sdk::Vec::new(&env);
+    dup_fund.push_back(id);
+    dup_fund.push_back(id);
+    let fund_err = client.try_batch_fund_trades(&buyer, &dup_fund);
+    assert_eq!(fund_err, Err(Ok(ContractError::DuplicateTradeInBatch)));
+
+    let mut single = soroban_sdk::Vec::new(&env);
+    single.push_back(id);
+    client.batch_fund_trades(&buyer, &single);
+    client.complete_trade(&id);
+
+    let mut dup_confirm = soroban_sdk::Vec::new(&env);
+    dup_confirm.push_back(id);
+    dup_confirm.push_back(id);
+    let confirm_err = client.try_batch_confirm_trades(&buyer, &dup_confirm);
+    assert_eq!(confirm_err, Err(Ok(ContractError::DuplicateTradeInBatch)));
+}
+
 #[test]
 fn test_custom_fee_configuration_changes_trade_fee_and_tier_state() {
     let (_env, client, _, seller, buyer) = setup();