feat(flash-swap): support liquidating vaults with underlying as collateral

packages/amm/test/integration/hifiPool/effects/buyHToken.ts

@@ -21,14 +21,14 @@ async function testBuyHToken(
   const buyer: SignerWithAddress = this.signers.alice;
 
   // Call the buyHToken function and calculate the delta in the hToken balance.
-  const preHTokenBalance: BigNumber = await this.contracts.hToken.balanceOf(buyer.address);
-  const preUnderlyingBalance: BigNumber = await this.contracts.underlying.balanceOf(buyer.address);
+  const oldHTokenBalance: BigNumber = await this.contracts.hToken.balanceOf(buyer.address);
+  const oldUnderlyingBalance: BigNumber = await this.contracts.underlying.balanceOf(buyer.address);
   await this.contracts.hifiPool.connect(buyer).buyHToken(buyer.address, hTokenOut);
-  const postHTokenBalance: BigNumber = await this.contracts.hToken.balanceOf(buyer.address);
-  const postUnderlyingBalance: BigNumber = await this.contracts.underlying.balanceOf(buyer.address);
+  const newHTokenBalance: BigNumber = await this.contracts.hToken.balanceOf(buyer.address);
+  const newUnderlyingBalance: BigNumber = await this.contracts.underlying.balanceOf(buyer.address);
 
-  const actualHTokenOut: BigNumber = postHTokenBalance.sub(preHTokenBalance);
-  const actualUnderlyingIn: BigNumber = preUnderlyingBalance.sub(postUnderlyingBalance);
+  const actualHTokenOut: BigNumber = newHTokenBalance.sub(oldHTokenBalance);
+  const actualUnderlyingIn: BigNumber = oldUnderlyingBalance.sub(newUnderlyingBalance);
 
   // Calculate the expected value of the delta using the local mirror implementation.
   const timeToMaturity: BigNumber = H_TOKEN_MATURITY_ONE_YEAR.sub(await getLatestBlockTimestamp()).mul(SCALE);

packages/amm/test/integration/hifiPool/effects/buyUnderlying.ts

@@ -22,14 +22,14 @@ async function testBuyUnderlying(
   const buyer: SignerWithAddress = this.signers.alice;
 
   // Call the buyUnderlying function and calculate the delta in the token balances.
-  const preHTokenBalance: BigNumber = await this.contracts.hToken.balanceOf(buyer.address);
-  const preUnderlyingBalance: BigNumber = await this.contracts.underlying.balanceOf(buyer.address);
+  const oldHTokenBalance: BigNumber = await this.contracts.hToken.balanceOf(buyer.address);
+  const oldUnderlyingBalance: BigNumber = await this.contracts.underlying.balanceOf(buyer.address);
   await this.contracts.hifiPool.connect(buyer).buyUnderlying(buyer.address, underlyingOut);
-  const postHTokenBalance: BigNumber = await this.contracts.hToken.balanceOf(buyer.address);
-  const postUnderlyingBalance: BigNumber = await this.contracts.underlying.balanceOf(buyer.address);
+  const newHTokenBalance: BigNumber = await this.contracts.hToken.balanceOf(buyer.address);
+  const newUnderlyingBalance: BigNumber = await this.contracts.underlying.balanceOf(buyer.address);
 
-  const actualHTokenIn: BigNumber = preHTokenBalance.sub(postHTokenBalance);
-  const actualUnderlyingOut: BigNumber = postUnderlyingBalance.sub(preUnderlyingBalance);
+  const actualHTokenIn: BigNumber = oldHTokenBalance.sub(newHTokenBalance);
+  const actualUnderlyingOut: BigNumber = newUnderlyingBalance.sub(oldUnderlyingBalance);
 
   // Calculate the expected value of the delta using the local mirror implementation.
   const timeToMaturity: BigNumber = H_TOKEN_MATURITY_ONE_YEAR.sub(await getLatestBlockTimestamp()).mul(SCALE);

packages/amm/test/integration/hifiPool/effects/sellHToken.ts

@@ -21,14 +21,14 @@ async function testSellHToken(
   const seller: SignerWithAddress = this.signers.alice;
 
   // Call the sellHToken function and calculate the delta in the token balances.
-  const preHTokenBalance: BigNumber = await this.contracts.hToken.balanceOf(seller.address);
-  const preUnderlyingBalance: BigNumber = await this.contracts.underlying.balanceOf(seller.address);
+  const oldHTokenBalance: BigNumber = await this.contracts.hToken.balanceOf(seller.address);
+  const oldUnderlyingBalance: BigNumber = await this.contracts.underlying.balanceOf(seller.address);
   await this.contracts.hifiPool.connect(seller).sellHToken(seller.address, hTokenIn);
-  const postUnderlyingBalance: BigNumber = await this.contracts.underlying.balanceOf(seller.address);
-  const postHTokenBalance: BigNumber = await this.contracts.hToken.balanceOf(seller.address);
+  const newUnderlyingBalance: BigNumber = await this.contracts.underlying.balanceOf(seller.address);
+  const newHTokenBalance: BigNumber = await this.contracts.hToken.balanceOf(seller.address);
 
-  const actualUnderlyingOut: BigNumber = postUnderlyingBalance.sub(preUnderlyingBalance);
-  const actualHTokenIn: BigNumber = preHTokenBalance.sub(postHTokenBalance);
+  const actualUnderlyingOut: BigNumber = newUnderlyingBalance.sub(oldUnderlyingBalance);
+  const actualHTokenIn: BigNumber = oldHTokenBalance.sub(newHTokenBalance);
 
   // Calculate the expected value of the delta using the local mirror implementation.
   const timeToMaturity: BigNumber = H_TOKEN_MATURITY_ONE_YEAR.sub(await getLatestBlockTimestamp()).mul(SCALE);

packages/amm/test/integration/hifiPool/effects/sellUnderlying.ts

@@ -22,14 +22,14 @@ async function testSellUnderlying(
   const seller: SignerWithAddress = this.signers.alice;
 
   // Call the sellUnderlying function and calculate the delta in the hToken balance.
-  const preHTokenBalance: BigNumber = await this.contracts.hToken.balanceOf(seller.address);
-  const preUnderlyingBalance: BigNumber = await this.contracts.underlying.balanceOf(seller.address);
+  const oldHTokenBalance: BigNumber = await this.contracts.hToken.balanceOf(seller.address);
+  const oldUnderlyingBalance: BigNumber = await this.contracts.underlying.balanceOf(seller.address);
   await this.contracts.hifiPool.connect(seller).sellUnderlying(seller.address, underlyingIn);
-  const postHTokenBalance: BigNumber = await this.contracts.hToken.balanceOf(seller.address);
-  const postUnderlyingBalance: BigNumber = await this.contracts.underlying.balanceOf(seller.address);
+  const newHTokenBalance: BigNumber = await this.contracts.hToken.balanceOf(seller.address);
+  const newUnderlyingBalance: BigNumber = await this.contracts.underlying.balanceOf(seller.address);
 
-  const actualHTokenOut: BigNumber = postHTokenBalance.sub(preHTokenBalance);
-  const actualUnderlyingIn: BigNumber = preUnderlyingBalance.sub(postUnderlyingBalance);
+  const actualHTokenOut: BigNumber = newHTokenBalance.sub(oldHTokenBalance);
+  const actualUnderlyingIn: BigNumber = oldUnderlyingBalance.sub(newUnderlyingBalance);
 
   // Calculate the expected value of the delta using the local mirror implementation.
   const timeToMaturity: BigNumber = H_TOKEN_MATURITY_ONE_YEAR.sub(await getLatestBlockTimestamp()).mul(SCALE);

packages/errors/src/flashSwap.ts

@@ -7,6 +7,6 @@ export enum CollateralFlashUniswapV2Errors {
 
 export enum UnderlyingFlashUniswapV2Errors {
   CallNotAuthorized = "UnderlyingFlashUniswapV2__CallNotAuthorized",
-  FlashBorrowWrongToken = "UnderlyingFlashUniswapV2__FlashBorrowWrongToken",
+  FlashBorrowOtherToken = "UnderlyingFlashUniswapV2__FlashBorrowOtherToken",
   UnderlyingNotInPool = "UnderlyingFlashUniswapV2__UnderlyingNotInPool",
 }

packages/flash-swap/contracts/uniswap-v2/CollateralFlashUniswapV2.sol

@@ -15,7 +15,7 @@ import "./IUniswapV2Pair.sol";
 error CollateralFlashUniswapV2__CallNotAuthorized(address caller);
 
 /// @notice Emitted when the flash borrowed asset is the collateral instead of the underlying.
-error CollateralFlashUniswapV2__FlashBorrowCollateral(uint256 collateralAmount);
+error CollateralFlashUniswapV2__FlashBorrowCollateral();
 
 /// @notice Emitted when the liquidation does not yield a sufficient profit.
 error CollateralFlashUniswapV2__InsufficientProfit(
@@ -72,13 +72,13 @@ contract CollateralFlashUniswapV2 is ICollateralFlashUniswapV2 {
         address token1 = pair.token1();
         if (token0 == address(underlying)) {
             if (amount1 > 0) {
-                revert CollateralFlashUniswapV2__FlashBorrowCollateral(amount1);
+                revert CollateralFlashUniswapV2__FlashBorrowCollateral();
             }
             collateral = IErc20(token1);
             underlyingAmount = amount0;
         } else if (token1 == address(underlying)) {
             if (amount0 > 0) {
-                revert CollateralFlashUniswapV2__FlashBorrowCollateral(amount0);
+                revert CollateralFlashUniswapV2__FlashBorrowCollateral();
             }
             collateral = IErc20(token0);
             underlyingAmount = amount1;
@@ -188,7 +188,7 @@ contract CollateralFlashUniswapV2 is ICollateralFlashUniswapV2 {
         vars.collateral.safeTransfer(sender, vars.profitCollateralAmount);
 
         // Emit an event.
-        emit FlashLiquidateBorrow(
+        emit FlashSwapCollateralAndLiquidateBorrow(
             sender,
             vars.borrower,
             address(vars.bond),

packages/flash-swap/contracts/uniswap-v2/FlashUtils.sol

@@ -3,6 +3,7 @@ pragma solidity >=0.8.4;
 
 import "@paulrberg/contracts/token/erc20/IErc20.sol";
 import "@hifi/protocol/contracts/core/balanceSheet/IBalanceSheetV1.sol";
+import "@hifi/protocol/contracts/core/hToken/IHToken.sol";
 
 /// @title FlashUtils
 /// @author Hifi
@@ -73,11 +74,11 @@ library FlashUtils {
         }
 
         // Mint hTokens.
-        uint256 preHTokenBalance = bond.balanceOf(address(this));
+        uint256 oldHTokenBalance = bond.balanceOf(address(this));
         bond.supplyUnderlying(underlyingAmount);
-        uint256 postHTokenBalance = bond.balanceOf(address(this));
+        uint256 newHTokenBalance = bond.balanceOf(address(this));
         unchecked {
-            mintedHTokenAmount = postHTokenBalance - preHTokenBalance;
+            mintedHTokenAmount = newHTokenBalance - oldHTokenBalance;
         }
     }
 }

packages/flash-swap/contracts/uniswap-v2/ICollateralFlashUniswapV2.sol

@@ -13,7 +13,7 @@ import "./IUniswapV2Pair.sol";
 interface ICollateralFlashUniswapV2 is IUniswapV2Callee {
     /// EVENTS ///
 
-    event FlashLiquidateBorrow(
+    event FlashSwapCollateralAndLiquidateBorrow(
         address indexed liquidator,
         address indexed borrower,
         address indexed bond,
@@ -48,23 +48,23 @@ interface ICollateralFlashUniswapV2 is IUniswapV2Callee {
         IErc20 underlying
     ) external view returns (IErc20 collateral, uint256 underlyingAmount);
 
-    /// @notice Calculates the amount that must be repaid to Uniswap. The formula applied is:
+    /// @notice Calculates the amount of collateral that must be repaid to Uniswap. The formula applied is:
     ///
     ///                         (collateralReserves * underlyingAmount) * 1000
-    /// collateralRepayAmount =  --------------------------------------------
+    /// repayCollateralAmount =  --------------------------------------------
     ///                            (usdcReserves - underlyingAmount) * 997
     ///
     /// @dev See "getAmountIn" and "getAmountOut" in UniswapV2Library.sol. Flash swaps that are repaid via the
     /// corresponding pair token is akin to a normal swap, so the 0.3% LP fee applies.
     /// @param pair The Uniswap V2 pair contract.
     /// @param underlying The address of the underlying contract.
     /// @param underlyingAmount The amount of underlying flash borrowed.
-    /// @return collateralRepayAmount The minimum amount of collateral that must be repaid.
+    /// @return repayCollateralAmount The minimum amount of collateral that must be repaid.
     function getRepayCollateralAmount(
         IUniswapV2Pair pair,
         IErc20 underlying,
         uint256 underlyingAmount
-    ) external view returns (uint256 collateralRepayAmount);
+    ) external view returns (uint256 repayCollateralAmount);
 
     /// @notice The address of the UniswapV2Factory contract.
     function uniV2Factory() external view returns (address);

packages/flash-swap/contracts/uniswap-v2/IUnderlyingFlashUniswapV2.sol

@@ -13,21 +13,21 @@ import "./IUniswapV2Pair.sol";
 interface IUnderlyingFlashUniswapV2 is IUniswapV2Callee {
     /// EVENTS ///
 
-    event FlashLiquidateBorrow(
+    event FlashSwapUnderlyingAndLiquidateBorrow(
         address indexed liquidator,
         address indexed borrower,
         address indexed bond,
         uint256 underlyingAmount,
-        uint256 seizedCollateralAmount,
-        uint256 repayCollateralAmount
+        uint256 seizedUnderlyingAmount,
+        uint256 repayUnderlyingAmount
     );
 
     /// CONSTANT FUNCTIONS ///
 
     /// @notice The unique BalanceSheet contract associated with this contract.
     function balanceSheet() external view returns (IBalanceSheetV1);
 
-    /// @notice Compares the token addresses to find the collateral address and the underlying amount.
+    /// @notice Compares the token addresses to find the other token and the underlying amount.
     /// @dev See this StackExchange post: https://ethereum.stackexchange.com/q/102670/24693.
     ///
     /// Requirements:
@@ -39,26 +39,26 @@ interface IUnderlyingFlashUniswapV2 is IUniswapV2Callee {
     /// @param amount0 The amount of token0.
     /// @param amount1 The amount of token1.
     /// @param underlying The address of the underlying contract.
-    /// @return collateral The collateral contract.
+    /// @return otherToken The address of the other token contract.
     /// @return underlyingAmount The amount of underlying flash borrowed.
-    function getCollateralAndUnderlyingAmount(
+    function getOtherTokenAndUnderlyingAmount(
         IUniswapV2Pair pair,
         uint256 amount0,
         uint256 amount1,
         IErc20 underlying
-    ) external view returns (IErc20 collateral, uint256 underlyingAmount);
+    ) external view returns (IErc20 otherToken, uint256 underlyingAmount);
 
-    /// @notice Calculates the amount that must be repaid to Uniswap. The formula applied is:
+    /// @notice Calculates the amount of underlying that must be repaid to Uniswap. The formula applied is:
     ///
     ///                         underlyingAmount * 1000
-    /// collateralRepayAmount =  ---------------------
+    /// repayUnderlyingAmount =  ---------------------
     ///                                   997
     ///
     /// @dev See "getAmountIn" and "getAmountOut" in UniswapV2Library.sol. Flash swaps are repaid via the
     /// same borrowed pair token and the 0.3% LP fee applies.
     /// @param underlyingAmount The amount of underlying flash borrowed.
-    /// @return collateralRepayAmount The minimum amount of collateral that must be repaid.
-    function getRepayCollateralAmount(uint256 underlyingAmount) external view returns (uint256 collateralRepayAmount);
+    /// @return repayUnderlyingAmount The minimum amount of underlying that must be repaid.
+    function getRepayUnderlyingAmount(uint256 underlyingAmount) external view returns (uint256 repayUnderlyingAmount);
 
     /// @notice The address of the UniswapV2Factory contract.
     function uniV2Factory() external view returns (address);