@bananapus/distributor-v6 0.0.30 → 0.0.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bananapus/distributor-v6",
-  "version": "0.0.30",
+  "version": "0.0.31",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/JB721Distributor.sol

@@ -85,7 +85,7 @@ contract JB721Distributor is JBDistributor, IJB721Distributor {
     //*********************************************************************//
 
     /// @param directory The JB directory used to verify terminal/controller callers.
-    /// @param controller The JB controller used to burn expired or forfeited project-token rewards.
+    /// @param controller The JB controller used to burn forfeited project-token rewards.
     /// @param revLoans The Revnet loans contract used to borrow against vested revnet rewards.
     /// @param revOwner The REVOwner contract that must own revnet reward token projects.
     /// @param initialRoundDuration The duration of each round, specified in seconds.
@@ -295,9 +295,9 @@ contract JB721Distributor is JBDistributor, IJB721Distributor {
 
             // Skip rounds that never received funding.
             if (rewardRound.amount != 0) {
-                // Expired rounds can no longer be claimed; burn their unclaimed remainder instead.
+                // Expired rounds can no longer be claimed as-is; recycle their unclaimed remainder instead.
                 if (_rewardRoundExpired(rewardRound)) {
-                    _burnExpiredRewardRound({hook: ctx.hook, token: token, round: rewardRoundNumber});
+                    _recycleExpiredRewardRound({hook: ctx.hook, token: token, round: rewardRoundNumber});
                 } else if (rewardRound.totalStake != 0) {
                     // Bundle the fixed round data used by every NFT in the batch.
                     JBVestContext memory vestCtx = JBVestContext({
@@ -314,7 +314,8 @@ contract JB721Distributor is JBDistributor, IJB721Distributor {
                     uint256 roundVestingAmount =
                         _claimRewardRoundForTokenIds({ctx: vestCtx, tokenIds: tokenIds, tokenAmounts: tokenAmounts});
 
-                    // Track only the amount that actually started vesting, leaving zero-vote and dust amounts burnable.
+                    // Track only the amount that actually started vesting, leaving zero-vote and dust amounts
+                    // recyclable.
                     if (roundVestingAmount != 0) {
                         rewardRound.claimedAmount = _toUint208(uint256(rewardRound.claimedAmount) + roundVestingAmount);
 

package/src/JBDistributor.sol

@@ -80,6 +80,9 @@ abstract contract JBDistributor is IJBDistributor {
     /// @notice Thrown when unexpected native ETH is sent with an ERC-20 operation.
     error JBDistributor_UnexpectedNativeValue(uint256 msgValue, address token);
 
+    /// @notice Thrown when an ERC-20 repayment does not credit the exact amount pulled from the caller.
+    error JBDistributor_UnexpectedRepayAmount(uint256 amount, uint256 expectedAmount);
+
     /// @notice Thrown when a function requires exactly one reward token.
     error JBDistributor_UnexpectedTokenCount(uint256 tokenCount);
 
@@ -123,7 +126,7 @@ abstract contract JBDistributor is IJBDistributor {
     /// @dev A zero duration means reward rounds do not expire.
     uint48 public immutable override CLAIM_DURATION;
 
-    /// @notice The JB controller used to burn expired or forfeited project-token rewards.
+    /// @notice The JB controller used to burn forfeited project-token rewards.
     IJBController public immutable override CONTROLLER;
 
     /// @notice The duration of each round, specified in seconds.
@@ -228,7 +231,7 @@ abstract contract JBDistributor is IJBDistributor {
     // -------------------------- constructor ---------------------------- //
     //*********************************************************************//
 
-    /// @param controller The JB controller used to burn expired or forfeited project-token rewards.
+    /// @param controller The JB controller used to burn forfeited project-token rewards.
     /// @param revLoans The Revnet loans contract used to borrow against vested revnet rewards.
     /// @param revOwner The REVOwner contract that must own revnet reward token projects.
     /// @param initialRoundDuration The duration of each round, specified in seconds.
@@ -349,11 +352,12 @@ abstract contract JBDistributor is IJBDistributor {
         _fund({hook: hook, token: token, amount: amount});
     }
 
-    /// @notice Burn unclaimed rewards from expired reward rounds.
-    /// @param hook The hook whose expired rewards should be burned.
-    /// @param token The reward token to burn.
-    /// @param rounds The reward rounds to burn.
-    /// @return amount The total amount burned.
+    /// @notice Recycle unclaimed rewards from expired reward rounds into the current reward round.
+    /// @dev The selector name is kept for compatibility with existing keeper integrations.
+    /// @param hook The hook whose expired rewards should be recycled.
+    /// @param token The reward token to recycle.
+    /// @param rounds The reward rounds to recycle.
+    /// @return amount The total amount recycled.
     function burnExpiredRewards(
         address hook,
         IERC20 token,
@@ -364,13 +368,13 @@ abstract contract JBDistributor is IJBDistributor {
         override
         returns (uint256 amount)
     {
-        // Do not let reward-token callbacks burn inventory during an inbound balance-delta measurement.
+        // Do not let reward-token callbacks recycle inventory during an inbound balance-delta measurement.
         _requireNotAcceptingToken();
 
         // Process every requested round independently so callers can batch keeper work.
         for (uint256 i; i < rounds.length;) {
             // Add this round's expired remainder to the batch total.
-            amount += _burnExpiredRewardRound({hook: hook, token: token, round: rounds[i]});
+            amount += _recycleExpiredRewardRound({hook: hook, token: token, round: rounds[i]});
 
             unchecked {
                 // Safe because the loop is bounded by calldata length.
@@ -920,9 +924,14 @@ abstract contract JBDistributor is IJBDistributor {
                 revert JBDistributor_UnexpectedNativeValue({msgValue: msg.value, token: loan.sourceToken});
             }
 
-            // Pull the exact current payoff from the caller.
+            // Pull the exact current payoff from the caller. Existing distributor inventory must not cover a shortfall.
             IERC20 sourceToken = IERC20(loan.sourceToken);
+            uint256 sourceBalanceBefore = sourceToken.balanceOf(address(this));
             sourceToken.safeTransferFrom({from: msg.sender, to: address(this), value: repayBorrowAmount});
+            uint256 receivedAmount = sourceToken.balanceOf(address(this)) - sourceBalanceBefore;
+            if (receivedAmount != repayBorrowAmount) {
+                revert JBDistributor_UnexpectedRepayAmount({amount: receivedAmount, expectedAmount: repayBorrowAmount});
+            }
 
             // Approve only the exact amount needed for this repayment.
             sourceToken.forceApprove({spender: address(REV_LOANS), value: repayBorrowAmount});
@@ -1158,32 +1167,47 @@ abstract contract JBDistributor is IJBDistributor {
         rewardRound.amount = _toUint208(uint256(rewardRound.amount) + amount);
     }
 
-    /// @notice Burn one expired reward round's unclaimed inventory.
-    /// @param hook The hook whose expired rewards should be burned.
-    /// @param token The reward token to burn.
-    /// @param round The reward round to burn.
-    /// @return burnAmount The amount burned.
-    function _burnExpiredRewardRound(address hook, IERC20 token, uint256 round) internal returns (uint256 burnAmount) {
+    /// @notice Recycle one expired reward round's unclaimed inventory into the current reward round.
+    /// @param hook The hook whose expired rewards should be recycled.
+    /// @param token The reward token to recycle.
+    /// @param round The reward round to recycle.
+    /// @return recycleAmount The amount recycled.
+    function _recycleExpiredRewardRound(
+        address hook,
+        IERC20 token,
+        uint256 round
+    )
+        internal
+        returns (uint256 recycleAmount)
+    {
         // Load the reward round once so expiry, claimed amount, and funded amount stay in sync.
         JBRewardRoundData storage rewardRound = rewardRoundOf[hook][token][round];
 
         // Ignore rounds that either never expire or have not reached their deadline yet.
         if (!_rewardRoundExpired(rewardRound)) return 0;
 
-        // If prior claims have already materialized the whole round, there is nothing left to burn.
+        // If prior claims have already materialized the whole round, there is nothing left to recycle.
         if (rewardRound.claimedAmount >= rewardRound.amount) return 0;
 
-        // Burn only the unclaimed remainder, preserving amounts that already started vesting.
-        burnAmount = uint256(rewardRound.amount) - uint256(rewardRound.claimedAmount);
+        // Recycle only the unclaimed remainder, preserving amounts that already started vesting.
+        recycleAmount = uint256(rewardRound.amount) - uint256(rewardRound.claimedAmount);
 
-        // Mark the whole round settled before transferring to close reentrancy-sensitive accounting.
+        // Mark the whole round settled before writing the recycled amount into a fresh round.
         rewardRound.claimedAmount = rewardRound.amount;
 
-        // Remove the expired remainder from distributor inventory and burn it through the JB controller.
-        _burnRewardTokens({hook: hook, token: token, amount: burnAmount});
+        // Keep the inventory in the distributor and give the current staker set a new claimable round.
+        uint256 recycledToRound = currentRound();
+        _recordRewardRound({hook: hook, token: token, amount: recycleAmount});
 
-        // Surface the permissionless burn for off-chain accounting.
-        emit ExpiredRewardsBurned({hook: hook, round: round, token: token, amount: burnAmount, caller: msg.sender});
+        // Surface the permissionless recycle for off-chain accounting.
+        emit ExpiredRewardsRecycled({
+            hook: hook,
+            fromRound: round,
+            toRound: recycledToRound,
+            token: token,
+            amount: recycleAmount,
+            caller: msg.sender
+        });
     }
 
     /// @notice Burn reward inventory using the JB controller.
@@ -1315,7 +1339,7 @@ abstract contract JBDistributor is IJBDistributor {
 
     /// @notice Whether a reward round has passed its claim deadline.
     /// @param rewardRound The reward round data.
-    /// @return expired True if unclaimed rewards can be burned.
+    /// @return expired True if unclaimed rewards can be recycled.
     function _rewardRoundExpired(JBRewardRoundData storage rewardRound) internal view returns (bool expired) {
         // Copy the packed deadline into memory so the zero check and timestamp compare use the same value.
         uint48 claimDeadline = rewardRound.claimDeadline;

package/src/JBTokenDistributor.sol

@@ -69,7 +69,7 @@ contract JBTokenDistributor is JBDistributor, IJBTokenDistributor {
     //*********************************************************************//
 
     /// @param directory The JB directory used to verify terminal/controller callers.
-    /// @param controller The JB controller used to burn expired or forfeited project-token rewards.
+    /// @param controller The JB controller used to burn forfeited project-token rewards.
     /// @param revLoans The Revnet loans contract used to borrow against vested revnet rewards.
     /// @param revOwner The REVOwner contract that must own revnet reward token projects.
     /// @param initialRoundDuration The duration of each round, specified in seconds.
@@ -328,9 +328,9 @@ contract JBTokenDistributor is JBDistributor, IJBTokenDistributor {
 
             // Skip rounds that never received funding.
             if (rewardRound.amount != 0) {
-                // Expired rounds can no longer be claimed; burn their unclaimed remainder instead.
+                // Expired rounds can no longer be claimed as-is; recycle their unclaimed remainder instead.
                 if (_rewardRoundExpired(rewardRound)) {
-                    _burnExpiredRewardRound({hook: hook, token: token, round: rewardRoundNumber});
+                    _recycleExpiredRewardRound({hook: hook, token: token, round: rewardRoundNumber});
                 } else if (rewardRound.totalStake != 0) {
                     // Use the funding round's snapshot block, not the block at which the staker finally claims.
                     uint256 tokenStakeAmount =
@@ -344,7 +344,7 @@ contract JBTokenDistributor is JBDistributor, IJBTokenDistributor {
 
                         // Ignore floor-rounded zero claims to avoid unnecessary storage writes.
                         if (claimAmount != 0) {
-                            // Track the portion that has started vesting so expiry burns only the remainder.
+                            // Track the portion that has started vesting so expiry recycles only the remainder.
                             rewardRound.claimedAmount = _toUint208(uint256(rewardRound.claimedAmount) + claimAmount);
 
                             // Add this round's vested amount to the staker's cumulative claim.

package/src/interfaces/IJBDistributor.sol

@@ -81,14 +81,20 @@ interface IJBDistributor {
     /// @param caller The address that triggered the snapshot recording.
     event RoundSnapshotRecorded(uint256 indexed round, uint256 snapshotBlock, address caller);
 
-    /// @notice Emitted when an expired reward round's unclaimed amount is burned.
-    /// @param hook The hook whose expired rewards were burned.
-    /// @param round The expired reward round.
-    /// @param token The reward token that was burned.
-    /// @param amount The unclaimed reward amount burned.
-    /// @param caller The address that triggered the burn.
-    event ExpiredRewardsBurned(
-        address indexed hook, uint256 indexed round, IERC20 indexed token, uint256 amount, address caller
+    /// @notice Emitted when an expired reward round's unclaimed amount is recycled into a later reward round.
+    /// @param hook The hook whose expired rewards were recycled.
+    /// @param fromRound The expired reward round.
+    /// @param toRound The reward round receiving the recycled rewards.
+    /// @param token The reward token that was recycled.
+    /// @param amount The unclaimed reward amount recycled.
+    /// @param caller The address that triggered the recycle.
+    event ExpiredRewardsRecycled(
+        address indexed hook,
+        uint256 indexed fromRound,
+        uint256 indexed toRound,
+        IERC20 token,
+        uint256 amount,
+        address caller
     );
 
     /// @notice Emitted when a liquidated distributor-held Revnet loan is written off.
@@ -147,7 +153,7 @@ interface IJBDistributor {
     /// @dev A zero duration means reward rounds do not expire.
     function CLAIM_DURATION() external view returns (uint48);
 
-    /// @notice The JB controller used to burn expired or forfeited project-token rewards.
+    /// @notice The JB controller used to burn forfeited project-token rewards.
     function CONTROLLER() external view returns (IJBController);
 
     /// @notice The duration of each round, specified in seconds.
@@ -279,11 +285,11 @@ interface IJBDistributor {
     /// @param amount The amount to fund.
     function fund(address hook, IERC20 token, uint256 amount) external payable;
 
-    /// @notice Burn unclaimed rewards from expired reward rounds.
-    /// @param hook The hook whose expired reward rounds should be burned.
-    /// @param token The reward token to burn.
-    /// @param rounds The reward rounds to burn.
-    /// @return amount The total amount burned.
+    /// @notice Recycle unclaimed rewards from expired reward rounds into the current reward round.
+    /// @param hook The hook whose expired reward rounds should be recycled.
+    /// @param token The reward token to recycle.
+    /// @param rounds The reward rounds to recycle.
+    /// @return amount The total amount recycled.
     function burnExpiredRewards(address hook, IERC20 token, uint256[] calldata rounds) external returns (uint256 amount);
 
     /// @notice Record the snapshot block for the current round. Callable by anyone (keepers, frontends).