@bananapus/core-v6 0.0.16 → 0.0.18

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

@@ -1,28 +1,216 @@
 // SPDX-License-Identifier: MIT
 pragma solidity 0.8.26;
 
-import {JBMultiTerminalSetup} from "./JBMultiTerminalSetup.sol";
+import {JBMultiTerminal} from "../../../../src/JBMultiTerminal.sol";
+import {IJBDirectory} from "../../../../src/interfaces/IJBDirectory.sol";
+import {IJBFeeTerminal} from "../../../../src/interfaces/IJBFeeTerminal.sol";
+import {IJBFeelessAddresses} from "../../../../src/interfaces/IJBFeelessAddresses.sol";
+import {IJBPermissions} from "../../../../src/interfaces/IJBPermissions.sol";
+import {IJBProjects} from "../../../../src/interfaces/IJBProjects.sol";
+import {IJBRulesetApprovalHook} from "../../../../src/interfaces/IJBRulesetApprovalHook.sol";
+import {IJBRulesets} from "../../../../src/interfaces/IJBRulesets.sol";
+import {IJBSplits} from "../../../../src/interfaces/IJBSplits.sol";
+import {IJBTerminalStore} from "../../../../src/interfaces/IJBTerminalStore.sol";
+import {IJBTokens} from "../../../../src/interfaces/IJBTokens.sol";
+import {JBFees} from "../../../../src/libraries/JBFees.sol";
+import {JBFee} from "../../../../src/structs/JBFee.sol";
+import {JBPayHookSpecification} from "../../../../src/structs/JBPayHookSpecification.sol";
+import {JBRuleset} from "../../../../src/structs/JBRuleset.sol";
+import {IPermit2} from "@uniswap/permit2/src/interfaces/IPermit2.sol";
+import {JBTest} from "../../../helpers/JBTest.sol";
 
