@bananapus/core-v6 0.0.1

package/test/TestPayBurnRedeemFlow.sol

@@ -0,0 +1,180 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.6;
+
+import /* {*} from */ "./helpers/TestBaseWorkflow.sol";
+
+// Project can issue token, receive payments in exchange for tokens, burn some of the claimed tokens, and allow holders
+// to cash out the rest of tokens.
+contract TestPayBurnCashOutFlow_Local is TestBaseWorkflow {
+    IJBController private _controller;
+    IJBMultiTerminal private _terminal;
+    JBTokens private _tokens;
+    uint112 private _weight;
+    JBRulesetMetadata _metadata;
+    uint256 private _projectId;
+    address private _projectOwner;
+    address private _beneficiary;
+
+    function setUp() public override {
+        super.setUp();
+
+        _projectOwner = multisig();
+        _beneficiary = beneficiary();
+        _controller = jbController();
+        _terminal = jbMultiTerminal();
+        _tokens = jbTokens();
+        _weight = 1000 * 10 ** 18;
+        _metadata = JBRulesetMetadata({
+            reservedPercent: 0,
+            cashOutTaxRate: JBConstants.MAX_CASH_OUT_TAX_RATE,
+            baseCurrency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+            pausePay: false,
+            pauseCreditTransfers: false,
+            allowOwnerMinting: false,
+            allowSetCustomToken: true,
+            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
+        });
+
+        IJBTerminal[] memory _terminals = new IJBTerminal[](1);
+        _terminals[0] = (_terminal);
+
+        // Package up ruleset configuration.
+        JBRulesetConfig[] memory _rulesetConfig = new JBRulesetConfig[](1);
+        _rulesetConfig[0].mustStartAtOrAfter = 0;
+        _rulesetConfig[0].duration = 0;
+        _rulesetConfig[0].weight = _weight;
+        _rulesetConfig[0].weightCutPercent = 0;
+        _rulesetConfig[0].approvalHook = IJBRulesetApprovalHook(address(0));
+        _rulesetConfig[0].metadata = _metadata;
+        _rulesetConfig[0].splitGroups = new JBSplitGroup[](0);
+        _rulesetConfig[0].fundAccessLimitGroups = new JBFundAccessLimitGroup[](0);
+
+        // Package up terminal configuration.
+        JBTerminalConfig[] memory _terminalConfigurations = new JBTerminalConfig[](1);
+        JBAccountingContext[] memory _tokensToAccept = new JBAccountingContext[](1);
+        _tokensToAccept[0] = JBAccountingContext({
+            token: JBConstants.NATIVE_TOKEN, decimals: 18, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
+        });
+        _terminalConfigurations[0] =
+            JBTerminalConfig({terminal: _terminal, accountingContextsToAccept: _tokensToAccept});
+
+        // Dummy project that will receive fees.
+        _controller.launchProjectFor({
+            owner: _projectOwner,
+            projectUri: "myIPFSHash",
+            rulesetConfigurations: _rulesetConfig,
+            terminalConfigurations: _terminalConfigurations,
+            memo: ""
+        });
+
+        _projectId = _controller.launchProjectFor({
+            owner: _projectOwner,
+            projectUri: "myIPFSHash",
+            rulesetConfigurations: _rulesetConfig,
+            terminalConfigurations: _terminalConfigurations,
+            memo: ""
+        });
+    }
+
+    function testFuzzPayBurnCashOutFlow(
+        uint112 _nativePayAmount,
+        uint256 _burnTokenAmount,
+        uint256 _cashOutAmount
+    )
+        external
+    {
+        // Issue an ERC-20 token for project.
+        vm.prank(_projectOwner);
+        _controller.deployERC20For(_projectId, "TestName", "TestSymbol", bytes32(0));
+
+        address someRandomUser = vm.addr(1);
+        vm.prank(someRandomUser);
+        vm.deal(someRandomUser, _nativePayAmount);
+        // Make a payment.
+        _terminal.pay{value: _nativePayAmount}({
+            projectId: _projectId,
+            amount: _nativePayAmount,
+            token: JBConstants.NATIVE_TOKEN, // Unused.
+            beneficiary: _beneficiary,
+            minReturnedTokens: 0,
+            memo: "Take my money!",
+            metadata: new bytes(0)
+        });
+
+        // Make sure the beneficiary has a balance of project tokens.
+        uint256 _beneficiaryTokenBalance =
+            UD60x18unwrap(UD60x18mul(UD60x18wrap(_nativePayAmount), UD60x18wrap(_weight)));
+        assertEq(_tokens.totalBalanceOf(_beneficiary, _projectId), _beneficiaryTokenBalance);
+
+        // Make sure the native token balance in terminal is up to date.
+        uint256 _terminalBalance = _nativePayAmount;
+        assertEq(
+            jbTerminalStore().balanceOf(address(_terminal), _projectId, JBConstants.NATIVE_TOKEN), _terminalBalance
+        );
+
+        // Burn tokens from beneficiary.
+        if (_burnTokenAmount == 0) {
+            vm.expectRevert(JBController.JBController_ZeroTokensToBurn.selector);
+        } else if (_burnTokenAmount > _beneficiaryTokenBalance) {
+            vm.expectRevert(
+                abi.encodeWithSelector(
+                    JBTokens.JBTokens_InsufficientTokensToBurn.selector, _burnTokenAmount, _beneficiaryTokenBalance
+                )
+            );
+        } else {
+            _beneficiaryTokenBalance -= _burnTokenAmount;
+        }
+
+        vm.prank(_beneficiary);
+        _controller.burnTokensOf({
+            holder: _beneficiary, projectId: _projectId, tokenCount: _burnTokenAmount, memo: "I hate tokens!"
+        });
+
+        // Make sure the beneficiary should has a new balance of project tokens.
+        assertEq(_tokens.totalBalanceOf(_beneficiary, _projectId), _beneficiaryTokenBalance);
+
+        // Cash out tokens.
+        if (_cashOutAmount > _beneficiaryTokenBalance) {
+            vm.expectRevert(
+                abi.encodeWithSelector(
+                    JBTerminalStore.JBTerminalStore_InsufficientTokens.selector,
+                    _cashOutAmount,
+                    _beneficiaryTokenBalance
+                )
+            );
+        } else {
+            _beneficiaryTokenBalance -= _cashOutAmount;
+        }
+
+        vm.prank(_beneficiary);
+        uint256 _reclaimAmt = _terminal.cashOutTokensOf({
+            holder: _beneficiary,
+            projectId: _projectId,
+            cashOutCount: _cashOutAmount,
+            tokenToReclaim: JBConstants.NATIVE_TOKEN, // Unused.
+            minTokensReclaimed: 0,
+            beneficiary: payable(_beneficiary),
+            metadata: new bytes(0)
+        });
+
+        // Make sure the beneficiary has a new balance of project tokens.
+        assertEq(_tokens.totalBalanceOf(_beneficiary, _projectId), _beneficiaryTokenBalance);
+
+        // Make sure the native token balance in terminal is up to date.
+        assertEq(
+            jbTerminalStore().balanceOf(address(_terminal), _projectId, JBConstants.NATIVE_TOKEN),
+            _terminalBalance - _reclaimAmt
+        );
+    }
+}

