Return amount of yield compounded from harvest_yield calls

common/src/market/external.rs

@@ -79,7 +79,7 @@ pub trait MarketExternalInterface {
     /// harvested in previous, non-compounding `harvest_yield` calls) is
     /// deposited to the supply record, so it will contribute to future yield
     /// calculations.
-    fn harvest_yield(&mut self, compounding: Option<bool>);
+    fn harvest_yield(&mut self, compounding: Option<bool>) -> BorrowAssetAmount;
 
     /// This value is an *expected average over time*.
     /// Supply positions actually earn all of their yield the instant it is

common/src/supply.rs

@@ -284,11 +284,13 @@ impl<'a> LinkedSupplyPositionMut<'a> {
 
         self.market.snapshot();
 
-        MarketEvent::SupplyDeposited {
-            account_id: self.account_id.clone(),
-            borrow_asset_amount: amount,
+        if !amount.is_zero() {
+            MarketEvent::SupplyDeposited {
+                account_id: self.account_id.clone(),
+                borrow_asset_amount: amount,
+            }
+            .emit();
         }
-        .emit();
     }
 
     pub fn record_yield_withdrawal(

contract/market/examples/gas_report.rs

@@ -57,7 +57,7 @@ async fn harvest_yield_gas(iterations: usize) -> Gas {
         c.repay(&borrow_user, 1100).await;
     }
 
-    let r = c.harvest_yield(&supply_user, true).await;
-
-    r.total_gas_burnt
+    c.harvest_yield_execution(&supply_user, true)
+        .await
+        .total_gas_burnt
 }

contract/market/src/impl_market_external.rs

@@ -207,7 +207,7 @@ impl MarketExternalInterface for Contract {
         self.withdrawal_queue.get_status()
     }
 
-    fn harvest_yield(&mut self, compounding: Option<bool>) {
+    fn harvest_yield(&mut self, compounding: Option<bool>) -> BorrowAssetAmount {
         let predecessor = env::predecessor_account_id();
         if let Some(mut supply_position) = self.get_linked_supply_position_mut(predecessor) {
             let proof = supply_position.accumulate_yield();
@@ -216,8 +216,11 @@ impl MarketExternalInterface for Contract {
                 let total_yield = supply_position.inner().borrow_asset_yield.get_total();
                 supply_position.record_yield_withdrawal(total_yield);
                 supply_position.record_deposit(proof, total_yield, env::block_timestamp_ms());
+                return total_yield;
             }
         }
+
+        BorrowAssetAmount::zero()
     }
 
     fn get_last_yield_rate(&self) -> Decimal {

contract/market/tests/happy_path.rs

@@ -135,7 +135,12 @@ async fn test_happy() {
                     80,
                 );
                 // Move the yield to the principal so that it can be withdrawn
-                c.harvest_yield(&supply_user, true).await;
+                let amount_moved_to_principal = c.harvest_yield(&supply_user, true).await;
+
+                assert_eq!(
+                    amount_moved_to_principal,
+                    supply_position.borrow_asset_yield.get_total(),
+                );
 
                 let balance_before = c.borrow_asset_balance_of(supply_user.id()).await;
                 // Withdraw all

test-utils/src/lib.rs

@@ -351,7 +351,7 @@ impl TestController {
             .unwrap()
     }
 
-    pub async fn harvest_yield(
+    pub async fn harvest_yield_execution(
         &self,
         supply_user: &Account,
         compounding: bool,
@@ -369,6 +369,25 @@ impl TestController {
             .unwrap()
     }
 
+    pub async fn harvest_yield(
+        &self,
+        supply_user: &Account,
+        compounding: bool,
+    ) -> BorrowAssetAmount {
+        eprintln!("{} harvesting yield...", supply_user.id());
+        supply_user
+            .call(self.contract.id(), "harvest_yield")
+            .args_json(json!({
+                "compounding": compounding,
+            }))
+            .max_gas()
+            .transact()
+            .await
+            .unwrap()
+            .json::<BorrowAssetAmount>()
+            .unwrap()
+    }
+
     pub async fn withdraw_static_yield(
         &self,
         account: &Account,