Fix denial of service borrowing vault

packages/protocol/src/abstracts/BaseVault.sol

@@ -589,6 +589,7 @@ abstract contract BaseVault is ERC20, SystemAccessControl, PausableVault, VaultP
     uint256 shares
   )
     internal
+    virtual
     whenNotPaused(VaultActions.Withdraw)
   {
     _burn(owner, shares);

packages/protocol/src/routers/ConnextRouter.sol

@@ -315,7 +315,7 @@ contract ConnextRouter is BaseRouter, IXReceiver {
 
     emit XCalled(
       transferId, msg.sender, routerByDomain[destDomain], destDomain, asset, amount, callData
-      );
+    );
 
     return beneficiary_;
   }

packages/protocol/src/vaults/borrowing/BorrowingVault.sol

@@ -67,6 +67,8 @@ contract BorrowingVault is BaseVault {
   error BorrowingVault__borrow_slippageTooHigh();
   error BorrowingVault__payback_slippageTooHigh();
   error BorrowingVault__burnDebtShares_amountExceedsBalance();
+  error BorrowingVault__correctDebt_noNeedForCorrection();
+  error BorrowingVault__withdraw_debtNeedsCorrection();
 
   /*///////////////////
    Liquidation controls
@@ -301,6 +303,37 @@ contract BorrowingVault is BaseVault {
     return shares;
   }
 
+  /**
+   * @dev Checks if vault debt has been paid off externally and pauses the vault if so.
+   * Will call withdraw if normal conditions are met.
+   *
+   * @param caller or {msg.sender}
+   * @param receiver to whom `assets` amount will be transferred to
+   * @param owner to whom `shares` will be burned
+   * @param assets amount transferred during this withraw
+   * @param shares amount burned to `owner` during this withdraw
+   */
+  function _withdraw(
+    address caller,
+    address receiver,
+    address owner,
+    uint256 assets,
+    uint256 shares
+  )
+    internal
+    override
+    whenNotPaused(VaultActions.Withdraw)
+  {
+    uint256 totalDebt_ = totalDebt();
+    uint256 supply = debtSharesSupply;
+
+    if (totalDebt_ == 0 && supply > 0 && supply > totalDebt_) {
+      _pause(VaultActions.Withdraw);
+      revert BorrowingVault__withdraw_debtNeedsCorrection();
+    }
+    super._withdraw(caller, receiver, owner, assets, shares);
+  }
+
   /*///////////////////////
       Borrow allowances 
   ///////////////////////*/
@@ -738,4 +771,24 @@ contract BorrowingVault is BaseVault {
 
     emit ProvidersChanged(providers);
   }
+
+  /**
+   * @notice In case someone repays this vault's debt directly to the lending provider,
+   * a borrow is done with the amount that was repaid so no issues regarding
+   * the relationship between debt and debt shares occurs.
+   *
+   * @param  treasury address to receive the borrowed amount
+   */
+  function correctDebt(address treasury) external onlyTimelock {
+    uint256 vaultDebt = totalDebt();
+    uint256 vaultDebtShares = debtSharesSupply;
+
+    // Check if there is need for correction.
+    if (vaultDebt >= vaultDebtShares || vaultDebt != 0 || vaultDebtShares == 0) {
+      revert BorrowingVault__correctDebt_noNeedForCorrection();
+    }
+
+    _executeProviderAction(vaultDebtShares, "borrow", activeProvider);
+    SafeERC20.safeTransfer(IERC20(debtAsset()), treasury, vaultDebtShares);
+  }
 }

packages/protocol/src/vaults/borrowing/BorrowingVaultFactory.sol

