feat: don't revert on sweepCurrency for non graduated auctions (#343)

Author: zhongeric

snapshots/AuctionTest.json

@@ -1,5 +1,5 @@
 {
-  "Auction bytecode size": "20415",
+  "Auction bytecode size": "20382",
   "checkpoint_advanceToCurrentStep": "180672",
   "checkpoint_noBids": "166644",
   "checkpoint_zeroSupply": "117018",

src/ContinuousClearingAuction.sol

@@ -656,8 +656,11 @@ contract ContinuousClearingAuction is
         if (msg.sender != FUNDS_RECIPIENT) revert NotAuthorized(FUNDS_RECIPIENT, msg.sender);
         // Cannot sweep if already swept
         if (sweepCurrencyBlock != 0) revert CannotSweepCurrency();
-        // Cannot sweep currency if the auction has not graduated, as all of the Currency must be refunded
-        if (!_isGraduated()) revert NotGraduated();
+        // If the auction did not graduate there is no currency to sweep as it all must be refunded to bidders
+        if (!_isGraduated()) {
+            _sweepCurrency(_getBlockNumberish(), 0);
+            return;
+        }
         // Sweep the currency and the protocol fee
         uint256 currencyRaised = currencyRaised();
         uint256 protocolFeeAmount =

test/Auction.graduation.t.sol

@@ -305,7 +305,7 @@ contract AuctionGraduationTest is AuctionBaseTest {
         auction.claimTokensBatch(alice, bids);
     }
 
-    function test_sweepCurrency_notGraduated_reverts(
+    function test_sweepCurrency_notGraduated_sweepsZeroCurrency(
         FuzzDeploymentParams memory _deploymentParams,
         uint128 _bidAmount,
         uint128 _maxPrice
@@ -327,9 +327,13 @@ contract AuctionGraduationTest is AuctionBaseTest {
         uint256 expectedCurrencyRaisedFromCheckpoint =
             (ValueX7.unwrap(auction.currencyRaisedQ96X7()) / ConstantsLib.MPS) >> FixedPoint96.RESOLUTION;
 
+        uint256 fundsRecipientBalanceBefore = fundsRecipient.balance;
+        vm.expectEmit(true, true, true, true);
+        emit IAuctionStorage.CurrencySwept(fundsRecipient, 0);
         vm.prank(fundsRecipient);
-        vm.expectRevert(IAuctionStorage.NotGraduated.selector);
         auction.sweepCurrency();
+        assertEq(auction.sweepCurrencyBlock(), block.number);
+        assertEq(fundsRecipient.balance, fundsRecipientBalanceBefore);
 
         emit log_string('===== Auction is NOT graduated =====');
         emit log_named_uint('currencyRaised in final checkpoint', expectedCurrencyRaisedFromCheckpoint);

test/Auction.invariant.t.sol

@@ -812,9 +812,11 @@ abstract contract AuctionInvariantBase is AuctionUnitTest {
             );
         } else {
             emit log_string('==================== NOT GRADUATED AUCTION ====================');
+            vm.expectEmit(true, true, true, true);
+            emit IAuctionStorage.CurrencySwept(mockAuction.fundsRecipient(), 0);
             vm.prank(mockAuction.fundsRecipient());
-            vm.expectRevert(IAuctionStorage.NotGraduated.selector);
             mockAuction.sweepCurrency();
+            assertEq(mockAuction.sweepCurrencyBlock(), block.number);
             // At this point we know all bids have been exited so auction balance should be zero
             assertEq(address(mockAuction).balance, 0, 'Auction balance is not zero at end of auction');
         }
@@ -900,9 +902,11 @@ abstract contract AuctionInvariantBase is AuctionUnitTest {
         );
         assertEq(token.balanceOf(address(mockAuction)), 0);
 
+        vm.expectEmit(true, true, true, true);
+        emit IAuctionStorage.CurrencySwept(mockAuction.fundsRecipient(), 0);
         vm.prank(mockAuction.fundsRecipient());
-        vm.expectRevert(IAuctionStorage.NotGraduated.selector);
         mockAuction.sweepCurrency();
+        assertEq(mockAuction.sweepCurrencyBlock(), block.number);
     }
 
     function helper__assertClaimsRevertWhenNotGraduated() internal {

test/Auction.t.sol

@@ -1058,9 +1058,11 @@ contract AuctionTest is AuctionBaseTest {
         assertEq(token.balanceOf(newAuction.tokensRecipient()), TOTAL_SUPPLY);
 
         // Expect no currency was swept
+        vm.expectEmit(true, true, true, true);
+        emit IAuctionStorage.CurrencySwept(newAuction.fundsRecipient(), 0);
         vm.prank(newAuction.fundsRecipient());
-        vm.expectRevert(IAuctionStorage.NotGraduated.selector);
         newAuction.sweepCurrency();
+        assertEq(newAuction.sweepCurrencyBlock(), block.number);
         assertEq(address(newAuction).balance, 0);
     }
 

test/btt/auction/sweepCurrency.t.sol

@@ -73,7 +73,9 @@ contract SweepCurrencyTest is BttBase {
         public
         givenEndBlockIsCheckpointed
     {
-        // it reverts with {NotGraduated}
+        // it writes sweepCurrencyBlock
+        // it does not transfer currency to funds recipient
+        // it emits {CurrencySwept} with zero amount
 
         vm.deal(address(this), type(uint256).max);
         vm.assume(_bidAmount > 0);
@@ -99,14 +101,22 @@ contract SweepCurrencyTest is BttBase {
         // max price must be > 1 (given min tick spacing)
 
         uint256 maxPrice = mParams.parameters.floorPrice + mParams.parameters.tickSpacing;
-        uint256 bidId = auction.submitBid{value: _bidAmount}(maxPrice, _bidAmount, owner, bytes(''));
+        auction.submitBid{value: _bidAmount}(maxPrice, _bidAmount, owner, bytes(''));
 
         vm.roll(mParams.parameters.endBlock);
-        auction.exitPartiallyFilledBid(bidId, mParams.parameters.startBlock, 0);
+        auction.checkpoint();
+
+        uint256 fundsRecipientBalanceBefore = mParams.parameters.fundsRecipient.balance;
+        uint256 auctionBalanceBefore = address(auction).balance;
 
+        vm.expectEmit(true, true, true, true);
+        emit IAuctionStorage.CurrencySwept(mParams.parameters.fundsRecipient, 0);
         vm.prank(mParams.parameters.fundsRecipient);
-        vm.expectRevert(IAuctionStorage.NotGraduated.selector);
         auction.sweepCurrency();
+
+        assertEq(auction.sweepCurrencyBlock(), block.number);
+        assertEq(mParams.parameters.fundsRecipient.balance, fundsRecipientBalanceBefore);
+        assertEq(address(auction).balance, auctionBalanceBefore);
     }
 
     modifier givenAuctionIsGraduated() {

test/btt/auction/sweepCurrency.tree

@@ -6,7 +6,9 @@ SweepCurrencyTest
     │   └── it reverts with {CannotSweepCurrency}
     └── given not previously swept
         ├── when auction is not graduated
-        │   └── it reverts with {NotGraduated}
+        │   ├── it writes sweepCurrencyBlock
+        │   ├── it does not transfer currency to funds recipient
+        │   └── it emits {CurrencySwept} with zero amount
         └── given auction is graduated
             ├── when amount GT zero
             │   ├── it writes sweepCurrencyBlock

test/utils/AuctionBaseTest.sol

@@ -510,10 +510,12 @@ abstract contract AuctionBaseTest is TokenHandler, Assertions, Test {
             auction.sweepUnsoldTokens();
             // Assert that all tokens were swept
             assertEq(token.balanceOf(auction.tokensRecipient()), auction.totalSupply());
-            // Expect to revert when sweeping currency
+            // Non-graduated auctions still mark currency as swept but transfer no funds.
+            vm.expectEmit(true, true, true, true);
+            emit IAuctionStorage.CurrencySwept(auction.fundsRecipient(), 0);
             vm.prank(auction.fundsRecipient());
-            vm.expectRevert(IAuctionStorage.NotGraduated.selector);
             auction.sweepCurrency();
+            assertEq(auction.sweepCurrencyBlock(), block.number);
         }
     }