@bananapus/core-v6 0.0.1

package/test/units/static/JBProjects/JBProjectsSetup.sol

@@ -0,0 +1,20 @@
+// 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 JBProjectsSetup is JBTest {
+    address _owner = makeAddr("owner");
+
+    // Target Contract
+    IJBProjects public _projects;
+
+    function projectsSetup() public virtual {
+        // Instantiate the contract being tested
+        _projects = new JBProjects(_owner, address(0), address(0));
+    }
+}

package/test/units/static/JBProjects/TestCreateFor.sol

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {IERC721Receiver} from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
+import {JBProjectsSetup} from "./JBProjectsSetup.sol";
+
+contract TestCreateFor_Local is JBProjectsSetup {
+    using stdStorage for StdStorage;
+
+    address _user = makeAddr("sudoer");
+
+    function setUp() public {
+        super.projectsSetup();
+    }
+
+    function test_WhenProjectIdPlusOneIsGtUint256Max() external {
+        // it will revert with overflow
+
+        // set storage to uint256 max
+        stdstore.target(address(_projects)).sig("count()").checked_write(type(uint256).max);
+
+        assertEq(_projects.count(), type(uint256).max);
+
+        vm.expectRevert(stdError.arithmeticError);
+        _projects.createFor(address(this));
+    }
+
+    modifier whenProjectIdPlusOneIsLtOrEqToUint256Max() {
+        _;
+    }
+
+    function test_GivenOwnerIsNotAContract() external whenProjectIdPlusOneIsLtOrEqToUint256Max {
+        // it will mint and emit Create
+
+        // created on behalf of user by this contract
+        vm.expectEmit();
+        emit IJBProjects.Create(1, _user, address(this));
+
+        _projects.createFor(_user);
+
+        // check count is incrementing
+        assertEq(_projects.count(), 1);
+    }
+
+    function test_GivenItIsIERC721Receiver() external whenProjectIdPlusOneIsLtOrEqToUint256Max {
+        // it will mint and emit Create
+
+        // mock IERC721Receiver support (return interface selector for onERC721Received)
+        bytes memory receiverCall =
+            abi.encodeCall(IERC721Receiver.onERC721Received, (address(this), address(0), 1, bytes("")));
+        bytes memory returned = abi.encode(IERC721Receiver.onERC721Received.selector);
+
+        mockExpect(address(this), receiverCall, returned);
+
+        _projects.createFor(address(this));
+    }
+
+    function test_GivenItDoesNotSupportIERC721Receiver() external whenProjectIdPlusOneIsLtOrEqToUint256Max {
+        // it will revert
+
+        // encode custom error
+        bytes4 selector = bytes4(keccak256("ERC721InvalidReceiver(address)"));
+        bytes memory expectedError = abi.encodeWithSelector(selector, address(this));
+
+        vm.expectRevert(expectedError);
+        _projects.createFor(address(this));
+    }
+}

package/test/units/static/JBProjects/TestInitialProject.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+
+contract TestInitialProject_Local is JBTest {
+    address _owner = makeAddr("owner");
+    IJBProjects _projects;
+
+    function setUp() public {}
+
+    function test_WhenInitialOwnerDNEQZeroAddress() external {
+        // It will create a project
+
+        vm.expectEmit();
+        emit IJBProjects.Create(1, _owner, address(this));
+        _projects = new JBProjects(_owner, _owner, address(0));
+    }
+}

package/test/units/static/JBProjects/TestInterfaces.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBProjectsSetup} from "./JBProjectsSetup.sol";
+
+contract TestSupportsInterface_Local is JBProjectsSetup {
+    function setUp() public {
+        super.projectsSetup();
+    }
+
+    function test_WhenInterfaceIdIsIJBProjects() external {
+        // it will return true
+    }
+
+    function test_WhenInterfaceIdIsIERC721() external {
+        // it will return true
+    }
+
+    function test_WhenInterfaceIdIsIERC721Metadata() external {
+        // it will return true
+    }
+
+    function test_WhenInterfaceIdIsAnythingElse() external {
+        // it will return false
+    }
+}