package/test/TestPayHooks.sol

@@ -0,0 +1,190 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.6;
+
+import /* {*} from */ "./helpers/TestBaseWorkflow.sol";
+
+contract TestPayHooks_Local is TestBaseWorkflow {
+    uint8 private constant _WEIGHT_DECIMALS = 18;
+    uint8 private constant _NATIVE_TOKEN_DECIMALS = 18;
+    uint112 private constant _WEIGHT = uint112(1000 * 10 ** _WEIGHT_DECIMALS);
+    uint256 private constant _DATA_HOOK_WEIGHT = 2000 * 10 ** _WEIGHT_DECIMALS;
+    address private constant _DATA_HOOK = address(bytes20(keccak256("datahook")));
+    bytes private constant _PAYER_METADATA = bytes("Some payer metadata");
+
+    IJBController private _controller;
+    IJBTerminal private _terminal;
+    address private _projectOwner;
+    address private _beneficiary;
+    address private _payer;
+
+    uint64 _projectId;
+
+    function setUp() public override {
+        super.setUp();
+
+        _controller = jbController();
+        _projectOwner = multisig();
+        _beneficiary = beneficiary();
+        _payer = address(1_234_567);
+        _terminal = jbMultiTerminal();
+
+        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: false,
+            useDataHookForPay: true,
+            useDataHookForCashOut: true,
+            dataHook: _DATA_HOOK,
+            metadata: 0
+        });
+
+        // Package up ruleset configuration.
+        JBRulesetConfig[] memory _rulesetConfig = new JBRulesetConfig[](1);
+        _rulesetConfig[0].mustStartAtOrAfter = 0;
+        _rulesetConfig[0].duration = 0;
+        _rulesetConfig[0].weight = _WEIGHT;
+        _rulesetConfig[0].weightCutPercent = 0;
+        _rulesetConfig[0].approvalHook = IJBRulesetApprovalHook(address(0));
+        _rulesetConfig[0].metadata = _metadata;
+        _rulesetConfig[0].splitGroups = new JBSplitGroup[](0);
+        _rulesetConfig[0].fundAccessLimitGroups = new JBFundAccessLimitGroup[](0);
+
+        JBTerminalConfig[] memory _terminalConfigurations = new JBTerminalConfig[](1);
+        JBAccountingContext[] memory _tokensToAccept = new JBAccountingContext[](1);
+        _tokensToAccept[0] = JBAccountingContext({
+            token: JBConstants.NATIVE_TOKEN, decimals: 18, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
+        });
+        _terminalConfigurations[0] =
+            JBTerminalConfig({terminal: _terminal, accountingContextsToAccept: _tokensToAccept});
+
+        _projectId = uint64(
+            _controller.launchProjectFor({
+                owner: _projectOwner,
+                projectUri: "myIPFSHash",
+                rulesetConfigurations: _rulesetConfig,
+                terminalConfigurations: _terminalConfigurations,
+                memo: ""
+            })
+        );
+    }
+
+    function testPayHooks(uint256 _numberOfSpecifications, uint256 _nativePayAmount) public {
+        // Bound the number of specifications to a reasonable amount.
+        _numberOfSpecifications = bound(_numberOfSpecifications, 1, 20);
+        // Make sure the amount of tokens generated fits in a register, and that each specification can get some.
+        _nativePayAmount = bound(_nativePayAmount, _numberOfSpecifications, type(uint256).max / _DATA_HOOK_WEIGHT);
+
+        // epa * weight / epad < max*epad/weight
+
+        // Keep a reference to the specifications.
+        JBPayHookSpecification[] memory _specifications = new JBPayHookSpecification[](_numberOfSpecifications);
+
+        // Keep a reference to the amounts in the specifications.
+        uint256[] memory _payHookAmounts = new uint256[](_numberOfSpecifications);
+
+        // Keep a reference to the amount that'll be paid and sent to pay hooks.
+        uint256 _totalToAllocate = _nativePayAmount;
+
+        // Spread the paid amount through all specifications, in various chunks, omitting the last entry.
+        for (uint256 i; i < _numberOfSpecifications - 1; i++) {
+            _payHookAmounts[i] = _totalToAllocate / (_payHookAmounts.length * 2);
+            _totalToAllocate -= _payHookAmounts[i];
+        }
+
+        // Send the rest to the last entry.
+        _payHookAmounts[_payHookAmounts.length - 1] = _totalToAllocate;
+
+        // Keep a reference to the current ruleset.
+        (JBRuleset memory _ruleset,) = _controller.currentRulesetOf(_projectId);
+
+        // Iterate through each specification.
+        for (uint256 i = 0; i < _numberOfSpecifications; i++) {
+            // Make up an address for the hook.
+            address _hookAddress = address(bytes20(keccak256(abi.encodePacked("PayHook", i))));
+
+            // Send along some metadata to the pay hook.
+            bytes memory _hookMetadata = bytes("Some data hook metadata");
+
+            // Package up the specification struct.
+            _specifications[i] = JBPayHookSpecification(IJBPayHook(_hookAddress), _payHookAmounts[i], _hookMetadata);
+
+            // Keep a reference to the data that'll be received by the hook.
+            JBAfterPayRecordedContext memory _postRecordPayContext = JBAfterPayRecordedContext({
+                payer: _payer,
+                projectId: _projectId,
+                rulesetId: _ruleset.id,
+                amount: JBTokenAmount(
+                    JBConstants.NATIVE_TOKEN,
+                    _terminal.accountingContextForTokenOf(_projectId, JBConstants.NATIVE_TOKEN).decimals,
+                    _terminal.accountingContextForTokenOf(_projectId, JBConstants.NATIVE_TOKEN).currency,
+                    _nativePayAmount
+                ),
+                forwardedAmount: JBTokenAmount(
+                    JBConstants.NATIVE_TOKEN,
+                    _terminal.accountingContextForTokenOf(_projectId, JBConstants.NATIVE_TOKEN).decimals,
+                    _terminal.accountingContextForTokenOf(_projectId, JBConstants.NATIVE_TOKEN).currency,
+                    _payHookAmounts[i]
+                ),
+                weight: _WEIGHT,
+                newlyIssuedTokenCount: mulDiv(_nativePayAmount, _DATA_HOOK_WEIGHT, 10 ** _NATIVE_TOKEN_DECIMALS),
+                beneficiary: _beneficiary,
+                hookMetadata: _hookMetadata,
+                payerMetadata: _PAYER_METADATA
+            });
+
+            // Mock the hook.
+            vm.mockCall(
+                _hookAddress,
+                abi.encodeWithSelector(IJBPayHook.afterPayRecordedWith.selector),
+                abi.encode(_postRecordPayContext)
+            );
+
+            // Assert that the hook gets called with the expected value.
+            vm.expectCall(
+                _hookAddress,
+                _payHookAmounts[i],
+                abi.encodeWithSelector(IJBPayHook.afterPayRecordedWith.selector, _postRecordPayContext)
+            );
+
+            // Expect an event to be emitted for every hook.
+            vm.expectEmit(true, true, true, true);
+            emit HookAfterRecordPay(IJBPayHook(_hookAddress), _postRecordPayContext, _payHookAmounts[i], _payer);
+        }
+
+        vm.mockCall(
+            _DATA_HOOK,
+            abi.encodeWithSelector(IJBRulesetDataHook.beforePayRecordedWith.selector),
+            abi.encode(_DATA_HOOK_WEIGHT, _specifications)
+        );
+
+        vm.deal(_payer, _nativePayAmount);
+        vm.prank(_payer);
+
+        // Pay the project such that the `_beneficiary` receives project tokens.
+        _terminal.pay{value: _nativePayAmount}({
+            projectId: _projectId,
+            amount: _nativePayAmount,
+            token: JBConstants.NATIVE_TOKEN,
+            beneficiary: _beneficiary,
+            minReturnedTokens: 0,
+            memo: "Forge Test",
+            metadata: _PAYER_METADATA
+        });
+    }
+
+    event HookAfterRecordPay(
+        IJBPayHook indexed hook, JBAfterPayRecordedContext context, uint256 specificationAmount, address caller
+    );
+}

