@bananapus/core-v6 0.0.1

package/test/units/static/JBChainlinkV3PriceFeed/TestPriceFeed.sol

@@ -0,0 +1,220 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBChainlinkV3PriceFeed} from "../../../../src/JBChainlinkV3PriceFeed.sol";
+import {AggregatorV3Interface} from "@chainlink/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol";
+import {JBFixedPointNumber} from "../../../../src/libraries/JBFixedPointNumber.sol";
+
+/// @notice Mock Chainlink AggregatorV3Interface for testing.
+contract MockAggregator {
+    int256 public price;
+    uint8 public decimals_;
+    uint256 public updatedAt_;
+    uint80 public roundId_;
+
+    function setPrice(int256 _price) external {
+        price = _price;
+    }
+
+    function setDecimals(uint8 _decimals) external {
+        decimals_ = _decimals;
+    }
+
+    function setUpdatedAt(uint256 _updatedAt) external {
+        updatedAt_ = _updatedAt;
+    }
+
+    function setRoundId(uint80 _roundId) external {
+        roundId_ = _roundId;
+    }
+
+    function decimals() external view returns (uint8) {
+        return decimals_;
+    }
+
+    function latestRoundData()
+        external
+        view
+        returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound)
+    {
+        return (roundId_, price, block.timestamp, updatedAt_, roundId_);
+    }
+}
+
+/// @notice Tests for JBChainlinkV3PriceFeed.
+contract TestPriceFeed_Local is JBTest {
+    using JBFixedPointNumber for uint256;
+
+    MockAggregator mockFeed;
+    JBChainlinkV3PriceFeed priceFeed;
+
+    uint256 constant THRESHOLD = 1 hours;
+
+    function setUp() external {
+        mockFeed = new MockAggregator();
+        mockFeed.setDecimals(8);
+        mockFeed.setPrice(200_000_000_000); // $2000 with 8 decimals
+        mockFeed.setUpdatedAt(block.timestamp);
+        mockFeed.setRoundId(1);
+
+        priceFeed = new JBChainlinkV3PriceFeed(AggregatorV3Interface(address(mockFeed)), THRESHOLD);
+    }
+
+    //*********************************************************************//
+    // --- Normal Operation --------------------------------------------- //
+    //*********************************************************************//
+
+    /// @notice Price is returned correctly with same decimals as feed.
+    function test_normalPrice_sameDecimals() external view {
+        uint256 price = priceFeed.currentUnitPrice(8);
+        assertEq(price, 200_000_000_000, "price should be 2000e8");
+    }
+
+    /// @notice Price is adjusted when requesting more decimals than the feed.
+    function test_normalPrice_scaleUp() external view {
+        uint256 price = priceFeed.currentUnitPrice(18);
+        assertEq(price, 2_000_000_000_000_000_000_000, "price should be 2000e18");
+    }
+
+    /// @notice Price is adjusted when requesting fewer decimals than the feed.
+    function test_normalPrice_scaleDown() external view {
+        uint256 price = priceFeed.currentUnitPrice(6);
+        assertEq(price, 2_000_000_000, "price should be 2000e6");
+    }
+
+    /// @notice Price of 1 (minimum positive) is returned.
+    function test_normalPrice_minimumPositive() external {
+        mockFeed.setPrice(1);
+        uint256 price = priceFeed.currentUnitPrice(8);
+        assertEq(price, 1, "minimum positive price should be 1");
+    }
+
+    //*********************************************************************//
+    // --- Stale Price -------------------------------------------------- //
+    //*********************************************************************//
+
+    /// @notice Reverts when price is older than threshold.
+    function test_stalePrice_reverts() external {
+        // Set updatedAt to a time older than threshold
+        mockFeed.setUpdatedAt(block.timestamp - THRESHOLD - 1);
+
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                JBChainlinkV3PriceFeed.JBChainlinkV3PriceFeed_StalePrice.selector,
+                block.timestamp,
+                THRESHOLD,
+                block.timestamp - THRESHOLD - 1
+            )
+        );
+        priceFeed.currentUnitPrice(18);
+    }
+
+    /// @notice Does not revert when price is exactly at the threshold boundary.
+    function test_stalePrice_atBoundary_succeeds() external {
+        // Set updatedAt exactly at the threshold
+        mockFeed.setUpdatedAt(block.timestamp - THRESHOLD);
+        uint256 price = priceFeed.currentUnitPrice(8);
+        assertEq(price, 200_000_000_000, "price at boundary should succeed");
+    }
+
+    //*********************************************************************//
+    // --- Incomplete Round --------------------------------------------- //
+    //*********************************************************************//
+
+    /// @notice Reverts when updatedAt is 0 (incomplete round).
+    /// @dev Note: the stale check fires first when block.timestamp > THRESHOLD.
+    ///      To test the IncompleteRound path, we use a priceFeed with THRESHOLD > block.timestamp.
+    function test_incompleteRound_reverts() external {
+        // Create a price feed with a huge threshold so stale check passes
+        JBChainlinkV3PriceFeed largeThrPriceFeed =
+            new JBChainlinkV3PriceFeed(AggregatorV3Interface(address(mockFeed)), type(uint256).max);
+        mockFeed.setUpdatedAt(0);
+
+        vm.expectRevert(JBChainlinkV3PriceFeed.JBChainlinkV3PriceFeed_IncompleteRound.selector);
+        largeThrPriceFeed.currentUnitPrice(18);
+    }
+
+    //*********************************************************************//
+    // --- Negative / Zero Price ---------------------------------------- //
+    //*********************************************************************//
+
+    /// @notice Reverts when price is 0.
+    function test_zeroPrice_reverts() external {
+        mockFeed.setPrice(0);
+
+        vm.expectRevert(
+            abi.encodeWithSelector(JBChainlinkV3PriceFeed.JBChainlinkV3PriceFeed_NegativePrice.selector, int256(0))
+        );
+        priceFeed.currentUnitPrice(18);
+    }
+
+    /// @notice Reverts when price is negative.
+    function test_negativePrice_reverts() external {
+        mockFeed.setPrice(-100);
+
+        vm.expectRevert(
+            abi.encodeWithSelector(JBChainlinkV3PriceFeed.JBChainlinkV3PriceFeed_NegativePrice.selector, int256(-100))
+        );
+        priceFeed.currentUnitPrice(18);
+    }
+
+    //*********************************************************************//
+    // --- Fuzz Tests --------------------------------------------------- //
+    //*********************************************************************//
+
+    /// @notice Decimal adjustment is consistent with JBFixedPointNumber.
+    function testFuzz_decimalsAdjustment(uint128 rawPrice, uint8 feedDecimals, uint8 requestedDecimals) external {
+        rawPrice = uint128(bound(uint256(rawPrice), 1, type(uint128).max));
+        feedDecimals = uint8(bound(uint256(feedDecimals), 0, 18));
+        requestedDecimals = uint8(bound(uint256(requestedDecimals), 0, 36));
+
+        MockAggregator fuzzFeed = new MockAggregator();
+        fuzzFeed.setDecimals(feedDecimals);
+        fuzzFeed.setPrice(int256(uint256(rawPrice)));
+        fuzzFeed.setUpdatedAt(block.timestamp);
+        fuzzFeed.setRoundId(1);
+
+        JBChainlinkV3PriceFeed fuzzPriceFeed =
+            new JBChainlinkV3PriceFeed(AggregatorV3Interface(address(fuzzFeed)), THRESHOLD);
+
+        uint256 price = fuzzPriceFeed.currentUnitPrice(requestedDecimals);
+        uint256 expected = uint256(rawPrice).adjustDecimals({decimals: feedDecimals, targetDecimals: requestedDecimals});
+        assertEq(price, expected, "price should match JBFixedPointNumber.adjustDecimals");
+    }
+
+    /// @notice Fresh prices never revert (for valid price ranges).
+    function testFuzz_freshPrice_doesNotRevert(uint128 rawPrice) external {
+        rawPrice = uint128(bound(uint256(rawPrice), 1, type(uint128).max));
+
+        mockFeed.setPrice(int256(uint256(rawPrice)));
+        mockFeed.setUpdatedAt(block.timestamp);
+
+        // Should not revert
+        priceFeed.currentUnitPrice(18);
+    }
+
+    /// @notice Stale prices always revert.
+    function testFuzz_stalePrice_alwaysReverts(uint256 delay) external {
+        delay = bound(delay, THRESHOLD + 1, block.timestamp);
+
+        mockFeed.setUpdatedAt(block.timestamp - delay);
+
+        vm.expectRevert();
+        priceFeed.currentUnitPrice(18);
+    }
+
+    //*********************************************************************//
+    // --- Immutable Properties ----------------------------------------- //
+    //*********************************************************************//
+
+    /// @notice FEED is set correctly.
+    function test_feedIsSet() external view {
+        assertEq(address(priceFeed.FEED()), address(mockFeed), "FEED should match mock");
+    }
+
+    /// @notice THRESHOLD is set correctly.
+    function test_thresholdIsSet() external view {
+        assertEq(priceFeed.THRESHOLD(), THRESHOLD, "THRESHOLD should match");
+    }
+}