-contract TestProcessHeldFeesOf_Local is JBMultiTerminalSetup {
-    // covered extensively in other units but leaving the scaffolding for now
-    /* function setUp() public {
-            super.multiTerminalSetup();
-        }
+/// @dev Harness that exposes internal held fee storage for direct manipulation in tests.
+contract ForTest_JBMultiTerminal is JBMultiTerminal {
+    constructor(
+        IJBFeelessAddresses feelessAddresses,
+        IJBPermissions permissions,
+        IJBProjects projects,
+        IJBSplits splits,
+        IJBTerminalStore store,
+        IJBTokens tokens,
+        IPermit2 permit2,
+        address trustedForwarder
+    )
+        JBMultiTerminal(feelessAddresses, permissions, projects, splits, store, tokens, permit2, trustedForwarder)
+    {}
 
-        function test_WhenHeldFeeUnlockTimestampGTBlocktimestamp() external {
-            // it will add the fee back to _heldFeesOf
-        }
+    function forTestAddHeldFee(uint256 projectId, address token, JBFee memory fee) external {
+        _heldFeesOf[projectId][token].push(fee);
+    }
+
+    function forTestSetNextHeldFeeIndex(uint256 projectId, address token, uint256 index) external {
+        _nextHeldFeeIndexOf[projectId][token] = index;
+    }
+}
+
+contract TestProcessHeldFeesOf_Local is JBTest {
+    // Target Contract (harness)
+    ForTest_JBMultiTerminal public _terminal;
+
+    // Mocks
+    IJBPermissions public permissions = IJBPermissions(makeAddr("permissions"));
+    IJBProjects public projects = IJBProjects(makeAddr("projects"));
+    IJBDirectory public directory = IJBDirectory(makeAddr("directory"));
+    IJBRulesets public rulesets = IJBRulesets(makeAddr("rulesets"));
+    IJBTokens public tokens = IJBTokens(makeAddr("tokens"));
+    IJBSplits public splits = IJBSplits(makeAddr("splits"));
+    IJBTerminalStore public store = IJBTerminalStore(makeAddr("store"));
+    IJBFeelessAddresses public feelessAddresses = IJBFeelessAddresses(makeAddr("feeless"));
+    IPermit2 public permit2 = IPermit2(makeAddr("permit2"));
+    address trustedForwarder = makeAddr("forwarder");
+
+    uint256 _projectId = 2;
+    address _mockToken = makeAddr("token");
+    address _beneficiary = makeAddr("beneficiary");
+
+    function setUp() public {
+        // Constructor will call to find directory and rulesets from the terminal store
+        mockExpect(address(store), abi.encodeCall(IJBTerminalStore.DIRECTORY, ()), abi.encode(address(directory)));
+        mockExpect(address(store), abi.encodeCall(IJBTerminalStore.RULESETS, ()), abi.encode(address(rulesets)));
+
+        _terminal = new ForTest_JBMultiTerminal(
+            feelessAddresses, permissions, projects, splits, store, tokens, permit2, trustedForwarder
+        );
+    }
+
+    function test_WhenHeldFeeUnlockTimestampGTBlocktimestamp() external {
+        // it will not process the fee (fee remains held)
+
+        // Add a held fee with unlockTimestamp in the future
+        uint48 futureTimestamp = uint48(block.timestamp + 1000);
+        _terminal.forTestAddHeldFee(
+            _projectId, _mockToken, JBFee({amount: 100, beneficiary: _beneficiary, unlockTimestamp: futureTimestamp})
+        );
+
+        // Mock the directory call to find the fee terminal (project 1 is the fee beneficiary)
+        mockExpect(
+            address(directory),
+            abi.encodeCall(IJBDirectory.primaryTerminalOf, (1, _mockToken)),
+            abi.encode(address(_terminal))
+        );
+
+        // Call processHeldFeesOf - the fee should NOT be processed because it's still locked
+        _terminal.processHeldFeesOf(_projectId, _mockToken, 1);
+
+        // Verify the fee is still held
+        JBFee[] memory remaining = _terminal.heldFeesOf(_projectId, _mockToken, 10);
+        assertEq(remaining.length, 1, "fee should still be held");
+        assertEq(remaining[0].amount, 100, "fee amount should be unchanged");
+        assertEq(remaining[0].unlockTimestamp, futureTimestamp, "unlock timestamp should be unchanged");
+    }
+
+    modifier whenHeldFeeIsUnlocked() {
+        _;
+    }
+
+    function test_GivenExecuteProcessFeeSucceeds() external whenHeldFeeIsUnlocked {
+        // it will process the fee and emit ProcessFee
+
+        // Add a held fee that is already unlocked
+        uint48 pastTimestamp = uint48(block.timestamp - 1);
+        uint256 heldAmount = 1000;
+        _terminal.forTestAddHeldFee(
+            _projectId,
+            _mockToken,
+            JBFee({amount: heldAmount, beneficiary: _beneficiary, unlockTimestamp: pastTimestamp})
+        );
+
+        // The fee amount that will be calculated from the held amount
+        uint256 expectedFeeAmount = JBFees.feeAmountFrom({amountBeforeFee: heldAmount, feePercent: _terminal.FEE()});
+
+        // Mock the directory call to find the fee terminal - return _terminal itself so it uses internal _pay
+        mockExpect(
+            address(directory),
+            abi.encodeCall(IJBDirectory.primaryTerminalOf, (1, _mockToken)),
+            abi.encode(address(_terminal))
+        );
+
+        // Mock executeProcessFee: when the terminal calls itself, it will call recordPaymentFrom on the store.
+        // Since executeProcessFee is external and calls pay on the feeTerminal (which is _terminal itself),
+        // we need to mock the internal pay path: recordPaymentFrom on the store.
+        // The token amount struct for the fee payment
+        // Note: accounting context for project 1 on _mockToken is unset, so decimals=0 and currency=0.
+        vm.mockCall(
+            address(store),
+            abi.encodeWithSelector(IJBTerminalStore.recordPaymentFrom.selector),
+            abi.encode(
+                JBRuleset({
+                    cycleNumber: 1,
+                    id: 1,
+                    basedOnId: 0,
+                    start: 0,
+                    duration: 0,
+                    weight: 0,
+                    weightCutPercent: 0,
+                    approvalHook: IJBRulesetApprovalHook(address(0)),
+                    metadata: 0
+                }),
+                uint256(0),
+                new JBPayHookSpecification[](0)
+            )
+        );
+
+        // Expect ProcessFee event
+        vm.expectEmit();
+        emit IJBFeeTerminal.ProcessFee({
+            projectId: _projectId,
+            token: _mockToken,
+            amount: expectedFeeAmount,
+            wasHeld: true,
+            beneficiary: _beneficiary,
+            caller: address(this)
+        });
+
+        _terminal.processHeldFeesOf(_projectId, _mockToken, 1);
+
+        // Verify held fees are cleaned up
+        JBFee[] memory remaining = _terminal.heldFeesOf(_projectId, _mockToken, 10);
+        assertEq(remaining.length, 0, "held fees should be empty after processing");
+    }
+
+    function test_GivenExecuteProcessFeeFails() external whenHeldFeeIsUnlocked {
+        // it will readd balance and emit FeeReverted
+
+        // Add a held fee that is already unlocked
+        uint48 pastTimestamp = uint48(block.timestamp - 1);
+        uint256 heldAmount = 1000;
+        _terminal.forTestAddHeldFee(
+            _projectId,
+            _mockToken,
+            JBFee({amount: heldAmount, beneficiary: _beneficiary, unlockTimestamp: pastTimestamp})
+        );
+
+        // The fee amount that will be calculated from the held amount
+        uint256 expectedFeeAmount = JBFees.feeAmountFrom({amountBeforeFee: heldAmount, feePercent: _terminal.FEE()});
+
+        // Mock the directory call to find the fee terminal - return address(0) which will cause
+        // executeProcessFee to revert with FeeTerminalNotFound
+        mockExpect(
+            address(directory), abi.encodeCall(IJBDirectory.primaryTerminalOf, (1, _mockToken)), abi.encode(address(0))
+        );
 
-        modifier whenHeldFeeIsUnlocked() {
-            _;
-        }
+        // Mock the recordAddedBalanceFor call that happens on fee revert (balance returned to project)
+        mockExpect(
+            address(store),
+            abi.encodeCall(IJBTerminalStore.recordAddedBalanceFor, (_projectId, _mockToken, expectedFeeAmount)),
+            abi.encode()
+        );
 
-        function test_GivenExecuteProcessFeeSucceeds() external whenHeldFeeIsUnlocked {
-            // it will process the fee and emit ProcessFee
-        }
+        // Expect FeeReverted event
+        vm.expectEmit(true, true, true, false);
+        emit IJBFeeTerminal.FeeReverted({
+            projectId: _projectId,
+            token: _mockToken,
+            feeProjectId: 1,
+            amount: expectedFeeAmount,
+            reason: "",
+            caller: address(this)
+        });
 
-        function test_GivenExecuteProcessFeeFails() external whenHeldFeeIsUnlocked {
-            // it will readd balance and emit FeeReverted
-        } */
+        _terminal.processHeldFeesOf(_projectId, _mockToken, 1);
 
+        // Verify held fees are cleaned up (entry was deleted even though fee processing failed)
+        JBFee[] memory remaining = _terminal.heldFeesOf(_projectId, _mockToken, 10);
+        assertEq(remaining.length, 0, "held fees should be empty after failed processing");
     }
