@bananapus/core-v6 0.0.1

package/test/units/static/JBMultiTerminal/TestSendPayoutsOf.sol

@@ -0,0 +1,243 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBMultiTerminalSetup} from "./JBMultiTerminalSetup.sol";
+
+contract TestSendPayoutsOf_Local is JBMultiTerminalSetup {
+    uint256 _projectId = 1;
+    uint256 _defaultAmount = 1e18;
+
+    function setUp() public {
+        super.multiTerminalSetup();
+    }
+
+    function test_WhenAmountPaidOutLtMinTokensPaidOut() external {
+        // it will revert UNDER_MIN_TOKENS_PAID_OUT
+
+        // needed for terminal store mock call
+        JBRuleset memory returnedRuleset = JBRuleset({
+            cycleNumber: 1,
+            id: 1,
+            basedOnId: 0,
+            start: 0,
+            duration: 0,
+            weight: 0,
+            weightCutPercent: 0,
+            approvalHook: IJBRulesetApprovalHook(address(0)),
+            metadata: 0
+        });
+
+        JBAccountingContext memory mockTokenContext = JBAccountingContext({token: address(0), decimals: 0, currency: 0});
+
+        // record payout mock call
+        mockExpect(
+            address(store),
+            abi.encodeCall(IJBTerminalStore.recordPayoutFor, (_projectId, mockTokenContext, 0, 0)),
+            abi.encode(returnedRuleset, 0)
+        );
+
+        // projects owner of
+        mockExpect(address(projects), abi.encodeCall(IERC721.ownerOf, (_projectId)), abi.encode(address(this)));
+
+        // needed for splits return call
+        JBSplit[] memory returnedSplits = new JBSplit[](0);
+
+        // mock splits of call
+        mockExpect(
+            address(splits),
+            abi.encodeCall(IJBSplits.splitsOf, (_projectId, returnedRuleset.id, 0)),
+            abi.encode(returnedSplits)
+        );
+
+        // mock directory call for fee processing
+        mockExpect(
+            address(directory),
+            abi.encodeCall(IJBDirectory.primaryTerminalOf, (1, address(0))),
+            abi.encode(address(_terminal))
+        );
+
+        vm.expectRevert(abi.encodeWithSelector(JBMultiTerminal.JBMultiTerminal_UnderMinTokensPaidOut.selector, 0, 1));
+        _terminal.sendPayoutsOf(_projectId, address(0), 0, 0, 1);
+    }
+
+    function test_WhenOwnerMustSendPayoutsButCallerDNEQOwner() external {
+        // it will check permissions
+
+        // needed for terminal store mock call
+        JBRuleset memory returnedRuleset = generateUnfriendlyRuleset();
+
+        JBAccountingContext memory mockTokenContext = JBAccountingContext({token: address(0), decimals: 0, currency: 0});
+
+        // record payout mock call
+        mockExpect(
+            address(store),
+            abi.encodeCall(IJBTerminalStore.recordPayoutFor, (_projectId, mockTokenContext, 0, 0)),
+            abi.encode(returnedRuleset, 0)
+        );
+
+        address owner = makeAddr("owner");
+
+        // projects owner of
+        mockExpect(address(projects), abi.encodeCall(IERC721.ownerOf, (_projectId)), abi.encode(owner));
+
+        // mock permissions call
+        bytes memory _permCall = abi.encodeCall(
+            IJBPermissions.hasPermission, (address(this), owner, _projectId, JBPermissionIds.SEND_PAYOUTS, true, true)
+        );
+        mockExpect(address(permissions), _permCall, abi.encode(false));
+
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                JBPermissioned.JBPermissioned_Unauthorized.selector,
+                owner,
+                address(this),
+                _projectId,
+                JBPermissionIds.SEND_PAYOUTS
+            )
+        );
+        _terminal.sendPayoutsOf(_projectId, address(0), 0, 0, 1);
+    }
+
+    function test_WhenExecutePayoutFails() external {
+        // it will revert PayoutReverted
+
+        // needed for terminal store mock call
+        JBRuleset memory returnedRuleset = JBRuleset({
+            cycleNumber: 1,
+            id: 1,
+            basedOnId: 0,
+            start: 0,
+            duration: 0,
+            weight: 0,
+            weightCutPercent: 0,
+            approvalHook: IJBRulesetApprovalHook(address(0)),
+            metadata: 0
+        });
+
+        JBAccountingContext memory mockTokenContext = JBAccountingContext({token: address(0), decimals: 0, currency: 0});
+
+        // record payout mock call
+        mockExpect(
+            address(store),
+            abi.encodeCall(IJBTerminalStore.recordPayoutFor, (_projectId, mockTokenContext, 0, 0)),
+            abi.encode(returnedRuleset, 0)
+        );
+
+        // projects owner of
+        mockExpect(address(projects), abi.encodeCall(IERC721.ownerOf, (_projectId)), abi.encode(address(this)));
+
+        // needed for splits return call
+        // invalid data to ensure revert
+        JBSplit[] memory returnedSplits = new JBSplit[](1);
+        returnedSplits[0] = JBSplit({
+            preferAddToBalance: false,
+            percent: 0,
+            projectId: 0,
+            beneficiary: payable(address(this)),
+            lockedUntil: uint48(block.timestamp + 1),
+            hook: IJBSplitHook(address(0))
+        });
+
+        // mock splits of call
+        mockExpect(
+            address(splits),
+            abi.encodeCall(IJBSplits.splitsOf, (_projectId, returnedRuleset.id, 0)),
+            abi.encode(returnedSplits)
+        );
+
+        // mock directory call for fee processing
+        mockExpect(
+            address(directory),
+            abi.encodeCall(IJBDirectory.primaryTerminalOf, (1, address(0))),
+            abi.encode(address(_terminal))
+        );
+
+        // mock call to feelessAddresses
+        mockExpect(
+            address(feelessAddresses), abi.encodeCall(IJBFeelessAddresses.isFeeless, (address(this))), abi.encode(true)
+        );
+
+        vm.expectEmit(true, true, true, false);
+        emit IJBPayoutTerminal.PayoutReverted(
+            _projectId,
+            returnedSplits[0],
+            0,
+            bytes("0x9996b3150000000000000000000000000000000000000000000000000000000000000000"),
+            address(this)
+        );
+
+        _terminal.sendPayoutsOf(_projectId, address(0), 0, 0, 0);
+    }
+
+    // it will revert UNDER_MIN_TOKENS_PAID_OUT
+    function test_WhenPayoutFailsDoNotTakeFee() external {
+        // needed for terminal store mock call
+        JBRuleset memory returnedRuleset = JBRuleset({
+            cycleNumber: 1,
+            id: 1,
+            basedOnId: 0,
+            start: 0,
+            duration: 0,
+            weight: 0,
+            weightCutPercent: 0,
+            approvalHook: IJBRulesetApprovalHook(address(0)),
+            metadata: 0
+        });
+
+        JBAccountingContext memory mockTokenContext = JBAccountingContext({token: address(0), decimals: 0, currency: 0});
+
+        // record payout mock call
+        mockExpect(
+            address(store),
+            abi.encodeCall(IJBTerminalStore.recordPayoutFor, (_projectId, mockTokenContext, 0, 100)),
+            abi.encode(returnedRuleset, 100)
+        );
+
+        // projects owner of
+        mockExpect(address(projects), abi.encodeCall(IERC721.ownerOf, (_projectId)), abi.encode(address(this)));
+
+        // mock call to feeless addresses
+        mockExpect(
+            address(feelessAddresses), abi.encodeCall(IJBFeelessAddresses.isFeeless, (address(this))), abi.encode(false)
+        );
+
+        // needed for splits return call
+        JBSplit[] memory returnedSplits = new JBSplit[](1);
+        returnedSplits[0] = JBSplit({
+            preferAddToBalance: false,
+            percent: 0,
+            projectId: 0,
+            beneficiary: payable(address(this)),
+            lockedUntil: uint48(block.timestamp + 1),
+            hook: IJBSplitHook(address(1))
+        });
+
+        // mock splits of call
+        mockExpect(
+            address(splits),
+            abi.encodeCall(IJBSplits.splitsOf, (_projectId, returnedRuleset.id, 0)),
+            abi.encode(returnedSplits)
+        );
+
+        // mock directory call for fee processing
+        mockExpect(
+            address(directory),
+            abi.encodeCall(IJBDirectory.primaryTerminalOf, (1, address(0))),
+            abi.encode(address(_terminal))
+        );
+
+        vm.expectEmit(true, true, true, true);
+        emit IJBPayoutTerminal.PayoutTransferReverted(
+            _projectId,
+            address(this),
+            address(0),
+            98, // Amount that would have been transferred after fee.
+            2, // fee amount
+            bytes(hex"5274afe70000000000000000000000000000000000000000000000000000000000000000"),
+            address(this)
+        );
+
+        _terminal.sendPayoutsOf(_projectId, address(0), 0, 100, 100);
+    }
+}