@@ -117,7 +117,7 @@ contract BorrowingVaultFactory is VaultDeployer {
 
     emit DeployBorrowingVault(
       vault, vdata.asset, vdata.debtAsset, vdata.name, vdata.symbol, vdata.salt
-      );
+    );
   }
 
   /**

packages/protocol/test/forking/mainnet/DenialOfService.t.sol

@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity 0.8.15;
+
+import "forge-std/console.sol";
+import {Routines} from "../../utils/Routines.sol";
+import {ForkingSetup} from "../ForkingSetup.sol";
+import {AaveV2} from "../../../src/providers/mainnet/AaveV2.sol";
+import {ILendingProvider} from "../../../src/interfaces/ILendingProvider.sol";
+import {BorrowingVault} from "../../../src/vaults/borrowing/BorrowingVault.sol";
+import {IERC20} from "openzeppelin-contracts/contracts/token/ERC20/IERC20.sol";
+import {IV2Pool} from "../../../src/interfaces/aaveV2/IV2Pool.sol";
+import {SafeERC20} from "openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol";
+import {PausableVault} from "../../../src/abstracts/PausableVault.sol";
+
+contract DenialOfServiceTest is Routines, ForkingSetup {
+  using SafeERC20 for IERC20;
+
+  uint256 public constant TREASURY_PK = 0xF;
+  address public TREASURY = vm.addr(TREASURY_PK);
+
+  ILendingProvider public aaveV2;
+
+  uint256 public TROUBLEMAKER_PK = 0x1122;
+  address public TROUBLEMAKER = vm.addr(TROUBLEMAKER_PK);
+
+  uint256 public constant DEPOSIT_AMOUNT = 1 ether;
+  uint256 public constant BORROW_AMOUNT = 800 * 1e6;
+
+  IV2Pool public aaveV2pool;
+
+  function setUp() public {
+    setUpFork(MAINNET_DOMAIN);
+
+    vm.label(TROUBLEMAKER, "TROUBLEMAKER");
+
+    aaveV2 = new AaveV2();
+    ILendingProvider[] memory providers = new ILendingProvider[](1);
+    providers[0] = aaveV2;
+
+    deploy(providers);
+
+    aaveV2pool = IV2Pool(0x7d2768dE32b0b80b7a3454c06BdAc94A69DDc7A9);
+  }
+
+  function testFail_tryWithdrawWithoutCorrectDebt() public {
+    // Alice deposits and borrows
+    do_deposit(DEPOSIT_AMOUNT, vault, ALICE);
+    do_borrow(BORROW_AMOUNT, vault, ALICE);
+
+    // Troublemaker pays vaults debt
+    deal(debtAsset, TROUBLEMAKER, BORROW_AMOUNT * 10);
+    vm.startPrank(TROUBLEMAKER);
+    IERC20(debtAsset).safeApprove(address(aaveV2pool), BORROW_AMOUNT);
+    aaveV2pool.repay(vault.debtAsset(), BORROW_AMOUNT, 2, address(vault));
+    vm.stopPrank();
+
+    assertEq(vault.balanceOf(ALICE), DEPOSIT_AMOUNT);
+    assertEq(vault.balanceOfDebt(ALICE), 0);
+
+    //Withdraw will fail until debt is corrected and withdraw is unpaused
+    uint256 maxAmount = vault.maxWithdraw(ALICE);
+    do_withdraw(maxAmount, vault, ALICE);
+  }
+
+  function test_correctDebtUnpauseAndWithdraw() public {
+    uint256 amountCorrected = BORROW_AMOUNT;
+
+    do_deposit(DEPOSIT_AMOUNT, vault, ALICE);
+    do_borrow(BORROW_AMOUNT, vault, ALICE);
+
+    // Troublemaker pays vaults debt
+    deal(debtAsset, TROUBLEMAKER, BORROW_AMOUNT * 10);
+    vm.startPrank(TROUBLEMAKER);
+    //TODO check this after rounding issue is fixed
+    //approve more than needed because of rounding issues
+    IERC20(debtAsset).safeApprove(address(aaveV2pool), BORROW_AMOUNT + 10);
+    //pay full amount, sometimes bigger than BORROW_AMOUNT
+    aaveV2pool.repay(
+      vault.debtAsset(), aaveV2.getBorrowBalance(address(vault), vault), 2, address(vault)
+    );
+    vm.stopPrank();
+
+    bytes memory data = abi.encodeWithSelector(BorrowingVault.correctDebt.selector, TREASURY);
+    _callWithTimelock(address(vault), data);
+    skip(2 days);
+
+    //try to payback and withdraw and check it works
+    do_payback(BORROW_AMOUNT, vault, ALICE);
+    do_withdraw(DEPOSIT_AMOUNT, vault, ALICE);
+
+    //DEPOSIT_AMOUNT has built up some interest after the call with timelock (lets assume 1%)
+    assertApproxEqAbs(vault.balanceOf(ALICE), 0, DEPOSIT_AMOUNT / 100);
+
+    //check the actual corrected amount is in TREASURY
+    assertEq(aaveV2.getBorrowBalance(address(vault), vault), 0);
+    assertEq(IERC20(debtAsset).balanceOf(TREASURY), amountCorrected);
+  }
+}

packages/protocol/test/utils/Routines.sol

@@ -20,6 +20,9 @@ contract Routines is Test {
   }
 
   function do_deposit(uint256 amount, IVault v, address from) internal {
+    uint256 mintedShares = v.balanceOf(from);
+    uint256 assetBalanceBefore = v.convertToAssets(mintedShares);
+
     address asset = v.asset();
     deal(asset, from, amount);
 
@@ -31,10 +34,10 @@ contract Routines is Test {
     vm.warp(block.timestamp + 13 seconds);
     vm.roll(block.number + 1);
 
-    uint256 mintedShares = v.balanceOf(from);
+    mintedShares = v.balanceOf(from);
     uint256 assetBalance = v.convertToAssets(mintedShares);
 
-    assertApproxEqAbs(assetBalance, amount, amount / 1000);
+    assertApproxEqAbs(assetBalance - assetBalanceBefore, amount, amount / 1000);
 
     vm.warp(block.timestamp - 13 seconds);
     vm.roll(block.number - 1);
@@ -51,10 +54,12 @@ contract Routines is Test {
   }
 
   function do_borrow(uint256 amount, IVault v, address from) internal {
+    uint256 prevDebt = IERC20(v.debtAsset()).balanceOf(from);
+
     vm.prank(from);
     v.borrow(amount, from, from);
 
-    assertEq(IERC20(v.debtAsset()).balanceOf(from), amount);
+    assertEq(IERC20(v.debtAsset()).balanceOf(from) - prevDebt, amount);
   }
 
   function do_payback(uint256 amount, IVault v, address from) internal {