cooler liquidation tests

src/external/cooler/DelegateEscrowFactory.sol

@@ -12,12 +12,8 @@ import {DelegateEscrow} from "src/external/cooler/DelegateEscrow.sol";
 contract DelegateEscrowFactory {
     using ClonesWithImmutableArgs for address;
 
-    // --- ERRORS ----------------------------------------------------
-
     error NotFromFactory();
 
-    // --- EVENTS ----------------------------------------------------
-
     /// @notice A caller has created a new escrow for a delegate
     event DelegateEscrowCreated(
         address indexed caller,
@@ -36,8 +32,6 @@ contract DelegateEscrowFactory {
         int256 delegationAmountDelta
     );
 
-    // -- STATE VARIABLES --------------------------------------------
-
     /// @notice Reference implementation (deployed on creation to clone from).
     DelegateEscrow public immutable escrowImplementation;
 
@@ -47,14 +41,10 @@ contract DelegateEscrowFactory {
     /// @notice Mapping to query escrows for a given delegate.
     mapping(address => DelegateEscrow) public escrowFor;
 
-    // --- INITIALIZATION --------------------------------------------
-
     constructor(address gohm_) {
         escrowImplementation = new DelegateEscrow(gohm_);
     }
 
-    // --- DEPLOY NEW COOLERS ----------------------------------------
-
     /// @notice creates a new escrow contract for a delegate.
     function create(address delegate) external returns (DelegateEscrow escrow) {
         escrow = escrowFor[delegate];
@@ -76,14 +66,6 @@ contract DelegateEscrowFactory {
         }
     }
 
-    // --- EMIT EVENTS -----------------------------------------------
-
-    /// @notice Ensure that the called is a Cooler.
-    modifier onlyFromFactory() {
-        if (!created[msg.sender]) revert NotFromFactory();
-        _;
-    }
-
     /// @notice Emit a global event when a new loan request is created.
     function logDelegate(
         address caller,
@@ -92,4 +74,10 @@ contract DelegateEscrowFactory {
     ) external onlyFromFactory {
         emit Delegate(msg.sender, caller, onBehalfOf, delegationAmountDelta);
     }
+
+    /// @notice Ensure that the called is a Cooler.
+    modifier onlyFromFactory() {
+        if (!created[msg.sender]) revert NotFromFactory();
+        _;
+    }
 }

src/policies/cooler/MonoCooler.sol

@@ -503,25 +503,21 @@ contract MonoCooler is IMonoCooler, Policy, RolesConsumer {
     //                                       LIQUIDATIONS                                         //
     //============================================================================================//
 
-    // @todo incentivise liquidations
-    /*
-Frontier:
-> I wasn't sure how we want to incentivise liquidations. Heart based model with increasing reward doesn't work here imo since we can't easily know the start time of when it first became unhealthy.
-
-Anon:
-> First thought that comes to mind is have interest keep accruing but give the keeper the delta above liq point? kind of an already there gda mechanism
-
-It means the liquidation won't happen until that accrued interest pays for gas++, but probably not a problem if it's a few hours/days after the fact. It’s a softer liquidation mechanism but that’s more in the nature of expiry time to debt threshold, ie you could top up or repay before liquidation bot actually liquidates
-*/
-
     /// @inheritdoc IMonoCooler
     function batchLiquidate(
         address[] calldata accounts,
         DLGTEv1.DelegationRequest[][] calldata delegationRequests
-    ) external override returns (uint128 totalCollateralClaimed, uint128 totalDebtWiped) {
+    ) external override returns (
+        uint128 totalCollateralClaimed,
+        uint128 totalDebtWiped,
+        uint128 totalLiquidationIncentive
+    ) {
         if (liquidationsPaused) revert Paused();
 
-        uint256 totalLiquidationIncentive;
+        // Delegation requests can be left empty, otherwise it needs to be the same length as the
+        // `accounts`.
+        if (delegationRequests.length > 0 && delegationRequests.length != accounts.length) revert InvalidDelegationRequests();
+
         LiquidationStatus memory status;
         GlobalStateCache memory gState = _globalStateRW();
         address account;
@@ -532,17 +528,21 @@ It means the liquidation won't happen until that accrued interest pays for gas++
 
             // Skip if this account is still under the maxLTV
             if (status.exceededLiquidationLtv) {
-                emit Liquidated(account, status.collateral, status.currentDebt);
-
-                // Apply any undelegation requests
-                DLGTEv1.DelegationRequest[] calldata dreqs = delegationRequests[i];
-                if (dreqs.length > 1) {
-                    // Note: More collateral may be undelegated than required for the liquidation here.
-                    // But this is assumed ok - the liquidated user will need to re-apply the delegations again.
-                    (uint256 appliedDelegations, ) = DLGTE.applyDelegations(account, dreqs);
-
-                    // For liquidations, only allow undelegation requests
-                    if (appliedDelegations > 0) revert InvalidDelegationRequests();
+                emit Liquidated(msg.sender, account, status.collateral, status.currentDebt, status.currentIncentive);
+
+                // Apply any undelegation requests.
+                // Can be left empty, otherwise needs to be the same length as the
+                // `accounts`.
+                if (delegationRequests.length > 0) {
+                    DLGTEv1.DelegationRequest[] calldata dreqs = delegationRequests[i];
+                    if (dreqs.length > 0) {
+                        // Note: More collateral may be undelegated than required for the liquidation here.
+                        // But this is assumed ok - the liquidated user will need to re-apply the delegations again.
+                        (uint256 appliedDelegations, ) = DLGTE.applyDelegations(account, dreqs);
+
+                        // Only allow undelegation requests
+                        if (appliedDelegations > 0) revert InvalidDelegationRequests();
+                    }
                 }
 
                 // Withdraw the undelegated gOHM
@@ -560,7 +560,7 @@ It means the liquidation won't happen until that accrued interest pays for gas++
         // burn the gOHM collateral and update the total state.
         if (totalCollateralClaimed > 0) {
             // Unstake and burn gOHM holdings.
-            uint256 gOhmToBurn = totalCollateralClaimed - totalLiquidationIncentive;
+            uint128 gOhmToBurn = totalCollateralClaimed - totalLiquidationIncentive;
             collateralToken.safeApprove(address(staking), gOhmToBurn);
 
             MINTR.burnOhm(

src/policies/interfaces/IMonoCooler.sol

@@ -64,7 +64,7 @@ interface IMonoCooler {
         address indexed onBehalfOf,
         uint128 repayAmount
     );
-    event Liquidated(address indexed account, uint128 collateralSeized, uint128 debtWiped);
+    event Liquidated(address indexed caller, address indexed account, uint128 collateralSeized, uint128 debtWiped, uint128 incentives);
     event AuthorizationSet(address indexed caller, address indexed account, address indexed authorized, uint96 authorizationDeadline);
 
     /// @notice The record of an individual account's collateral and debt data
@@ -376,7 +376,11 @@ interface IMonoCooler {
     function batchLiquidate(
         address[] calldata accounts,
         DLGTEv1.DelegationRequest[][] calldata delegationRequests
-    ) external returns (uint128 totalCollateralClaimed, uint128 totalDebtWiped);
+    ) external returns (
+        uint128 totalCollateralClaimed,
+        uint128 totalDebtWiped,
+        uint128 totalLiquidationIncentive
+    );
 
     /**
      * @notice If an account becomes unhealthy and has many delegations such that liquidation can't be

src/test/external/cooler/DelegateEscrowFactory.t.sol

@@ -0,0 +1,172 @@
+// SPDX-License-Identifier: MAGPL-3.0-only
+pragma solidity 0.8.15;
+
+import {Test} from "forge-std/Test.sol";
+import {MockGohm} from "test/mocks/MockGohm.sol";
+
+import {DelegateEscrowFactory} from "src/external/cooler/DelegateEscrowFactory.sol";
+import {DelegateEscrow} from "src/external/cooler/DelegateEscrow.sol";
+import {IVotes} from "openzeppelin/governance/utils/IVotes.sol";
+
+contract DelegateEscrowFactoryTestBase is Test {
+
+    address public immutable ALICE = makeAddr("ALICE");
+    address public immutable BOB = makeAddr("BOB");
+    address public immutable CHARLIE = makeAddr("CHARLIE");
+
+    MockGohm internal gohm;
+    DelegateEscrowFactory escrowFactory;
+
+    event DelegateEscrowCreated(
+        address indexed caller,
+        address indexed delegate,
+        address indexed escrow
+    );
+
+    event Delegate(
+        address indexed escrow,
+        address indexed caller,
+        address indexed onBehalfOf,
+        int256 delegationAmountDelta
+    );
+
+    function setUp() public virtual {
+        gohm = new MockGohm("gOHM", "gOHM", 18);
+        escrowFactory = new DelegateEscrowFactory(address(gohm));
+    }
+}
+
+contract DelegateEscrowFactoryTest is DelegateEscrowFactoryTestBase {
+    function test_create_new() public {
+        vm.startPrank(ALICE);
+        address expectedEscrow = 0x8d2C17FAd02B7bb64139109c6533b7C2b9CADb81;
+        vm.assertEq(address(escrowFactory.escrowFor(BOB)), address(0));
+        vm.assertEq(escrowFactory.created(expectedEscrow), false);
+
+        vm.expectEmit(address(escrowFactory));
+        emit DelegateEscrowCreated(ALICE, BOB, expectedEscrow);
+        DelegateEscrow escrow = escrowFactory.create(BOB);
+        assertEq(address(escrow), expectedEscrow);
+
+        vm.assertEq(address(escrowFactory.escrowFor(BOB)), expectedEscrow);
+        vm.assertEq(escrowFactory.created(expectedEscrow), true);
+    }
+
+    function test_create_existing() public {
+        vm.startPrank(ALICE);
+        address expectedEscrow = 0x8d2C17FAd02B7bb64139109c6533b7C2b9CADb81;
+        DelegateEscrow escrow = escrowFactory.create(BOB);
+        assertEq(address(escrow), expectedEscrow);
+        escrow = escrowFactory.create(BOB);
+        assertEq(address(escrow), expectedEscrow);
+
+        vm.assertEq(address(escrowFactory.escrowFor(BOB)), expectedEscrow);
+        vm.assertEq(escrowFactory.created(expectedEscrow), true);
+    }
+
+    function test_access_logDelegate() public {
+        vm.startPrank(ALICE);
+        vm.expectRevert(abi.encodeWithSelector(DelegateEscrowFactory.NotFromFactory.selector));
+        escrowFactory.logDelegate(ALICE, ALICE, 123);
+    }
+
+    function test_logDelegate_failFactory() public {
+        vm.startPrank(ALICE);
+        vm.expectRevert(abi.encodeWithSelector(DelegateEscrowFactory.NotFromFactory.selector));
+        escrowFactory.logDelegate(ALICE, ALICE, 123);
+    }
+
+    function test_logDelegate_success() public {
+        vm.startPrank(ALICE);
+        DelegateEscrow escrow = escrowFactory.create(ALICE);
+        vm.startPrank(address(escrow));
+        vm.expectEmit(address(escrowFactory));
+        emit Delegate(address(escrow), ALICE, BOB, 123);
+        escrowFactory.logDelegate(ALICE, BOB, 123);
+    }
+}
+
+contract DelegateEscrowImplTest is DelegateEscrowFactoryTestBase {
+    DelegateEscrow internal aliceEscrow;
+
+    address internal immutable CALLER1 = makeAddr("CALLER1");
+    address internal immutable CALLER2 = makeAddr("CALLER2");
+
+    function delegate(address caller, uint256 amount, address onBehalfOf) internal returns (uint256) {
+        vm.startPrank(caller);
+        deal(address(gohm), caller, amount);
+        gohm.approve(address(aliceEscrow), amount);
+
+        vm.expectEmit(address(escrowFactory));
+        emit Delegate(address(aliceEscrow), caller, onBehalfOf, int256(amount));
+        return aliceEscrow.delegate(onBehalfOf, amount);
+    }
+
+    function rescind(address caller, address onBehalfOf, uint256 amount) internal returns (uint256 remaining) {
+        vm.startPrank(caller);
+        uint256 balBefore = gohm.balanceOf(caller);
+        vm.expectEmit(address(escrowFactory));
+        emit Delegate(address(aliceEscrow), caller, onBehalfOf, -int256(amount));
+        remaining = aliceEscrow.rescindDelegation(onBehalfOf, amount);
+        assertEq(gohm.balanceOf(caller)-balBefore, amount);
+        return remaining;
+    }
+
+    function setUp() public override {
+        DelegateEscrowFactoryTestBase.setUp();
+        aliceEscrow = escrowFactory.create(ALICE);
+    }
+
+    function test_constructor() public view {
+        assertEq(IVotes(address(gohm)).delegates(address(aliceEscrow)), ALICE);
+        assertEq(aliceEscrow.delegateAccount(), ALICE);
+        assertEq(address(aliceEscrow.factory()), address(escrowFactory));
+    }
+
+    function test_delegate() public {
+        assertEq(delegate(CALLER1, 10e18, ALICE), 10e18);
+        assertEq(aliceEscrow.delegations(CALLER1, ALICE), 10e18);
+        assertEq(delegate(CALLER1, 33e18, ALICE), 43e18);
+        assertEq(aliceEscrow.delegations(CALLER1, ALICE), 43e18);
+        assertEq(delegate(CALLER1, 10e18, BOB), 10e18);
+        assertEq(aliceEscrow.delegations(CALLER1, ALICE), 43e18);
+        assertEq(aliceEscrow.delegations(CALLER1, BOB), 10e18);
+
+        assertEq(delegate(CALLER2, 10e18, ALICE), 10e18);
+        assertEq(delegate(CALLER2, 33e18, ALICE), 43e18);
+        assertEq(delegate(CALLER2, 10e18, BOB), 10e18);
+        assertEq(aliceEscrow.delegations(CALLER2, ALICE), 43e18);
+        assertEq(aliceEscrow.delegations(CALLER2, BOB), 10e18);
+
+        assertEq(aliceEscrow.delegations(CALLER1, ALICE), 43e18);
+        assertEq(aliceEscrow.delegations(CALLER1, BOB), 10e18);
+    }
+
+    function test_rescindDelegation() public {
+        delegate(CALLER1, 43e18, ALICE);
+        delegate(CALLER1, 10e18, BOB);
+        delegate(CALLER2, 43e18, ALICE);
+        delegate(CALLER2, 10e18, BOB);
+
+        vm.startPrank(CALLER1);
+        vm.expectRevert(abi.encodeWithSelector(DelegateEscrow.ExceededDelegationBalance.selector));
+        aliceEscrow.rescindDelegation(ALICE, 43e18+1);
+
+        assertEq(rescind(CALLER1, ALICE, 5e18), 38e18);
+        assertEq(aliceEscrow.delegations(CALLER1, ALICE), 38e18);
+        assertEq(rescind(CALLER1, ALICE, 5e18), 33e18);
+        assertEq(aliceEscrow.delegations(CALLER1, ALICE), 33e18);
+        assertEq(rescind(CALLER1, BOB, 5e18), 5e18);
+        assertEq(aliceEscrow.delegations(CALLER1, BOB), 5e18);
+
+        assertEq(rescind(CALLER2, ALICE, 5e18), 38e18);
+        assertEq(aliceEscrow.delegations(CALLER2, ALICE), 38e18);
+        assertEq(rescind(CALLER2, ALICE, 5e18), 33e18);
+        assertEq(aliceEscrow.delegations(CALLER2, ALICE), 33e18);
+        assertEq(rescind(CALLER2, BOB, 5e18), 5e18);
+        assertEq(aliceEscrow.delegations(CALLER2, BOB), 5e18);
+
+        assertEq(aliceEscrow.delegations(CALLER1, ALICE), 33e18);
+        assertEq(aliceEscrow.delegations(CALLER1, BOB), 5e18);
+    }
+}

src/test/mocks/MockGohm.sol

@@ -4,22 +4,23 @@ pragma solidity ^0.8.0;
 import {MockERC20} from "solmate/test/utils/mocks/MockERC20.sol";
 
 interface IDelegate {
-    function delegate(address) external returns (bool);
+    function delegate(address) external;
+    function delegates(address) external view returns (address);
 }
 
 contract MockGohm is MockERC20, IDelegate {
     uint256 public constant index = 10000;
-    address public delegatee;
+
+    mapping(address => address) public override delegates;
 
     constructor(
         string memory name_,
         string memory symbol_,
         uint8 decimals_
     ) MockERC20(name_, symbol_, decimals_) {}
 
-    function delegate(address delegatee_) public returns (bool) {
-        delegatee = delegatee_;
-        return true;
+    function delegate(address delegatee_) public {
+        delegates[msg.sender] = delegatee_;
     }
 
     function balanceFrom(uint256 amount_) public view returns (uint256) {