package/test/units/static/JBController/JBControllerSetup.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+
+/*
+Contract that deploys a target contract with other mock contracts to satisfy the constructor.
+Tests relative to this contract will be dependent on mock calls/emits and stdStorage.
+*/
+contract JBControllerSetup is JBTest {
+    // Target Contract
+    IJBController public _controller;
+
+    // Mocks
+    IJBPermissions public permissions = IJBPermissions(makeAddr("permissions"));
+    IJBProjects public projects = IJBProjects(makeAddr("projects"));
+    IJBDirectory public directory = IJBDirectory(makeAddr("directory"));
+    IJBRulesets public rulesets = IJBRulesets(makeAddr("rulesets"));
+    IJBTokens public tokens = IJBTokens(makeAddr("tokens"));
+    IJBPrices public prices = IJBPrices(makeAddr("prices"));
+    IJBSplits public splits = IJBSplits(makeAddr("splits"));
+    IJBFundAccessLimits public fundAccessLimits = IJBFundAccessLimits(makeAddr("limits"));
+    address public trustedForwarder = makeAddr("forwarder");
+
+    function controllerSetup() public virtual {
+        // Instantiate the contract being tested
+        _controller = new JBController(
+            directory,
+            fundAccessLimits,
+            permissions,
+            prices,
+            projects,
+            rulesets,
+            splits,
+            tokens,
+            address(0),
+            trustedForwarder
+        );
+    }
+}