package/test/units/static/JBMultiTerminal/TestUseAllowanceOf.sol

@@ -0,0 +1,310 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBMultiTerminalSetup} from "./JBMultiTerminalSetup.sol";
+
+contract TestUseAllowanceOf_Local is JBMultiTerminalSetup {
+    uint256 _projectId = 1;
+
+    function setUp() public {
+        super.multiTerminalSetup();
+    }
+
+    function test_WhenAmountPaidOutLTMinTokensPaidOut() external {
+        // it will revert UNDER_MIN_TOKENS_PAID_OUT
+
+        // mock owner call
+        mockExpect(address(projects), abi.encodeCall(IERC721.ownerOf, (_projectId)), abi.encode(address(this)));
+
+        // needed for terminal store mock call
+        JBRuleset memory returnedRuleset = JBRuleset({
+            cycleNumber: 1,
+            id: 1,
+            basedOnId: 0,
+            start: 0,
+            duration: 0,
+            weight: 0,
+            weightCutPercent: 0,
+            approvalHook: IJBRulesetApprovalHook(address(0)),
+            metadata: 0
+        });
+
+        JBAccountingContext memory mockTokenContext = JBAccountingContext({token: address(0), decimals: 0, currency: 0});
+
+        // recordUsedAllowance
+        mockExpect(
+            address(store),
+            abi.encodeCall(IJBTerminalStore.recordUsedAllowanceOf, (_projectId, mockTokenContext, 0, 0)),
+            abi.encode(returnedRuleset, 0)
+        );
+
+        // feeless check
+        mockExpect(
+            address(feelessAddresses), abi.encodeCall(IJBFeelessAddresses.isFeeless, (address(this))), abi.encode(true)
+        );
+
+        vm.expectRevert(abi.encodeWithSelector(JBMultiTerminal.JBMultiTerminal_UnderMinTokensPaidOut.selector, 0, 1));
+        _terminal.useAllowanceOf(_projectId, address(0), 0, 0, 1, payable(address(this)), payable(address(this)), "");
+    }
+
+    function test_WhenOwnerEQFeeless() external {
+        // it will not incur fees
+        address mockToken = makeAddr("token");
+
+        // mock owner call
+        mockExpect(address(projects), abi.encodeCall(IERC721.ownerOf, (_projectId)), abi.encode(address(this)));
+
+        // needed for terminal store mock call
+        JBRuleset memory returnedRuleset = JBRuleset({
+            cycleNumber: 1,
+            id: 1,
+            basedOnId: 0,
+            start: 0,
+            duration: 0,
+            weight: 0,
+            weightCutPercent: 0,
+            approvalHook: IJBRulesetApprovalHook(address(0)),
+            metadata: 0
+        });
+
+        JBAccountingContext memory mockTokenContext = JBAccountingContext({token: address(0), decimals: 0, currency: 0});
+
+        // recordUsedAllowance
+        mockExpect(
+            address(store),
+            abi.encodeCall(IJBTerminalStore.recordUsedAllowanceOf, (_projectId, mockTokenContext, 100, 0)),
+            abi.encode(returnedRuleset, 100)
+        );
+
+        // feeless check
+        mockExpect(
+            address(feelessAddresses), abi.encodeCall(IJBFeelessAddresses.isFeeless, (address(this))), abi.encode(true)
+        );
+
+        mockExpect(mockToken, abi.encodeCall(IERC20.transfer, (address(this), 100)), abi.encode(true));
+
+        vm.expectEmit();
+        emit IJBPayoutTerminal.UseAllowance({
+            rulesetId: returnedRuleset.id,
+            rulesetCycleNumber: returnedRuleset.cycleNumber,
+            projectId: _projectId,
+            beneficiary: address(this),
+            feeBeneficiary: address(this),
+            amount: 100,
+            amountPaidOut: 100,
+            netAmountPaidOut: 100,
+            memo: "",
+            caller: address(this)
+        });
+        _terminal.useAllowanceOf(_projectId, mockToken, 100, 0, 0, payable(address(this)), payable(address(this)), "");
+    }
+
+    function test_WhenBeneficiaryIsFeeless() external {
+        address mockToken = makeAddr("token");
+        address beneficiary = makeAddr("bene");
+
+        // mock owner call
+        mockExpect(address(projects), abi.encodeCall(IERC721.ownerOf, (_projectId)), abi.encode(address(this)));
+
+        // needed for terminal store mock call
+        JBRuleset memory returnedRuleset = JBRuleset({
+            cycleNumber: 1,
+            id: 1,
+            basedOnId: 0,
+            start: 0,
+            duration: 0,
+            weight: 0,
+            weightCutPercent: 0,
+            approvalHook: IJBRulesetApprovalHook(address(0)),
+            metadata: 0
+        });
+
+        JBAccountingContext memory mockTokenContext = JBAccountingContext({token: address(0), decimals: 0, currency: 0});
+
+        // recordUsedAllowance
+        mockExpect(
+            address(store),
+            abi.encodeCall(IJBTerminalStore.recordUsedAllowanceOf, (_projectId, mockTokenContext, 100, 0)),
+            abi.encode(returnedRuleset, 100)
+        );
+
+        // first feeless check which will return false.
+        mockExpect(
+            address(feelessAddresses), abi.encodeCall(IJBFeelessAddresses.isFeeless, (address(this))), abi.encode(false)
+        );
+
+        // second which is true for beneficiary.
+        mockExpect(
+            address(feelessAddresses), abi.encodeCall(IJBFeelessAddresses.isFeeless, (beneficiary)), abi.encode(true)
+        );
+
+        mockExpect(mockToken, abi.encodeCall(IERC20.transfer, (beneficiary, 100)), abi.encode(true));
+
+        vm.expectEmit();
+        emit IJBPayoutTerminal.UseAllowance({
+            rulesetId: returnedRuleset.id,
+            rulesetCycleNumber: returnedRuleset.cycleNumber,
+            projectId: _projectId,
+            beneficiary: beneficiary,
+            feeBeneficiary: address(this),
+            amount: 100,
+            amountPaidOut: 100,
+            netAmountPaidOut: 100,
+            memo: "",
+            caller: address(this)
+        });
+
+        _terminal.useAllowanceOf({
+            projectId: _projectId,
+            token: mockToken,
+            amount: 100,
+            currency: 0,
+            minTokensPaidOut: 100,
+            beneficiary: payable(beneficiary),
+            feeBeneficiary: payable(address(this)),
+            memo: ""
+        });
+    }
+
+    function test_WhenNotFeeless() external {
+        address mockToken = makeAddr("token");
+        address beneficiary = makeAddr("bene");
+
+        // Mock controller for mint call on fee payments
+        address controller = makeAddr("controller");
+
+        // Weight for a fee calculation that would take place in terminal store
+        uint112 weight = 1000 * 10 ** 18;
+
+        uint32 currencyId = uint32(uint160(mockToken));
+
+        // Start the cascade of issuing project tokens to the fee beneficiary. (recieving platform tokens for paying a
+        // fee, or being designated as such).
+        mockExpect(
+            address(directory), abi.encodeCall(IJBDirectory.controllerOf, (_projectId)), abi.encode(address(controller))
+        );
+
+        // mock owner call
+        mockExpect(address(projects), abi.encodeCall(IERC721.ownerOf, (_projectId)), abi.encode(address(this)));
+
+        // needed for terminal store mock call
+        JBRuleset memory returnedRuleset = JBRuleset({
+            cycleNumber: 1,
+            id: 0,
+            basedOnId: 0,
+            start: 0,
+            duration: 0,
+            weight: weight,
+            weightCutPercent: 0,
+            approvalHook: IJBRulesetApprovalHook(address(0)),
+            metadata: 0
+        });
+
+        // mock call to tokens decimals()
+        mockExpect(mockToken, abi.encodeCall(IERC20Metadata.decimals, ()), abi.encode(18));
+
+        // mock call to rulesets currentOf returning 0 to bypass ruleset checking
+        mockExpect(address(rulesets), abi.encodeCall(IJBRulesets.currentOf, (_projectId)), abi.encode(returnedRuleset));
+
+        // call params
+        JBAccountingContext[] memory _tokens = new JBAccountingContext[](1);
+        _tokens[0] = JBAccountingContext({token: mockToken, decimals: 18, currency: currencyId});
+
+        _terminal.addAccountingContextsFor(_projectId, _tokens);
+
+        _terminal.accountingContextForTokenOf(_projectId, mockToken);
+
+        // recordUsedAllowance
+        mockExpect(
+            address(store),
+            abi.encodeCall(IJBTerminalStore.recordUsedAllowanceOf, (_projectId, _tokens[0], 100, 0)),
+            abi.encode(returnedRuleset, 100)
+        );
+
+        // first feeless check which will return false.
+        mockExpect(
+            address(feelessAddresses), abi.encodeCall(IJBFeelessAddresses.isFeeless, (address(this))), abi.encode(false)
+        );
+
+        // second which is also false.
+        mockExpect(
+            address(feelessAddresses), abi.encodeCall(IJBFeelessAddresses.isFeeless, (beneficiary)), abi.encode(false)
+        );
+
+        mockExpect(mockToken, abi.encodeCall(IERC20.transfer, (beneficiary, 98)), abi.encode(true));
+
+        // call to find the primary terminal for fee processing
+        mockExpect(
+            address(directory),
+            abi.encodeCall(IJBDirectory.primaryTerminalOf, (1, mockToken)),
+            abi.encode(address(_terminal))
+        );
+
+        JBTokenAmount memory tokenContext =
+            JBTokenAmount({token: mockToken, decimals: 18, currency: currencyId, value: 2});
+
+        // mock call to jbterminalstore
+        mockExpect(
+            address(store),
+            abi.encodeCall(
+                IJBTerminalStore.recordPaymentFrom,
+                // feeBeneficiary will receive platform tokens for paying a fee, project id is encoded for memo
+                (address(_terminal), tokenContext, _projectId, address(this), bytes(abi.encodePacked(_projectId)))
+            ),
+            abi.encode(returnedRuleset, 1, new JBPayHookSpecification[](0))
+        );
+
+        // Return the mint of call as minting one project token for paying a fee.
+        mockExpect(
+            address(controller),
+            abi.encodeCall(IJBController.mintTokensOf, (_projectId, 1, address(this), "", true)),
+            abi.encode(2)
+        );
+
+        vm.expectEmit();
+        emit IJBPayoutTerminal.UseAllowance({
+            rulesetId: returnedRuleset.id,
+            rulesetCycleNumber: returnedRuleset.cycleNumber,
+            projectId: _projectId,
+            beneficiary: beneficiary,
+            feeBeneficiary: address(this),
+            amount: 100,
+            amountPaidOut: 100,
+            netAmountPaidOut: 98,
+            memo: "",
+            caller: address(this)
+        });
+
+        _terminal.useAllowanceOf({
+            projectId: _projectId,
+            token: mockToken,
+            amount: 100,
+            currency: 0,
+            minTokensPaidOut: 97,
+            beneficiary: payable(beneficiary),
+            feeBeneficiary: payable(address(this)),
+            memo: ""
+        });
+    }
+
+    modifier whenMsgSenderDNEQFeeless() {
+        _;
+    }
+
+    function test_GivenRulesetHoldFeesEQTrue() external whenMsgSenderDNEQFeeless {
+        // it will hold fees and emit HoldFee
+    }
+
+    function test_GivenRulesetHoldFeesDNEQTrue() external whenMsgSenderDNEQFeeless {
+        // it will not hold fees and emit ProcessFee
+    }
+
+    function test_WhenTokenEQNATIVE_TOKEN() external {
+        // it will send ETH via sendValue
+    }
+
+    function test_WhenTokenEQERC20() external {
+        // it will call safeTransfer
+    }
+}

