@bananapus/distributor-v6 0.0.44 → 0.0.46

package/README.md

@@ -75,7 +75,9 @@ This repo does not explain why an allocation exists. It only defines how funded
   NFT's tier
 - `recycleExpiredRewards` is permissionless; it recycles the expired round's unmaterialized remainder while preserving
   amounts that already started vesting
-- eligible expired and forfeited rewards stay in distributor inventory and are recycled into the current reward round
+- eligible expired and forfeited rewards stay in distributor inventory and are recycled into the current reward round.
+  A reward round never recycles into itself; if the requested round is still current, the call is a no-op, including
+  for zero-stake rounds
 - revnet loan-backed vesting is opt-in at deployment; the reward token must be a REVOwner-owned revnet token, the
   distributor keeps the loan NFT, and repayment restores the original vesting schedule instead of releasing all
   collateral immediately

package/package.json

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

package/src/JBDistributor.sol

@@ -305,7 +305,8 @@ abstract contract JBDistributor is IJBDistributor {
     }
 
     /// @notice Recycle unclaimed rewards from expired reward rounds into the current reward round.
-    /// @dev Recycling is permissionless; any keeper or frontend can sweep an expired round.
+    /// @dev Recycling is permissionless; any keeper or frontend can sweep an eligible prior round. Passing the current
+    /// reward round is a no-op, even when its snapshot stake is zero.
     /// @param hook The hook whose expired rewards should be recycled.
     /// @param token The reward token to recycle.
     /// @param rounds The reward rounds to recycle.
@@ -1185,11 +1186,19 @@ abstract contract JBDistributor is IJBDistributor {
         internal
         returns (uint256 recycleAmount)
     {
+        // Never recycle a round into itself. This keeps raw round accounting stable for zero-stake current rounds; the
+        // same inventory can be swept once a later round is current.
+        uint256 recycledToRound = currentRound();
+        if (round == recycledToRound) return 0;
+
         // Load the reward round once so expiry, claimed amount, and funded amount stay in sync.
         JBRewardRoundData storage rewardRound = rewardRoundOf[hook][groupId][token][round];
 
-        // Ignore rounds that either never expire or have not reached their deadline yet.
-        if (!_rewardRoundExpired(rewardRound)) return 0;
+        // Ignore rounds that have not reached their deadline yet — UNLESS the round can never be claimed because its
+        // snapshot `totalStake` is zero (e.g. funded before anyone delegated). Such a round's funds are unclaimable;
+        // gating recycle on expiry would strand them forever when `CLAIM_DURATION == 0` (a zero deadline never
+        // expires), so allow recycling a zero-stake round regardless of deadline. There is no claimant to protect.
+        if (!_rewardRoundExpired(rewardRound) && rewardRound.totalStake != 0) return 0;
 
         // If prior claims have already materialized the whole round, there is nothing left to recycle.
         if (rewardRound.claimedAmount >= rewardRound.amount) return 0;
@@ -1201,7 +1210,6 @@ abstract contract JBDistributor is IJBDistributor {
         rewardRound.claimedAmount = rewardRound.amount;
 
         // Keep the inventory in the distributor and give the current staker set a new claimable round.
-        uint256 recycledToRound = currentRound();
         _recordRewardRound({hook: hook, groupId: groupId, token: token, amount: recycleAmount});
 
         // Surface the permissionless recycle for off-chain accounting.

package/src/JBTokenDistributor.sol

@@ -21,10 +21,14 @@ import {JBClaimContext} from "./structs/JBClaimContext.sol";
 import {JBRewardRoundData} from "./structs/JBRewardRoundData.sol";
 import {JBVestingData} from "./structs/JBVestingData.sol";
 
-/// @notice A singleton distributor that distributes ERC-20 rewards to IVotes-compatible token holders with delegated
-/// voting power and linear vesting.
+/// @notice A singleton distributor that distributes ERC-20 rewards to holders of an `IJBActiveVotes` token with
+/// delegated voting power and linear vesting.
 /// @dev Any project can use this distributor by configuring a payout split with
-/// `hook = this contract` and `beneficiary = address(their IVotes token)`.
+/// `hook = this contract` and `beneficiary = address(their token)`. The token MUST implement `IJBActiveVotes` (e.g. a
+/// Juicebox `JBERC20`); a plain OpenZeppelin `IVotes`/`ERC20Votes` token lacks `getPastTotalActiveVotes` and will
+/// revert inside `_recordRewardRound` at fund time. Because funding arrives via a payout split, that revert is
+/// swallowed by the terminal's split try/catch — the funds soft-land back in the project and nothing distributes,
+/// silently. Wire only an `IJBActiveVotes` token.
 /// @dev The stake weight of each holder is their delegated voting power at the funded round's snapshot block.
 /// Holders must delegate (even to themselves) to participate.
 /// @dev Funded rewards are assigned to the funding round. Holders claim historical rounds lazily; all unclaimed past
@@ -414,7 +418,7 @@ contract JBTokenDistributor is JBDistributor, IJBTokenDistributor {
     /// @notice The delegated voting power of a staker at the current round's snapshot block.
     /// @dev Uses `IVotes.getPastVotes` for checkpointed lookups. The block number is derived from
     /// `roundSnapshotBlock[currentRound()]`, which is set on first interaction in a round.
-    /// @param hook The IVotes-compatible token contract.
+    /// @param hook The `IJBActiveVotes` token contract.
     /// @param tokenId The encoded staker address (`uint256(uint160(stakerAddress))`).
     /// @return tokenStakeAmount The delegated voting power at the round's snapshot block.
     function _tokenStake(address hook, uint256 tokenId) internal view override returns (uint256 tokenStakeAmount) {
@@ -423,7 +427,7 @@ contract JBTokenDistributor is JBDistributor, IJBTokenDistributor {
     }
 
     /// @notice The delegated voting power of a staker at an explicit snapshot block.
-    /// @param hook The IVotes-compatible token contract.
+    /// @param hook The `IJBActiveVotes` token contract.
     /// @param tokenId The encoded staker address.
     /// @param blockNumber The historical block to query.
     /// @return tokenStakeAmount The delegated voting power at `blockNumber`.
@@ -450,7 +454,7 @@ contract JBTokenDistributor is JBDistributor, IJBTokenDistributor {
     /// @notice The total stake denominator recorded when a token reward round is first funded.
     /// @dev Always uses `IJBActiveVotes.getPastTotalActiveVotes`, so undelegated balances such as AMM-held tokens do
     /// not share rewards. `CLAIM_DURATION` only controls whether unmaterialized allocations can expire.
-    /// @param hook The IVotes-compatible token contract.
+    /// @param hook The `IJBActiveVotes` token contract.
     /// @param groupId The reward group (unused for token distributors — kept for base-hook conformance).
     /// @param blockNumber The block number to get the active total at.
     /// @return totalStakedAmount The stake denominator to record for the funded round.

package/src/interfaces/IJBDistributor.sol

@@ -301,7 +301,8 @@ interface IJBDistributor {
     /// @notice Record the snapshot block for the current round. Callable by anyone (keepers, frontends).
     function poke() external;
 
-    /// @notice Recycle unclaimed rewards from expired default-group reward rounds into the current reward round.
+    /// @notice Recycle unclaimed rewards from eligible prior default-group reward rounds into the current reward round.
+    /// @dev Passing the current round is a no-op, including for zero-stake rounds.
     /// @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.