fix(validate-open): liquidate the position if start price is below liqPriceWithoutPenaltyNorFunding (#766)

* fix(validate-open): liquidate the position if start price is below liqPriceWithoutPenaltyNorFunding

* fix(validate-open): use the right liq price for the effective price of the liq position event

* docs(validate-open): add comment to explain new condition

* test: fix typo in NatSpecs of new test

* test: fix incorrect NatSpecs in tests

* test: fix incorrect comment in new test

* docs(actions-long): remove innacurate comment in prepare validate open function

Author: KirienzoEth

src/UsdnProtocol/libraries/UsdnProtocolActionsLongLibrary.sol

@@ -590,12 +590,24 @@ library UsdnProtocolActionsLongLibrary {
         data_.oldPosValue =
             Utils._positionValueOptimized(data_.pos.totalExpo, data_.lastPrice, data_.liqPriceWithoutPenalty);
 
-        // if lastPrice > liqPriceWithPenalty but startPrice <= liqPriceWithPenalty then the user dodged liquidations
-        // we still can't let the position open, because we can't calculate the leverage with a start price that is
-        // lower than a liquidation price, and we also can't liquidate the whole tick because other users could have
-        // opened positions in this tick after the user of the current position
+        data_.liqPriceWithoutPenaltyNorFunding = Utils._getEffectivePriceForTick(
+            Utils._calcTickWithoutPenalty(data_.action.tick, data_.liquidationPenalty), data_.action.liqMultiplier
+        );
+
+        // if lastPrice > liqPriceWithPenalty
+        // but startPrice <= liqPriceWithPenalty OR startPrice <= liqPriceWithoutPenaltyNorFunding,
+        // then the user dodged liquidations. We still can't let the position open, because we can't calculate the
+        // leverage with a start price that is lower than a liquidation price, and we also can't liquidate the whole
+        // tick because other users could have opened positions in this tick after the user of the current position,
         // our only choice is to liquidate this position only
-        if (data_.startPrice <= liqPriceWithPenalty) {
+        if (data_.startPrice <= liqPriceWithPenalty || data_.startPrice <= data_.liqPriceWithoutPenaltyNorFunding) {
+            uint256 liquidationPrice = liqPriceWithPenalty;
+            // if the liquidation occurs because of liqPriceWithoutPenaltyNorFunding, use it as the effective price for
+            // the liquidation event
+            if (data_.startPrice > liqPriceWithPenalty && data_.startPrice <= data_.liqPriceWithoutPenaltyNorFunding) {
+                liquidationPrice = data_.liqPriceWithoutPenaltyNorFunding;
+            }
+
             s._balanceLong -= data_.oldPosValue;
             s._balanceVault += data_.oldPosValue;
 
@@ -611,18 +623,14 @@ library UsdnProtocolActionsLongLibrary {
                     index: data_.action.index
                 }),
                 data_.startPrice,
-                liqPriceWithPenalty
+                liquidationPrice
             );
 
             return (data_, true);
         }
 
-        data_.liqPriceWithoutPenaltyNorFunding = Utils._getEffectivePriceForTick(
-            Utils._calcTickWithoutPenalty(data_.action.tick, data_.liquidationPenalty), data_.action.liqMultiplier
-        );
         // calculate the leverage of the position without considering the penalty nor the funding by using the
         // multiplier state at T+24
-        // reverts if liqPriceWithoutPenaltyNorFunding >= startPrice
         data_.leverage = Utils._getLeverage(data_.startPrice, data_.liqPriceWithoutPenaltyNorFunding);
     }
 

test/unit/UsdnProtocol/Actions/_PrepareValidateOpenPositionData.t.sol

@@ -187,9 +187,7 @@ contract TestUsdnProtocolActionsPrepareValidateOpenPositionData is UsdnProtocolB
      * below its position's liquidation price
      * @custom:given Partial liquidations occurred that left the user's tick un-liquidated
      * @custom:when The user tries to validate its position
-     * @custom:then Nothing happens
-     * @custom:when The lastPrice value is updated and the user tries to validate again
-     * @custom:then The position was not liquidated and matching data is returned
+     * @custom:then The position is liquidated
      */
     function test_prepareValidateOpenPositionDataWithStartPriceLowerThanLiquidationPrice() public {
         skip(1 hours);
@@ -211,8 +209,9 @@ contract TestUsdnProtocolActionsPrepareValidateOpenPositionData is UsdnProtocolB
             protocol.i_prepareValidateOpenPositionData(pendingAction, currentPriceData);
 
         uint24 liquidationPenalty = protocol.getLiquidationPenalty();
-        uint256 positionTotalExpo =
-            protocol.i_calcPositionTotalExpo(POSITION_AMOUNT, params.initialPrice, liqPriceWithoutPenalty);
+        uint256 positionTotalExpo = protocol.i_calcPositionTotalExpo(
+            POSITION_AMOUNT, params.initialPrice, data.liqPriceWithoutPenaltyNorFunding
+        );
 
         /* ------------------------ checking returned values ------------------------ */
         assertTrue(liquidated, "The position should have been liquidated");
@@ -259,12 +258,84 @@ contract TestUsdnProtocolActionsPrepareValidateOpenPositionData is UsdnProtocolB
         );
     }
 