package/test/units/static/JBProjects/TestSetResolver.sol

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBProjectsSetup} from "./JBProjectsSetup.sol";
+
+contract TestSetTokenURIResolver_Local is JBProjectsSetup {
+    IJBTokenUriResolver _resolver = IJBTokenUriResolver(makeAddr("uri"));
+
+    function setUp() public {
+        super.projectsSetup();
+    }
+
+    function test_WhenCallerIsOwner() external {
+        // it will set resolver and emit SetTokenUriResolver
+
+        // expect call from owner since we prank
+        vm.expectEmit();
+        emit IJBProjects.SetTokenUriResolver(_resolver, _owner);
+
+        vm.prank(_owner);
+        _projects.setTokenUriResolver(_resolver);
+    }
+
+    function test_WhenCallerIsNotOwner() external {
+        // it will revert
+
+        // encode custom error
+        bytes4 selector = bytes4(keccak256("OwnableUnauthorizedAccount(address)"));
+        bytes memory expectedError = abi.encodeWithSelector(selector, address(this));
+
+        vm.expectRevert(expectedError);
+
+        _projects.setTokenUriResolver(_resolver);
+    }
+}

package/test/units/static/JBProjects/TestTokenUri.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBProjectsSetup} from "./JBProjectsSetup.sol";
+
+contract TestTokenURI_Local is JBProjectsSetup {
+    using stdStorage for StdStorage;
+
+    IJBTokenUriResolver _resolver = IJBTokenUriResolver(makeAddr("uri"));
+
+    function setUp() public {
+        super.projectsSetup();
+    }
+
+    function test_WhenTheresNoResolver() external view {
+        // it will return empty string
+        string memory uri = IERC721Metadata(address(_projects)).tokenURI(0);
+
+        assertEq(bytes(uri), "");
+    }
+
+    function test_WhenTheresAResolver() external {
+        // it will return the resolved URI
+
+        // set tokenUriResolver
+        stdstore.target(address(_projects)).sig("tokenUriResolver()").checked_write(address(_resolver));
+
+        // mock call to mock resolver
+        bytes memory resolverCall = abi.encodeCall(IJBTokenUriResolver.getUri, (0));
+        bytes memory returned = abi.encode("JUICAY");
+
+        mockExpect(address(_resolver), resolverCall, returned);
+
+        string memory uri = IERC721Metadata(address(_projects)).tokenURI(0);
+        assertEq(bytes(uri), bytes("JUICAY"));
+    }
+}

package/test/units/static/JBRulesetMetadataResolver/TestSetCashOutTaxRateTo.sol

