@bananapus/core-v6 0.0.6 → 0.0.7

package/README.md

@@ -1,4 +1,4 @@
-# nana-core-v6
+# Juicebox Core
 
 The core protocol contracts for Juicebox V6 on EVM. A flexible toolkit for launching and managing a treasury-backed token on Ethereum and L2s.
 

package/SKILLS.md

@@ -1,4 +1,4 @@
-# nana-core-v6
+# Juicebox Core
 
 ## Purpose
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bananapus/core-v6",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/JBRulesets.sol

@@ -840,50 +840,53 @@ contract JBRulesets is JBControlled, IJBRulesets {
         return _getStructFor({projectId: projectId, rulesetId: rulesetId});
     }
 
-    /// @notice Cache the value of the ruleset weight.
+    /// @notice Cache the value of the ruleset weight for a specific ruleset.
+    /// @dev The caller should pass the ruleset ID that `currentOf()` actually uses. When a queued ruleset is rejected
+    /// by an approval hook, `currentOf()` falls back to the base ruleset — callers should pass that base ruleset's
+    /// ID,
+    /// not the rejected latest.
     /// @param projectId The ID of the project having its ruleset weight cached.
-    function updateRulesetWeightCache(uint256 projectId) external override {
-        // Keep a reference to the struct for the latest queued ruleset.
-        // The cached value will be based on this struct.
-        JBRuleset memory latestQueuedRuleset =
-            _getStructFor({projectId: projectId, rulesetId: latestRulesetIdOf[projectId]});
+    /// @param rulesetId The ID of the ruleset to update the cache for.
+    function updateRulesetWeightCache(uint256 projectId, uint256 rulesetId) external override {
+        // Get the target ruleset.
+        JBRuleset memory targetRuleset = _getStructFor({projectId: projectId, rulesetId: rulesetId});
 
-        // Nothing to cache if the latest ruleset doesn't have a duration or a weight cut percent.
+        // Nothing to cache if the target ruleset doesn't have a duration or a weight cut percent.
         // slither-disable-next-line incorrect-equality
-        if (latestQueuedRuleset.duration == 0 || latestQueuedRuleset.weightCutPercent == 0) return;
+        if (targetRuleset.duration == 0 || targetRuleset.weightCutPercent == 0) return;
 
         // Get a reference to the current cache.
-        JBRulesetWeightCache storage cache = _weightCacheOf[projectId][latestQueuedRuleset.id];
+        JBRulesetWeightCache storage cache = _weightCacheOf[projectId][targetRuleset.id];
 
         // Determine the largest start timestamp the cache can be filled to.
         // Cap the advance to the cache lookup threshold per call to stay within the iteration limit in
         // deriveWeightFrom.
         // Multiple calls are needed to advance the cache for large cycle gaps.
-        uint256 maxStart = latestQueuedRuleset.start
-            + (cache.weightCutMultiple + _WEIGHT_CUT_MULTIPLE_CACHE_LOOKUP_THRESHOLD) * latestQueuedRuleset.duration;
+        uint256 maxStart = targetRuleset.start + (cache.weightCutMultiple + _WEIGHT_CUT_MULTIPLE_CACHE_LOOKUP_THRESHOLD)
+            * targetRuleset.duration;
 
         // Determine the start timestamp to derive a weight from for the cache.
         uint256 start = block.timestamp < maxStart ? block.timestamp : maxStart;
 
         // The difference between the start of the latest queued ruleset and the start of the ruleset we're caching the
         // weight of.
-        uint256 startDistance = start - latestQueuedRuleset.start;
+        uint256 startDistance = start - targetRuleset.start;
 
         // Calculate the weight cut multiple.
         uint168 weightCutMultiple;
         unchecked {
-            weightCutMultiple = uint168(startDistance / latestQueuedRuleset.duration);
+            weightCutMultiple = uint168(startDistance / targetRuleset.duration);
         }
 
         // Store the new values.
         cache.weight = uint112(
             deriveWeightFrom({
                 projectId: projectId,
-                baseRulesetStart: latestQueuedRuleset.start,
-                baseRulesetDuration: latestQueuedRuleset.duration,
-                baseRulesetWeight: latestQueuedRuleset.weight,
-                baseRulesetWeightCutPercent: latestQueuedRuleset.weightCutPercent,
-                baseRulesetCacheId: latestQueuedRuleset.id,
+                baseRulesetStart: targetRuleset.start,
+                baseRulesetDuration: targetRuleset.duration,
+                baseRulesetWeight: targetRuleset.weight,
+                baseRulesetWeightCutPercent: targetRuleset.weightCutPercent,
+                baseRulesetCacheId: targetRuleset.id,
                 start: start
             })
         );

package/src/interfaces/IJBRulesets.sol

@@ -145,7 +145,9 @@ interface IJBRulesets {
         external
         returns (JBRuleset memory ruleset);
 
-    /// @notice Updates the weight cache for a project to allow efficient weight derivation over many cycles.
+    /// @notice Updates the weight cache for a specific ruleset to allow efficient weight derivation over many cycles.
     /// @param projectId The ID of the project to update the weight cache for.
-    function updateRulesetWeightCache(uint256 projectId) external;
+    /// @param rulesetId The ID of the ruleset to update the cache for. This should be the ruleset that currentOf()
+    /// actually uses, which may differ from latestRulesetIdOf if the latest was rejected by an approval hook.
+    function updateRulesetWeightCache(uint256 projectId, uint256 rulesetId) external;
 }

package/test/TestWeightCacheStaleAfterRejection.sol

@@ -0,0 +1,289 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.6;
+
+import /* {*} from */ "./helpers/TestBaseWorkflow.sol";
+
+/// @notice Mock approval hook that ALWAYS rejects queued rulesets.
+contract AlwaysRejectApprovalHook is IJBRulesetApprovalHook {
+    function DURATION() external pure override returns (uint256) {
+        return 0;
+    }
+
+    function approvalStatusOf(uint256, JBRuleset memory) external pure override returns (JBApprovalStatus) {
+        return JBApprovalStatus.Failed;
+    }
+
+    function supportsInterface(bytes4 interfaceId) external pure override returns (bool) {
+        return interfaceId == type(IJBRulesetApprovalHook).interfaceId || interfaceId == type(IERC165).interfaceId;
+    }
+}
+
+/// @notice Regression tests for the weight cache stale-after-rejection fix.
+///
+/// Before the fix, updateRulesetWeightCache() only updated the cache for latestRulesetIdOf.
+/// When a queued ruleset was rejected by an approval hook, currentOf() would fall back to
+/// the base ruleset, but that base ruleset's cache could never be updated — causing
+/// deriveWeightFrom() to revert with WeightCacheRequired after >20,000 cycles.
+///
+/// The fix adds a rulesetId parameter to updateRulesetWeightCache() so callers can
+/// specify exactly which ruleset's cache to update — typically the one currentOf() uses.
+contract TestWeightCacheStaleAfterRejection is TestBaseWorkflow {
+    IJBController private _controller;
+    IJBRulesets private _rulesets;
+    address private _projectOwner;
+    AlwaysRejectApprovalHook private _rejectHook;
+
+    uint256 private _projectId;
+
+    function setUp() public override {
+        super.setUp();
+        _controller = jbController();
+        _rulesets = jbRulesets();
+        _projectOwner = multisig();
+        _rejectHook = new AlwaysRejectApprovalHook();
+    }
+
+    /// @notice Launch a project with a 1-second duration ruleset, weight decay, and an always-reject approval hook.
+    function _launchProject() internal returns (uint256 projectId) {
+        JBRulesetConfig[] memory rulesetConfigurations = new JBRulesetConfig[](1);
+
+        JBRulesetMetadata memory metadata = JBRulesetMetadata({
+            reservedPercent: 0,
+            cashOutTaxRate: 0,
+            baseCurrency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+            pausePay: false,
+            pauseCreditTransfers: false,
+            allowOwnerMinting: false,
+            allowSetCustomToken: false,
+            allowTerminalMigration: false,
+            allowSetTerminals: false,
+            ownerMustSendPayouts: false,
+            allowSetController: false,
+            allowAddAccountingContext: true,
+            allowAddPriceFeed: false,
+            holdFees: false,
+            useTotalSurplusForCashOuts: true,
+            useDataHookForPay: false,
+            useDataHookForCashOut: false,
+            dataHook: address(0),
+            metadata: 0
+        });
+
+        rulesetConfigurations[0] = JBRulesetConfig({
+            mustStartAtOrAfter: 0,
+            duration: 1, // 1 second — cycles very fast
+            weight: 1000e18,
+            weightCutPercent: 1, // Non-zero so weight decays each cycle
+            approvalHook: _rejectHook, // Will reject all subsequent rulesets
+            metadata: metadata,
+            splitGroups: new JBSplitGroup[](0),
+            fundAccessLimitGroups: new JBFundAccessLimitGroup[](0)
+        });
+
+        vm.prank(_projectOwner);
+        projectId = _controller.launchProjectFor({
+            owner: _projectOwner,
+            projectUri: "ipfs://test",
+            rulesetConfigurations: rulesetConfigurations,
+            terminalConfigurations: new JBTerminalConfig[](0),
+            memo: ""
+        });
+    }
+
+    /// @notice Helper to build a new ruleset config for queuing (will be rejected).
+    function _buildRejectedConfig() internal pure returns (JBRulesetConfig[] memory newConfigs) {
+        newConfigs = new JBRulesetConfig[](1);
+        newConfigs[0] = JBRulesetConfig({
+            mustStartAtOrAfter: 0,
+            duration: 1,
+            weight: 500e18, // Specific weight, not 1 (inherit), to avoid deriveWeightFrom during queuing
+            weightCutPercent: 1,
+            approvalHook: IJBRulesetApprovalHook(address(0)),
+            metadata: JBRulesetMetadata({
+                reservedPercent: 0,
+                cashOutTaxRate: 0,
+                baseCurrency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+                pausePay: false,
+                pauseCreditTransfers: false,
+                allowOwnerMinting: false,
+                allowSetCustomToken: false,
+                allowTerminalMigration: false,
+                allowSetTerminals: false,
+                ownerMustSendPayouts: false,
+                allowSetController: false,
+                allowAddAccountingContext: true,
+                allowAddPriceFeed: false,
+                holdFees: false,
+                useTotalSurplusForCashOuts: true,
+                useDataHookForPay: false,
+                useDataHookForCashOut: false,
+                dataHook: address(0),
+                metadata: 0
+            }),
+            splitGroups: new JBSplitGroup[](0),
+            fundAccessLimitGroups: new JBFundAccessLimitGroup[](0)
+        });
+    }
+
+    /// @notice REGRESSION: After queuing a rejected ruleset and warping >20k cycles,
+    /// updateRulesetWeightCache() should update the active base ruleset's cache (not just the
+    /// rejected latest), allowing currentOf() to succeed.
+    function test_weightCache_fixedAfterApprovalRejection() public {
+        _projectId = _launchProject();
+
+        // Verify the project works initially.
+        JBRuleset memory initial = _rulesets.currentOf(_projectId);
+        assertGt(initial.weight, 0, "Initial weight should be set");
+
+        // Queue a new ruleset (B). It will be rejected by A's approval hook.
+        vm.prank(_projectOwner);
+        _controller.queueRulesetsOf({projectId: _projectId, rulesetConfigurations: _buildRejectedConfig(), memo: ""});
+
+        // Verify B is now the latest but A is still the current (B is rejected).
+        uint256 latestId = _rulesets.latestRulesetIdOf(_projectId);
+        assertGt(latestId, initial.id, "Latest should be B");
+        JBRuleset memory afterQueue = _rulesets.currentOf(_projectId);
+        assertEq(afterQueue.id, initial.id, "Current should still be A (B is rejected)");
+
+        // Warp beyond the 20,000-cycle cache threshold.
+        vm.warp(block.timestamp + 20_001);
+
+        // Before the fix, updateRulesetWeightCache only accepted projectId and always updated
+        // latestRulesetIdOf — which is the rejected B. A's cache could never be updated.
+        // After the fix, the caller passes the rulesetId of the active base ruleset (A).
+        _rulesets.updateRulesetWeightCache(_projectId, initial.id);
+
+        // Now currentOf() should succeed because A's cache is populated.
+        JBRuleset memory afterFix = _rulesets.currentOf(_projectId);
+        assertEq(afterFix.id, initial.id, "Should still use ruleset A");
+        // Weight should be less than initial (decayed over 20k+ cycles).
+        assertLt(afterFix.weight, initial.weight, "Weight should have decayed");
+    }
+
+    /// @notice Multiple cache updates work correctly when the latest is rejected.
+    /// Verifies that progressive caching (multiple updateRulesetWeightCache calls) also
+    /// works for the base ruleset, not just the latest.
+    function test_weightCache_progressiveCachingForRejectedLatest() public {
+        _projectId = _launchProject();
+
+        // Capture the base ruleset (A) ID before warping — after the warp, currentOf() would revert.
+        uint256 baseRulesetId = _rulesets.currentOf(_projectId).id;
+
+        // Queue a rejected ruleset.
+        vm.prank(_projectOwner);
+        _controller.queueRulesetsOf({projectId: _projectId, rulesetConfigurations: _buildRejectedConfig(), memo: ""});
+
+        // Warp far into the future (50k cycles — needs 3 cache update calls).
+        vm.warp(block.timestamp + 50_001);
+
+        // First cache update covers up to 20k cycles.
+        _rulesets.updateRulesetWeightCache(_projectId, baseRulesetId);
+        // Second covers up to 40k.
+        _rulesets.updateRulesetWeightCache(_projectId, baseRulesetId);
+        // Third covers up to 50k.
+        _rulesets.updateRulesetWeightCache(_projectId, baseRulesetId);
+
+        // currentOf() should now work.
+        JBRuleset memory current = _rulesets.currentOf(_projectId);
+        assertGt(current.cycleNumber, 50_000, "Should be past 50k cycles");
+    }
+
+    /// @notice With the fix applied, payments and cashouts continue to work even after
+    /// a rejected ruleset + large cycle gap.
+    function test_weightCache_terminalOperationsWorkAfterFix() public {
+        // Set up terminal for the project.
+        JBAccountingContext[] memory accountingContexts = new JBAccountingContext[](1);
+        accountingContexts[0] = JBAccountingContext({
+            token: JBConstants.NATIVE_TOKEN, decimals: 18, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
+        });
+
+        JBTerminalConfig[] memory terminalConfigs = new JBTerminalConfig[](1);
+        terminalConfigs[0] =
+            JBTerminalConfig({terminal: jbMultiTerminal(), accountingContextsToAccept: accountingContexts});
+
+        // Launch with terminals.
+        JBRulesetConfig[] memory rulesetConfigurations = new JBRulesetConfig[](1);
+        rulesetConfigurations[0] = JBRulesetConfig({
+            mustStartAtOrAfter: 0,
+            duration: 1,
+            weight: 1000e18,
+            weightCutPercent: 1,
+            approvalHook: _rejectHook,
+            metadata: JBRulesetMetadata({
+                reservedPercent: 0,
+                cashOutTaxRate: 0,
+                baseCurrency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+                pausePay: false,
+                pauseCreditTransfers: false,
+                allowOwnerMinting: false,
+                allowSetCustomToken: false,
+                allowTerminalMigration: false,
+                allowSetTerminals: false,
+                ownerMustSendPayouts: false,
+                allowSetController: false,
+                allowAddAccountingContext: true,
+                allowAddPriceFeed: false,
+                holdFees: false,
+                useTotalSurplusForCashOuts: true,
+                useDataHookForPay: false,
+                useDataHookForCashOut: false,
+                dataHook: address(0),
+                metadata: 0
+            }),
+            splitGroups: new JBSplitGroup[](0),
+            fundAccessLimitGroups: new JBFundAccessLimitGroup[](0)
+        });
+
+        vm.prank(_projectOwner);
+        _projectId = _controller.launchProjectFor({
+            owner: _projectOwner,
+            projectUri: "ipfs://test",
+            rulesetConfigurations: rulesetConfigurations,
+            terminalConfigurations: terminalConfigs,
+            memo: ""
+        });
+
+        // Make a payment so there are funds in the terminal.
+        address payer = makeAddr("payer");
+        vm.deal(payer, 10 ether);
+        vm.prank(payer);
+        jbMultiTerminal().pay{value: 5 ether}({
+            projectId: _projectId,
+            token: JBConstants.NATIVE_TOKEN,
+            amount: 5 ether,
+            beneficiary: payer,
+            minReturnedTokens: 0,
+            memo: "",
+            metadata: ""
+        });
+
+        // Capture the base ruleset (A) ID before queuing a rejected one.
+        uint256 baseRulesetId = _rulesets.currentOf(_projectId).id;
+
+        // Queue a rejected ruleset.
+        vm.prank(_projectOwner);
+        _controller.queueRulesetsOf({projectId: _projectId, rulesetConfigurations: _buildRejectedConfig(), memo: ""});
+
+        // Warp beyond 20k cycles.
+        vm.warp(block.timestamp + 20_001);
+
+        // Update the cache for the active base ruleset (A), not the rejected latest (B).
+        _rulesets.updateRulesetWeightCache(_projectId, baseRulesetId);
+
+        // Payments should succeed after cache update.
+        vm.deal(payer, 1 ether);
+        vm.prank(payer);
+        jbMultiTerminal().pay{value: 1 ether}({
+            projectId: _projectId,
+            token: JBConstants.NATIVE_TOKEN,
+            amount: 1 ether,
+            beneficiary: payer,
+            minReturnedTokens: 0,
+            memo: "",
+            metadata: ""
+        });
+
+        uint256 tokenBalance = jbTokens().totalBalanceOf(payer, _projectId);
+        assertGt(tokenBalance, 0, "Payer should have tokens after fix");
+    }
+}

package/test/invariants/handlers/RulesetsHandler.sol

@@ -106,6 +106,6 @@ contract RulesetsHandler is Test {
 
     /// @notice Update the weight cache for the project.
     function updateWeightCache() public {
-        try rulesets.updateRulesetWeightCache(projectId) {} catch {}
+        try rulesets.updateRulesetWeightCache(projectId, rulesets.latestRulesetIdOf(projectId)) {} catch {}
     }
 }

package/test/units/static/JBRulesets/TestRulesets.sol

@@ -550,10 +550,10 @@ contract TestJBRulesetsUnits_Local is JBTest {
         // Update the weight cache incrementally — each call advances by at most 20,000 cycles.
         // With 20,000 cycles and 10% weight cut per cycle, weight reaches 0 well before 20,000 cycles.
         // First call: advances cache by up to 20,000 cycles (weight decays to 0).
-        _rulesets.updateRulesetWeightCache(_projectId);
+        _rulesets.updateRulesetWeightCache(_projectId, _rulesets.latestRulesetIdOf(_projectId));
 
         // Second call during the same block should mirror the previous (cache already covers current time).
-        _rulesets.updateRulesetWeightCache(_projectId);
+        _rulesets.updateRulesetWeightCache(_projectId, _rulesets.latestRulesetIdOf(_projectId));
     }
 
     function test_QueueForApprovalHookDNSupportInterface() external {

package/test/units/static/JBRulesets/TestUpdateRulesetWeightCache.sol

@@ -48,7 +48,7 @@ contract TestUpdateRulesetWeightCache_Local is JBRulesetsSetup {
     function test_WhenLatestRulesetOfProjectDurationOrWeightCutPercentEQZero() external {
         // it will return without updating
 
-        _rulesets.updateRulesetWeightCache(_projectId);
+        _rulesets.updateRulesetWeightCache(_projectId, _rulesets.latestRulesetIdOf(_projectId));
     }
 
     function test_WhenLatestRulesetHasProperDurationAndWeightCutPercent() external {
@@ -86,6 +86,6 @@ contract TestUpdateRulesetWeightCache_Local is JBRulesetsSetup {
             mustStartAtOrAfter: _mustStartAt
         });
 
-        _rulesets.updateRulesetWeightCache(_projectId);
+        _rulesets.updateRulesetWeightCache(_projectId, _rulesets.latestRulesetIdOf(_projectId));
     }
 }