package/test/units/static/JBPermissions/JBPermissionsSetup.sol

@@ -0,0 +1,18 @@
+// 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 JBPermissionsSetup is JBTest {
+    // Target Contract
+    IJBPermissions public _permissions;
+
+    function permissionsSetup() public virtual {
+        // Instantiate the contract being tested
+        _permissions = new JBPermissions(address(0));
+    }
+}

package/test/units/static/JBPermissions/TestHasPermission.sol

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBPermissionsSetup} from "./JBPermissionsSetup.sol";
+
+contract TestHasPermissions_Local is JBPermissionsSetup {
+    address _op = makeAddr("operator");
+    address _account = makeAddr("account");
+    uint256 _projectId = 1;
+    uint256 _permission = 256;
+
+    function setUp() public {
+        super.permissionsSetup();
+    }
+
+    function test_WhenPermissionIdGt255() external {
+        // it will revert with PERMISSION_ID_OUT_OF_BOUNDS
+
+        vm.expectRevert(abi.encodeWithSelector(JBPermissions.JBPermissions_PermissionIdOutOfBounds.selector, 256));
+        _permissions.hasPermission(_op, _account, _projectId, _permission, true, true);
+    }
+
+    modifier whenPermissionIdLt255() {
+        _permission = 1;
+        _;
+    }
+
+    function test_GivenOperatorHasPermissionForAccountOfProject() external whenPermissionIdLt255 {
+        // it will return true
+        uint256 permissions = 1 << 1;
+
+        // Find the storage slot
+        bytes32 permissionsOfSlot = keccak256(abi.encode(_op, uint256(0)));
+        bytes32 accountSlot = keccak256(abi.encode(_account, uint256(permissionsOfSlot)));
+        bytes32 slot = keccak256(abi.encode(_projectId, accountSlot));
+
+        // Set storage
+        vm.store(address(_permissions), slot, bytes32(permissions));
+
+        bool has = _permissions.hasPermission(_op, _account, _projectId, 1, true, true);
+        assertEq(has, true);
+    }
+
+    function test_GivenOperatorDoesntHavePermissionForAccountOfProject() external whenPermissionIdLt255 {
+        // it will return false
+        bool has = _permissions.hasPermission(_op, _account, _projectId, 1, true, true);
+        assertEq(has, false);
+    }
+}