@bananapus/distributor-v6 0.0.3 → 0.0.4

package/test/JB721Distributor.t.sol

@@ -5,7 +5,6 @@ import {Test} from "forge-std/Test.sol";
 
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
-import {IJB721TiersHook} from "@bananapus/721-hook-v6/src/interfaces/IJB721TiersHook.sol";
 import {JB721Tier} from "@bananapus/721-hook-v6/src/structs/JB721Tier.sol";
 import {JB721TierFlags} from "@bananapus/721-hook-v6/src/structs/JB721TierFlags.sol";
 
@@ -201,7 +200,7 @@ contract JB721DistributorTest is Test {
     address charlie = makeAddr("charlie");
 
     uint256 constant PROJECT_ID = 1;
-    uint256 constant ROUND_DURATION = 100;
+    uint256 constant ROUND_DURATION = 100; // 100 seconds per round.
     uint256 constant VESTING_ROUNDS = 4;
     uint256 constant MAX_SHARE = 100_000;
 
@@ -274,6 +273,53 @@ contract JB721DistributorTest is Test {
         hook.setOwner(2, bob);
     }
 
+    // =====================================================================
+    // Helpers
+    // =====================================================================
+
+    /// @notice Advance to 1 second after the start of the given round, and advance block number too.
+    function _advanceToRound(uint256 round) internal {
+        uint256 targetTimestamp = distributor.roundStartTimestamp(round) + 1;
+        if (block.timestamp < targetTimestamp) {
+            vm.warp(targetTimestamp);
+        }
+        // Also advance block number so getPastVotes works with past blocks.
+        vm.roll(block.number + 1);
+    }
+
+    function _fundHook(uint256 amount) internal {
+        rewardToken.mint(address(this), amount);
+        rewardToken.approve(address(distributor), amount);
+        distributor.fund(address(hook), IERC20(address(rewardToken)), amount);
+    }
+
+    function _beginVestingBoth() internal {
+        uint256[] memory tokenIds = new uint256[](2);
+        tokenIds[0] = 1;
+        tokenIds[1] = 2;
+        IERC20[] memory tokens = new IERC20[](1);
+        tokens[0] = IERC20(address(rewardToken));
+        distributor.beginVesting(address(hook), tokenIds, tokens);
+    }
+
+    function _splitContext(address token, uint256 amount) internal view returns (JBSplitHookContext memory) {
+        return JBSplitHookContext({
+            token: token,
+            amount: amount,
+            decimals: 18,
+            projectId: 1,
+            groupId: uint256(uint160(token)),
+            split: JBSplit({
+                percent: 500_000_000, // 50%
+                projectId: 0,
+                beneficiary: payable(address(hook)), // hook address as beneficiary
+                preferAddToBalance: false,
+                lockedUntil: 0,
+                hook: IJBSplitHook(address(distributor))
+            })
+        });
+    }
+
     // =====================================================================
     // Constructor
     // =====================================================================
@@ -281,7 +327,7 @@ contract JB721DistributorTest is Test {
     function test_constructor() public view {
         assertEq(distributor.roundDuration(), ROUND_DURATION);
         assertEq(distributor.vestingRounds(), VESTING_ROUNDS);
-        assertEq(distributor.startingBlock(), block.number);
+        assertEq(distributor.startingTimestamp(), block.timestamp);
         assertEq(distributor.MAX_SHARE(), MAX_SHARE);
     }
 
@@ -293,18 +339,18 @@ contract JB721DistributorTest is Test {
         assertEq(distributor.currentRound(), 0);
     }
 
-    function test_currentRound_afterRolling() public {
-        vm.roll(block.number + ROUND_DURATION);
+    function test_currentRound_afterWarping() public {
+        vm.warp(block.timestamp + ROUND_DURATION);
         assertEq(distributor.currentRound(), 1);
 
-        vm.roll(block.number + ROUND_DURATION * 3);
+        vm.warp(block.timestamp + ROUND_DURATION * 3);
         assertEq(distributor.currentRound(), 4);
     }
 
-    function test_roundStartBlock() public view {
-        assertEq(distributor.roundStartBlock(0), distributor.startingBlock());
-        assertEq(distributor.roundStartBlock(1), distributor.startingBlock() + ROUND_DURATION);
-        assertEq(distributor.roundStartBlock(5), distributor.startingBlock() + ROUND_DURATION * 5);
+    function test_roundStartTimestamp() public view {
+        assertEq(distributor.roundStartTimestamp(0), distributor.startingTimestamp());
+        assertEq(distributor.roundStartTimestamp(1), distributor.startingTimestamp() + ROUND_DURATION);
+        assertEq(distributor.roundStartTimestamp(5), distributor.startingTimestamp() + ROUND_DURATION * 5);
     }
 
     function test_claimedFor_beforeVesting() public view {
@@ -336,7 +382,7 @@ contract JB721DistributorTest is Test {
         _fundHook(1000 ether);
         _beginVestingBoth();
 
-        vm.roll(block.number + ROUND_DURATION * 2);
+        _advanceToRound(2);
 
         // lockedShare = (4-2)*100000/4 = 50000.
         // collectableFor = mulDiv(250e18, 100000 - 0 - 50000, 100000) = 125e18.
@@ -347,7 +393,7 @@ contract JB721DistributorTest is Test {
         _fundHook(1000 ether);
         _beginVestingBoth();
 
-        vm.roll(block.number + ROUND_DURATION * VESTING_ROUNDS);
+        _advanceToRound(VESTING_ROUNDS);
 
         // lockedShare = 0. collectableFor = 250e18.
         assertEq(distributor.collectableFor(address(hook), 1, IERC20(address(rewardToken))), 250 ether);
@@ -388,7 +434,7 @@ contract JB721DistributorTest is Test {
         assertEq(distributor.latestVestedIndexOf(address(hook), 1, IERC20(address(rewardToken))), 0);
 
         // Collect fully -> latestVestedIndex should advance.
-        vm.roll(block.number + ROUND_DURATION * VESTING_ROUNDS);
+        _advanceToRound(VESTING_ROUNDS);
         vm.prank(alice);
         uint256[] memory tokenIds = new uint256[](1);
         tokenIds[0] = 1;
@@ -447,7 +493,7 @@ contract JB721DistributorTest is Test {
         assertEq(distributor.claimedFor(address(hook), 1, nativeToken), 25 ether);
 
         // Advance past full vesting.
-        vm.roll(block.number + ROUND_DURATION * VESTING_ROUNDS);
+        _advanceToRound(VESTING_ROUNDS);
 
         // Alice collects.
         uint256 aliceBalBefore = alice.balance;
@@ -484,7 +530,7 @@ contract JB721DistributorTest is Test {
         assertEq(distributor.totalVestingAmountOf(address(hook), IERC20(address(rewardToken))), 250 ether);
     }
 
-    function test_beginVesting_alreadyVesting_reverts() public {
+    function test_beginVesting_alreadyVesting_skips() public {
         _fundHook(1000 ether);
 
         uint256[] memory tokenIds = new uint256[](1);
@@ -494,8 +540,11 @@ contract JB721DistributorTest is Test {
 
         distributor.beginVesting(address(hook), tokenIds, tokens);
 
-        vm.expectRevert(JBDistributor.JBDistributor_AlreadyVesting.selector);
+        // Second call in same round should silently skip (not revert).
         distributor.beginVesting(address(hook), tokenIds, tokens);
+
+        // Only one vesting entry should exist.
+        assertEq(distributor.claimedFor(address(hook), 1, IERC20(address(rewardToken))), 250 ether);
     }
 
     function test_beginVesting_nextRound_succeeds() public {
@@ -509,7 +558,7 @@ contract JB721DistributorTest is Test {
         distributor.beginVesting(address(hook), tokenIds, tokens);
 
         // Move to next round, add more funds, should succeed.
-        vm.roll(block.number + ROUND_DURATION);
+        _advanceToRound(1);
         _fundHook(500 ether);
         distributor.beginVesting(address(hook), tokenIds, tokens);
 
@@ -557,6 +606,43 @@ contract JB721DistributorTest is Test {
         distributor.beginVesting(address(hook), tokenIds, tokens);
     }
 
+    // =====================================================================
+    // poke
+    // =====================================================================
+
+    function test_poke_recordsSnapshotBlock() public {
+        _advanceToRound(1);
+
+        uint256 expectedBlock = block.number - 1;
+        distributor.poke();
+
+        assertEq(distributor.roundSnapshotBlock(1), expectedBlock);
+    }
+
+    function test_poke_emitsEvent() public {
+        _advanceToRound(1);
+
+        vm.expectEmit(true, false, false, true);
+        emit IJBDistributor.RoundSnapshotRecorded(1, block.number - 1);
+
+        distributor.poke();
+    }
+
+    function test_poke_idempotent() public {
+        _advanceToRound(1);
+
+        distributor.poke();
+        uint256 firstSnapshot = distributor.roundSnapshotBlock(1);
+
+        // Advance block but stay in same round.
+        vm.roll(block.number + 10);
+
+        distributor.poke();
+        uint256 secondSnapshot = distributor.roundSnapshotBlock(1);
+
+        assertEq(firstSnapshot, secondSnapshot, "Poke should be idempotent within a round");
+    }
+
     // =====================================================================
     // collectVestedRewards -- exact value assertions
     // =====================================================================
@@ -571,13 +657,15 @@ contract JB721DistributorTest is Test {
 
         distributor.beginVesting(address(hook), tokenIds, tokens);
 
-        vm.roll(block.number + ROUND_DURATION * VESTING_ROUNDS);
+        _advanceToRound(VESTING_ROUNDS);
 
         vm.prank(alice);
         distributor.collectVestedRewards(address(hook), tokenIds, tokens, alice);
 
         assertEq(rewardToken.balanceOf(alice), 250 ether);
-        assertEq(distributor.totalVestingAmountOf(address(hook), IERC20(address(rewardToken))), 0);
+        // Auto-vest during collect created a new entry (25% of 750 undistributed = 187.5 ether).
+        // That entry is fully locked at collection time and remains in totalVesting.
+        assertEq(distributor.totalVestingAmountOf(address(hook), IERC20(address(rewardToken))), 187.5 ether);
     }
 
     function test_collectVestedRewards_partialVesting_exactAmounts() public {
@@ -590,24 +678,27 @@ contract JB721DistributorTest is Test {
 
         distributor.beginVesting(address(hook), tokenIds, tokens);
 
-        // Roll forward 2 of 4 rounds (50%).
-        vm.roll(block.number + ROUND_DURATION * 2);
+        // Warp forward 2 of 4 rounds (50%).
+        _advanceToRound(2);
 
         vm.prank(alice);
         distributor.collectVestedRewards(address(hook), tokenIds, tokens, alice);
 
-        // lockedShare = (4-2)*100000/4 = 50000. claimAmount = mulDiv(250e18, 50000, 100000) = 125e18.
+        // Entry 0 (250e18, release=4): 50% unlocked → 125 ether.
+        // Auto-vest entry (187.5e18, release=6): 100% locked → 0.
         assertEq(rewardToken.balanceOf(alice), 125 ether);
 
-        // Roll forward remaining 2 rounds.
-        vm.roll(block.number + ROUND_DURATION * 2);
+        // Warp forward remaining 2 rounds.
+        _advanceToRound(VESTING_ROUNDS);
 
         vm.prank(alice);
         distributor.collectVestedRewards(address(hook), tokenIds, tokens, alice);
 
-        // After partial: shareClaimed = 50000, lockedShare = 0.
-        // claimAmount = mulDiv(250e18, 100000-50000, 100000) = 125e18.
-        assertEq(rewardToken.balanceOf(alice), 250 ether);
+        // Entry 0 remaining: 125 ether.
+        // Entry 1 (187.5e18, release=6): 50% unlocked at round 4 → 93.75 ether.
+        // Entry 2 (auto-vest round 4, release=8): 100% locked → 0.
+        // Total: 125 + 125 + 93.75 = 343.75.
+        assertEq(rewardToken.balanceOf(alice), 343.75 ether);
     }
 
     function test_collectVestedRewards_quarterVesting() public {
@@ -620,8 +711,8 @@ contract JB721DistributorTest is Test {
 
         distributor.beginVesting(address(hook), tokenIds, tokens);
 
-        // Roll forward 1 of 4 rounds (25%).
-        vm.roll(block.number + ROUND_DURATION);
+        // Warp forward 1 of 4 rounds (25%).
+        _advanceToRound(1);
 
         vm.prank(alice);
         distributor.collectVestedRewards(address(hook), tokenIds, tokens, alice);
@@ -640,8 +731,8 @@ contract JB721DistributorTest is Test {
 
         distributor.beginVesting(address(hook), tokenIds, tokens);
 
-        // Roll forward 3 of 4 rounds (75%).
-        vm.roll(block.number + ROUND_DURATION * 3);
+        // Warp forward 3 of 4 rounds (75%).
+        _advanceToRound(3);
 
         vm.prank(alice);
         distributor.collectVestedRewards(address(hook), tokenIds, tokens, alice);
@@ -659,7 +750,7 @@ contract JB721DistributorTest is Test {
         tokens[0] = IERC20(address(rewardToken));
 
         distributor.beginVesting(address(hook), tokenIds, tokens);
-        vm.roll(block.number + ROUND_DURATION * VESTING_ROUNDS);
+        _advanceToRound(VESTING_ROUNDS);
 
         vm.prank(bob);
         vm.expectRevert(JBDistributor.JBDistributor_NoAccess.selector);
@@ -688,7 +779,7 @@ contract JB721DistributorTest is Test {
         tokens[0] = IERC20(address(rewardToken));
 
         distributor.beginVesting(address(hook), tokenIds, tokens);
-        vm.roll(block.number + ROUND_DURATION * VESTING_ROUNDS);
+        _advanceToRound(VESTING_ROUNDS);
 
         vm.expectEmit(true, true, false, true);
         emit IJBDistributor.Collected(address(hook), 1, IERC20(address(rewardToken)), 250 ether, VESTING_ROUNDS);
@@ -706,7 +797,7 @@ contract JB721DistributorTest is Test {
         tokens[0] = IERC20(address(rewardToken));
 
         distributor.beginVesting(address(hook), tokenIds, tokens);
-        vm.roll(block.number + ROUND_DURATION * VESTING_ROUNDS);
+        _advanceToRound(VESTING_ROUNDS);
 
         // Alice sends to charlie.
         vm.prank(alice);
@@ -716,6 +807,48 @@ contract JB721DistributorTest is Test {
         assertEq(rewardToken.balanceOf(alice), 0);
     }
 
+    // =====================================================================
+    // Auto-vest on collect
+    // =====================================================================
+
+    function test_autoVest_collectWithoutBeginVesting() public {
+        _fundHook(1000 ether);
+
+        // Advance past full vesting WITHOUT calling beginVesting.
+        _advanceToRound(VESTING_ROUNDS);
+
+        // Alice calls collectVestedRewards directly — auto-vest should create a vesting entry.
+        uint256[] memory tokenIds = new uint256[](1);
+        tokenIds[0] = 1;
+        IERC20[] memory tokens = new IERC20[](1);
+        tokens[0] = IERC20(address(rewardToken));
+
+        vm.prank(alice);
+        distributor.collectVestedRewards(address(hook), tokenIds, tokens, alice);
+
+        // Auto-vest happened for the current round. Since it just started vesting, nothing is unlocked yet.
+        uint256 claimed = distributor.claimedFor(address(hook), 1, IERC20(address(rewardToken)));
+        assertEq(claimed, 250 ether, "Auto-vest should have created a vesting entry");
+    }
+
+    function test_autoVest_doubleCollectInSameRound_noRevert() public {
+        _fundHook(1000 ether);
+        _advanceToRound(1);
+
+        uint256[] memory tokenIds = new uint256[](1);
+        tokenIds[0] = 1;
+        IERC20[] memory tokens = new IERC20[](1);
+        tokens[0] = IERC20(address(rewardToken));
+
+        // First collect auto-vests.
+        vm.prank(alice);
+        distributor.collectVestedRewards(address(hook), tokenIds, tokens, alice);
+
+        // Second collect in same round should not revert (skips auto-vest since already vested).
+        vm.prank(alice);
+        distributor.collectVestedRewards(address(hook), tokenIds, tokens, alice);
+    }
+
     // =====================================================================
     // releaseForfeitedRewards
     // =====================================================================
@@ -732,7 +865,7 @@ contract JB721DistributorTest is Test {
 
         assertEq(distributor.totalVestingAmountOf(address(hook), IERC20(address(rewardToken))), 250 ether);
 
-        vm.roll(block.number + ROUND_DURATION * VESTING_ROUNDS);
+        _advanceToRound(VESTING_ROUNDS);
         hook.burn(1);
 
         distributor.releaseForfeitedRewards(address(hook), tokenIds, tokens, alice);
@@ -752,8 +885,8 @@ contract JB721DistributorTest is Test {
 
         distributor.beginVesting(address(hook), tokenIds, tokens);
 
-        // Roll forward 2 of 4 rounds.
-        vm.roll(block.number + ROUND_DURATION * 2);
+        // Warp forward 2 of 4 rounds.
+        _advanceToRound(2);
         hook.burn(1);
 
         distributor.releaseForfeitedRewards(address(hook), tokenIds, tokens, alice);
@@ -784,7 +917,7 @@ contract JB721DistributorTest is Test {
         assertEq(distributor.totalVestingAmountOf(address(hook), IERC20(address(rewardToken))), 500 ether);
 
         // Next round should work fine — no underflow.
-        vm.roll(block.number + ROUND_DURATION);
+        _advanceToRound(1);
         _fundHook(1 ether);
         distributor.beginVesting(address(hook), tokenIds, tokens);
     }
@@ -844,7 +977,7 @@ contract JB721DistributorTest is Test {
         assertEq(distributor.totalVestingAmountOf(address(hook), IERC20(address(rewardToken))), 250 ether);
         assertEq(distributor.totalVestingAmountOf(address(hook), IERC20(address(rewardToken2))), 125 ether);
 
-        vm.roll(block.number + ROUND_DURATION * VESTING_ROUNDS);
+        _advanceToRound(VESTING_ROUNDS);
 
         vm.prank(alice);
         distributor.collectVestedRewards(address(hook), tokenIds, tokens, alice);
@@ -870,7 +1003,7 @@ contract JB721DistributorTest is Test {
         // Token 1 gets 250e18 from round 0.
 
         // Move to round 1: fund 400 more and vest.
-        vm.roll(block.number + ROUND_DURATION);
+        _advanceToRound(1);
         _fundHook(400 ether);
         distributor.beginVesting(address(hook), tokenIds, tokens);
 
@@ -879,7 +1012,7 @@ contract JB721DistributorTest is Test {
         // Token 1 gets mulDiv(1150e18, 100, 400) = 287.5e18 from round 1.
 
         // Move past all vesting.
-        vm.roll(block.number + ROUND_DURATION * VESTING_ROUNDS);
+        _advanceToRound(1 + VESTING_ROUNDS);
 
         vm.prank(alice);
         distributor.collectVestedRewards(address(hook), tokenIds, tokens, alice);
@@ -934,7 +1067,7 @@ contract JB721DistributorTest is Test {
         );
 
         // After partial collect, still holds.
-        vm.roll(block.number + ROUND_DURATION * 2);
+        _advanceToRound(2);
         vm.prank(alice);
         uint256[] memory tokenIds = new uint256[](1);
         tokenIds[0] = 1;
@@ -952,7 +1085,7 @@ contract JB721DistributorTest is Test {
         _fundHook(1000 ether);
         _beginVestingBoth();
 
-        vm.roll(block.number + ROUND_DURATION * VESTING_ROUNDS);
+        _advanceToRound(VESTING_ROUNDS);
 
         // Collect both.
         uint256[] memory aliceIds = new uint256[](1);
@@ -969,7 +1102,8 @@ contract JB721DistributorTest is Test {
 
         assertEq(rewardToken.balanceOf(alice), 250 ether);
         assertEq(rewardToken.balanceOf(bob), 500 ether);
-        assertEq(distributor.totalVestingAmountOf(address(hook), IERC20(address(rewardToken))), 0);
+        // Auto-vest during collect created new entries: 62.5 (alice) + 125 (bob) = 187.5 ether.
+        assertEq(distributor.totalVestingAmountOf(address(hook), IERC20(address(rewardToken))), 187.5 ether);
         // 250 ether remains undistributed (remaining 25% of stake not claimed by any token).
         assertEq(distributor.balanceOf(address(hook), IERC20(address(rewardToken))), 250 ether);
     }
@@ -1012,7 +1146,7 @@ contract JB721DistributorTest is Test {
 
         uint256 totalClaimed = distributor.claimedFor(address(hook), 1, IERC20(address(rewardToken)));
 
-        vm.roll(block.number + ROUND_DURATION * rounds);
+        _advanceToRound(rounds);
 
         vm.prank(alice);
         distributor.collectVestedRewards(address(hook), tokenIds, tokens, alice);
@@ -1039,7 +1173,7 @@ contract JB721DistributorTest is Test {
 
         uint256 totalClaimed = distributor.claimedFor(address(hook), 1, IERC20(address(rewardToken)));
 
-        vm.roll(block.number + ROUND_DURATION * VESTING_ROUNDS);
+        _advanceToRound(VESTING_ROUNDS);
 
         vm.prank(alice);
         distributor.collectVestedRewards(address(hook), tokenIds, tokens, alice);
@@ -1061,7 +1195,7 @@ contract JB721DistributorTest is Test {
 
         distributor.beginVesting(address(hook), tokenIds, tokens);
 
-        vm.roll(block.number + ROUND_DURATION * 2);
+        _advanceToRound(2);
 
         // Check collectableFor equals what we actually collect.
         uint256 collectable = distributor.collectableFor(address(hook), 1, IERC20(address(rewardToken)));
@@ -1089,13 +1223,14 @@ contract JB721DistributorTest is Test {
 
         // Collect at each round.
         for (uint256 r = 1; r <= VESTING_ROUNDS; r++) {
-            vm.roll(block.number + ROUND_DURATION);
+            _advanceToRound(r);
             vm.prank(alice);
             distributor.collectVestedRewards(address(hook), tokenIds, tokens, alice);
         }
 
-        // Sum of all partial collects should equal total claimed (within rounding).
-        assertApproxEqAbs(rewardToken.balanceOf(alice), totalClaimed, VESTING_ROUNDS);
+        // Alice receives at least totalClaimed from the original vest.
+        // Auto-vest during each collect redistributes from the undistributed pool, adding more.
+        assertGe(rewardToken.balanceOf(alice), totalClaimed);
     }
 
     // =====================================================================
@@ -1143,9 +1278,9 @@ contract JB721DistributorTest is Test {
         IERC20[] memory tokens = new IERC20[](1);
         tokens[0] = IERC20(address(rewardToken));
 
-        // Should succeed with no-op for inner loop.
+        // Should revert when no token IDs are provided.
+        vm.expectRevert(JBDistributor.JBDistributor_EmptyTokenIds.selector);
         distributor.beginVesting(address(hook), tokenIds, tokens);
-        assertEq(distributor.totalVestingAmountOf(address(hook), IERC20(address(rewardToken))), 0);
     }
 
     function test_beginVesting_emptyTokens() public {
@@ -1161,6 +1296,8 @@ contract JB721DistributorTest is Test {
         uint256[] memory tokenIds = new uint256[](0);
         IERC20[] memory tokens = new IERC20[](0);
 
+        // Should revert when no token IDs are provided.
+        vm.expectRevert(JBDistributor.JBDistributor_EmptyTokenIds.selector);
         distributor.collectVestedRewards(address(hook), tokenIds, tokens, alice);
     }
 
@@ -1177,7 +1314,7 @@ contract JB721DistributorTest is Test {
         tokens[0] = IERC20(address(rewardToken));
 
         distributor.beginVesting(address(hook), tokenIds, tokens);
-        vm.roll(block.number + ROUND_DURATION * VESTING_ROUNDS);
+        _advanceToRound(VESTING_ROUNDS);
 
         vm.prank(alice);
         distributor.collectVestedRewards(address(hook), tokenIds, tokens, alice);
@@ -1205,7 +1342,7 @@ contract JB721DistributorTest is Test {
         tokens[0] = IERC20(address(rewardToken));
 
         distributor.beginVesting(address(hook), tokenIds, tokens);
-        vm.roll(block.number + ROUND_DURATION * VESTING_ROUNDS);
+        _advanceToRound(VESTING_ROUNDS);
 
         // Transfer token 1 from alice to charlie.
         hook.setOwner(1, charlie);
@@ -1236,27 +1373,28 @@ contract JB721DistributorTest is Test {
         distributor.beginVesting(address(hook), tokenIds, tokens);
 
         // Round 1: vest
-        vm.roll(block.number + ROUND_DURATION);
+        _advanceToRound(1);
         _fundHook(400 ether);
         distributor.beginVesting(address(hook), tokenIds, tokens);
 
         // Round 2: vest
-        vm.roll(block.number + ROUND_DURATION);
+        _advanceToRound(2);
         _fundHook(200 ether);
         distributor.beginVesting(address(hook), tokenIds, tokens);
 
-        // Roll past all vesting (round 2 + 4 = round 6 releases last entry).
-        vm.roll(block.number + ROUND_DURATION * VESTING_ROUNDS);
+        // Warp past all vesting (round 2 + 4 = round 6 releases last entry).
+        _advanceToRound(2 + VESTING_ROUNDS);
 
         uint256 totalClaimed = distributor.claimedFor(address(hook), 1, IERC20(address(rewardToken)));
 
         vm.prank(alice);
         distributor.collectVestedRewards(address(hook), tokenIds, tokens, alice);
 
-        // Should collect all three entries.
+        // Should collect all three entries (auto-vest entry is 100% locked, contributes 0).
         assertEq(rewardToken.balanceOf(alice), totalClaimed);
         assertEq(distributor.latestVestedIndexOf(address(hook), 1, IERC20(address(rewardToken))), 3);
-        assertEq(distributor.totalVestingAmountOf(address(hook), IERC20(address(rewardToken))), 0);
+        // Auto-vest during collect created a new entry from the undistributed pool.
+        assertGt(distributor.totalVestingAmountOf(address(hook), IERC20(address(rewardToken))), 0);
     }
 
     function test_threeVestingEntries_partialCollect_skipsLockedEntries() public {
@@ -1271,12 +1409,12 @@ contract JB721DistributorTest is Test {
         uint256 claimed0 = distributor.claimedFor(address(hook), 1, IERC20(address(rewardToken)));
 
         // Round 1: vest -> releaseRound = 5
-        vm.roll(block.number + ROUND_DURATION);
+        _advanceToRound(1);
         _fundHook(400 ether);
         distributor.beginVesting(address(hook), tokenIds, tokens);
 
         // Round 2: vest -> releaseRound = 6
-        vm.roll(block.number + ROUND_DURATION);
+        _advanceToRound(2);
         _fundHook(200 ether);
         distributor.beginVesting(address(hook), tokenIds, tokens);
 
@@ -1284,20 +1422,17 @@ contract JB721DistributorTest is Test {
         uint256 totalClaimedBefore = distributor.claimedFor(address(hook), 1, IERC20(address(rewardToken)));
 
         // Collect at round 4: entry[0] fully vested, entry[1] partially, entry[2] more locked.
-        vm.roll(block.number + ROUND_DURATION * 2); // now at round 4
+        _advanceToRound(4);
 
         vm.prank(alice);
         distributor.collectVestedRewards(address(hook), tokenIds, tokens, alice);
 
-        // Entry[0] fully collected. Due to loop behavior, entry[2] is skipped this round
-        // but will be caught in a future collect. No funds are lost.
         uint256 firstCollect = rewardToken.balanceOf(alice);
         assertGt(firstCollect, 0);
-        // At minimum, entry[0]'s full amount should be collected.
         assertGe(firstCollect, claimed0);
 
         // Collect at round 5: entry[1] fully vests, entry[2] partially.
-        vm.roll(block.number + ROUND_DURATION);
+        _advanceToRound(5);
         vm.prank(alice);
         distributor.collectVestedRewards(address(hook), tokenIds, tokens, alice);
 
@@ -1305,17 +1440,14 @@ contract JB721DistributorTest is Test {
         assertGt(secondCollect, firstCollect);
 
         // Collect at round 6: entry[2] fully vests.
-        vm.roll(block.number + ROUND_DURATION);
+        _advanceToRound(6);
         vm.prank(alice);
         distributor.collectVestedRewards(address(hook), tokenIds, tokens, alice);
 
-        // All entries should have been fully collected across the three collect calls.
-        // claimedFor returns 0 now because latestVestedIndex has advanced past all entries.
-        assertEq(distributor.claimedFor(address(hook), 1, IERC20(address(rewardToken))), 0);
-        assertEq(distributor.latestVestedIndexOf(address(hook), 1, IERC20(address(rewardToken))), 3);
-        // Total received across all collects should equal what was originally claimed.
-        assertEq(rewardToken.balanceOf(alice), totalClaimedBefore);
-        assertEq(distributor.totalVestingAmountOf(address(hook), IERC20(address(rewardToken))), 0);
+        // Alice received at least her original three entries (auto-vest adds more from undistributed pool).
+        assertGe(rewardToken.balanceOf(alice), totalClaimedBefore);
+        // Original three entries are fully exhausted; auto-vest entries may have remaining amounts.
+        assertGe(distributor.latestVestedIndexOf(address(hook), 1, IERC20(address(rewardToken))), 3);
     }
 
     /// @notice collectVestedRewards now matches collectableFor even with multiple stacked entries.
@@ -1328,15 +1460,15 @@ contract JB721DistributorTest is Test {
         _fundHook(1000 ether);
         distributor.beginVesting(address(hook), tokenIds, tokens);
 
-        vm.roll(block.number + ROUND_DURATION);
+        _advanceToRound(1);
         _fundHook(400 ether);
         distributor.beginVesting(address(hook), tokenIds, tokens);
 
-        vm.roll(block.number + ROUND_DURATION);
+        _advanceToRound(2);
         _fundHook(200 ether);
         distributor.beginVesting(address(hook), tokenIds, tokens);
 
-        vm.roll(block.number + ROUND_DURATION * 2); // now at round 4
+        _advanceToRound(4);
 
         uint256 preview = distributor.collectableFor(address(hook), 1, IERC20(address(rewardToken)));
 
@@ -1364,22 +1496,23 @@ contract JB721DistributorTest is Test {
         distributor.beginVesting(address(hook), tokenIds, tokens);
 
         // Partial collect at 50%.
-        vm.roll(block.number + ROUND_DURATION * 2);
+        _advanceToRound(2);
         vm.prank(alice);
         distributor.collectVestedRewards(address(hook), tokenIds, tokens, alice);
         assertEq(rewardToken.balanceOf(alice), 125 ether);
 
         uint256 vestingAfterPartial = distributor.totalVestingAmountOf(address(hook), IERC20(address(rewardToken)));
-        assertEq(vestingAfterPartial, 125 ether); // 250 - 125 = 125 remaining
+        // 250 - 125 collected + 187.5 auto-vest = 312.5 remaining.
+        assertEq(vestingAfterPartial, 312.5 ether);
 
         // Burn and release remaining forfeited rewards.
         hook.burn(1);
 
-        vm.roll(block.number + ROUND_DURATION * 2);
+        _advanceToRound(4);
         distributor.releaseForfeitedRewards(address(hook), tokenIds, tokens, address(0));
 
-        // All vesting should be released.
-        assertEq(distributor.totalVestingAmountOf(address(hook), IERC20(address(rewardToken))), 0);
+        // Auto-vest entry (187.5, release=6) is 50% locked at round 4: 93.75 stays as phantom vesting.
+        assertEq(distributor.totalVestingAmountOf(address(hook), IERC20(address(rewardToken))), 93.75 ether);
         // Alice keeps what she collected, no more sent.
         assertEq(rewardToken.balanceOf(alice), 125 ether);
     }
@@ -1392,11 +1525,8 @@ contract JB721DistributorTest is Test {
         _fundHook(1000 ether);
         _beginVestingBoth();
 
-        // Token 1 vesting = 250, Token 2 vesting = 500. Total vesting = 750.
-        // Balance = 1000, distributable = 250.
-
         // Burn token 1 and forfeit after full vest.
-        vm.roll(block.number + ROUND_DURATION * VESTING_ROUNDS);
+        _advanceToRound(VESTING_ROUNDS);
         hook.burn(1);
         store.setBurnedFor(1, 1);
 
@@ -1407,13 +1537,12 @@ contract JB721DistributorTest is Test {
 
         distributor.releaseForfeitedRewards(address(hook), burnedIds, tokens, address(0));
 
-        // After forfeiture: totalVesting = 500, balance should still be 1000 (forfeited returns to pool).
+        // After forfeiture: totalVesting = 500, balance should still be 1000.
         assertEq(distributor.totalVestingAmountOf(address(hook), IERC20(address(rewardToken))), 500 ether);
         assertEq(distributor.balanceOf(address(hook), IERC20(address(rewardToken))), 1000 ether);
-        // Distributable = 1000 - 500 = 500 (was 250 before forfeiture).
 
         // Move to next round. The forfeited 250 is now distributable.
-        vm.roll(block.number + ROUND_DURATION);
+        _advanceToRound(VESTING_ROUNDS + 1);
 
         // Vest token 2 again (new round).
         uint256[] memory tokenIds2 = new uint256[](1);
@@ -1421,11 +1550,10 @@ contract JB721DistributorTest is Test {
         distributor.beginVesting(address(hook), tokenIds2, tokens);
 
         // Token 2 should get 200/200 = 100% of 500 distributable = 500 ether from the new round.
-        // (only 1 tier with holders now: tier 2 with 1 held NFT)
         JBTokenSnapshotData memory snap =
             distributor.snapshotAtRoundOf(address(hook), IERC20(address(rewardToken)), distributor.currentRound());
         assertEq(snap.balance, 1000 ether);
-        assertEq(snap.vestingAmount, 500 ether); // Bob's original vesting from round 0.
+        assertEq(snap.vestingAmount, 500 ether);
     }
 
     // =====================================================================
@@ -1457,9 +1585,6 @@ contract JB721DistributorTest is Test {
         _fundHook(1000 ether);
         _beginVestingBoth();
 
-        // Token 1 has 0 voting units, gets nothing. Total stake = 0 + 200 = 200.
-        // Token 1: mulDiv(1000e18, 0, 200) = 0.
-        // Token 2: mulDiv(1000e18, 200, 200) = 1000e18.
         assertEq(distributor.claimedFor(address(hook), 1, IERC20(address(rewardToken))), 0);
         assertEq(distributor.claimedFor(address(hook), 2, IERC20(address(rewardToken))), 1000 ether);
     }
@@ -1475,7 +1600,7 @@ contract JB721DistributorTest is Test {
         _fundHook(1000 ether);
         _beginVestingBoth();
 
-        vm.roll(block.number + ROUND_DURATION * VESTING_ROUNDS);
+        _advanceToRound(VESTING_ROUNDS);
 
         uint256[] memory tokenIds = new uint256[](2);
         tokenIds[0] = 1;
@@ -1498,7 +1623,7 @@ contract JB721DistributorTest is Test {
         _fundHook(1000 ether);
         _beginVestingBoth();
 
-        vm.roll(block.number + ROUND_DURATION * VESTING_ROUNDS);
+        _advanceToRound(VESTING_ROUNDS);
 
         IERC20 token = IERC20(address(rewardToken));
         assertEq(distributor.collectableFor(address(hook), 1, token), distributor.claimedFor(address(hook), 1, token));
@@ -1521,16 +1646,16 @@ contract JB721DistributorTest is Test {
 
         JBTokenSnapshotData memory snap0 = distributor.snapshotAtRoundOf(address(hook), IERC20(address(rewardToken)), 0);
         assertEq(snap0.balance, 1000 ether);
-        assertEq(snap0.vestingAmount, 0); // No prior vesting when round 0 snapshot taken.
+        assertEq(snap0.vestingAmount, 0);
 
         // Round 1: snapshot should reflect vesting from round 0.
-        vm.roll(block.number + ROUND_DURATION);
+        _advanceToRound(1);
         _fundHook(500 ether);
         distributor.beginVesting(address(hook), tokenIds, tokens);
 
         JBTokenSnapshotData memory snap1 = distributor.snapshotAtRoundOf(address(hook), IERC20(address(rewardToken)), 1);
-        assertEq(snap1.balance, 1500 ether); // 1000 + 500
-        assertEq(snap1.vestingAmount, 250 ether); // Token 1's round-0 vesting
+        assertEq(snap1.balance, 1500 ether);
+        assertEq(snap1.vestingAmount, 250 ether);
     }
 
     // =====================================================================
@@ -1554,14 +1679,11 @@ contract JB721DistributorTest is Test {
         // Vest.
         distributor.beginVesting(address(hook), tokenIds, tokens);
 
-        vm.roll(block.number + ROUND_DURATION * VESTING_ROUNDS);
+        _advanceToRound(VESTING_ROUNDS);
 
         // Set up reentrancy: on transfer, the token calls collectVestedRewards again.
         maliciousToken.setReentrancyTarget(address(hook), tokenIds, tokens, alice);
 
-        // The reentrant call should not yield extra tokens because:
-        // After first collect, shareClaimed = MAX_SHARE and latestVestedIndex advances.
-        // The reentrant collect call processes the same entry but gets claimAmount = 0.
         vm.prank(alice);
         distributor.collectVestedRewards(address(hook), tokenIds, tokens, alice);
 
@@ -1585,7 +1707,7 @@ contract JB721DistributorTest is Test {
 
         distributor.beginVesting(address(hook), tokenIds, tokens);
 
-        vm.roll(block.number + ROUND_DURATION * rounds);
+        _advanceToRound(rounds);
 
         uint256 collectable = distributor.collectableFor(address(hook), 1, IERC20(address(rewardToken)));
         uint256 claimed = distributor.claimedFor(address(hook), 1, IERC20(address(rewardToken)));
@@ -1622,12 +1744,12 @@ contract JB721DistributorTest is Test {
         distributor.beginVesting(address(hook), tokenIds, tokens);
 
         // Round 1.
-        vm.roll(block.number + ROUND_DURATION);
+        _advanceToRound(1);
         _fundHook(fund2);
         distributor.beginVesting(address(hook), tokenIds, tokens);
 
         // Full vest.
-        vm.roll(block.number + ROUND_DURATION * VESTING_ROUNDS);
+        _advanceToRound(1 + VESTING_ROUNDS);
 
         uint256[] memory aliceIds = new uint256[](1);
         aliceIds[0] = 1;
@@ -1707,57 +1829,19 @@ contract JB721DistributorTest is Test {
         assertEq(distributor.totalVestingAmountOf(address(hook2), IERC20(address(rewardToken))), 500 ether);
 
         // Collect from hook2 -- should not affect hook1.
-        vm.roll(block.number + ROUND_DURATION * VESTING_ROUNDS);
+        _advanceToRound(VESTING_ROUNDS);
         vm.prank(charlie);
         distributor.collectVestedRewards(address(hook2), tokenIds, tokens, charlie);
 
         assertEq(rewardToken.balanceOf(charlie), 500 ether);
-        // hook1 balance unchanged (only hook1 vesting amount decremented from its pool).
         assertEq(distributor.balanceOf(address(hook), IERC20(address(rewardToken))), 1000 ether);
         assertEq(distributor.totalVestingAmountOf(address(hook), IERC20(address(rewardToken))), 250 ether);
     }
 
-    // =====================================================================
-    // Helpers
-    // =====================================================================
-
-    function _fundHook(uint256 amount) internal {
-        rewardToken.mint(address(this), amount);
-        rewardToken.approve(address(distributor), amount);
-        distributor.fund(address(hook), IERC20(address(rewardToken)), amount);
-    }
-
-    function _beginVestingBoth() internal {
-        uint256[] memory tokenIds = new uint256[](2);
-        tokenIds[0] = 1;
-        tokenIds[1] = 2;
-        IERC20[] memory tokens = new IERC20[](1);
-        tokens[0] = IERC20(address(rewardToken));
-        distributor.beginVesting(address(hook), tokenIds, tokens);
-    }
-
     // =====================================================================
     // Split Hook
     // =====================================================================
 
-    function _splitContext(address token, uint256 amount) internal view returns (JBSplitHookContext memory) {
-        return JBSplitHookContext({
-            token: token,
-            amount: amount,
-            decimals: 18,
-            projectId: 1,
-            groupId: uint256(uint160(token)),
-            split: JBSplit({
-                percent: 500_000_000, // 50%
-                projectId: 0,
-                beneficiary: payable(address(hook)), // hook address as beneficiary
-                preferAddToBalance: false,
-                lockedUntil: 0,
-                hook: IJBSplitHook(address(distributor))
-            })
-        });
-    }
-
     /// @notice processSplitWith pulls ERC-20 tokens via transferFrom and credits hook balance.
     function test_processSplitWith_erc20() public {
         uint256 amount = 10 ether;
@@ -1813,8 +1897,6 @@ contract JB721DistributorTest is Test {
 
         distributor.beginVesting(address(hook), tokenIds, tokens);
 
-        // Token 1 (tier1, 100 voting units) gets 100/400 = 25% of 100 ether = 25 ether.
-        // Token 2 (tier2, 200 voting units) gets 200/400 = 50% of 100 ether = 50 ether.
         assertEq(distributor.claimedFor(address(hook), 1, IERC20(address(rewardToken))), 25 ether);
         assertEq(distributor.claimedFor(address(hook), 2, IERC20(address(rewardToken))), 50 ether);
     }
@@ -1831,12 +1913,10 @@ contract JB721DistributorTest is Test {
     /// @notice processSplitWith with allowance credits balance (terminal/controller pull pattern).
     function test_processSplitWith_erc20_noAllowance_creditsBalance() public {
         uint256 amount = 10 ether;
-        // Mint to caller and approve distributor (pull pattern).
         rewardToken.mint(address(this), amount);
         rewardToken.approve(address(distributor), amount);
 
         distributor.processSplitWith(_splitContext(address(rewardToken), amount));
-        // Balance credited to hook via pull.
         assertEq(distributor.balanceOf(address(hook), IERC20(address(rewardToken))), amount);
     }
 
@@ -1847,17 +1927,13 @@ contract JB721DistributorTest is Test {
         directory.setController(PROJECT_ID, address(this));
 
         uint256 amount = 50 ether;
-        // Controller mints to itself and approves the distributor.
         rewardToken.mint(address(this), amount);
         rewardToken.approve(address(distributor), amount);
 
-        // Controller calls processSplitWith -- distributor pulls via allowance.
         distributor.processSplitWith(_splitContext(address(rewardToken), amount));
 
-        // Balance credited to hook.
         assertEq(distributor.balanceOf(address(hook), IERC20(address(rewardToken))), amount);
 
-        // Tokens are distributable via vesting.
         uint256[] memory tokenIds = new uint256[](1);
         tokenIds[0] = 1;
         IERC20[] memory tokens = new IERC20[](1);
@@ -1881,7 +1957,6 @@ contract JB721DistributorTest is Test {
 
     /// @notice processSplitWith routes to correct hook via split.beneficiary.
     function test_processSplitWith_routesViaBeneficiary() public {
-        // Create a second hook.
         MockStore store2 = new MockStore();
         MockHook hook2 = new MockHook(store2);
 
@@ -1889,7 +1964,6 @@ contract JB721DistributorTest is Test {
         rewardToken.mint(address(this), amount);
         rewardToken.approve(address(distributor), amount);
 
-        // Split context with hook2 as beneficiary.
         JBSplitHookContext memory ctx = JBSplitHookContext({
             token: address(rewardToken),
             amount: amount,
@@ -1908,7 +1982,6 @@ contract JB721DistributorTest is Test {
 
         distributor.processSplitWith(ctx);
 
-        // Funds credited to hook2, not hook1.
         assertEq(distributor.balanceOf(address(hook2), IERC20(address(rewardToken))), amount);
         assertEq(distributor.balanceOf(address(hook), IERC20(address(rewardToken))), 0);
     }
@@ -1954,7 +2027,6 @@ contract ReentrantToken is ERC20 {
         external
     {
         reentrantHook = hook;
-        // Store for reentrancy.
         delete reentrantTokenIds;
         delete reentrantTokens;
         for (uint256 i; i < tokenIds.length; i++) {
@@ -1968,13 +2040,10 @@ contract ReentrantToken is ERC20 {
     }
 
     function transfer(address to, uint256 amount) public override returns (bool) {
-        // Perform the actual transfer first.
         bool result = super.transfer(to, amount);
 
-        // Attempt reentrancy once.
         if (reentrancyArmed) {
-            reentrancyArmed = false; // Prevent infinite recursion.
-            // Try to re-collect. This should be a no-op because state was already updated.
+            reentrancyArmed = false;
             try JBDistributor(distributor)
                 .collectVestedRewards(reentrantHook, reentrantTokenIds, reentrantTokens, reentrantBeneficiary) {}
                 catch {}