@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+
+contract TestSetCashOutTaxRateTo_Local is JBTest {
+    using JBRulesetMetadataResolver for JBRulesetMetadata;
+
+    function setUp() external {}
+
+    function testFuzzEnsureCorrectlyPackedBits(
+        uint16 _fuzzReservedPercent,
+        uint16 _fuzzCashOutTaxRate,
+        uint16 _fuzzMetadata
+    )
+        external
+    {
+        // cash out tax rate should be re-set and re-packed correctly
+
+        address _hookAddress = makeAddr("someting");
+
+        _fuzzReservedPercent = uint16(bound(_fuzzReservedPercent, 0, JBConstants.MAX_RESERVED_PERCENT));
+        _fuzzCashOutTaxRate = uint16(bound(_fuzzCashOutTaxRate, 0, JBConstants.MAX_CASH_OUT_TAX_RATE));
+        // Ensure the metadata is a max of 14 bits.
+        _fuzzMetadata = uint16(bound(_fuzzCashOutTaxRate, 0, 16_383));
+
+        JBRulesetMetadata memory _rulesMetadata = JBRulesetMetadata({
+            reservedPercent: _fuzzReservedPercent,
+            cashOutTaxRate: _fuzzCashOutTaxRate,
+            baseCurrency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+            pausePay: true,
+            pauseCreditTransfers: true,
+            allowOwnerMinting: true,
+            allowSetCustomToken: true,
+            allowTerminalMigration: true,
+            allowSetTerminals: true,
+            ownerMustSendPayouts: true,
+            allowSetController: true,
+            allowAddAccountingContext: true,
+            allowAddPriceFeed: true,
+            holdFees: true,
+            useTotalSurplusForCashOuts: true,
+            useDataHookForPay: true,
+            useDataHookForCashOut: true,
+            dataHook: _hookAddress,
+            metadata: _fuzzMetadata
+        });
+
+        uint256 _packed = _rulesMetadata.packRulesetMetadata();
+
+        // Reserved Rate
+        uint256 _reservedPercent = uint256(uint16(_packed >> 4));
+
+        // Cash out tax rate
+        uint256 _cashOutTaxRate = uint256(uint16(_packed >> 20));
+
+        assertEq(_reservedPercent, _fuzzReservedPercent);
+        assertEq(_cashOutTaxRate, _fuzzCashOutTaxRate);
+
+        for (uint256 _i = 68; _i < 81; _i++) {
+            uint256 _flag = uint256(uint16(_packed >> _i) & 1);
+            assertEq(_flag, 1);
+        }
+
+        // Data source address
+        address _packedDataHook = address(uint160(_packed >> 82));
+        assertEq(_packedDataHook, _hookAddress);
+
+        // Metadata
+        uint256 _packedMetadata = uint256(uint16(_packed >> 242));
+        assertEq(_packedMetadata, uint256(_fuzzMetadata));
+    }
+
+    function testFuzzEnsureCorrectlyPackedBits_implementationIndependent(JBRulesetMetadata memory _rulesMetadata)
+        external
+        pure
+    {
+        // Handle the unique constraints of the JBRulesetMetadata.
+        {
+            // First 2 bits of `metadata.metadata` are ignored
+            _rulesMetadata.metadata = _rulesMetadata.metadata % 16_383;
+        }
+
+        // Get the keccak from before.
+        bytes32 _before = keccak256(abi.encode(_rulesMetadata));
+
+        // Pack the metadata.
+        uint256 _packed = _rulesMetadata.packRulesetMetadata();
+
+        // Unpack the metadata and calculate the new keccak.
+        JBRuleset memory _ruleset;
+        _ruleset.metadata = _packed;
+        JBRulesetMetadata memory _unpackedMetadata = JBRulesetMetadataResolver.expandMetadata(_ruleset);
+        bytes32 _after = keccak256(abi.encode(_unpackedMetadata));
+
+        // Compare the before and the after.
+        assertEq(_before, _after);
+    }
+}

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

@@ -0,0 +1,21 @@
+// 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 JBRulesetsSetup is JBTest {
+    // Target Contract
+    IJBRulesets public _rulesets;
+
+    // Mocks
+    IJBDirectory public directory = IJBDirectory(makeAddr("directory"));
+
+    function rulesetsSetup() public virtual {
+        // Instantiate the contract being tested
+        _rulesets = new JBRulesets(directory);
+    }
+}

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

