@bananapus/core-v6 0.0.1

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

@@ -0,0 +1,148 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBControllerSetup} from "./JBControllerSetup.sol";
+
+contract TestMigrateController_Local is JBControllerSetup {
+    using stdStorage for StdStorage;
+
+    function setUp() public {
+        super.controllerSetup();
+    }
+
+    modifier whenCallerHasPermission() {
+        // mock ownerOf call
+        bytes memory _ownerOfCall = abi.encodeCall(IERC721.ownerOf, (1));
+        bytes memory _ownerData = abi.encode(address(this));
+
+        mockExpect(address(projects), _ownerOfCall, _ownerData);
+        _;
+    }
+
+    modifier migrationIsAllowedByRuleset() {
+        JBRulesetMetadata memory _metadata = JBRulesetMetadata({
+            reservedPercent: JBConstants.MAX_RESERVED_PERCENT / 2, //50%
+            cashOutTaxRate: JBConstants.MAX_CASH_OUT_TAX_RATE / 2, //50%
+            baseCurrency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+            pausePay: false,
+            pauseCreditTransfers: false,
+            allowOwnerMinting: false,
+            allowSetCustomToken: false,
+            allowTerminalMigration: false,
+            allowSetTerminals: false,
+            ownerMustSendPayouts: false,
+            allowSetController: true,
+            allowAddAccountingContext: true,
+            allowAddPriceFeed: false,
+            holdFees: false,
+            useTotalSurplusForCashOuts: true,
+            useDataHookForPay: false,
+            useDataHookForCashOut: false,
+            dataHook: address(0),
+            metadata: 0
+        });
+
+        uint256 _packedMetadata = JBRulesetMetadataResolver.packRulesetMetadata(_metadata);
+
+        // setup: return data
+        JBRuleset memory data = JBRuleset({
+            cycleNumber: 1,
+            id: uint48(block.timestamp),
+            basedOnId: 0,
+            start: uint48(block.timestamp),
+            duration: 0,
+            weight: 0,
+            weightCutPercent: 0,
+            approvalHook: IJBRulesetApprovalHook(address(0)),
+            metadata: _packedMetadata
+        });
+
+        // mock currentOf call
+        bytes memory _currentOfCall = abi.encodeCall(IJBRulesets.currentOf, (1));
+        bytes memory _returned = abi.encode(data);
+
+        mockExpect(address(rulesets), _currentOfCall, _returned);
+        _;
+    }
+
+    modifier migrationIsNotAllowedByRuleset() {
+        JBRulesetMetadata memory _metadata = JBRulesetMetadata({
+            reservedPercent: JBConstants.MAX_RESERVED_PERCENT / 2, //50%
+            cashOutTaxRate: JBConstants.MAX_CASH_OUT_TAX_RATE / 2, //50%
+            baseCurrency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+            pausePay: false,
+            pauseCreditTransfers: false,
+            allowOwnerMinting: false,
+            allowSetCustomToken: false,
+            allowTerminalMigration: false,
+            allowSetTerminals: false,
+            ownerMustSendPayouts: false,
+            allowSetController: true,
+            allowAddAccountingContext: true,
+            allowAddPriceFeed: false,
+            holdFees: false,
+            useTotalSurplusForCashOuts: true,
+            useDataHookForPay: false,
+            useDataHookForCashOut: false,
+            dataHook: address(0),
+            metadata: 0
+        });
+
+        uint256 _packedMetadata = JBRulesetMetadataResolver.packRulesetMetadata(_metadata);
+
+        // setup: return data
+        JBRuleset memory data = JBRuleset({
+            cycleNumber: 1,
+            id: uint48(block.timestamp),
+            basedOnId: 0,
+            start: uint48(block.timestamp),
+            duration: 0,
+            weight: 0,
+            weightCutPercent: 0,
+            approvalHook: IJBRulesetApprovalHook(address(0)),
+            metadata: _packedMetadata
+        });
+
+        // mock currentOf call
+        bytes memory _currentOfCall = abi.encodeCall(IJBRulesets.currentOf, (1));
+        bytes memory _returned = abi.encode(data);
+
+        mockExpect(address(rulesets), _currentOfCall, _returned);
+        _;
+    }
+
+    function test_Revert_When_Caller_Is_Not_Directory() external {
+        // it should revert
+
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                JBController.JBController_OnlyDirectory.selector, address(this), _controller.DIRECTORY()
+            )
+        );
+        IJBMigratable(address(_controller)).migrate(1, IJBMigratable(address(this)));
+    }
+
+    function test_Revert_When_GivenReservedTokenBalanceIsPending() external {
+        // it should send reserved tokens to splits
+        // set storage since we can't mock internal calls
+        stdstore.target(address(IJBMigratable(address(_controller)))).sig("pendingReservedTokenBalanceOf(uint256)")
+            .with_key(uint256(1)).checked_write(uint256(100));
+
+        vm.prank(address(directory));
+
+        // Revert as expected, this functionality is no longer allowed since `JBController4_1`,
+        // Pending is send out as part of `beforeReceiveMigrationFrom`.
+        vm.expectRevert(abi.encodeWithSelector(JBController.JBController_PendingReservedTokens.selector, 100));
+        IJBMigratable(address(_controller)).migrate(1, IJBMigratable(address(this)));
+    }
+
+    function test_GivenNoReservedTokenBalanceIsPending() external {
+        // event as expected
+        vm.expectEmit();
+        emit IJBMigratable.Migrate(1, IJBMigratable(address(this)), address(directory));
+
+        vm.prank(address(directory));
+        IJBMigratable(address(_controller)).migrate(1, IJBMigratable(address(this)));
+    }
+}

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

