@bananapus/core-v6 0.0.29 → 0.0.31

package/test/audit/CycledSurplusAllowanceReset.t.sol

@@ -0,0 +1,184 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.6;
+
+import {TestBaseWorkflow} from "../helpers/TestBaseWorkflow.sol";
+import {IJBRulesetApprovalHook} from "../../src/interfaces/IJBRulesetApprovalHook.sol";
+import {IJBTerminal} from "../../src/interfaces/IJBTerminal.sol";
+import {JBConstants} from "../../src/libraries/JBConstants.sol";
+import {JBAccountingContext} from "../../src/structs/JBAccountingContext.sol";
+import {JBCurrencyAmount} from "../../src/structs/JBCurrencyAmount.sol";
+import {JBFundAccessLimitGroup} from "../../src/structs/JBFundAccessLimitGroup.sol";
+import {JBRuleset} from "../../src/structs/JBRuleset.sol";
+import {JBRulesetConfig} from "../../src/structs/JBRulesetConfig.sol";
+import {JBRulesetMetadata} from "../../src/structs/JBRulesetMetadata.sol";
+import {JBSplitGroup} from "../../src/structs/JBSplitGroup.sol";
+import {JBTerminalConfig} from "../../src/structs/JBTerminalConfig.sol";
+
+contract CycledSurplusAllowanceResetTest is TestBaseWorkflow {
+    function test_surplusAllowanceDoesNotResetAcrossImplicitCycles() external {
+        _launchFeeProject();
+
+        JBRulesetConfig[] memory rulesetConfigurations = new JBRulesetConfig[](1);
+        rulesetConfigurations[0] = _makeRulesetConfig({
+            duration: 1 days,
+            metadata: _defaultMetadata(),
+            splitGroups: new JBSplitGroup[](0),
+            fundAccessLimitGroups: _makeFundAccessLimitGroup(1 ether)
+        });
+
+        uint256 projectId = jbController()
+            .launchProjectFor({
+                owner: multisig(),
+                projectUri: "cycle-allowance",
+                rulesetConfigurations: rulesetConfigurations,
+                terminalConfigurations: _makeTerminalConfig(),
+                memo: ""
+            });
+
+        address payer = makeAddr("payer");
+        vm.deal(payer, 5 ether);
+        vm.prank(payer);
+        jbMultiTerminal().pay{value: 5 ether}({
+            projectId: projectId,
+            amount: 5 ether,
+            token: JBConstants.NATIVE_TOKEN,
+            beneficiary: payer,
+            minReturnedTokens: 0,
+            memo: "",
+            metadata: new bytes(0)
+        });
+
+        vm.prank(multisig());
+        jbMultiTerminal()
+            .useAllowanceOf({
+                projectId: projectId,
+                token: JBConstants.NATIVE_TOKEN,
+                amount: 1 ether,
+                currency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+                minTokensPaidOut: 0,
+                beneficiary: payable(makeAddr("cycle1-beneficiary")),
+                feeBeneficiary: payable(multisig()),
+                memo: ""
+            });
+
+        JBRuleset memory cycleOneRuleset = jbRulesets().currentOf(projectId);
+        assertEq(cycleOneRuleset.cycleNumber, 1, "expected first cycle before warp");
+
+        vm.warp(block.timestamp + 1 days + 1);
+
+        JBRuleset memory cycledRuleset = jbRulesets().currentOf(projectId);
+        assertEq(cycledRuleset.cycleNumber, 2, "expected implicit second cycle");
+        assertEq(cycledRuleset.id, cycleOneRuleset.id, "cycled ruleset reuses base ruleset id");
+
+        vm.expectRevert();
+        vm.prank(multisig());
+        jbMultiTerminal()
+            .useAllowanceOf({
+                projectId: projectId,
+                token: JBConstants.NATIVE_TOKEN,
+                amount: 1 ether,
+                currency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+                minTokensPaidOut: 0,
+                beneficiary: payable(makeAddr("cycle2-beneficiary")),
+                feeBeneficiary: payable(multisig()),
+                memo: ""
+            });
+    }
+
+    function _launchFeeProject() private returns (uint256) {
+        JBRulesetConfig[] memory rulesetConfigurations = new JBRulesetConfig[](1);
+        rulesetConfigurations[0] = _makeRulesetConfig({
+            duration: 1 days,
+            metadata: _defaultMetadata(),
+            splitGroups: new JBSplitGroup[](0),
+            fundAccessLimitGroups: new JBFundAccessLimitGroup[](0)
+        });
+
+        return jbController()
+            .launchProjectFor({
+                owner: multisig(),
+                projectUri: "fee-project",
+                rulesetConfigurations: rulesetConfigurations,
+                terminalConfigurations: _makeTerminalConfig(),
+                memo: ""
+            });
+    }
+
+    function _defaultMetadata() private pure returns (JBRulesetMetadata memory) {
+        return JBRulesetMetadata({
+            reservedPercent: 0,
+            cashOutTaxRate: 0,
+            baseCurrency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+            pausePay: false,
+            pauseCreditTransfers: false,
+            allowOwnerMinting: true,
+            allowSetCustomToken: true,
+            allowTerminalMigration: true,
+            allowSetTerminals: true,
+            ownerMustSendPayouts: false,
+            allowSetController: true,
+            allowAddAccountingContext: true,
+            allowAddPriceFeed: true,
+            holdFees: false,
+            useTotalSurplusForCashOuts: false,
+            useDataHookForPay: false,
+            useDataHookForCashOut: false,
+            dataHook: address(0),
+            metadata: 0
+        });
+    }
+
+    function _makeTerminalConfig() private view returns (JBTerminalConfig[] memory terminalConfigurations) {
+        terminalConfigurations = new JBTerminalConfig[](1);
+
+        JBAccountingContext[] memory accountingContexts = new JBAccountingContext[](1);
+        accountingContexts[0] = JBAccountingContext({
+            token: JBConstants.NATIVE_TOKEN, decimals: 18, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
+        });
+
+        terminalConfigurations[0] = JBTerminalConfig({
+            terminal: IJBTerminal(address(jbMultiTerminal())), accountingContextsToAccept: accountingContexts
+        });
+    }
+
+    function _makeFundAccessLimitGroup(uint224 surplusAllowanceAmount)
+        private
+        view
+        returns (JBFundAccessLimitGroup[] memory groups)
+    {
+        groups = new JBFundAccessLimitGroup[](1);
+
+        JBCurrencyAmount[] memory surplusAllowances = new JBCurrencyAmount[](1);
+        surplusAllowances[0] =
+            JBCurrencyAmount({amount: surplusAllowanceAmount, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))});
+
+        groups[0] = JBFundAccessLimitGroup({
+            terminal: address(jbMultiTerminal()),
+            token: JBConstants.NATIVE_TOKEN,
+            payoutLimits: new JBCurrencyAmount[](0),
+            surplusAllowances: surplusAllowances
+        });
+    }
+
+    function _makeRulesetConfig(
+        uint32 duration,
+        JBRulesetMetadata memory metadata,
+        JBSplitGroup[] memory splitGroups,
+        JBFundAccessLimitGroup[] memory fundAccessLimitGroups
+    )
+        private
+        pure
+        returns (JBRulesetConfig memory)
+    {
+        return JBRulesetConfig({
+            mustStartAtOrAfter: 0,
+            duration: duration,
+            weight: 1000 * 10 ** 18,
+            weightCutPercent: 0,
+            approvalHook: IJBRulesetApprovalHook(address(0)),
+            metadata: metadata,
+            splitGroups: splitGroups,
+            fundAccessLimitGroups: fundAccessLimitGroups
+        });
+    }
+}

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