+}

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

@@ -4,6 +4,7 @@ pragma solidity 0.8.26;
 import {JBMultiTerminal} from "../../../../src/JBMultiTerminal.sol";
 import {IJBController} from "../../../../src/interfaces/IJBController.sol";
 import {IJBDirectory} from "../../../../src/interfaces/IJBDirectory.sol";
+import {IJBFeeTerminal} from "../../../../src/interfaces/IJBFeeTerminal.sol";
 import {IJBFeelessAddresses} from "../../../../src/interfaces/IJBFeelessAddresses.sol";
 import {IJBPayoutTerminal} from "../../../../src/interfaces/IJBPayoutTerminal.sol";
 import {IJBRulesetApprovalHook} from "../../../../src/interfaces/IJBRulesetApprovalHook.sol";
@@ -12,6 +13,9 @@ import {IJBTerminalStore} from "../../../../src/interfaces/IJBTerminalStore.sol"
 import {JBAccountingContext} from "../../../../src/structs/JBAccountingContext.sol";
 import {JBPayHookSpecification} from "../../../../src/structs/JBPayHookSpecification.sol";
 import {JBRuleset} from "../../../../src/structs/JBRuleset.sol";
+import {JBRulesetMetadata} from "../../../../src/structs/JBRulesetMetadata.sol";
+import {JBRulesetMetadataResolver} from "../../../../src/libraries/JBRulesetMetadataResolver.sol";
+import {JBConstants} from "../../../../src/libraries/JBConstants.sol";
 import {JBTokenAmount} from "../../../../src/structs/JBTokenAmount.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