@@ -0,0 +1,102 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBControllerSetup} from "./JBControllerSetup.sol";
+
+contract TestMintTokensOfUnits_Local is JBControllerSetup {
+    uint256 _projectId = 1;
+
+    function setUp() public {
+        super.controllerSetup();
+    }
+
+    function test_WhenNoRulesetIsActive() external {
+        // it should be able to mint
+    }
+
+    function test_MintNotAllowedSenderNotHookTerminalNorRulesetAllowsMint() external {
+        // 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);
+
+        // setup: return data
+        JBRulesetMetadata memory _metadata = JBRulesetMetadata({
+            reservedPercent: JBConstants.MAX_RESERVED_PERCENT / 2, //50%
+            cashOutTaxRate: JBConstants.MAX_CASH_OUT_TAX_RATE / 2, //50%
+            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
+        });
+
+        uint256 _packedMetadata = JBRulesetMetadataResolver.packRulesetMetadata(_metadata);
+
+        JBRuleset memory data = JBRuleset({
+            cycleNumber: 1,
+            id: uint48(block.timestamp),
+            basedOnId: 0,
+            start: uint48(block.timestamp),
+            duration: 8000,
+            weight: 5000,
+            weightCutPercent: 0,
+            approvalHook: IJBRulesetApprovalHook(address(0x1234567890123456789012345678901234567890)),
+            metadata: _packedMetadata
+        });
+
+        // mock call to rulesets
+        mockExpect(address(rulesets), abi.encodeCall(IJBRulesets.currentOf, (_projectId)), abi.encode(data));
+
+        // mock call to isTerminalOf
+        mockExpect(
+            address(directory),
+            abi.encodeCall(IJBDirectory.isTerminalOf, (_projectId, IJBTerminal(address(this)))),
+            abi.encode(false)
+        );
+
+        vm.expectRevert(
+            abi.encodeWithSelector(JBController.JBController_MintNotAllowedAndNotTerminalOrHook.selector, address(this))
+        );
+
+        _controller.mintTokensOf({
+            projectId: _projectId, tokenCount: 1, beneficiary: address(this), memo: "", useReservedPercent: true
+        });
+    }
+
+    function test_RevertWhen_MintingIsDisabledInTheFundingCycleRuleset() external {
+        // it should revert
+    }
+
+    modifier whenMintingIsEnabledInTheFundingCycleRuleset() {
+        _;
+    }
+
+    function test_GivenThatThereAreTokensAvailableToMint() external whenMintingIsEnabledInTheFundingCycleRuleset {
+        // it should be possible to mint
+    }
+
+    function test_GivenThatADataSourceIsConfigured() external whenMintingIsEnabledInTheFundingCycleRuleset {
+        // it should be able to mint
+    }
+
+    function test_GivenThatADataSourceHasPermissionedAnotherContractToMint()
+        external
+        whenMintingIsEnabledInTheFundingCycleRuleset
+    {
+        // it should be able to mint
+    }
+}

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

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBControllerSetup} from "./JBControllerSetup.sol";
+
+contract TestExecutePayReservedTokenToTerminal_Local is JBControllerSetup {
+    uint256 _projectId = 1;
+    uint256 _defaultAmount = 1e18;
+    IJBTerminal _terminal = IJBTerminal(makeAddr("someTerminal"));
+    IJBToken _token = IJBToken(makeAddr("someToken"));
+    address _bene = makeAddr("beneficiary");
+
+    function setUp() public {
+        super.controllerSetup();
+    }
+
+    function test_WhenCallerIsNotItself() external {
+        // it will revert
+        vm.expectRevert();
+        JBController(address(_controller))
+            .executePayReservedTokenToTerminal(_terminal, _projectId, _token, _defaultAmount, _bene, "");
+    }
+
+    modifier whenCallerIsItself() {
+        // put code at token address for OZ Address check
+        vm.etch(address(_token), abi.encode(1));
+
+        vm.prank(address(_controller));
+        _;
+    }
+
+    function test_GivenAllowanceEQZeroAfterPay() external whenCallerIsItself {
+        // it will not revert
+
+        // mock pay call to some terminal
+        mockExpect(
+            address(_terminal),
+            abi.encodeCall(IJBTerminal.pay, (_projectId, address(_token), _defaultAmount, _bene, 0, "", "")),
+            abi.encode(0)
+        );
+
+        // mock the allowance assertion
+        mockExpect(
+            address(_token), abi.encodeCall(IERC20.allowance, (address(_controller), address(_terminal))), abi.encode(0)
+        );
+
+        JBController(address(_controller))
+            .executePayReservedTokenToTerminal(_terminal, _projectId, _token, _defaultAmount, _bene, "");
+    }
+
+    function test_GivenAllowanceDNEQZeroAfterPay() external whenCallerIsItself {
+        // it will revert
+
+        // mock pay call to some terminal
+        mockExpect(
+            address(_terminal),
+            abi.encodeCall(IJBTerminal.pay, (_projectId, address(_token), _defaultAmount, _bene, 0, "", "")),
+            abi.encode(0)
+        );
+
+        // mock the allowance assertion
+        mockExpect(
+            address(_token), abi.encodeCall(IERC20.allowance, (address(_controller), address(_terminal))), abi.encode(1)
+        );
+
+        vm.expectRevert();
+        JBController(address(_controller))
+            .executePayReservedTokenToTerminal(_terminal, _projectId, _token, _defaultAmount, _bene, "");
+    }
+}

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

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBControllerSetup} from "./JBControllerSetup.sol";
+
+contract TestReceiveMigrationFrom_Local is JBControllerSetup {
+    uint256 _projectId = 1;
+    IERC165 _from = IERC165(makeAddr("from"));
+
+    function setUp() public {
+        super.controllerSetup();
+    }
+
+    function test_GivenThatTheCallerIsAlsoControllerOfProjectId() external {
+        vm.expectRevert(
+            abi.encodeWithSelector(JBController.JBController_OnlyDirectory.selector, address(this), address(directory))
+        );
+
+        vm.prank(address(this));
+        IJBMigratable(address(_controller)).beforeReceiveMigrationFrom(_from, _projectId);
+    }
+
+    function test_GivenThatTheCallerIsDirectory() external {
+        // mock supports interface call
+        mockExpect(
+            address(_from),
+            abi.encodeCall(IERC165.supportsInterface, (type(IJBProjectUriRegistry).interfaceId)),
+            abi.encode(true)
+        );
+
+        // mock call to from uriOf
+        mockExpect(address(_from), abi.encodeCall(IJBProjectUriRegistry.uriOf, (_projectId)), abi.encode("Juicay"));
+
+        // Mock does not support the controller interface.
+        mockExpect(
+            address(_from),
+            abi.encodeCall(IERC165.supportsInterface, (type(IJBController).interfaceId)),
+            abi.encode(false)
+        );
+
+        vm.prank(address(directory));
+        IJBMigratable(address(_controller)).beforeReceiveMigrationFrom(_from, _projectId);
+        string memory stored = _controller.uriOf(_projectId);
+        assertEq(stored, "Juicay");
+    }
+
+    function test_GivenThatTheCallerIsDirectory_FromSupportsControllerInterface(uint8 tokenAmount) external {
+        // mock supports interface call
+        mockExpect(
+            address(_from),
+            abi.encodeCall(IERC165.supportsInterface, (type(IJBProjectUriRegistry).interfaceId)),
+            abi.encode(true)
+        );
+
+        // mock call to from uriOf
+        mockExpect(address(_from), abi.encodeCall(IJBProjectUriRegistry.uriOf, (_projectId)), abi.encode("Juicay"));
+
+        // Mock does not support the controller interface.
+        mockExpect(
+            address(_from),
+            abi.encodeCall(IERC165.supportsInterface, (type(IJBController).interfaceId)),
+            abi.encode(true)
+        );
+
+        mockExpect(
+            address(_from),
+            abi.encodeCall(IJBController.pendingReservedTokenBalanceOf, (_projectId)),
+            abi.encode(uint256(tokenAmount))
+        );
+
+        if (tokenAmount > 0) {
+            // mock call to from mintTokensOf
+            mockExpect(
+                address(_from),
+                abi.encodeCall(IJBController.sendReservedTokensToSplitsOf, (_projectId)),
+                abi.encode(tokenAmount)
+            );
+        }
+
+        vm.prank(address(directory));
+        IJBMigratable(address(_controller)).beforeReceiveMigrationFrom(_from, _projectId);
+        string memory stored = _controller.uriOf(_projectId);
+        assertEq(stored, "Juicay");
+    }
+
+    function test_GivenThatTheCallerIsNotController() external {
+        // it will revert
+
+        vm.expectRevert(
+            abi.encodeWithSelector(JBController.JBController_OnlyDirectory.selector, address(this), address(directory))
+        );
+        IJBMigratable(address(_controller)).beforeReceiveMigrationFrom(_from, _projectId);
+    }
+}

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

