@bananapus/core-v6 0.0.36 → 0.0.38

package/test/TestFeeProcessingFailure.sol

@@ -1,218 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.6;
-
-import {TestBaseWorkflow} from "./helpers/TestBaseWorkflow.sol";
-import {JBMultiTerminal} from "../src/JBMultiTerminal.sol";
-import {JBTerminalStore} from "../src/JBTerminalStore.sol";
-import {JBTokens} from "../src/JBTokens.sol";
-import {IJBController} from "../src/interfaces/IJBController.sol";
-import {IJBRulesetApprovalHook} from "../src/interfaces/IJBRulesetApprovalHook.sol";
-import {IJBTerminal} from "../src/interfaces/IJBTerminal.sol";
-import {JBConstants} from "../src/libraries/JBConstants.sol";
-import {JBFees} from "../src/libraries/JBFees.sol";
-import {JBAccountingContext} from "../src/structs/JBAccountingContext.sol";
-import {JBCurrencyAmount} from "../src/structs/JBCurrencyAmount.sol";
-import {JBFundAccessLimitGroup} from "../src/structs/JBFundAccessLimitGroup.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";
-
-/// @notice Tests for the fee processing try-catch path in JBMultiTerminal.
-/// Proves that when fee payment reverts, the fee amount is credited back to
-/// the project's balance — meaning the fee is permanently waived.
-contract TestFeeProcessingFailure_Local is TestBaseWorkflow {
-    IJBController private _controller;
-    JBMultiTerminal private _terminal;
-    JBTokens private _tokens;
-    JBTerminalStore private _store;
-    uint256 private _projectId;
-    address private _projectOwner;
-
-    uint112 private constant WEIGHT = 1000 * 10 ** 18;
-    uint112 private constant PAY_AMOUNT = 10 ether;
-
-    function setUp() public override {
-        super.setUp();
-
-        _projectOwner = multisig();
-        _controller = jbController();
-        _terminal = jbMultiTerminal();
-        _tokens = jbTokens();
-        _store = jbTerminalStore();
-
-        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, // Fees processed immediately.
-            useTotalSurplusForCashOuts: false,
-            useDataHookForPay: false,
-            useDataHookForCashOut: false,
-            dataHook: address(0),
-            metadata: 0
-        });
-
-        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);
-
-        JBCurrencyAmount[] memory payoutLimits = new JBCurrencyAmount[](1);
-        payoutLimits[0] =
-            JBCurrencyAmount({amount: uint224(PAY_AMOUNT), currency: uint32(uint160(JBConstants.NATIVE_TOKEN))});
-        JBFundAccessLimitGroup[] memory limitGroups = new JBFundAccessLimitGroup[](1);
-        limitGroups[0] = JBFundAccessLimitGroup({
-            terminal: address(_terminal),
-            token: JBConstants.NATIVE_TOKEN,
-            payoutLimits: payoutLimits,
-            surplusAllowances: new JBCurrencyAmount[](0)
-        });
-        rulesetConfig[0].fundAccessLimitGroups = limitGroups;
-
-        JBAccountingContext[] memory tokensToAccept = new JBAccountingContext[](1);
-        tokensToAccept[0] = JBAccountingContext({
-            token: JBConstants.NATIVE_TOKEN, decimals: 18, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
-        });
-        JBTerminalConfig[] memory terminalConfigs = new JBTerminalConfig[](1);
-        terminalConfigs[0] =
-            JBTerminalConfig({terminal: IJBTerminal(address(_terminal)), accountingContextsToAccept: tokensToAccept});
-
-        // Fee project (#1) — set up normally so fees can be collected.
-        _controller.launchProjectFor({
-            owner: address(420),
-            projectUri: "fee",
-            rulesetConfigurations: rulesetConfig,
-            terminalConfigurations: terminalConfigs,
-            memo: ""
-        });
-
-        // Test project (#2).
-        _projectId = _controller.launchProjectFor({
-            owner: _projectOwner,
-            projectUri: "test",
-            rulesetConfigurations: rulesetConfig,
-            terminalConfigurations: terminalConfigs,
-            memo: ""
-        });
-    }
-
-    /// @notice Control test: fee payment succeeds under normal conditions.
-    function test_feePaymentSuccess_normalPath() external {
-        // Pay the project.
-        _terminal.pay{value: PAY_AMOUNT}({
-            projectId: _projectId,
-            amount: PAY_AMOUNT,
-            token: JBConstants.NATIVE_TOKEN,
-            beneficiary: _projectOwner,
-            minReturnedTokens: 0,
-            memo: "",
-            metadata: new bytes(0)
-        });
-
-        // Fee project balance before payout.
-        uint256 feeBalanceBefore = _store.balanceOf(address(_terminal), 1, JBConstants.NATIVE_TOKEN);
-
-        // Distribute payouts — fee should be processed immediately (holdFees=false).
-        vm.prank(_projectOwner);
-        _terminal.sendPayoutsOf({
-            projectId: _projectId,
-            token: JBConstants.NATIVE_TOKEN,
-            amount: PAY_AMOUNT,
-            currency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
-            minTokensPaidOut: 0
-        });
-
-        // Fee project should have received fees.
-        uint256 feeBalanceAfter = _store.balanceOf(address(_terminal), 1, JBConstants.NATIVE_TOKEN);
-        assertGt(feeBalanceAfter, feeBalanceBefore, "Fee project should receive fees under normal conditions");
-    }
-
-    /// @notice When fee payment reverts, the fee amount is returned to the project's balance.
-    /// This is the expected behavior documented in the try-catch at JBMultiTerminal._processFee.
-    function test_feePaymentReverts_fundsReturnedToProject() external {
-        // Pay the project.
-        _terminal.pay{value: PAY_AMOUNT}({
-            projectId: _projectId,
-            amount: PAY_AMOUNT,
-            token: JBConstants.NATIVE_TOKEN,
-            beneficiary: _projectOwner,
-            minReturnedTokens: 0,
-            memo: "",
-            metadata: new bytes(0)
-        });
-
-        // Make the fee project's terminal revert by making the pay call fail.
-        // We'll mock the pay call on the terminal to revert for fee project (#1).
-        // The fee terminal is _terminal itself (same terminal accepts fees for project 1).
-        // We can't easily make it revert selectively, but we CAN test the held fee path.
-
-        // Instead, test the held fee processing revert path:
-        // Create a project with holdFees=true, then make the fee terminal unavailable.
-        // This is more realistic since the fee try-catch is in _processFee.
-
-        // For this test, verify the FeeReverted event is emitted when fee processing fails.
-        // We'll manipulate the directory to return address(0) for fee project's terminal.
-
-        // The fee is taken during sendPayoutsOf. Under normal conditions, it goes to project #1.
-        // The _processFee try-catch handles failures gracefully.
-        // We verify that the normal path works (fee is deducted from payout and sent to fee project).
-        vm.prank(_projectOwner);
-        _terminal.sendPayoutsOf({
-            projectId: _projectId,
-            token: JBConstants.NATIVE_TOKEN,
-            amount: PAY_AMOUNT,
-            currency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
-            minTokensPaidOut: 0
-        });
-
-        // Fee was deducted from the payout — project balance is now only the surplus (if any).
-        // The fee was 2.5% of the payout amount.
-        uint256 feeAmount = JBFees.feeAmountFrom({amountBeforeFee: PAY_AMOUNT, feePercent: _terminal.FEE()});
-        assertGt(feeAmount, 0, "Fee should be non-zero");
-    }
-
-    /// @notice Held fee processing: when fee payment reverts, the FeeReverted event is emitted
-    /// and the fee amount is credited back to the project balance via _recordAddedBalanceFor.
-    function test_heldFeeProcessing_revert_refundsToProject() external view {
-        // This test requires holdFees=true ruleset — we test the principle:
-        // When _processFee's try block reverts, the catch block calls _recordAddedBalanceFor.
-        // This returns the fee amount to the project's terminal store balance.
-
-        // The mechanism is:
-        // 1. _processFee calls this.executeProcessFee (external call to self)
-        // 2. executeProcessFee calls _efficientPay on the fee terminal
-        // 3. If _efficientPay reverts, the catch block fires
-        // 4. Catch emits FeeReverted and calls _recordAddedBalanceFor
-
-        // We can verify this by checking that the FeeReverted event selector exists.
-        // The actual test of the catch path requires making the fee terminal revert,
-        // which is complex in an integration test. The unit tests in TestCashOutTokensOf
-        // already cover this with mocks.
-
-        // Here we verify the fee calculation is correct.
-        uint256 fee = _terminal.FEE(); // 25 (2.5%)
-        uint256 feeAmount = JBFees.feeAmountFrom({amountBeforeFee: PAY_AMOUNT, feePercent: fee});
-
-        // Fee of 10 ETH at 2.5%: 10 * 25 / 1000 = 0.25 ETH
-        assertEq(feeAmount, 0.25 ether, "Fee should be 2.5% of payout amount");
-
-        // Fee amount that would result in the payout getting `amount - feeAmount`:
-        uint256 resultingFee = JBFees.feeAmountFrom({amountBeforeFee: 1 ether, feePercent: fee});
-        assertEq(resultingFee, 0.025 ether, "1 ETH should have 0.025 ETH fee");
-    }
-}