feat: extract cancel thaw escrow to its own function

Signed-off-by: Tomás Migone <[email protected]>

Author: tmigone

packages/horizon/contracts/interfaces/IPaymentsEscrow.sol

@@ -38,8 +38,10 @@ interface IPaymentsEscrow {
      * @notice Emitted when a payer cancels an escrow thawing
      * @param payer The address of the payer
      * @param receiver The address of the receiver
+     * @param tokensThawing The amount of tokens that were being thawed
+     * @param thawEndTimestamp The timestamp at which the thawing period was ending
      */
-    event CancelThaw(address indexed payer, address indexed receiver);
+    event CancelThaw(address indexed payer, address indexed receiver, uint256 tokensThawing, uint256 thawEndTimestamp);
 
     /**
      * @notice Emitted when a payer thaws funds from the escrow for a payer-collector-receiver tuple
@@ -145,20 +147,29 @@ interface IPaymentsEscrow {
     /**
      * @notice Thaw a specific amount of escrow from a payer-collector-receiver's escrow account.
      * The payer is the transaction caller.
-     * If `tokens` is zero and funds were already thawing it will cancel the thawing.
      * Note that repeated calls to this function will overwrite the previous thawing amount
      * and reset the thawing period.
      * @dev Requirements:
      * - `tokens` must be less than or equal to the available balance
      *
-     * Emits a {Thaw} event. If `tokens` is zero it will emit a {CancelThaw} event.
+     * Emits a {Thaw} event.
      *
      * @param collector The address of the collector
      * @param receiver The address of the receiver
      * @param tokens The amount of tokens to thaw
      */
     function thaw(address collector, address receiver, uint256 tokens) external;
 
+    /**
+     * @notice Cancels the thawing of escrow from a payer-collector-receiver's escrow account.
+     * @param collector The address of the collector
+     * @param receiver The address of the receiver
+     * @dev Requirements:
+     * - The payer must be thawing funds
+     * Emits a {CancelThaw} event.
+     */
+    function cancelThaw(address collector, address receiver) external;
+
     /**
      * @notice Withdraws all thawed escrow from a payer-collector-receiver's escrow account.
      * The payer is the transaction caller.

packages/horizon/contracts/payments/PaymentsEscrow.sol

@@ -78,19 +78,9 @@ contract PaymentsEscrow is Initializable, MulticallUpgradeable, GraphDirectory,
      * @notice See {IPaymentsEscrow-thaw}
      */
     function thaw(address collector, address receiver, uint256 tokens) external override notPaused {
-        EscrowAccount storage account = escrowAccounts[msg.sender][collector][receiver];
-
-        // if amount thawing is zero and requested amount is zero this is an invalid request.
-        // otherwise if amount thawing is greater than zero and requested amount is zero this
-        // is a cancel thaw request.
-        if (tokens == 0) {
-            require(account.tokensThawing != 0, PaymentsEscrowNotThawing());
-            account.tokensThawing = 0;
-            account.thawEndTimestamp = 0;
-            emit CancelThaw(msg.sender, receiver);
-            return;
-        }
+        require(tokens > 0, PaymentsEscrowInvalidZeroTokens());
 
+        EscrowAccount storage account = escrowAccounts[msg.sender][collector][receiver];
         require(account.balance >= tokens, PaymentsEscrowInsufficientBalance(account.balance, tokens));
 
         account.tokensThawing = tokens;
@@ -99,6 +89,21 @@ contract PaymentsEscrow is Initializable, MulticallUpgradeable, GraphDirectory,
         emit Thaw(msg.sender, collector, receiver, tokens, account.thawEndTimestamp);
     }
 
+    /**
+     * @notice See {IPaymentsEscrow-cancelThaw}
+     */
+    function cancelThaw(address collector, address receiver) external override notPaused {
+        EscrowAccount storage account = escrowAccounts[msg.sender][collector][receiver];
+        require(account.tokensThawing != 0, PaymentsEscrowNotThawing());
+
+        uint256 tokensThawing = account.tokensThawing;
+        uint256 thawEndTimestamp = account.thawEndTimestamp;
+        account.tokensThawing = 0;
+        account.thawEndTimestamp = 0;
+
+        emit CancelThaw(msg.sender, receiver, tokensThawing, thawEndTimestamp);
+    }
+
     /**
      * @notice See {IPaymentsEscrow-withdraw}
      */

packages/horizon/test/escrow/GraphEscrow.t.sol

@@ -56,6 +56,19 @@ contract GraphEscrowTest is HorizonStakingSharedTest, PaymentsEscrowSharedTest {
         assertEq(thawEndTimestamp, expectedThawEndTimestamp);
     }
 
+    function _cancelThawEscrow(address collector, address receiver) internal {
+        (, address msgSender, ) = vm.readCallers();
+        (, uint256 amountThawingBefore, uint256 thawEndTimestampBefore) = escrow.escrowAccounts(msgSender, collector, receiver);
+
+        vm.expectEmit(address(escrow));
+        emit IPaymentsEscrow.CancelThaw(msgSender, receiver, amountThawingBefore, thawEndTimestampBefore);
+        escrow.cancelThaw(collector, receiver);
+
+        (, uint256 amountThawing, uint256 thawEndTimestamp) = escrow.escrowAccounts(msgSender, collector, receiver);
+        assertEq(amountThawing, 0);
+        assertEq(thawEndTimestamp, 0);
+    }
+
     struct CollectPaymentData {
         uint256 escrowBalance;
         uint256 paymentsBalance;

packages/horizon/test/escrow/thaw.t.sol

@@ -6,19 +6,32 @@ import "forge-std/Test.sol";
 import { GraphEscrowTest } from "./GraphEscrow.t.sol";
 
 contract GraphEscrowThawTest is GraphEscrowTest {
-
     /*
      * TESTS
      */
 
     function testThaw_Tokens(uint256 amount) public useGateway useDeposit(amount) {
+        amount = bound(amount, 1, type(uint256).max);
         _thawEscrow(users.verifier, users.indexer, amount);
     }
 
-    function testThaw_RevertWhen_InsufficientThawAmount(
-        uint256 amount
-    ) public useGateway useDeposit(amount) {
-        bytes memory expectedError = abi.encodeWithSignature("PaymentsEscrowNotThawing()");
+    function testThaw_Tokens_SuccesiveCalls(uint256 amount) public useGateway {
+        amount = bound(amount, 2, type(uint256).max - 10);
+        _depositTokens(users.verifier, users.indexer, amount);
+
+        uint256 firstAmountToThaw = (amount + 2 - 1) / 2;
+        uint256 secondAmountToThaw = (amount + 10 - 1) / 10;
+        _thawEscrow(users.verifier, users.indexer, firstAmountToThaw);
+        _thawEscrow(users.verifier, users.indexer, secondAmountToThaw);
+
+        (, address msgSender, ) = vm.readCallers();
+        (, uint256 amountThawing, uint256 thawEndTimestamp) = escrow.escrowAccounts(msgSender, users.verifier, users.indexer);
+        assertEq(amountThawing, secondAmountToThaw);
+        assertEq(thawEndTimestamp, block.timestamp + withdrawEscrowThawingPeriod);
+    }
+
+    function testThaw_Tokens_RevertWhen_AmountIsZero() public useGateway {
+        bytes memory expectedError = abi.encodeWithSignature("PaymentsEscrowInvalidZeroTokens()");
         vm.expectRevert(expectedError);
         escrow.thaw(users.verifier, users.indexer, 0);
     }
@@ -28,17 +41,23 @@ contract GraphEscrowThawTest is GraphEscrowTest {
         uint256 overAmount
     ) public useGateway useDeposit(amount) {
         overAmount = bound(overAmount, amount + 1, type(uint256).max);
-        bytes memory expectedError = abi.encodeWithSignature("PaymentsEscrowInsufficientBalance(uint256,uint256)", amount, overAmount);
+        bytes memory expectedError = abi.encodeWithSignature(
+            "PaymentsEscrowInsufficientBalance(uint256,uint256)",
+            amount,
+            overAmount
+        );
         vm.expectRevert(expectedError);
         escrow.thaw(users.verifier, users.indexer, overAmount);
     }
 
     function testThaw_CancelRequest(uint256 amount) public useGateway useDeposit(amount) {
-        escrow.thaw(users.verifier, users.indexer, amount);
-        escrow.thaw(users.verifier, users.indexer, 0);
+        _thawEscrow(users.verifier, users.indexer, amount);
+        _cancelThawEscrow(users.verifier, users.indexer);
+    }
 
-        (, uint256 amountThawing,uint256 thawEndTimestamp) = escrow.escrowAccounts(users.gateway, users.verifier, users.indexer);
-        assertEq(amountThawing, 0);
-        assertEq(thawEndTimestamp, 0);
+    function testThaw_CancelRequest_RevertWhen_NoThawing(uint256 amount) public useGateway useDeposit(amount) {
+        bytes memory expectedError = abi.encodeWithSignature("PaymentsEscrowNotThawing()");
+        vm.expectRevert(expectedError);
+        escrow.cancelThaw(users.verifier, users.indexer);
     }
-}
+}