@@ -0,0 +1,257 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBRulesetsSetup} from "./JBRulesetsSetup.sol";
+
+contract TestCurrentApprovalStatusForLatestRulesetOf_Local is JBRulesetsSetup {
+    // Necessary params
+    JBRulesetMetadata private _metadata;
+    JBRulesetMetadata private _metadataWithApprovalHook;
+    IJBRulesetApprovalHook private _mockApprovalHook = IJBRulesetApprovalHook(makeAddr("hook"));
+    uint256 _packedMetadata;
+    uint256 _packedWithApprovalHook;
+    uint256 _projectId = 1;
+    uint256 _duration = 3 days;
+    uint256 _weight = 0;
+    uint256 _weightCutPercent = 450_000_000;
+    uint48 _mustStartAt = 0;
+    uint256 _hookDuration = 1 days;
+    IJBRulesetApprovalHook private _noHook = IJBRulesetApprovalHook(address(0));
+
+    function setUp() public {
+        super.rulesetsSetup();
+
+        // Params for tests
+        _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: false,
+            useDataHookForPay: false,
+            useDataHookForCashOut: false,
+            dataHook: address(0),
+            metadata: 0
+        });
+
+        // Params for tests
+        _metadataWithApprovalHook = 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: false,
+            useDataHookForPay: false,
+            useDataHookForCashOut: false,
+            dataHook: address(0),
+            metadata: 0
+        });
+
+        _packedMetadata = JBRulesetMetadataResolver.packRulesetMetadata(_metadata);
+        _packedWithApprovalHook = JBRulesetMetadataResolver.packRulesetMetadata(_metadataWithApprovalHook);
+    }
+
+    modifier whenARulesetIsConfiguredWithHook() {
+        // put code at hook address
+        vm.etch(address(_mockApprovalHook), abi.encode(1));
+
+        // mock call to hook interface support
+        mockExpect(
+            address(_mockApprovalHook),
+            abi.encodeCall(IERC165.supportsInterface, (type(IJBRulesetApprovalHook).interfaceId)),
+            abi.encode(true)
+        );
+
+        // Setup: queueFor will call onlyControllerOf modifier -> Directory.controllerOf to see if caller has proper
+        // permissions, encode & mock that.
+        bytes memory _encodedCall = abi.encodeCall(IJBDirectory.controllerOf, (1));
+        bytes memory _willReturn = abi.encode(address(this));
+
+        mockExpect(address(directory), _encodedCall, _willReturn);
+
+        // Setup: expect ruleset event (RulesetQueued) is emitted
+        vm.expectEmit();
+        emit IJBRulesets.RulesetQueued(
+            block.timestamp,
+            _projectId,
+            _duration,
+            _weight,
+            _weightCutPercent,
+            _mockApprovalHook,
+            _packedWithApprovalHook,
+            block.timestamp,
+            address(this)
+        );
+
+        // Send: Call from this contract as it's been mock authorized above.
+        _rulesets.queueFor({
+            projectId: _projectId,
+            duration: _duration,
+            weight: _weight,
+            weightCutPercent: _weightCutPercent,
+            approvalHook: _mockApprovalHook,
+            metadata: _packedWithApprovalHook,
+            mustStartAtOrAfter: _mustStartAt
+        });
+
+        _;
+    }
+
+    function test_GivenTheBasedOnRulesetEqZero() external whenARulesetIsConfiguredWithHook {
+        // it will return status Empty
+
+        JBApprovalStatus status = _rulesets.currentApprovalStatusForLatestRulesetOf(_projectId);
+        assertEq(uint256(status), 0);
+    }
+
+    function test_GivenThereIsNoApprovalHook() external {
+        // it will return status Empty
+
+        // Setup: queueFor will call onlyControllerOf modifier -> Directory.controllerOf to see if caller has proper
+        // permissions, encode & mock that.
+        bytes memory _encodedCall = abi.encodeCall(IJBDirectory.controllerOf, (1));
+        bytes memory _willReturn = abi.encode(address(this));
+
+        mockExpect(address(directory), _encodedCall, _willReturn);
+
+        // Setup: expect ruleset event (RulesetQueued) is emitted
+        vm.expectEmit();
+        emit IJBRulesets.RulesetQueued(
+            block.timestamp,
+            _projectId,
+            _duration,
+            _weight,
+            _weightCutPercent,
+            _noHook,
+            _packedMetadata,
+            block.timestamp,
+            address(this)
+        );
+
+        // Send: Call from this contract as it's been mock authorized above.
+        _rulesets.queueFor({
+            projectId: _projectId,
+            duration: _duration,
+            weight: _weight,
+            weightCutPercent: _weightCutPercent,
+            approvalHook: _noHook,
+            metadata: _packedMetadata,
+            mustStartAtOrAfter: _mustStartAt
+        });
+
+        JBApprovalStatus status = _rulesets.currentApprovalStatusForLatestRulesetOf(_projectId);
+        assertEq(uint256(status), 0);
+    }
+
+    function test_GivenBasedOnDNEQZeroAndThereIsAnApprovalHook() external {
+        // it will return the approval status by calling the hook
+
+        // put code at hook address
+        vm.etch(address(_mockApprovalHook), abi.encode(1));
+
+        // mock call to hook interface support
+        mockExpect(
+            address(_mockApprovalHook),
+            abi.encodeCall(IERC165.supportsInterface, (type(IJBRulesetApprovalHook).interfaceId)),
+            abi.encode(true)
+        );
+
+        // Setup: queueFor will call onlyControllerOf modifier -> Directory.controllerOf to see if caller has proper
+        // permissions, encode & mock that.
+        bytes memory _encodedCall = abi.encodeCall(IJBDirectory.controllerOf, (1));
+        bytes memory _willReturn = abi.encode(address(this));
+
+        mockExpect(address(directory), _encodedCall, _willReturn);
+
+        // First queue a base funding cycle
+
+        // Setup: expect ruleset event (RulesetQueued) is emitted
+        vm.expectEmit();
+        emit IJBRulesets.RulesetQueued(
+            block.timestamp,
+            _projectId,
+            _duration,
+            _weight,
+            _weightCutPercent,
+            _mockApprovalHook,
+            _packedWithApprovalHook,
+            block.timestamp,
+            address(this)
+        );
+
+        // mock call to hook duration
+        mockExpect(
+            address(_mockApprovalHook), abi.encodeCall(IJBRulesetApprovalHook.DURATION, ()), abi.encode(_hookDuration)
+        );
+
+        // Send: Call from this contract as it's been mock authorized above.
+        _rulesets.queueFor({
+            projectId: _projectId,
+            duration: _duration,
+            weight: _weight,
+            weightCutPercent: _weightCutPercent,
+            approvalHook: _mockApprovalHook,
+            metadata: _packedWithApprovalHook,
+            mustStartAtOrAfter: _mustStartAt
+        });
+
+        // Setup: expect ruleset event (RulesetQueued) is emitted
+        vm.expectEmit();
+        emit IJBRulesets.RulesetQueued(
+            block.timestamp + 1,
+            _projectId,
+            _duration,
+            _weight,
+            _weightCutPercent,
+            _noHook,
+            _packedMetadata,
+            block.timestamp,
+            address(this)
+        );
+
+        // Send: Call from this contract as it's been mock authorized above.
+        _rulesets.queueFor({
+            projectId: _projectId,
+            duration: _duration,
+            weight: _weight,
+            weightCutPercent: _weightCutPercent,
+            approvalHook: _noHook,
+            metadata: _packedMetadata,
+            mustStartAtOrAfter: _mustStartAt
+        });
+
+        uint256 _latestQueuedId = _rulesets.latestRulesetIdOf(_projectId);
+        JBRuleset memory _queuedRuleset = _rulesets.getRulesetOf(_projectId, _latestQueuedId);
+
+        // mock call to hook approvalStatusOf
+        mockExpect(
+            address(_mockApprovalHook),
+            abi.encodeCall(IJBRulesetApprovalHook.approvalStatusOf, (_projectId, _queuedRuleset)),
+            abi.encode(JBApprovalStatus.Failed)
+        );
+
+        JBApprovalStatus status = _rulesets.currentApprovalStatusForLatestRulesetOf(_projectId);
+        assertEq(uint256(status), 5);
+    }
+}