Merge pull request #270 from stabilitydao/254-sial-bug-decreasing-ltv-on-exits

254 sial bug decreasing ltv on exits

Author: a17

src/integrations/balancerv3/IBalancerV3FlashCallback.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+interface IBalancerV3FlashCallback {
+  function receiveFlashLoanV3(address token, uint amount, bytes memory userData) external;
+}

src/integrations/balancerv3/IVaultMainV3.sol

@@ -0,0 +1,143 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity ^0.8.24;
+
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+/// @notice Restored from 0xbA1333333333a1BA1108E8412f11850A5C319bA9 (sonic)
+interface IVaultMainV3 {
+  struct TokenConfig {
+    address token;
+    uint8 tokenType;
+    address rateProvider;
+    bool paysYieldFees;
+  }
+
+  struct PoolRoleAccounts {
+    address pauseManager;
+    address swapFeeManager;
+    address poolCreator;
+  }
+
+  struct HooksConfig {
+    bool enableHookAdjustedAmounts;
+    bool shouldCallBeforeInitialize;
+    bool shouldCallAfterInitialize;
+    bool shouldCallComputeDynamicSwapFee;
+    bool shouldCallBeforeSwap;
+    bool shouldCallAfterSwap;
+    bool shouldCallBeforeAddLiquidity;
+    bool shouldCallAfterAddLiquidity;
+    bool shouldCallBeforeRemoveLiquidity;
+    bool shouldCallAfterRemoveLiquidity;
+    address hooksContract;
+  }
+
+  struct LiquidityManagement {
+    bool disableUnbalancedLiquidity;
+    bool enableAddLiquidityCustom;
+    bool enableRemoveLiquidityCustom;
+    bool enableDonation;
+  }
+
+  struct AddLiquidityParams {
+    address pool;
+    address to;
+    uint256[] maxAmountsIn;
+    uint256 minBptAmountOut;
+    uint8 kind;
+    bytes userData;
+  }
+
+  struct BufferWrapOrUnwrapParams {
+    uint8 kind;
+    uint8 direction;
+    address wrappedToken;
+    uint256 amountGivenRaw;
+    uint256 limitRaw;
+  }
+
+  struct RemoveLiquidityParams {
+    address pool;
+    address from;
+    uint256 maxBptAmountIn;
+    uint256[] minAmountsOut;
+    uint8 kind;
+    bytes userData;
+  }
+
+  struct VaultSwapParams {
+    uint8 kind;
+    address pool;
+    address tokenIn;
+    address tokenOut;
+    uint256 amountGivenRaw;
+    uint256 limitRaw;
+    bytes userData;
+  }
+
+  fallback() external payable;
+
+  function addLiquidity(AddLiquidityParams memory params)
+  external
+  returns (
+    uint256[] memory amountsIn,
+    uint256 bptAmountOut,
+    bytes memory returnData
+  );
+
+  function erc4626BufferWrapOrUnwrap(BufferWrapOrUnwrapParams memory params)
+  external
+  returns (
+    uint256 amountCalculatedRaw,
+    uint256 amountInRaw,
+    uint256 amountOutRaw
+  );
+
+  function getPoolTokenCountAndIndexOfToken(address pool, address token)
+  external
+  view
+  returns (uint256, uint256);
+
+  function getVaultExtension() external view returns (address);
+
+  function reentrancyGuardEntered() external view returns (bool);
+
+  function removeLiquidity(RemoveLiquidityParams memory params)
+  external
+  returns (
+    uint256 bptAmountIn,
+    uint256[] memory amountsOut,
+    bytes memory returnData
+  );
+
+  function sendTo(address token, address to, uint256 amount) external;
+
+  function settle(address token, uint256 amountHint) external returns (uint256 credit);
+
+  function swap(VaultSwapParams memory vaultSwapParams)
+  external
+  returns (
+    uint256 amountCalculated,
+    uint256 amountIn,
+    uint256 amountOut
+  );
+
+  function transfer(address owner, address to, uint256 amount) external returns (bool);
+
+  function transferFrom(address spender, address from, address to, uint256 amount) external returns (bool);
+
+  /// @notice Creates a context for a sequence of operations (i.e., "unlocks" the Vault).
+  /// @dev Performs a callback on msg.sender with arguments provided in `data`. The Callback is `transient`,
+  /// meaning all balances for the caller have to be settled at the end.
+  /// Implementation in balancer-v3-monorepo is following:
+  ///     function unlock(bytes calldata data) external transient returns (bytes memory result) {
+  ///        return (msg.sender).functionCall(data);
+  ///    }
+  /// @param data Contains function signature and args to be passed to the msg.sender
+  /// @return result Resulting data from the call
+  function unlock(bytes memory data) external returns (bytes memory result);
+
+  receive() external payable;
+}
+