@@ -19,6 +23,8 @@ import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
 import {JBMultiTerminalSetup} from "./JBMultiTerminalSetup.sol";
 
 contract TestUseAllowanceOf_Local is JBMultiTerminalSetup {
+    using JBRulesetMetadataResolver for JBRulesetMetadata;
+
     uint256 _projectId = 1;
 
     function setUp() public {
@@ -310,10 +316,284 @@ contract TestUseAllowanceOf_Local is JBMultiTerminalSetup {
 
     function test_GivenRulesetHoldFeesEQTrue() external whenMsgSenderDNEQFeeless {
         // it will hold fees and emit HoldFee
+        address mockToken = makeAddr("token");
+        address beneficiary = makeAddr("bene");
+
+        // Mock controller (needed for addAccountingContextsFor permission check)
+        address controller = makeAddr("controller");
+
+        // forge-lint: disable-next-line(unsafe-typecast)
+        uint32 currencyId = uint32(uint160(mockToken));
+
+        // Mock controllerOf for addAccountingContextsFor permission check
+        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)));
+
+        // Build a ruleset with holdFees=true via packed metadata
+        JBRulesetMetadata memory _rulesMetadata = 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: true,
+            useTotalSurplusForCashOuts: false,
+            useDataHookForPay: false,
+            useDataHookForCashOut: false,
+            dataHook: address(0),
+            metadata: 0
+        });
+
+        uint256 packedMetadata = JBRulesetMetadataResolver.packRulesetMetadata(_rulesMetadata);
+
+        JBRuleset memory returnedRuleset = JBRuleset({
+            cycleNumber: 1,
+            id: 1,
+            basedOnId: 0,
+            start: 0,
+            duration: 0,
+            weight: 0,
+            weightCutPercent: 0,
+            approvalHook: IJBRulesetApprovalHook(address(0)),
+            metadata: packedMetadata
+        });
+
+        // mock call to tokens decimals()
+        mockExpect(mockToken, abi.encodeCall(IERC20Metadata.decimals, ()), abi.encode(18));
+
+        // mock call to rulesets currentOf
+        mockExpect(address(rulesets), abi.encodeCall(IJBRulesets.currentOf, (_projectId)), abi.encode(returnedRuleset));
+
+        // Set up accounting context so the token is recognized
+        JBAccountingContext[] memory _tokens = new JBAccountingContext[](1);
+        _tokens[0] = JBAccountingContext({token: mockToken, decimals: 18, currency: currencyId});
+
+        _terminal.addAccountingContextsFor(_projectId, _tokens);
+
+        // recordUsedAllowance
+        mockExpect(
+            address(store),
+            abi.encodeCall(IJBTerminalStore.recordUsedAllowanceOf, (_projectId, _tokens[0], 100, 0)),
+            abi.encode(returnedRuleset, 100)
+        );
+
+        // first feeless check: owner is NOT feeless
+        mockExpect(
+            address(feelessAddresses), abi.encodeCall(IJBFeelessAddresses.isFeeless, (address(this))), abi.encode(false)
+        );
+
+        // second feeless check: beneficiary is NOT feeless
+        mockExpect(
+            address(feelessAddresses), abi.encodeCall(IJBFeelessAddresses.isFeeless, (beneficiary)), abi.encode(false)
+        );
+
+        // Fee is 2.5% of 100 = 2, so net = 98
+        mockExpect(mockToken, abi.encodeCall(IERC20.transfer, (beneficiary, 98)), abi.encode(true));
+
+        // Expect HoldFee event (fee is held, not processed)
+        vm.expectEmit(true, true, true, true);
+        emit IJBFeeTerminal.HoldFee({
+            projectId: _projectId,
+            token: mockToken,
+            amount: 100,
+            fee: 25,
+            beneficiary: address(this),
+            caller: address(this)
+        });
+
+        // Expect UseAllowance event
+        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: ""
+        });
     }
 
     function test_GivenRulesetHoldFeesDNEQTrue() external whenMsgSenderDNEQFeeless {
         // it will not hold fees and emit ProcessFee
+        address mockToken = makeAddr("token2");
+        address beneficiary = makeAddr("bene2");
+
+        // Mock controller for mint call on fee payments
+        address controller = makeAddr("controller2");
+
+        // Weight for a fee calculation that would take place in terminal store
+        uint112 weight = 1000 * 10 ** 18;
+
+        // forge-lint: disable-next-line(unsafe-typecast)
+        uint32 currencyId = uint32(uint160(mockToken));
+
+        // Build a ruleset with holdFees=false explicitly via packed metadata
+        JBRulesetMetadata memory _rulesMetadata = 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
+        });
+
+        uint256 packedMetadata = JBRulesetMetadataResolver.packRulesetMetadata(_rulesMetadata);
+
+        // Start the cascade of issuing project tokens to the fee beneficiary.
+        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)));
+
+        JBRuleset memory returnedRuleset = JBRuleset({
+            cycleNumber: 1,
+            id: 1,
+            basedOnId: 0,
+            start: 0,
+            duration: 0,
+            weight: weight,
+            weightCutPercent: 0,
+            approvalHook: IJBRulesetApprovalHook(address(0)),
+            metadata: packedMetadata
+        });
+
+        // mock call to tokens decimals()
+        mockExpect(mockToken, abi.encodeCall(IERC20Metadata.decimals, ()), abi.encode(18));
+
+        // mock call to rulesets currentOf
+        mockExpect(address(rulesets), abi.encodeCall(IJBRulesets.currentOf, (_projectId)), abi.encode(returnedRuleset));
+
+        // Set up accounting context
+        JBAccountingContext[] memory _tokens = new JBAccountingContext[](1);
+        _tokens[0] = JBAccountingContext({token: mockToken, decimals: 18, currency: currencyId});
+
+        _terminal.addAccountingContextsFor(_projectId, _tokens);
+
+        // recordUsedAllowance
+        mockExpect(
+            address(store),
+            abi.encodeCall(IJBTerminalStore.recordUsedAllowanceOf, (_projectId, _tokens[0], 100, 0)),
+            abi.encode(returnedRuleset, 100)
+        );
+
+        // first feeless check: false
+        mockExpect(
+            address(feelessAddresses), abi.encodeCall(IJBFeelessAddresses.isFeeless, (address(this))), abi.encode(false)
+        );
+
+        // second feeless check: false
+        mockExpect(
+            address(feelessAddresses), abi.encodeCall(IJBFeelessAddresses.isFeeless, (beneficiary)), abi.encode(false)
+        );
+
+        // Fee = 2.5% of 100 = 2, net = 98
+        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 recordPaymentFrom for the fee payment
+        mockExpect(
+            address(store),
+            abi.encodeCall(
+                IJBTerminalStore.recordPaymentFrom,
+                (address(_terminal), tokenContext, _projectId, address(this), bytes(abi.encodePacked(_projectId)))
+            ),
+            abi.encode(returnedRuleset, 1, new JBPayHookSpecification[](0))
+        );
+
+        // Return the mint 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)
+        );
+
+        // Expect ProcessFee event (fee is processed immediately, not held)
+        vm.expectEmit(true, true, true, true);
+        emit IJBFeeTerminal.ProcessFee({
+            projectId: _projectId,
+            token: mockToken,
+            amount: 2,
+            wasHeld: false,
+            beneficiary: address(this),
+            caller: address(this)
+        });
+
+        // Expect UseAllowance event
+        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: ""
+        });
     }
 
     function test_WhenTokenEQNATIVE_TOKEN() external {