package/test/units/static/JBController/TestBurnTokensOf.sol

@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBControllerSetup} from "./JBControllerSetup.sol";
+
+contract TestBurnTokensOf_Local is JBControllerSetup {
+    uint256 _projectId = 1;
+    uint256 _rootProjectId = 0;
+    uint256 _validCount = 1;
+    uint256 _invalidCount = 0;
+    string _memo = "JUICAY";
+    address _holder = makeAddr("hodl");
+
+    function setUp() public {
+        super.controllerSetup();
+    }
+
+    function test_WhenCallerIsNotPermissionedOrTerminal() external {
+        // it should revert UNAUTHORIZED()
+
+        // it will call directory to check if caller is terminal first
+        bytes memory _directoryCall = abi.encodeCall(IJBDirectory.isTerminalOf, (1, IJBTerminal(address(this))));
+        bytes memory _directoryReturned = abi.encode(false);
+        mockExpect(address(directory), _directoryCall, _directoryReturned);
+
+        // it will call permissions after to first check permissions over the specific project
+        bytes memory _permCall = abi.encodeCall(
+            IJBPermissions.hasPermission, (address(this), _holder, _projectId, JBPermissionIds.BURN_TOKENS, true, true)
+        );
+        bytes memory _permReturn = abi.encode(false);
+        mockExpect(address(permissions), _permCall, _permReturn);
+
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                JBPermissioned.JBPermissioned_Unauthorized.selector,
+                _holder,
+                address(this),
+                _projectId,
+                JBPermissionIds.BURN_TOKENS
+            )
+        );
+        _controller.burnTokensOf(_holder, _projectId, _validCount, _memo);
+    }
+
+    function test_WhenCallerIsTerminalAndTokenCountGtZero() external {
+        // it should burn and emit BurnTokens
+
+        // it will call directory to check if caller is terminal first
+        bytes memory _directoryCall = abi.encodeCall(IJBDirectory.isTerminalOf, (1, IJBTerminal(address(this))));
+        bytes memory _directoryReturned = abi.encode(true);
+        mockExpect(address(directory), _directoryCall, _directoryReturned);
+
+        // since we spoofed a terminal it will call JBTokens to burn
+        bytes memory _burnFromCall = abi.encodeCall(IJBTokens.burnFrom, (_holder, _projectId, _validCount));
+        bytes memory _burnFromReturn = "";
+        mockExpect(address(tokens), _burnFromCall, _burnFromReturn);
+
+        vm.expectEmit();
+        emit IJBController.BurnTokens(_holder, _projectId, _validCount, _memo, address(this));
+        _controller.burnTokensOf(_holder, _projectId, _validCount, _memo);
+    }
+
+    function test_WhenCallerHasRootPermissionAndTokenCountGtZero() external {
+        // it should burn and emit BurnTokens
+
+        // it will call directory to check if caller is terminal first
+        bytes memory _directoryCall = abi.encodeCall(IJBDirectory.isTerminalOf, (1, IJBTerminal(address(this))));
+        bytes memory _directoryReturned = abi.encode(false);
+        mockExpect(address(directory), _directoryCall, _directoryReturned);
+
+        // it will call permissions after to first check permissions over the specific project
+        bytes memory _permCall = abi.encodeCall(
+            IJBPermissions.hasPermission, (address(this), _holder, _projectId, JBPermissionIds.BURN_TOKENS, true, true)
+        );
+        bytes memory _permReturn = abi.encode(true);
+        mockExpect(address(permissions), _permCall, _permReturn);
+
+        // it will call JBTokens to burn
+        bytes memory _burnFromCall = abi.encodeCall(IJBTokens.burnFrom, (_holder, _projectId, _validCount));
+        bytes memory _burnFromReturn = "";
+        mockExpect(address(tokens), _burnFromCall, _burnFromReturn);
+
+        vm.expectEmit();
+        emit IJBController.BurnTokens(_holder, _projectId, _validCount, _memo, address(this));
+        _controller.burnTokensOf(_holder, _projectId, _validCount, _memo);
+    }
+
+    function test_WhenTokenCountEqZero() external {
+        // it should revert NO_BURNABLE_TOKENS
+
+        // it will call directory to check if caller is terminal first
+        bytes memory _directoryCall = abi.encodeCall(IJBDirectory.isTerminalOf, (1, IJBTerminal(address(this))));
+        bytes memory _directoryReturned = abi.encode(false);
+        mockExpect(address(directory), _directoryCall, _directoryReturned);
+
+        // it will call permissions after to first check permissions over the specific project
+        bytes memory _permCall = abi.encodeCall(
+            IJBPermissions.hasPermission, (address(this), _holder, _projectId, JBPermissionIds.BURN_TOKENS, true, true)
+        );
+        bytes memory _permReturn = abi.encode(true);
+        mockExpect(address(permissions), _permCall, _permReturn);
+
+        vm.expectRevert(JBController.JBController_ZeroTokensToBurn.selector);
+        _controller.burnTokensOf(_holder, _projectId, _invalidCount, _memo);
+    }
+}