@@ -0,0 +1,219 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBControllerSetup} from "./JBControllerSetup.sol";
+
+/**
+ * @title
+ */
+contract TestRulesetViews_Local is JBControllerSetup {
+    // A library that parses packed ruleset metadata into a friendlier format.
+    using JBRulesetMetadataResolver for JBRuleset;
+
+    function setUp() public {
+        super.controllerSetup();
+    }
+
+    function genMetadata() public pure returns (uint256) {
+        uint256 packed = 1;
+        packed |= 5000 << 4;
+        packed |= 8000 << 20;
+        packed |= 1 << 36;
+        packed |= 1 << 69;
+        packed |= 1 << 72;
+        packed |= 1 << 73;
+        packed |= 1 << 74;
+        packed |= 1 << 77;
+        packed |= uint256(uint160(address(0x1234567890123456789012345678901234567890))) << 80;
+        packed |= 65_535 << 240;
+
+        return packed;
+    }
+
+    function test_getRulesetOf() external {
+        // it should call rulesets and access storage (we avoid setting and reading here)
+
+        // setup: return data
+        JBRuleset memory data = JBRuleset({
+            cycleNumber: 1,
+            id: uint48(block.timestamp),
+            basedOnId: 0,
+            start: uint48(block.timestamp),
+            duration: 8000,
+            weight: 5000,
+            weightCutPercent: 0,
+            approvalHook: IJBRulesetApprovalHook(address(0x1234567890123456789012345678901234567890)),
+            metadata: genMetadata()
+        });
+
+        // setup: mock call
+        bytes memory _encodedCall = abi.encodeCall(IJBRulesets.getRulesetOf, (1, block.timestamp));
+        bytes memory _willReturn = abi.encode(data);
+
+        mockExpect(address(rulesets), _encodedCall, _willReturn);
+
+        // send
+        (JBRuleset memory ruleset, JBRulesetMetadata memory metadata) = _controller.getRulesetOf(1, block.timestamp);
+
+        // check: return makes sense
+        assertEq(data.duration, ruleset.duration);
+        assertEq(metadata.reservedPercent, data.expandMetadata().reservedPercent);
+    }
+
+    function test_latestQueuedOf() external {
+        // setup: return data
+        JBRuleset memory data = JBRuleset({
+            cycleNumber: 1,
+            id: uint48(block.timestamp),
+            basedOnId: 0,
+            start: uint48(block.timestamp),
+            duration: 8000,
+            weight: 5000,
+            weightCutPercent: 0,
+            approvalHook: IJBRulesetApprovalHook(address(0x1234567890123456789012345678901234567890)),
+            metadata: genMetadata()
+        });
+
+        // setup: mock call
+        bytes memory _encodedCall = abi.encodeCall(IJBRulesets.latestQueuedOf, (1));
+        bytes memory _willReturn = abi.encode(data, JBApprovalStatus.Empty);
+
+        mockExpect(address(rulesets), _encodedCall, _willReturn);
+
+        // send
+        (JBRuleset memory ruleset, JBRulesetMetadata memory metadata, JBApprovalStatus approvalStatus) =
+            _controller.latestQueuedRulesetOf(1);
+
+        // check: return makes sense
+        assertEq(data.duration, ruleset.duration);
+        assertEq(metadata.reservedPercent, data.expandMetadata().reservedPercent);
+        assertEq(abi.encode(approvalStatus), abi.encode(JBApprovalStatus.Empty));
+    }
+
+    function test_queuedRulesetsOf() external {
+        // setup: return data
+        JBRuleset memory data = JBRuleset({
+            cycleNumber: 1,
+            id: uint48(block.timestamp),
+            basedOnId: 0,
+            start: uint48(block.timestamp),
+            duration: 8000,
+            weight: 100,
+            weightCutPercent: 0,
+            approvalHook: IJBRulesetApprovalHook(address(0x1234567890123456789012345678901234567890)),
+            metadata: genMetadata()
+        });
+
+        // setup: return data
+        JBRuleset memory data2 = JBRuleset({
+            cycleNumber: 1,
+            id: uint48(block.timestamp),
+            basedOnId: 0,
+            start: uint48(block.timestamp),
+            duration: 8000,
+            weight: 200,
+            weightCutPercent: 0,
+            approvalHook: IJBRulesetApprovalHook(address(0x1234567890123456789012345678901234567890)),
+            metadata: genMetadata()
+        });
+
+        JBRuleset[] memory rulesetsArray = new JBRuleset[](2);
+        rulesetsArray[0] = data;
+        rulesetsArray[1] = data2;
+
+        // setup: mock call
+        bytes memory _encodedCall = abi.encodeCall(IJBRulesets.allOf, (1, block.timestamp, 2));
+        bytes memory _willReturn = abi.encode(rulesetsArray);
+
+        mockExpect(address(rulesets), _encodedCall, _willReturn);
+
+        // send
+        (JBRulesetWithMetadata[] memory queuedRulesets) = _controller.allRulesetsOf(1, block.timestamp, 2);
+
+        // check: return makes sense
+        assertEq(rulesetsArray[0].weight, queuedRulesets[0].ruleset.weight);
+    }
+
+    function test_upcomingOf() external {
+        // setup: return data
+        JBRuleset memory data = JBRuleset({
+            cycleNumber: 1,
+            id: uint48(block.timestamp),
+            basedOnId: 0,
+            start: uint48(block.timestamp),
+            duration: 8000,
+            weight: 5000,
+            weightCutPercent: 0,
+            approvalHook: IJBRulesetApprovalHook(address(0x1234567890123456789012345678901234567890)),
+            metadata: genMetadata()
+        });
+
+        // setup: mock call
+        bytes memory _encodedCall = abi.encodeCall(IJBRulesets.upcomingOf, (1));
+        bytes memory _willReturn = abi.encode(data, JBApprovalStatus.Empty);
+
+        mockExpect(address(rulesets), _encodedCall, _willReturn);
+
+        // send
+        (JBRuleset memory ruleset, JBRulesetMetadata memory metadata) = _controller.upcomingRulesetOf(1);
+
+        // check: return makes sense
+        assertEq(data.duration, ruleset.duration);
+        assertEq(metadata.reservedPercent, data.expandMetadata().reservedPercent);
+    }
+
+    function test_SetTerminalAllowed() public {
+        // setup: return data
+        JBRuleset memory data = JBRuleset({
+            cycleNumber: 1,
+            id: uint48(block.timestamp),
+            basedOnId: 0,
+            start: uint48(block.timestamp),
+            duration: 8000,
+            weight: 5000,
+            weightCutPercent: 0,
+            approvalHook: IJBRulesetApprovalHook(address(0x1234567890123456789012345678901234567890)),
+            metadata: genMetadata()
+        });
+
+        // setup: mock call
+        bytes memory _encodedCall = abi.encodeCall(IJBRulesets.currentOf, (1));
+        bytes memory _willReturn = abi.encode(data);
+
+        mockExpect(address(rulesets), _encodedCall, _willReturn);
+
+        // send
+        (bool allowed) = _controller.setTerminalsAllowed(1);
+
+        // check: return makes sense
+        assertEq(allowed, true);
+    }
+
+    function testSetControllerAllowed() public {
+        // setup: return data
+        JBRuleset memory data = JBRuleset({
+            cycleNumber: 1,
+            id: uint48(block.timestamp),
+            basedOnId: 0,
+            start: uint48(block.timestamp),
+            duration: 8000,
+            weight: 5000,
+            weightCutPercent: 0,
+            approvalHook: IJBRulesetApprovalHook(address(0x1234567890123456789012345678901234567890)),
+            metadata: genMetadata()
+        });
+
+        // setup: mock call
+        bytes memory _encodedCall = abi.encodeCall(IJBRulesets.currentOf, (1));
+        bytes memory _willReturn = abi.encode(data);
+
+        mockExpect(address(rulesets), _encodedCall, _willReturn);
+
+        // send
+        (bool allowed) = _controller.setControllerAllowed(1);
+
+        // check: return makes sense
+        assertEq(allowed, true);
+    }
+}