@bananapus/core-v6 0.0.33 → 0.0.35

package/src/abstract/JBPermissioned.sol

@@ -34,6 +34,34 @@ abstract contract JBPermissioned is Context, IJBPermissioned {
     // -------------------------- internal views ------------------------- //
     //*********************************************************************//
 
+    /// @notice Check whether an operator is the account or has the relevant permission.
+    /// @param operator The address to check.
+    /// @param account The account to allow.
+    /// @param projectId The project ID to check the permission under.
+    /// @param permissionId The required permission ID. The operator must have this permission within the specified
+    /// project ID.
+    /// @return Whether the operator is the account or has the permission.
+    function _hasPermissionFrom(
+        address operator,
+        address account,
+        uint256 projectId,
+        uint256 permissionId
+    )
+        internal
+        view
+        returns (bool)
+    {
+        return operator == account
+            || PERMISSIONS.hasPermission({
+                operator: operator,
+                account: account,
+                projectId: projectId,
+                permissionId: permissionId,
+                includeRoot: true,
+                includeWildcardProjectId: true
+            });
+    }
+
     /// @notice Require the message sender to be the account or have the relevant permission.
     /// @param account The account to allow.
     /// @param projectId The project ID to check the permission under.

package/src/interfaces/IJBRulesetDataHook.sol

@@ -19,7 +19,11 @@ interface IJBRulesetDataHook is IERC165 {
     /// @return cashOutTaxRate The rate determining the reclaimable amount for a given surplus and token supply.
     /// @return effectiveCashOutCount The effective token count to use for pricing the cash out. The terminal still
     /// burns the caller-supplied token count.
-    /// @return effectiveTotalSupply The effective total supply to use for pricing the cash out.
+    /// @return effectiveTotalSupply The effective total supply to use for both the proportional reclaim and tax
+    /// calculations. For omnichain projects, this should include tokens on other chains so the tax cannot be bypassed.
+    /// @return effectiveSurplusValue The surplus value to use for the bonding curve calculation, denominated in the
+    /// same token, decimals, and currency as `context.surplus`. The terminal caps the reclaim at locally available
+    /// funds.
     /// @return hookSpecifications The amount and data to send to cash out hooks instead of returning to the
     /// beneficiary.
     function beforeCashOutRecordedWith(JBBeforeCashOutRecordedContext calldata context)
@@ -29,6 +33,7 @@ interface IJBRulesetDataHook is IERC165 {
             uint256 cashOutTaxRate,
             uint256 effectiveCashOutCount,
             uint256 effectiveTotalSupply,
+            uint256 effectiveSurplusValue,
             JBCashOutHookSpecification[] memory hookSpecifications
         );
 

package/src/interfaces/IJBToken.sol

@@ -26,11 +26,11 @@ interface IJBToken {
     /// @param amount The amount of tokens to burn.
     function burn(address account, uint256 amount) external;
 
-    /// @notice Initializes the token with a name, symbol, and owner.
+    /// @notice Initializes the token with a name, symbol, and the JBTokens contract.
     /// @param name The token's name.
     /// @param symbol The token's symbol.
-    /// @param owner The token contract's owner.
-    function initialize(string memory name, string memory symbol, address owner) external;
+    /// @param tokens The JBTokens contract that manages this token.
+    function initialize(string memory name, string memory symbol, address tokens) external;
 
     /// @notice Mints tokens to an account.
     /// @param account The address to mint tokens to.

package/src/structs/JBAccountingContext.sol

@@ -5,7 +5,6 @@ pragma solidity ^0.8.0;
 /// @custom:member decimals The number of decimals expected in that token's fixed point accounting.
 /// @custom:member currency The currency that the token is priced in terms of. By convention, this is
 /// `uint32(uint160(tokenAddress))` for tokens, or a constant ID from e.g. `JBCurrencyIds` for other currencies.
-// forge-lint: disable-next-line(pascal-case-struct)
 struct JBAccountingContext {
     address token;
     uint8 decimals;

package/src/structs/JBAfterCashOutRecordedContext.sol

@@ -16,7 +16,6 @@ import {JBTokenAmount} from "./JBTokenAmount.sol";
 /// @custom:member beneficiary The address the reclaimed amount will be sent to.
 /// @custom:member hookMetadata Extra data specified by the data hook, which is sent to the cash out hook.
 /// @custom:member cashOutMetadata Extra data specified by the account cashing out, which is sent to the cash out hook.
-// forge-lint: disable-next-line(pascal-case-struct)
 struct JBAfterCashOutRecordedContext {
     address holder;
     uint256 projectId;

package/src/structs/JBAfterPayRecordedContext.sol

@@ -15,7 +15,6 @@ import {JBTokenAmount} from "./JBTokenAmount.sol";
 /// @custom:member beneficiary The address which receives any tokens this payment yields.
 /// @custom:member hookMetadata Extra data specified by the data hook, which is sent to the pay hook.
 /// @custom:member payerMetadata Extra data specified by the payer, which is sent to the pay hook.
-// forge-lint: disable-next-line(pascal-case-struct)
 struct JBAfterPayRecordedContext {
     address payer;
     uint256 projectId;

package/src/structs/JBBeforeCashOutRecordedContext.sol

@@ -20,7 +20,6 @@ import {JBTokenAmount} from "./JBTokenAmount.sol";
 /// that charge their own fees — they can skip fees when value stays in the protocol (e.g. project-to-project
 /// routing).
 /// @custom:member metadata Extra data provided by the casher.
-// forge-lint: disable-next-line(pascal-case-struct)
 struct JBBeforeCashOutRecordedContext {
     address terminal;
     address holder;

package/src/structs/JBBeforePayRecordedContext.sol

@@ -15,7 +15,6 @@ import {JBTokenAmount} from "./JBTokenAmount.sol";
 /// @custom:member weight The weight of the ruleset during which the payment is being made.
 /// @custom:member reservedPercent The reserved percent of the ruleset the payment is being made during.
 /// @custom:member metadata Extra data specified by the payer.
-// forge-lint: disable-next-line(pascal-case-struct)
 struct JBBeforePayRecordedContext {
     address terminal;
     address payer;

package/src/structs/JBCashOutHookSpecification.sol

@@ -9,7 +9,6 @@ import {IJBCashOutHook} from "../interfaces/IJBCashOutHook.sol";
 /// @custom:member noop A flag indicating if the hook callback should be skipped.
 /// @custom:member amount The amount to send to the hook.
 /// @custom:member metadata Metadata to pass to the hook.
-// forge-lint: disable-next-line(pascal-case-struct)
 struct JBCashOutHookSpecification {
     IJBCashOutHook hook;
     bool noop;

package/src/structs/JBCurrencyAmount.sol

@@ -4,7 +4,6 @@ pragma solidity ^0.8.0;
 /// @custom:member amount The amount of the currency.
 /// @custom:member currency The currency. By convention, this is `uint32(uint160(tokenAddress))` for tokens, or a
 /// constant ID from e.g. `JBCurrencyIds` for other currencies.
-// forge-lint: disable-next-line(pascal-case-struct)
 struct JBCurrencyAmount {
     uint224 amount;
     uint32 currency;

package/src/structs/JBFee.sol

@@ -5,7 +5,6 @@ pragma solidity ^0.8.0;
 /// decimals as the terminal in which this struct was created.
 /// @custom:member beneficiary The address that will receive the tokens that are minted as a result of the fee payment.
 /// @custom:member unlockTimestamp The timestamp at which the fee is unlocked and can be processed.
-// forge-lint: disable-next-line(pascal-case-struct)
 struct JBFee {
     uint256 amount;
     address beneficiary;

package/src/structs/JBFundAccessLimitGroup.sol

@@ -20,7 +20,6 @@ import {JBCurrencyAmount} from "./JBCurrencyAmount.sol";
 /// @custom:member surplusAllowances An array of surplus allowances. The surplus allowances cumulatively dictates the
 /// maximum value of `token`s a project can pay out from its surplus (balance less payouts) in a terminal during a
 /// ruleset. Each surplus allowance can have a unique currency and amount.
-// forge-lint: disable-next-line(pascal-case-struct)
 struct JBFundAccessLimitGroup {
     address terminal;
     address token;

package/src/structs/JBPayHookSpecification.sol

@@ -9,7 +9,6 @@ import {IJBPayHook} from "../interfaces/IJBPayHook.sol";
 /// @custom:member noop A flag indicating if the hook callback should be skipped.
 /// @custom:member amount The amount to send to the hook.
 /// @custom:member metadata Metadata to pass the hook.
-// forge-lint: disable-next-line(pascal-case-struct)
 struct JBPayHookSpecification {
     IJBPayHook hook;
     bool noop;

package/src/structs/JBPermissionsData.sol

@@ -6,7 +6,6 @@ pragma solidity ^0.8.0;
 /// permissions under this project's scope. An ID of 0 is a wildcard, which gives an operator permissions across all
 /// projects.
 /// @custom:member permissionIds The IDs of the permissions being given. See the `JBPermissionIds` library.
-// forge-lint: disable-next-line(pascal-case-struct)
 struct JBPermissionsData {
     address operator;
     uint64 projectId;

package/src/structs/JBRuleset.sol

@@ -29,7 +29,6 @@ import {IJBRulesetApprovalHook} from "./../interfaces/IJBRulesetApprovalHook.sol
 /// ruleset is rejected, it won't go into effect. An approval hook can be used to create rules which dictate how a
 /// project owner can change their ruleset over time.
 /// @custom:member metadata Extra data associated with a ruleset which can be used by other contracts.
-// forge-lint: disable-next-line(pascal-case-struct)
 struct JBRuleset {
     uint48 cycleNumber;
     uint48 id;

package/src/structs/JBRulesetConfig.sol

@@ -31,7 +31,6 @@ import {JBSplitGroup} from "./JBSplitGroup.sol";
 /// its balance in each payment terminal while the ruleset is active. Amounts are fixed point numbers using the same
 /// number of decimals as the corresponding terminal. The `_payoutLimit` and `_surplusAllowance` parameters must fit in
 /// a `uint232`.
-// forge-lint: disable-next-line(pascal-case-struct)
 struct JBRulesetConfig {
     uint48 mustStartAtOrAfter;
     uint32 duration;

package/src/structs/JBRulesetMetadata.sol

@@ -33,7 +33,6 @@ pragma solidity ^0.8.0;
 /// @custom:member dataHook The data hook to use during this ruleset.
 /// @custom:member metadata Metadata of the metadata, only the 14 least significant bits can be used, the 2 most
 /// significant bits are disregarded.
-// forge-lint: disable-next-line(pascal-case-struct)
 struct JBRulesetMetadata {
     uint16 reservedPercent;
     uint16 cashOutTaxRate;

package/src/structs/JBRulesetWeightCache.sol

@@ -3,7 +3,6 @@ pragma solidity ^0.8.0;
 
 /// @custom:member weight The cached weight value.
 /// @custom:member weightCutMultiple The weight cut multiple that produces the given weight.
-// forge-lint: disable-next-line(pascal-case-struct)
 struct JBRulesetWeightCache {
     uint112 weight;
     uint168 weightCutMultiple;

package/src/structs/JBRulesetWithMetadata.sol

@@ -6,7 +6,6 @@ import {JBRulesetMetadata} from "./JBRulesetMetadata.sol";
 
 /// @custom:member ruleset The ruleset.
 /// @custom:member metadata The ruleset's metadata.
-// forge-lint: disable-next-line(pascal-case-struct)
 struct JBRulesetWithMetadata {
     JBRuleset ruleset;
     JBRulesetMetadata metadata;

package/src/structs/JBSingleAllowance.sol

@@ -7,7 +7,6 @@ pragma solidity ^0.8.0;
 /// @custom:member nonce An incrementing value indexed per owner,token,and spender for each signature.
 /// @custom:member signature The signature over the permit data. Supports EOA signatures, compact signatures defined by
 /// EIP-2098, and contract signatures defined by EIP-1271.
-// forge-lint: disable-next-line(pascal-case-struct)
 struct JBSingleAllowance {
     uint256 sigDeadline;
     uint160 amount;

package/src/structs/JBSplit.sol

@@ -30,7 +30,6 @@ import {IJBSplitHook} from "./../interfaces/IJBSplitHook.sol";
 /// preserve those splits at the governance/configuration layer.
 /// @custom:member hook A contract which will receive this split's tokens and properties, and can define custom
 /// behavior.
-// forge-lint: disable-next-line(pascal-case-struct)
 struct JBSplit {
     uint32 percent;
     uint64 projectId;

package/src/structs/JBSplitGroup.sol

@@ -6,7 +6,6 @@ import {JBSplit} from "./JBSplit.sol";
 /// @custom:member groupId An identifier for the group. By convention, this ID is `uint256(uint160(tokenAddress))` for
 /// payouts and `1` for reserved tokens.
 /// @custom:member splits The splits in the group.
-// forge-lint: disable-next-line(pascal-case-struct)
 struct JBSplitGroup {
     uint256 groupId;
     JBSplit[] splits;

package/src/structs/JBSplitHookContext.sol

@@ -10,7 +10,6 @@ import {JBSplit} from "./JBSplit.sol";
 /// @custom:member groupId The group the split belongs to. By convention, this ID is `uint256(uint160(tokenAddress))`
 /// for payouts and `1` for reserved tokens.
 /// @custom:member split The split which specified the hook.
-// forge-lint: disable-next-line(pascal-case-struct)
 struct JBSplitHookContext {
     address token;
     uint256 amount;

package/src/structs/JBTerminalConfig.sol

@@ -6,7 +6,6 @@ import {IJBTerminal} from "./../interfaces/IJBTerminal.sol";
 
 /// @custom:member terminal The terminal to configure.
 /// @custom:member accountingContextsToAccept The accounting contexts to accept from the terminal.
-// forge-lint: disable-next-line(pascal-case-struct)
 struct JBTerminalConfig {
     IJBTerminal terminal;
     JBAccountingContext[] accountingContextsToAccept;

package/src/structs/JBTokenAmount.sol

@@ -6,7 +6,6 @@ pragma solidity ^0.8.0;
 /// @custom:member currency The currency. By convention, this is `uint32(uint160(tokenAddress))` for tokens, or a
 /// constant ID from e.g. `JBCurrencyIds` for other currencies.
 /// @custom:member value The amount of tokens that was paid, as a fixed point number.
-// forge-lint: disable-next-line(pascal-case-struct)
 struct JBTokenAmount {
     address token;
     uint8 decimals;

package/test/TestCashOutHooks.sol

@@ -207,7 +207,11 @@ contract TestCashOutHooks_Local is TestBaseWorkflow {
             _DATA_HOOK,
             abi.encodeWithSelector(IJBRulesetDataHook.beforeCashOutRecordedWith.selector),
             abi.encode(
-                _ruleset.cashOutTaxRate(), _beneficiaryTokenBalance / 2, _beneficiaryTokenBalance, _specifications
+                _ruleset.cashOutTaxRate(),
+                _beneficiaryTokenBalance / 2,
+                _beneficiaryTokenBalance,
+                _nativePayAmount,
+                _specifications
             )
         );
 
@@ -322,7 +326,13 @@ contract TestCashOutHooks_Local is TestBaseWorkflow {
         vm.mockCall(
             _DATA_HOOK,
             abi.encodeWithSelector(IJBRulesetDataHook.beforeCashOutRecordedWith.selector),
-            abi.encode(_customCashOutTaxRate, _customCashOutCount, _customTotalSupply, _specifications)
+            abi.encode(
+                _customCashOutTaxRate,
+                _customCashOutCount,
+                _customTotalSupply,
+                _nativeTerminalBalance, // Same as _nativePayAmount (no payouts); avoids stack depth limit.
+                _specifications
+            )
         );
 
         _terminal.cashOutTokensOf({

package/test/TestDataHookFuzzing.sol

@@ -261,12 +261,12 @@ contract TestDataHookFuzzing_Local is TestBaseWorkflow {
         uint256 cashOutCount = tokenBalance / 2;
         _hookTotalSupply = bound(_hookTotalSupply, cashOutCount, tokenBalance * 10);
 
-        // Data hook returns: cashOutTaxRate=0, cashOutCount=half, custom totalSupply, no hook specs.
+        // Data hook returns: cashOutTaxRate=0, cashOutCount=half, custom totalSupply, local surplus, no hook specs.
         JBCashOutHookSpecification[] memory _emptyCashOutSpecs = new JBCashOutHookSpecification[](0);
         vm.mockCall(
             _DATA_HOOK,
             abi.encodeWithSelector(IJBRulesetDataHook.beforeCashOutRecordedWith.selector),
-            abi.encode(uint256(0), cashOutCount, _hookTotalSupply, _emptyCashOutSpecs)
+            abi.encode(uint256(0), cashOutCount, _hookTotalSupply, _payAmount, _emptyCashOutSpecs)
         );
 
         uint256 balanceBefore = address(this).balance;
@@ -336,7 +336,7 @@ contract TestDataHookFuzzing_Local is TestBaseWorkflow {
         vm.mockCall(
             _DATA_HOOK,
             abi.encodeWithSelector(IJBRulesetDataHook.beforeCashOutRecordedWith.selector),
-            abi.encode(uint256(0), cashOutCount, tokenBalance, _specs)
+            abi.encode(uint256(0), cashOutCount, tokenBalance, _payAmount, _specs)
         );
 
         // Mock the cash out hook call.
@@ -500,7 +500,7 @@ contract TestDataHookFuzzing_Local is TestBaseWorkflow {
         vm.mockCall(
             _DATA_HOOK,
             abi.encodeWithSelector(IJBRulesetDataHook.beforeCashOutRecordedWith.selector),
-            abi.encode(uint256(0), tokenBalance, tokenBalance, _specs)
+            abi.encode(uint256(0), tokenBalance, tokenBalance, _payAmount, _specs)
         );
 
         vm.expectRevert(

package/test/TestForwardedTokenConsumption.sol

@@ -145,7 +145,13 @@ contract TestForwardedTokenConsumption_Local is TestBaseWorkflow {
         vm.mockCall(
             _DATA_HOOK,
             abi.encodeWithSelector(IJBRulesetDataHook.beforeCashOutRecordedWith.selector),
-            abi.encode(0, cashOutCount, _controller.totalTokenSupplyWithReservedTokensOf(_projectId), specifications)
+            abi.encode(
+                0,
+                cashOutCount,
+                _controller.totalTokenSupplyWithReservedTokensOf(_projectId),
+                _PAY_AMOUNT,
+                specifications
+            )
         );
 
         vm.prank(multisig());

package/test/TestJBERC20Inheritance.sol

@@ -3,6 +3,8 @@ pragma solidity 0.8.28;
 
 import {TestBaseWorkflow} from "./helpers/TestBaseWorkflow.sol";
 import {JBERC20} from "../src/JBERC20.sol";
+import {IJBPermissions} from "../src/interfaces/IJBPermissions.sol";
+import {IJBProjects} from "../src/interfaces/IJBProjects.sol";
 import {IJBRulesetApprovalHook} from "../src/interfaces/IJBRulesetApprovalHook.sol";
 import {IJBToken} from "../src/interfaces/IJBToken.sol";
 import {JBConstants} from "../src/libraries/JBConstants.sol";
@@ -15,7 +17,7 @@ import {JBTerminalConfig} from "../src/structs/JBTerminalConfig.sol";
 
 import {ERC20Votes} from "../src/JBERC20.sol";
 
-contract JBERC20Inheritance_Local is JBERC20, TestBaseWorkflow {
+contract JBERC20Inheritance_Local is JBERC20(IJBPermissions(address(1)), IJBProjects(address(2))), TestBaseWorkflow {
     /// This test is to verify that the inheritance order of JBERC20 is correct and that it calls the
     /// `ERC20Votes._update()`
     /// forge-config: default.allow_internal_expect_revert = true

package/test/TestTokenFlow.sol

@@ -99,8 +99,8 @@ contract TestTokenFlow_Local is TestBaseWorkflow {
             });
         } else {
             // Create a new `IJBToken` and change it's owner to the `JBTokens` contract.
-            IJBToken _newToken = IJBToken(Clones.clone(address(new JBERC20())));
-            _newToken.initialize({name: "NewTestName", symbol: "NewTestSymbol", owner: address(_tokens)});
+            IJBToken _newToken = IJBToken(Clones.clone(address(new JBERC20(jbPermissions(), jbProjects()))));
+            _newToken.initialize({name: "NewTestName", symbol: "NewTestSymbol", tokens: address(_tokens)});
 
             // Mock the token can be added to the project.
             vm.mockCall(

package/test/audit/CashOutReenterPay.t.sol

@@ -260,6 +260,7 @@ contract CashOutReenterPay is TestBaseWorkflow {
                 ruleset.cashOutTaxRate(), // Use the ruleset's 50% cash out tax rate.
                 cashOutCount, // Number of tokens being cashed out.
                 totalSupply, // Total supply for the bonding curve.
+                PAY_AMOUNT, // effectiveSurplusValue — full initial funding, no payouts yet.
                 specifications // Our malicious hook specification.
             )
         );
@@ -475,6 +476,9 @@ contract CashOutReenterPay is TestBaseWorkflow {
         // Read the current total supply for the bonding curve calculation.
         uint256 totalSupply = _tokens.totalSupplyOf(_projectId);
 
+        // Read the current surplus for the bonding curve.
+        uint256 surplus = jbTerminalStore().balanceOf(address(_terminal), _projectId, JBConstants.NATIVE_TOKEN);
+
         // Mock the data hook to return no hook specifications (simple cashout).
         vm.mockCall(
             DATA_HOOK,
@@ -483,6 +487,7 @@ contract CashOutReenterPay is TestBaseWorkflow {
                 ruleset.cashOutTaxRate(), // Pass through the ruleset's tax rate.
                 cashOutCount, // Number of tokens being cashed out.
                 totalSupply, // Current total supply.
+                surplus, // effectiveSurplusValue — current terminal balance.
                 new JBCashOutHookSpecification[](0) // No hooks for this cashout.
             )
         );

package/test/audit/CodexHeldFeeRounding.t.sol

@@ -0,0 +1,159 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.6;
+
+import {TestBaseWorkflow} from "../helpers/TestBaseWorkflow.sol";
+import {IJBController} from "../../src/interfaces/IJBController.sol";
+import {IJBMultiTerminal} from "../../src/interfaces/IJBMultiTerminal.sol";
+import {IJBRulesetApprovalHook} from "../../src/interfaces/IJBRulesetApprovalHook.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 {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 CodexHeldFeeRoundingTest is TestBaseWorkflow {
+    IJBController private _controller;
+    IJBMultiTerminal private _terminal;
+
+    uint256 private _projectId;
+    address private _projectOwner;
+    address private _beneficiary;
+
+    function setUp() public override {
+        super.setUp();
+
+        _projectOwner = multisig();
+        _beneficiary = beneficiary();
+        _terminal = jbMultiTerminal();
+        _controller = jbController();
+
+        JBRulesetMetadata memory metadata = JBRulesetMetadata({
+            reservedPercent: 0,
+            cashOutTaxRate: 0,
+            baseCurrency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+            pausePay: false,
+            pauseCreditTransfers: false,
+            allowOwnerMinting: false,
+            allowSetCustomToken: false,
+            allowTerminalMigration: true,
+            allowSetTerminals: false,
+            ownerMustSendPayouts: false,
+            allowSetController: false,
+            allowAddAccountingContext: true,
+            allowAddPriceFeed: false,
+            holdFees: true,
+            useTotalSurplusForCashOuts: false,
+            useDataHookForPay: false,
+            useDataHookForCashOut: false,
+            dataHook: address(0),
+            metadata: 0
+        });
+
+        JBCurrencyAmount[] memory payoutLimits = new JBCurrencyAmount[](1);
+        payoutLimits[0] = JBCurrencyAmount({amount: 100, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))});
+
+        JBCurrencyAmount[] memory surplusAllowances = new JBCurrencyAmount[](1);
+        surplusAllowances[0] = JBCurrencyAmount({amount: 0, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))});
+
+        JBFundAccessLimitGroup[] memory fundAccessLimits = new JBFundAccessLimitGroup[](1);
+        fundAccessLimits[0] = JBFundAccessLimitGroup({
+            terminal: address(_terminal),
+            token: JBConstants.NATIVE_TOKEN,
+            payoutLimits: payoutLimits,
+            surplusAllowances: surplusAllowances
+        });
+
+        JBRulesetConfig[] memory rulesetConfigs = new JBRulesetConfig[](1);
+        rulesetConfigs[0] = JBRulesetConfig({
+            mustStartAtOrAfter: 0,
+            duration: 0,
+            weight: 0,
+            weightCutPercent: 0,
+            approvalHook: IJBRulesetApprovalHook(address(0)),
+            metadata: metadata,
+            splitGroups: new JBSplitGroup[](0),
+            fundAccessLimitGroups: fundAccessLimits
+        });
+
+        JBAccountingContext[] memory contexts = new JBAccountingContext[](1);
+        contexts[0] = JBAccountingContext({
+            token: JBConstants.NATIVE_TOKEN, decimals: 18, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
+        });
+
+        JBTerminalConfig[] memory terminalConfigs = new JBTerminalConfig[](1);
+        terminalConfigs[0] = JBTerminalConfig({terminal: _terminal, accountingContextsToAccept: contexts});
+
+        // Project 1 is the fee project.
+        _controller.launchProjectFor({
+            owner: _projectOwner,
+            projectUri: "fee-project",
+            rulesetConfigurations: rulesetConfigs,
+            terminalConfigurations: terminalConfigs,
+            memo: ""
+        });
+
+        _projectId = _controller.launchProjectFor({
+            owner: _projectOwner,
+            projectUri: "project",
+            rulesetConfigurations: rulesetConfigs,
+            terminalConfigurations: terminalConfigs,
+            memo: ""
+        });
+    }
+
+    function test_partialHeldFeeRepaymentCanEraseRemainingFee() external {
+        // Seed the project with enough balance to send a payout that holds fees.
+        _terminal.pay{value: 100}({
+            projectId: _projectId,
+            amount: 100,
+            token: JBConstants.NATIVE_TOKEN,
+            beneficiary: _beneficiary,
+            minReturnedTokens: 0,
+            memo: "",
+            metadata: new bytes(0)
+        });
+
+        _terminal.sendPayoutsOf({
+            projectId: _projectId,
+            token: JBConstants.NATIVE_TOKEN,
+            amount: 40,
+            currency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+            minTokensPaidOut: 0
+        });
+
+        // 40 gross produces a 1 wei fee and 39 wei net payout.
+        assertEq(address(_projectOwner).balance, 39);
+
+        vm.prank(_projectOwner);
+        _terminal.addToBalanceOf{value: 1}({
+            projectId: _projectId,
+            token: JBConstants.NATIVE_TOKEN,
+            amount: 1,
+            shouldReturnHeldFees: true,
+            memo: "",
+            metadata: new bytes(0)
+        });
+
+        // After repaying only 1 wei of the 39 wei payout, the fee should still be owed in full.
+        uint256 feeProjectBalanceBefore = jbTerminalStore().balanceOf(address(_terminal), 1, JBConstants.NATIVE_TOKEN);
+        assertEq(feeProjectBalanceBefore, 0);
+
+        vm.warp(block.timestamp + 2_419_200);
+        _terminal.processHeldFeesOf(_projectId, JBConstants.NATIVE_TOKEN, 10);
+
+        uint256 feeProjectBalanceAfter = jbTerminalStore().balanceOf(address(_terminal), 1, JBConstants.NATIVE_TOKEN);
+        uint256 projectBalanceAfter =
+            jbTerminalStore().balanceOf(address(_terminal), _projectId, JBConstants.NATIVE_TOKEN);
+
+        // The fee project never receives the original 1 wei fee.
+        assertEq(feeProjectBalanceAfter, 0);
+        // The payer project only gets its explicit top-up recorded.
+        assertEq(projectBalanceAfter, 61);
+        // One wei remains stranded in the terminal: actual native balance exceeds tracked balances.
+        assertEq(address(_terminal).balance, 62);
+        assertEq(address(_terminal).balance - (feeProjectBalanceAfter + projectBalanceAfter), 1);
+    }
+}

package/test/helpers/TestBaseWorkflow.sol

@@ -293,7 +293,7 @@ contract TestBaseWorkflow is JBTest, DeployPermit2 {
         _jbPermissions = new JBPermissions(_trustedForwarder);
         _jbProjects = new JBProjects(_multisig, address(0), _trustedForwarder);
         _jbDirectory = new JBDirectory(_jbPermissions, _jbProjects, _multisig);
-        _jbErc20 = new JBERC20();
+        _jbErc20 = new JBERC20(_jbPermissions, _jbProjects);
         _jbTokens = new JBTokens(_jbDirectory, _jbErc20);
         _jbRulesets = new JBRulesets(_jbDirectory);
         _jbPrices = new JBPrices(_jbDirectory, _jbPermissions, _jbProjects, _multisig, _trustedForwarder);

package/test/units/static/JBERC20/JBERC20Setup.sol

@@ -3,6 +3,8 @@ pragma solidity 0.8.28;
 
 import {Clones} from "@openzeppelin/contracts/proxy/Clones.sol";
 import {JBERC20} from "../../../../src/JBERC20.sol";
+import {IJBPermissions} from "../../../../src/interfaces/IJBPermissions.sol";
+import {IJBProjects} from "../../../../src/interfaces/IJBProjects.sol";
 import {IJBToken} from "../../../../src/interfaces/IJBToken.sol";
 import {JBTest} from "../../../helpers/JBTest.sol";
 
@@ -11,7 +13,10 @@ Contract that deploys a target contract with other mock contracts to satisfy the
 Tests relative to this contract will be dependent on mock calls/emits and stdStorage.
 */
 contract JBERC20Setup is JBTest {
-    address _owner = makeAddr("owner");
+    // Mocks
+    address _tokens = makeAddr("tokens");
+    IJBProjects _projects = IJBProjects(makeAddr("projects"));
+    IJBPermissions _permissions = IJBPermissions(makeAddr("permissions"));
 
     // Implementation (constructor sets _name = "invalid", cannot be initialized)
     IJBToken public _implementation;
@@ -20,8 +25,8 @@ contract JBERC20Setup is JBTest {
     IJBToken public _erc20;
 
     function erc20Setup() public virtual {
-        // Deploy the implementation
-        _implementation = new JBERC20();
+        // Deploy the implementation with immutable permissions and projects
+        _implementation = new JBERC20(_permissions, _projects);
 
         // Clone it — clones start with empty storage, so initialize() works
         _erc20 = IJBToken(Clones.clone(address(_implementation)));