package/test/units/static/JBController/TestClaimTokensFor.sol

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBControllerSetup} from "./JBControllerSetup.sol";
+
+contract TestClaimTokensFor_Local is JBControllerSetup {
+    address _holder = makeAddr("hodler");
+    uint256 _projectId = 1;
+    uint256 _rootId = 0;
+    uint256 _amount = 1e18;
+    address _beneficiary = makeAddr("bene");
+
+    function setUp() public {
+        super.controllerSetup();
+    }
+
+    function test_WhenCallerIsPermissioned() external {
+        // it should call JBTokens to claim on behalf of holder
+
+        // it will call permissions
+        bytes memory _permCall = abi.encodeCall(
+            IJBPermissions.hasPermission, (address(this), _holder, _projectId, JBPermissionIds.CLAIM_TOKENS, true, true)
+        );
+        bytes memory _permReturn = abi.encode(true);
+        mockExpect(address(permissions), _permCall, _permReturn);
+
+        // it will call JBTokens to claim when permissioned
+        bytes memory _tokensCall =
+            abi.encodeCall(IJBTokens.claimTokensFor, (_holder, _projectId, _amount, _beneficiary));
+        bytes memory _tokensReturn = "";
+        mockExpect(address(tokens), _tokensCall, _tokensReturn);
+
+        // will succeed
+        _controller.claimTokensFor(_holder, _projectId, _amount, _beneficiary);
+    }
+
+    function test_WhenCallerIsNotPermissioned() external {
+        // it should revert UNAUTHORIZED
+
+        // it will call permissions
+        bytes memory _permCall = abi.encodeCall(
+            IJBPermissions.hasPermission, (address(this), _holder, _projectId, JBPermissionIds.CLAIM_TOKENS, true, true)
+        );
+        bytes memory _permReturn = abi.encode(false);
+        mockExpect(address(permissions), _permCall, _permReturn);
+
+        // will revert
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                JBPermissioned.JBPermissioned_Unauthorized.selector,
+                _holder,
+                address(this),
+                _projectId,
+                JBPermissionIds.CLAIM_TOKENS
+            )
+        );
+        _controller.claimTokensFor(_holder, _projectId, _amount, _beneficiary);
+    }
+}