+    /**
+     * @custom:scenario A user wants to validate its action but the provided price is not fresh and the lastPrice is
+     * below its position's liquidation price (without liq penalty nor fundings)
+     * @custom:given `startPrice` is above the liquidation price but below the liquidation price without fundings
+     * @custom:and fundings are enabled
+     * @custom:when The user tries to validate its position
+     * @custom:then The position is liquidated
+     */
+    function test_prepareValidateOpenPositionDataWithStartPriceLowerThanLiquidationPriceWithoutPenaltyNorFunding()
+        public
+    {
+        skip(1 hours);
+        vm.startPrank(ADMIN);
+        protocol.setFundingSF(500);
+        vm.stopPrank();
+
+        // big position to have high fundings
+        setUpUserPositionInVault(USER_1, ProtocolAction.ValidateDeposit, 20 ether, DEFAULT_PARAMS.initialPrice);
+
+        (, posId) = protocol.initiateOpenPosition(
+            POSITION_AMOUNT,
+            params.initialPrice * 8 / 10,
+            type(uint128).max,
+            protocol.getMaxLeverage(),
+            address(this),
+            USER_1,
+            type(uint256).max,
+            currentPriceData,
+            EMPTY_PREVIOUS_DATA
+        );
+        timestampAtInitiate = uint40(block.timestamp);
+
+        skip(4 hours);
+
+        // update lastPrice and lastUpdatedTimestamp
+        protocol.liquidate(currentPriceData);
+
+        liqPriceWithoutPenalty = protocol.getEffectivePriceForTick(protocol.i_calcTickWithoutPenalty(posId.tick));
+        (pendingAction,) = protocol.i_getPendingAction(USER_1);
+        uint24 liquidationPenalty = protocol.getLiquidationPenalty();
+        uint256 liqPriceWithoutPenaltyNorFunding = protocol.i_getEffectivePriceForTick(
+            protocol.i_calcTickWithoutPenalty(posId.tick, liquidationPenalty), pendingAction.var6
+        );
+
+        // price below the liquidation price of the initiated position
+        uint256 price = protocol.getEffectivePriceForTick(posId.tick) + 10 ether;
+        currentPriceData = abi.encode(price);
+
+        vm.expectEmit();
+        emit LiquidatedPosition(USER_1, posId, price, liqPriceWithoutPenaltyNorFunding);
+        (ValidateOpenPositionData memory data, bool liquidated) =
+            protocol.i_prepareValidateOpenPositionData(pendingAction, currentPriceData);
+
+        /* ------------------------------ sanity checks ----------------------------- */
+        assertGt(
+            data.liqPriceWithoutPenaltyNorFunding,
+            liqPriceWithoutPenalty,
+            "liqPriceWithoutPenaltyNorFunding should be higher than liqPriceWithoutPenalty"
+        );
+        assertLt(data.liqPriceWithoutPenalty, price, "liqPriceWithoutPenalty should be less than the current price");
+        assertGt(
+            data.liqPriceWithoutPenaltyNorFunding,
+            price,
+            "liqPriceWithoutPenaltyNorFunding should be higher than the current price"
+        );
+
+        /* ------------------------ checking returned values ------------------------ */
+        assertTrue(liquidated, "The position should have been liquidated");
+        assertFalse(data.isLiquidationPending, "There should not be any pending liquidations");
+    }
+
     /// @notice Assert the data in ValidateOpenPositionData depending on `isEarlyReturn`
     function _assertData(ValidateOpenPositionData memory data, bool isEarlyReturn) private view {
         uint128 currentPrice = abi.decode(currentPriceData, (uint128));
         uint24 liquidationPenalty = protocol.getLiquidationPenalty();
-        uint256 positionTotalExpo =
-            protocol.i_calcPositionTotalExpo(POSITION_AMOUNT, params.initialPrice, liqPriceWithoutPenalty);
+        uint256 positionTotalExpo = protocol.i_calcPositionTotalExpo(
+            POSITION_AMOUNT, params.initialPrice, data.liqPriceWithoutPenaltyNorFunding
+        );
         uint128 liqPriceWithoutPenaltyNorFunding = protocol.i_getEffectivePriceForTick(
             protocol.i_calcTickWithoutPenalty(data.action.tick, data.liquidationPenalty), data.action.liqMultiplier
         );