src/integrations/uniswapv3/IUniswapV3FlashCallback.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.5.0;
+
+/// @title Callback for IUniswapV3PoolActions#flash
+/// @notice Any contract that calls IUniswapV3PoolActions#flash must implement this interface
+interface IUniswapV3FlashCallback {
+  /// @notice Called to `msg.sender` after transferring to the recipient from IUniswapV3Pool#flash.
+  /// @dev In the implementation you must repay the pool the tokens sent by flash plus the computed fee amounts.
+  /// The caller of this method must be checked to be a UniswapV3Pool deployed by the canonical UniswapV3Factory.
+  /// @param fee0 The fee amount in token0 due to the pool by the end of the flash
+  /// @param fee1 The fee amount in token1 due to the pool by the end of the flash
+  /// @param data Any data passed through by the caller via the IUniswapV3PoolActions#flash call
+  function uniswapV3FlashCallback(
+    uint256 fee0,
+    uint256 fee1,
+    bytes calldata data
+  ) external;
+}

src/interfaces/IControllable.sol

@@ -23,6 +23,8 @@ interface IControllable {
     error NotTheOwner();
     error ETHTransferFailed();
     error IncorrectInitParams();
+    error InsufficientBalance();
+    error IncorrectLtv(uint ltv);
     //endregion -- Custom Errors -----
 
     event ContractInitialized(address platform, uint ts, uint block);

src/interfaces/ILeverageLendingStrategy.sol

@@ -12,6 +12,7 @@ interface ILeverageLendingStrategy {
     event LeverageLendingHealth(uint ltv, uint leverage);
     event TargetLeveragePercent(uint value);
     event UniversalParams(uint[] params);
+    event UniversalAddresses(address[] addresses);
 
     /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
     /*                         DATA TYPES                         */
@@ -53,6 +54,8 @@ interface ILeverageLendingStrategy {
         uint swapPriceImpactTolerance0;
         /// @dev Swap price impact tolerance on re-balance debt
         uint swapPriceImpactTolerance1;
+        /// @notice Flash loan kind. 0 - balancer v2 (paid), 1 - balancer v3 (free)
+        uint flashLoanKind;
     }
 
     struct LeverageLendingStrategyBaseInitParams {
@@ -80,7 +83,17 @@ interface ILeverageLendingStrategy {
         Deposit,
         Withdraw,
         DecreaseLtv,
-        IncreaseLtv
+        /// @notice All available balances are used
+        IncreaseLtv,
+        /// @notice Amounts of collateral and borrow that can be used are limited through temp vars
+        IncreaseLtvLimited
+    }
+
+    enum FlashLoanKind {
+        /// @notice Balancer V2
+        Default_0,
+        BalancerV3_1,
+        UniswapV3_2
     }
 
     /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
@@ -90,18 +103,21 @@ interface ILeverageLendingStrategy {
     /// @notice Re-balance debt
     /// @param newLtv Target LTV after re-balancing with 4 decimals. 90_00 is 90%.
     /// @return resultLtv LTV after re-balance. For static calls.
-    function rebalanceDebt(uint newLtv) external returns (uint resultLtv);
+    /// @return resultSharePrice Share price after applying rebalance debt
+    function rebalanceDebt(uint newLtv, uint minSharePrice) external returns (uint resultLtv, uint resultSharePrice);
 
     /// @notice Change target leverage percent
     /// @param value Value with 4 decimals, 90_00 is 90%.
     function setTargetLeveragePercent(uint value) external;
 
     /// @notice Change universal configurable params
-    function setUniversalParams(uint[] memory params) external;
+    function setUniversalParams(uint[] memory params, address[] memory addresses) external;
 
     /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
     /*                       VIEW FUNCTIONS                       */
     /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+    /// @notice Get universal configurable params
+    function getUniversalParams() external view returns (uint[] memory params, address[] memory addresses);
 
     /// @notice Difference between collateral and debt
     /// @return tvl USD amount of user deposited assets