@@ -17,9 +17,11 @@ contract TestPreviewMintOf_Local is JBControllerSetup {
         super.controllerSetup();
     }
 
-    function test_RevertsWhenTokenCountIsZero() external {
-        vm.expectRevert(JBController.JBController_ZeroTokensToMint.selector);
-        _controller.previewMintOf(_projectId, 0, true);
+    function test_ReturnsZeroCountsWhenTokenCountIsZero() external view {
+        (uint256 beneficiaryTokenCount, uint256 reservedTokenCount) = _controller.previewMintOf(_projectId, 0, true);
+
+        assertEq(beneficiaryTokenCount, 0);
+        assertEq(reservedTokenCount, 0);
     }
 
     function test_ReturnsSplitCountsWhenUsingReservedPercent() external {

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

@@ -220,11 +220,7 @@ contract TestCashOutTokensOf_Local is JBMultiTerminalSetup {
         // forge-lint: disable-next-line(unsafe-typecast)
         _acceptToken(_mockToken, 18, uint32(uint160(_mockToken)));
 
-        vm.expectRevert(
-            abi.encodeWithSelector(
-                JBMultiTerminal.JBMultiTerminal_UnderMinTokensReclaimed.selector, reclaimAmount, 1e18
-            )
-        );
+        vm.expectRevert(abi.encodeWithSelector(JBMultiTerminal.JBMultiTerminal_UnderMin.selector, reclaimAmount, 1e18));
         vm.prank(_bene);
         _terminal.cashOutTokensOf(_holder, _projectId, _defaultAmount, _mockToken, 1e18, _bene, ""); // minReclaimAmount
         // = 1e18 but only 1e9 reclaimed
@@ -431,10 +427,14 @@ contract TestCashOutTokensOf_Local is JBMultiTerminalSetup {
         // ensure approval is set via forceApprove
         vm.expectCall(address(_mockToken2), abi.encodeCall(IERC20.approve, (address(_mockHook), _defaultAmount)));
 
-        _acceptToken(address(_mockToken2), 18, uint32(uint160(address(_mockToken2))));
+        // Mock the temporary allowance as fully consumed by the hook so the cleanup guard passes.
+        vm.mockCall(
+            address(_mockToken2),
+            abi.encodeCall(IERC20.allowance, (address(_terminal), address(_mockHook))),
+            abi.encode(0)
+        );
 
-        vm.expectEmit();
-        emit IJBCashOutTerminal.HookAfterRecordCashOut(_mockHook, context, _defaultAmount, 0, address(_bene));
+        _acceptToken(address(_mockToken2), 18, uint32(uint160(address(_mockToken2))));
 
         vm.prank(_bene);
         _terminal.cashOutTokensOf(_holder, _projectId, _defaultAmount, address(_mockToken2), _minReclaimed, _bene, "");
@@ -548,6 +548,13 @@ contract TestCashOutTokensOf_Local is JBMultiTerminalSetup {
 
         mockExpect(address(_mockHook), abi.encodeCall(IJBCashOutHook.afterCashOutRecordedWith, (context)), "");
 
+        // Mock the temporary allowance as fully consumed by the hook so the cleanup guard passes.
+        vm.mockCall(
+            address(_mockToken2),
+            abi.encodeCall(IERC20.allowance, (address(_terminal), address(_mockHook))),
+            abi.encode(0)
+        );
+
         // primary terminal check
         mockExpect(
             address(directory),
@@ -567,9 +574,6 @@ contract TestCashOutTokensOf_Local is JBMultiTerminalSetup {
 
         _acceptToken(address(_mockToken2), 18, uint32(uint160(address(_mockToken2))));
 
-        vm.expectEmit();
-        emit IJBCashOutTerminal.HookAfterRecordCashOut(_mockHook, context, passedAfterTax, hookTax, address(_bene));
-
         vm.prank(_bene);
         _terminal.cashOutTokensOf(_holder, _projectId, _defaultAmount, address(_mockToken2), _minReclaimed, _bene, "");
     }

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

@@ -335,6 +335,9 @@ contract TestExecutePayout_Local is JBMultiTerminalSetup {
         // mock call for SafeERC20s forceApprove approval
         mockExpect(_usdc, abi.encodeCall(IERC20.approve, (_mockSecondTerminal, amountAfterTax)), "");
 
+        // Mock the forwarded allowance as fully consumed by the recipient terminal.
+        vm.mockCall(_usdc, abi.encodeCall(IERC20.allowance, (address(_terminal), _mockSecondTerminal)), abi.encode(0));
+
         // mock call to second terminals addToBalanceOf
         mockExpect(
             _mockSecondTerminal,
@@ -419,6 +422,9 @@ contract TestExecutePayout_Local is JBMultiTerminalSetup {
         // mock call for SafeERC20s forceApprove approval
         mockExpect(_usdc, abi.encodeCall(IERC20.approve, (_mockSecondTerminal, amountAfterTax)), "");
 
+        // Mock the forwarded allowance as fully consumed by the recipient terminal.
+        vm.mockCall(_usdc, abi.encodeCall(IERC20.allowance, (address(_terminal), _mockSecondTerminal)), abi.encode(0));
+
         // mock call to second terminals pay function
         mockExpect(
             _mockSecondTerminal,

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

@@ -73,6 +73,9 @@ contract TestExecuteProcessFee_Local is JBMultiTerminalSetup {
         // mock approval call for forceApprove
         mockExpect(_usdc, abi.encodeCall(IERC20.approve, (address(_feeTerminal), _defaultAmount)), "");
 
+        // Mock the forwarded allowance as fully consumed by the fee terminal.
+        vm.mockCall(_usdc, abi.encodeCall(IERC20.allowance, (address(_terminal), address(_feeTerminal))), abi.encode(0));
+
         // mock pay call to fee terminal
         mockExpect(
             address(_feeTerminal),

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

@@ -135,6 +135,9 @@ contract TestMigrateBalanceOf_Local is JBMultiTerminalSetup {
         // mock call for SafeERC20s forceApprove approval
         mockExpect(_usdc, abi.encodeCall(IERC20.approve, (address(_newTerminal), _defaultAmount)), "");
 
+        // Mock the forwarded allowance as fully consumed by the destination terminal.
+        vm.mockCall(_usdc, abi.encodeCall(IERC20.allowance, (address(_terminal), address(_newTerminal))), abi.encode(0));
+
         // mock call to new terminal addToBalance
         mockExpect(
             address(_newTerminal),

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

@@ -16,6 +16,7 @@ import {JBAfterPayRecordedContext} from "../../../../src/structs/JBAfterPayRecor
 import {JBPayHookSpecification} from "../../../../src/structs/JBPayHookSpecification.sol";
 import {JBRuleset} from "../../../../src/structs/JBRuleset.sol";
 import {JBTokenAmount} from "../../../../src/structs/JBTokenAmount.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
 import {JBMultiTerminalSetup} from "./JBMultiTerminalSetup.sol";
 
@@ -138,7 +139,7 @@ contract TestPay_Local is JBMultiTerminalSetup {
 
         mockExpect(address(tokens), abi.encodeCall(IJBTokens.totalBalanceOf, (_bene, _projectId)), abi.encode(0));
 
-        vm.expectRevert(abi.encodeWithSelector(JBMultiTerminal.JBMultiTerminal_UnderMinReturnedTokens.selector, 0, 1));
+        vm.expectRevert(abi.encodeWithSelector(JBMultiTerminal.JBMultiTerminal_UnderMin.selector, 0, 1));
         _terminal.pay{value: 1e18}({
             projectId: _projectId,
             token: _native,
@@ -298,21 +299,12 @@ contract TestPay_Local is JBMultiTerminalSetup {
         // mock call to hook
         mockExpect(address(_mockHook), abi.encodeCall(IJBPayHook.afterPayRecordedWith, (context)), "");
 
-        vm.expectEmit();
-        emit IJBTerminal.Pay(
-            returnedRuleset.id,
-            returnedRuleset.cycleNumber,
-            _projectId,
-            address(this),
-            _bene,
-            _defaultAmount,
-            _mintAmount,
-            "",
-            bytes(""),
-            address(this)
+        // Mock the temporary allowance as fully consumed by the hook so the cleanup guard passes.
+        vm.mockCall(
+            address(_mockToken),
+            abi.encodeCall(IERC20.allowance, (address(_terminal), address(_mockHook))),
+            abi.encode(0)
         );
-        vm.expectEmit();
-        emit IJBTerminal.HookAfterRecordPay(_mockHook, context, _defaultAmount, address(this));
 
         // Data for subsequent calls made for balance checks
         bytes[] memory subsequentReturns = new bytes[](2);

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

@@ -71,7 +71,7 @@ contract TestSendPayoutsOf_Local is JBMultiTerminalSetup {
             abi.encode(address(_terminal))
         );
 
-        vm.expectRevert(abi.encodeWithSelector(JBMultiTerminal.JBMultiTerminal_UnderMinTokensPaidOut.selector, 0, 1));
+        vm.expectRevert(abi.encodeWithSelector(JBMultiTerminal.JBMultiTerminal_UnderMin.selector, 0, 1));
         _terminal.sendPayoutsOf(_projectId, address(0), 0, 0, 1);
     }
 

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

@@ -62,7 +62,7 @@ contract TestUseAllowanceOf_Local is JBMultiTerminalSetup {
             address(feelessAddresses), abi.encodeCall(IJBFeelessAddresses.isFeeless, (address(this))), abi.encode(true)
         );
 
-        vm.expectRevert(abi.encodeWithSelector(JBMultiTerminal.JBMultiTerminal_UnderMinTokensPaidOut.selector, 0, 1));
+        vm.expectRevert(abi.encodeWithSelector(JBMultiTerminal.JBMultiTerminal_UnderMin.selector, 0, 1));
         _terminal.useAllowanceOf(_projectId, address(0), 0, 0, 1, payable(address(this)), payable(address(this)), "");
     }