Merge pull request #276 from lishmanTech/newcom

fix: implement validation and fund transfer for release_partial

Author: Cybermaxi7

README.md

@@ -364,9 +364,9 @@ Persistent entries on Soroban expire unless their TTL is extended. The contract
 
 ## Current Implementation Notes
 
-The current public flows are `create_escrow`, `fund_escrow`, `release_escrow`, `resolve_dispute`, pause/unpause, fee updates, fee-collector rotation, storage rent estimation, and `bump_escrow`.
+The current public flows are `create_escrow`, `fund_escrow`, `release_escrow`, `release_partial`, `release_item`, `refund_escrow`, `resolve_dispute`, pause/unpause, fee updates, fee-collector rotation, storage rent estimation, and `bump_escrow`.
 
-`release_partial`, `refund_escrow`, and broader pending-state transitions are still placeholders and should not yet be treated as production-ready flows.
+`release_partial` supports arbitrary releases only for non-itemized funded escrows. Itemized escrows must use `release_item`; the contract rejects attempts to mix these release paths. `refund_escrow` is implemented and persists refund requests for dispute resolution.
 
 ## License
 

contracts/marketx/src/lifecycle.rs

@@ -178,6 +178,12 @@ impl Contract {
 
         Self::assert_escrow_funded(&escrow)?;
 
+        // Itemized escrows must be released through release_item so each item
+        // can only be paid once.
+        if !escrow.items.is_empty() {
+            return Err(ContractError::InvalidEscrowState);
+        }
+
         escrow.buyer.require_auth();
         let actor = escrow.buyer.clone();
         let from_status = escrow.status.clone();
@@ -210,9 +216,79 @@ impl Contract {
 
         Ok(())
     }
-    pub fn release_partial(env: Env, _escrow_id: u64, _amount: i128) -> Result<(), ContractError> {
+
+    /// Release part of a non-itemized funded escrow to the seller.
+    ///
+    /// Only the buyer can authorize a release. The escrow amount is reduced
+    /// by the released amount and becomes Released when its balance reaches
+    /// zero. Itemized escrows must use `release_item` instead.
+    ///
+    /// # Arguments
+    /// * `escrow_id` - The ID of the escrow
+    /// * `amount` - The positive amount to release
+    ///
+    /// # Errors
+    /// * `EscrowNotFound` - If the escrow doesn't exist
+    /// * `InvalidEscrowState` - If the escrow is not funded or is itemized
+    /// * `InvalidEscrowAmount` - If the amount is non-positive or exceeds the remaining balance
+    /// * `FeatureDisabled` - If partial releases are disabled
+    pub fn release_partial(env: Env, escrow_id: u64, amount: i128) -> Result<(), ContractError> {
         Self::assert_not_paused(&env)?;
         Self::assert_partial_releases_enabled(&env)?;
+
+        let mut escrow: Escrow = env
+            .storage()
+            .persistent()
+            .get(&DataKey::Escrow(escrow_id))
+            .ok_or(ContractError::EscrowNotFound)?;
+
+        Self::assert_escrow_funded(&escrow)?;
+        if !escrow.items.is_empty() {
+            return Err(ContractError::InvalidEscrowState);
+        }
+        if amount <= 0 || amount > escrow.amount {
+            return Err(ContractError::InvalidEscrowAmount);
+        }
+
+        escrow.buyer.require_auth();
+        let from_status = escrow.status.clone();
+        let fee = Self::process_seller_transfer(
+            &env,
+            escrow_id,
+            amount,
+            &escrow.token,
+            &escrow.seller,
+            &escrow.buyer,
+        )?;
+
+        escrow.amount -= amount;
+        if escrow.amount == 0 {
+            escrow.status = EscrowStatus::Released;
+            escrow.cancellation_proposer = None;
+        }
+        env.storage()
+            .persistent()
+            .set(&DataKey::Escrow(escrow_id), &escrow);
+
+        FundsReleasedEvent {
+            escrow_id,
+            amount,
+            fee,
+        }
+        .publish(&env);
+
+        if escrow.status != from_status {
+            Self::emit_status_change(
+                &env,
+                escrow_id,
+                from_status,
+                escrow.status.clone(),
+                escrow.buyer.clone(),
+            );
+        }
+
+        Self::add_i128(&env, DataKey::TotalReleasedAmount, amount);
+        Self::add_u32(&env, DataKey::TotalReleasedCount);
         Ok(())
     }
 

contracts/marketx/src/test.rs

@@ -274,6 +274,169 @@ fn disabled_feature_flags_block_paths() {
     assert_eq!(resolve_dispute, Err(Ok(ContractError::FeatureDisabled)));
 }
 
+#[test]
+fn partial_release_validates_amount_and_escrow() {
+    let (env, client) = setup();
+    let admin = Address::generate(&env);
+    let buyer = Address::generate(&env);
+    let seller = Address::generate(&env);
+    let token_id = env.register_stellar_asset_contract_v2(admin.clone());
+    let token_admin = soroban_sdk::token::StellarAssetClient::new(&env, &token_id.address());
+
+    env.mock_all_auths();
+    client.initialize(&admin, &admin, &0, &0, &0);
+    token_admin.mint(&buyer, &1000);
+
+    let escrow_id = client.create_escrow(
+        &buyer,
+        &seller,
+        &token_id.address(),
+        &1000,
+        &None,
+        &None,
+        &None,
+        &None,
+    );
+    client.fund_escrow(&escrow_id);
+
+    assert_eq!(
+        client.try_release_partial(&999_999, &1),
+        Err(Ok(ContractError::EscrowNotFound))
+    );
+    assert_eq!(
+        client.try_release_partial(&escrow_id, &0),
+        Err(Ok(ContractError::InvalidEscrowAmount))
+    );
+    assert_eq!(
+        client.try_release_partial(&escrow_id, &-1),
+        Err(Ok(ContractError::InvalidEscrowAmount))
+    );
+    assert_eq!(
+        client.try_release_partial(&escrow_id, &1001),
+        Err(Ok(ContractError::InvalidEscrowAmount))
+    );
+}
+
+#[test]
+#[should_panic]
+fn non_buyer_cannot_make_partial_release() {
+    let (env, client) = setup();
+    let admin = Address::generate(&env);
+    let buyer = Address::generate(&env);
+    let seller = Address::generate(&env);
+    let token_id = env.register_stellar_asset_contract_v2(admin.clone());
+    let token_admin = soroban_sdk::token::StellarAssetClient::new(&env, &token_id.address());
+
+    env.mock_all_auths();
+    client.initialize(&admin, &admin, &0, &0, &0);
+    token_admin.mint(&buyer, &1000);
+    let escrow_id = client.create_escrow(
+        &buyer,
+        &seller,
+        &token_id.address(),
+        &1000,
+        &None,
+        &None,
+        &None,
+        &None,
+    );
+    client.fund_escrow(&escrow_id);
+
+    client
+        .mock_auths(&[MockAuth {
+            address: &seller,
+            invoke: &MockAuthInvoke {
+                contract: &client.address,
+                fn_name: "release_partial",
+                args: (&escrow_id, 100i128).into_val(&env),
+                sub_invokes: &[],
+            },
+        }])
+        .release_partial(&escrow_id, &100);
+}
+
+#[test]
+fn partial_release_transfers_remaining_balance_and_updates_analytics() {
+    let (env, client) = setup();
+    let admin = Address::generate(&env);
+    let buyer = Address::generate(&env);
+    let seller = Address::generate(&env);
+    let token_id = env.register_stellar_asset_contract_v2(admin.clone());
+    let token_admin = soroban_sdk::token::StellarAssetClient::new(&env, &token_id.address());
+    let token = soroban_sdk::token::Client::new(&env, &token_id.address());
+
+    env.mock_all_auths();
+    client.initialize(&admin, &admin, &0, &0, &0);
+    token_admin.mint(&buyer, &1000);
+    let escrow_id = client.create_escrow(
+        &buyer,
+        &seller,
+        &token_id.address(),
+        &1000,
+        &None,
+        &None,
+        &None,
+        &None,
+    );
+    client.fund_escrow(&escrow_id);
+
+    client.release_partial(&escrow_id, &400);
+    let escrow = client.get_escrow(&escrow_id).unwrap();
+    assert_eq!(escrow.amount, 600);
+    assert_eq!(escrow.status, crate::types::EscrowStatus::Funded);
+    assert_eq!(token.balance(&seller), 400);
+    assert_eq!(client.get_total_released_amount(), 400);
+    assert_eq!(client.get_total_released_count(), 1);
+
+    client.release_partial(&escrow_id, &600);
+    let escrow = client.get_escrow(&escrow_id).unwrap();
+    assert_eq!(escrow.amount, 0);
+    assert_eq!(escrow.status, crate::types::EscrowStatus::Released);
+    assert_eq!(token.balance(&seller), 1000);
+    assert_eq!(client.get_total_released_amount(), 1000);
+    assert_eq!(client.get_total_released_count(), 2);
+}
+
+#[test]
+fn partial_release_cannot_be_used_with_itemized_escrow() {
+    let (env, client) = setup();
+    let admin = Address::generate(&env);
+    let buyer = Address::generate(&env);
+    let seller = Address::generate(&env);
+    let token_id = env.register_stellar_asset_contract_v2(admin.clone());
+    let token_admin = soroban_sdk::token::StellarAssetClient::new(&env, &token_id.address());
+    let mut items = Vec::new(&env);
+    items.push_back(EscrowItem {
+        amount: 1000,
+        released: false,
+        description: None,
+    });
+
+    env.mock_all_auths();
+    client.initialize(&admin, &admin, &0, &0, &0);
+    token_admin.mint(&buyer, &1000);
+    let escrow_id = client.create_escrow(
+        &buyer,
+        &seller,
+        &token_id.address(),
+        &1000,
+        &None,
+        &None,
+        &Some(items),
+        &None,
+    );
+    client.fund_escrow(&escrow_id);
+
+    assert_eq!(
+        client.try_release_partial(&escrow_id, &500),
+        Err(Ok(ContractError::InvalidEscrowState))
+    );
+    assert_eq!(
+        client.try_release_escrow(&escrow_id),
+        Err(Ok(ContractError::InvalidEscrowState))
+    );
+}
+
 #[test]
 fn escrow_ids_increment_sequentially() {
     let (env, client) = setup();