package/test/units/static/JBController/TestDeployErc20For.sol

@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBControllerSetup} from "./JBControllerSetup.sol";
+
+contract TestDeployERC20For_Local is JBControllerSetup {
+    uint256 _projectId = 1;
+    IJBToken _token = IJBToken(makeAddr("token"));
+    string _name = "Juice";
+    string _symbol = "JCY";
+    bytes32 _salt = bytes32(0);
+
+    function setUp() public {
+        super.controllerSetup();
+    }
+
+    function test_WhenCallerIsPermissioned() external {
+        // it will deploy ERC20 and return IJBToken
+
+        // mock call to JBProjects ownerOf which will give permission
+        bytes memory _projectsCall = abi.encodeCall(IERC721.ownerOf, (_projectId));
+        bytes memory _projectsCallReturn = abi.encode(address(this));
+        mockExpect(address(projects), _projectsCall, _projectsCallReturn);
+
+        // mock the call to JBTokens deployERC20For
+        bytes memory _deployCall = abi.encodeCall(IJBTokens.deployERC20For, (_projectId, _name, _symbol, _salt));
+        bytes memory _deployCallReturn = abi.encode(_token);
+        mockExpect(address(tokens), _deployCall, _deployCallReturn);
+
+        _controller.deployERC20For(_projectId, _name, _symbol, _salt);
+    }
+
+    function test_WhenCallerIsPermissionedAndSaltIsNonZero() external {
+        // it will deploy ERC20 and return IJBToken
+
+        bytes32 _nonZeroSalt = bytes32("somesalt");
+        bytes32 _encodedSalt = keccak256(abi.encodePacked(address(this), _nonZeroSalt));
+
+        // mock call to JBProjects ownerOf which will give permission
+        bytes memory _projectsCall = abi.encodeCall(IERC721.ownerOf, (_projectId));
+        bytes memory _projectsCallReturn = abi.encode(address(this));
+        mockExpect(address(projects), _projectsCall, _projectsCallReturn);
+
+        // mock the call to JBTokens deployERC20For
+        bytes memory _deployCall = abi.encodeCall(IJBTokens.deployERC20For, (_projectId, _name, _symbol, _encodedSalt));
+        bytes memory _deployCallReturn = abi.encode(_token);
+        mockExpect(address(tokens), _deployCall, _deployCallReturn);
+
+        _controller.deployERC20For(_projectId, _name, _symbol, _nonZeroSalt);
+    }
+
+    function test_WhenCallerIsNotPermissioned() external {
+        // it will revert UNAUTHORIZED
+
+        // mock call to JBProjects ownerOf which will give permission
+        bytes memory _projectsCall = abi.encodeCall(IERC721.ownerOf, (_projectId));
+        address _projectsCallReturn = address(0);
+        mockExpect(address(projects), _projectsCall, abi.encode(_projectsCallReturn));
+
+        // mock call for projects permission
+        bytes memory _permissionCall1 = abi.encodeCall(
+            IJBPermissions.hasPermission,
+            (address(this), address(0), _projectId, JBPermissionIds.DEPLOY_ERC20, true, true)
+        );
+        bytes memory _permissionCallReturn1 = abi.encode(false);
+        mockExpect(address(permissions), _permissionCall1, _permissionCallReturn1);
+
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                JBPermissioned.JBPermissioned_Unauthorized.selector,
+                _projectsCallReturn,
+                address(this),
+                _projectId,
+                JBPermissionIds.DEPLOY_ERC20
+            )
+        );
+        _controller.deployERC20For(_projectId, _name, _symbol, _salt);
+    }
+}