package/test/TestPermissions.sol

@@ -0,0 +1,305 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.6;
+
+import /* {*} from */ "./helpers/TestBaseWorkflow.sol";
+
+contract TestPermissions_Local is TestBaseWorkflow, JBTest {
+    IJBController private _controller;
+    JBRulesetMetadata private _metadata;
+    IJBTerminal private _terminal;
+    IJBPermissions private _permissions;
+
+    address private _projectOwner;
+    uint64 private _projectZero;
+    uint64 private _projectOne;
+
+    function setUp() public override {
+        super.setUp();
+
+        _projectOwner = multisig();
+        _terminal = jbMultiTerminal();
+        _controller = jbController();
+        _permissions = jbPermissions();
+
+        _metadata = JBRulesetMetadata({
+            reservedPercent: 0,
+            cashOutTaxRate: 0,
+            baseCurrency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+            pausePay: false,
+            pauseCreditTransfers: false,
+            allowOwnerMinting: false,
+            allowSetCustomToken: true,
+            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
+        });
+
+        // Package up ruleset configuration.
+        JBRulesetConfig[] memory _rulesetConfig = new JBRulesetConfig[](1);
+        _rulesetConfig[0].mustStartAtOrAfter = 0;
+        _rulesetConfig[0].duration = 0;
+        _rulesetConfig[0].weight = 0;
+        _rulesetConfig[0].weightCutPercent = 0;
+        _rulesetConfig[0].approvalHook = IJBRulesetApprovalHook(address(0));
+        _rulesetConfig[0].metadata = _metadata;
+        _rulesetConfig[0].splitGroups = new JBSplitGroup[](0);
+        _rulesetConfig[0].fundAccessLimitGroups = new JBFundAccessLimitGroup[](0);
+
+        // Package up terminal configuration.
+        JBTerminalConfig[] memory _terminalConfigurations = new JBTerminalConfig[](1);
+        JBAccountingContext[] memory _tokensToAccept = new JBAccountingContext[](1);
+        _tokensToAccept[0] = JBAccountingContext({
+            token: JBConstants.NATIVE_TOKEN, decimals: 18, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
+        });
+        _terminalConfigurations[0] =
+            JBTerminalConfig({terminal: _terminal, accountingContextsToAccept: _tokensToAccept});
+
+        _projectZero = uint64(
+            _controller.launchProjectFor({
+                owner: makeAddr("zeroOwner"),
+                projectUri: "myIPFSHash",
+                rulesetConfigurations: _rulesetConfig,
+                terminalConfigurations: _terminalConfigurations,
+                memo: ""
+            })
+        );
+
+        _projectOne = uint64(
+            _controller.launchProjectFor({
+                owner: _projectOwner,
+                projectUri: "myIPFSHash",
+                rulesetConfigurations: _rulesetConfig,
+                terminalConfigurations: _terminalConfigurations,
+                memo: ""
+            })
+        );
+    }
+
+    function test_RevertIf_MostBasicAccess() public {
+        // Package up ruleset configuration.
+        JBRulesetConfig[] memory _rulesetConfig = new JBRulesetConfig[](1);
+        _rulesetConfig[0].mustStartAtOrAfter = 0;
+        _rulesetConfig[0].duration = 0;
+        _rulesetConfig[0].weight = 0;
+        _rulesetConfig[0].weightCutPercent = 0;
+        _rulesetConfig[0].approvalHook = IJBRulesetApprovalHook(address(0));
+        _rulesetConfig[0].metadata = _metadata;
+        _rulesetConfig[0].splitGroups = new JBSplitGroup[](0);
+        _rulesetConfig[0].fundAccessLimitGroups = new JBFundAccessLimitGroup[](0);
+
+        vm.prank(makeAddr("zeroOwner"));
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                JBPermissioned.JBPermissioned_Unauthorized.selector,
+                _projectOwner,
+                makeAddr("zeroOwner"),
+                _projectOne,
+                JBPermissionIds.QUEUE_RULESETS
+            )
+        );
+        uint256 queued = _controller.queueRulesetsOf(_projectOne, _rulesetConfig, "");
+
+        assertNotEq(queued, block.timestamp);
+    }
+
+    function test_RevertIf_SetOperators() public {
+        // Pack up our permission data.
+        JBPermissionsData[] memory permData = new JBPermissionsData[](1);
+
+        uint8[] memory permIds = new uint8[](256);
+
+        // Push an index higher than 255.
+        for (uint8 i; i < 255; i++) {
+            permIds[i] = i;
+
+            permData[0] = JBPermissionsData({operator: address(0), projectId: _projectOne, permissionIds: permIds});
+
+            // Set em.
+            vm.prank(_projectOwner);
+            vm.expectRevert(JBPermissions.JBPermissions_NoZeroPermission.selector);
+            _permissions.setPermissionsFor(_projectOwner, permData[0]);
+        }
+    }
+
+    function testHasPermissions(
+        address _account,
+        address _op,
+        uint56 _projectId,
+        uint8 _checkedId,
+        uint8[] memory _set_permissions
+    )
+        public
+    {
+        vm.assume(_projectId != 0);
+        vm.assume(_set_permissions.length != 0);
+        vm.assume(_account != trustedForwarder());
+
+        uint256[] memory _check_permissions = new uint256[](1);
+        _check_permissions[0] = _checkedId;
+
+        bool hasPerm;
+        bool hasZero;
+        for (uint256 i; i < _set_permissions.length; i++) {
+            // Flag if index is zero, meaning set call should revert later.
+            if (_set_permissions[i] == 0) hasZero = true;
+
+            // Flag if hasPermissions check will be true if the array contains it or has root ID.
+            if (_set_permissions[i] == _checkedId) hasPerm = true;
+        }
+
+        // If setting with a zero permission id, will revert.
+        if (hasZero) vm.expectRevert(JBPermissions.JBPermissions_NoZeroPermission.selector);
+
+        // Set the permissions.
+        vm.prank(_account);
+        _permissions.setPermissionsFor(
+            _account, JBPermissionsData({operator: _op, projectId: _projectId, permissionIds: _set_permissions})
+        );
+
+        // Check permissions if the call didn't revert.
+        if (!hasZero) {
+            // Call has permissions and assert.
+            assertEq(_permissions.hasPermissions(_op, _account, _projectId, _check_permissions, false, false), hasPerm);
+        }
+    }
+
+    function testBasicAccessSetup() public {
+        address zeroOwner = makeAddr("zeroOwner");
+        address token = address(usdcToken());
+
+        // Pack up our permission data.
+        JBPermissionsData[] memory permData = new JBPermissionsData[](1);
+        uint8[] memory permIds = new uint8[](1);
+        permIds[0] = 1;
+
+        permData[0] = JBPermissionsData({operator: address(this), projectId: _projectZero, permissionIds: permIds});
+
+        // Set em.
+        vm.prank(zeroOwner);
+        _permissions.setPermissionsFor(zeroOwner, permData[0]);
+
+        // Should be true given root check
+        bool _check = _permissions.hasPermission(address(this), zeroOwner, _projectZero, 2, true, true);
+        assertEq(_check, true);
+
+        // Will revert attempting to set another projects token
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                JBPermissioned.JBPermissioned_Unauthorized.selector,
+                _projectOwner,
+                address(this),
+                2,
+                JBPermissionIds.SET_TOKEN
+            )
+        );
+        _controller.setTokenFor(2, IJBToken(token));
+
+        // Will succeed when setting the correct projects token
+        mockExpect(token, abi.encodeCall(MockERC20.decimals, ()), abi.encode(18));
+        mockExpect(token, abi.encodeCall(IJBToken.canBeAddedTo, (1)), abi.encode(true));
+        _controller.setTokenFor(1, IJBToken(token));
+    }
+
+    function testCannotForwardRoot() public {
+        address zeroOwner = makeAddr("zeroOwner");
+
+        // Pack up our permission data.
+        JBPermissionsData[] memory permData = new JBPermissionsData[](1);
+        uint8[] memory permIds = new uint8[](1);
+        permIds[0] = 1;
+
+        permData[0] = JBPermissionsData({operator: address(this), projectId: _projectZero, permissionIds: permIds});
+
+        // Set em.
+        vm.prank(zeroOwner);
+        _permissions.setPermissionsFor(zeroOwner, permData[0]);
+
+        // Should be true given root check
+        bool _check = _permissions.hasPermission(address(this), zeroOwner, _projectZero, 2, true, true);
+        assertEq(_check, true);
+
+        // Pack up our non-root permission data.
+        JBPermissionsData[] memory permData2 = new JBPermissionsData[](1);
+        uint8[] memory permIds2 = new uint8[](1);
+        permIds2[0] = 2;
+
+        permData2[0] = JBPermissionsData({operator: address(0), projectId: _projectZero, permissionIds: permIds2});
+
+        // Should be able to forward other permissions
+        // Note that this contract is now authorized to do so above- address(this)
+
+        // in emit
+        uint256 packed;
+
+        vm.expectEmit();
+        emit IJBPermissions.OperatorPermissionsSet(
+            permData2[0].operator,
+            zeroOwner,
+            permData2[0].projectId,
+            permData2[0].permissionIds,
+            packed |= 1 << 2,
+            address(this)
+        );
+        _permissions.setPermissionsFor(zeroOwner, permData2[0]);
+
+        // Change the permission being set back to root
+        permData2[0] = JBPermissionsData({operator: address(0), projectId: _projectZero, permissionIds: permIds});
+
+        // Shouldn't be able to forward root
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                JBPermissions.JBPermissions_Unauthorized.selector,
+                zeroOwner,
+                address(this),
+                _projectZero,
+                JBPermissionIds.ROOT
+            )
+        );
+        _permissions.setPermissionsFor(zeroOwner, permData2[0]);
+    }
+
+    function testWildcardCannotBeSetForWildcardRootOperator() public {
+        address zeroOwner = makeAddr("zeroOwner");
+
+        // Pack up our permission data.
+        JBPermissionsData[] memory permData = new JBPermissionsData[](1);
+        uint8[] memory permIds = new uint8[](1);
+        permIds[0] = 1;
+
+        uint56 wildcardProjectId = 0;
+
+        permData[0] = JBPermissionsData({operator: address(this), projectId: wildcardProjectId, permissionIds: permIds});
+
+        // Set em.
+        vm.prank(zeroOwner);
+        _permissions.setPermissionsFor(zeroOwner, permData[0]);
+
+        // Should be true given root check
+        bool _check = _permissions.hasPermission(address(this), zeroOwner, _projectZero, 2, true, true);
+        assertEq(_check, true);
+
+        // Pack up our non-root wildcard permission data.
+        JBPermissionsData[] memory permData2 = new JBPermissionsData[](1);
+        uint8[] memory permIds2 = new uint8[](1);
+        permIds2[0] = 2;
+
+        permData2[0] = JBPermissionsData({operator: address(0), projectId: wildcardProjectId, permissionIds: permIds2});
+
+        // Shouldn't be able to set permission for wildcard project
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                JBPermissions.JBPermissions_Unauthorized.selector, zeroOwner, address(this), 0, JBPermissionIds.ROOT
+            )
+        );
+        _permissions.setPermissionsFor(zeroOwner, permData2[0]);
+    }
+}