feat(a_token_factory): add directional rounding to transfer_on_liquidation

- Add rounding_up: bool parameter to control rounding direction
- Use ray_div_up when rounding_up=true, ray_div when rounding_up=false
- Update liquidation collateral transfer to use rounding_up=true (favor protocol)
- Update liquidation protocol fee transfer to use rounding_up=false (favor user)
- Update function documentation and inline comments
- Fix all affected unit tests to pass new parameter
- Align with directional rounding principles and existing API patterns

Author: matchv

aave-core/sources/aave-logic/liquidation_logic.move

@@ -267,7 +267,8 @@ module aave_pool::liquidation_logic {
             account_address,
             vars.actual_collateral_to_liquidate,
             index,
-            vars.collateral_a_token
+            vars.collateral_a_token,
+            true // Round up, consistent with burn path, ensure complete liquidation without dust
         );
 
         // For the special case of account_address == params.user (self-liquidation) the liquidator_previous_a_token_balance
@@ -809,7 +810,8 @@ module aave_pool::liquidation_logic {
                 a_token_treasury,
                 vars.liquidation_protocol_fee_amount,
                 liquidity_index,
-                vars.collateral_a_token
+                vars.collateral_a_token,
+                false // Round half up, conservative charging, avoid overcharging users
             );
         };
 

aave-core/sources/aave-tokens/a_token_factory.move

@@ -610,21 +610,30 @@ module aave_pool::a_token_factory {
     /// @param amount The amount of tokens getting transferred
     /// @param index The next liquidity index of the reserve
     /// @param metadata_address The address of the aToken
+    /// @param rounding_up Whether to round up: true=ray_div_up, false=ray_div (round half up)
     public(friend) fun transfer_on_liquidation(
         from: address,
         to: address,
         amount: u256,
         index: u256,
-        metadata_address: address
+        metadata_address: address,
+        rounding_up: bool
     ) acquires TokenMap {
         assert_token_exists(metadata_address);
 
-        // Pre-calculate scaled amount using ray_div (same calculation as token_base::transfer)
+        // Pre-calculate scaled amount using directional rounding based on rounding_up parameter
         // Reasons for pre-calculation:
         // 1. Event accuracy: Must match the actual transferred scaled amount for event consistency
         // 2. Dust handling: Liquidation protocol fees can be tiny (1-2 octa), which may round to 0
         //    We must check and skip these dust transfers to prevent assert failure in token_base::transfer
-        let amount_scaled = wad_ray_math::ray_div(amount, index);
+        // 3. Directional rounding: rounding_up=true for collateral transfer (favor protocol, consistent with burn),
+        //    rounding_up=false for protocol fees (conservative charging, favor user)
+        let amount_scaled =
+            if (rounding_up) {
+                wad_ray_math::ray_div_up(amount, index) // Round up, consistent with burn path
+            } else {
+                wad_ray_math::ray_div(amount, index) // Round half up, conservative charging
+            };
 
         // Skip transfer if scaled amount is 0 (dust)
         // This prevents assertion failure in token_base::transfer
@@ -756,6 +765,6 @@ module aave_pool::a_token_factory {
         index: u256,
         metadata_address: address
     ) acquires TokenMap {
-        transfer_on_liquidation(from, to, amount, index, metadata_address)
+        transfer_on_liquidation(from, to, amount, index, metadata_address, false) // Use round half up, conservative handling
     }
 }

aave-core/tests/aave-tokens/a_token_factory_tests.move

@@ -327,7 +327,8 @@ module aave_pool::a_token_factory_tests {
             transfer_receiver,
             20,
             reserve_index,
-            a_token_address
+            a_token_address,
+            false // Use round half up for testing
         );
         assert!(
             a_token_factory::scaled_balance_of(transfer_receiver, a_token_address)
@@ -880,7 +881,8 @@ module aave_pool::a_token_factory_tests {
             transfer_receiver,
             transfer_amount,
             reserve_index,
-            a_token_address
+            a_token_address,
+            false // Use round half up for testing
         );
         assert!(
             a_token_factory::scaled_balance_of(transfer_receiver, a_token_address)
@@ -1055,7 +1057,8 @@ module aave_pool::a_token_factory_tests {
             transfer_receiver,
             transfer_amount,
             new_reserve_index,
-            a_token_address
+            a_token_address,
+            false // Use round half up for testing
         );
 
         // check emitted events
@@ -1094,7 +1097,8 @@ module aave_pool::a_token_factory_tests {
             transfer_receiver,
             new_transfer_amount,
             new_reserve_index,
-            a_token_address
+            a_token_address,
+            false // Use round half up for testing
         );
 
         // check emitted events
@@ -1811,7 +1815,12 @@ module aave_pool::a_token_factory_tests {
     ) {
         a_token_factory::test_init_module(aave_pool);
         a_token_factory::transfer_on_liquidation(
-            @0x55, @0x66, 100, 1 * wad_ray_math::ray(), @0x22
+            @0x55,
+            @0x66,
+            100,
+            1 * wad_ray_math::ray(),
+            @0x22,
+            false
         );
     }