@bananapus/core-v6 0.0.36 → 0.0.38

package/foundry.lock

@@ -1,11 +1,5 @@
 {
   "lib/forge-std": {
     "rev": "726a6ee5fc8427a0013d6f624e486c9130c0e336"
-  },
-  "lib/sphinx": {
-    "branch": {
-      "name": "v0.23.0",
-      "rev": "5fb24a825f46bd6ae0b5359fe0da1d2346126b09"
-    }
   }
-}
+}

package/foundry.toml

@@ -17,7 +17,7 @@ fail_on_revert = false
 ethereum = "${RPC_ETHEREUM_MAINNET}"
 
 [lint]
-exclude_lints = ["pascal-case-struct", "mixed-case-variable"]
+exclude_lints = ["block-timestamp", "mixed-case-variable", "pascal-case-struct"]
 [fmt]
 number_underscore = "thousands"
 multiline_func_header = "all"

package/package.json

@@ -1,11 +1,23 @@
 {
   "name": "@bananapus/core-v6",
-  "version": "0.0.36",
+  "version": "0.0.38",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Bananapus/nana-core-v6"
   },
+  "files": [
+    "CHANGELOG.md",
+    "foundry.lock",
+    "foundry.toml",
+    "references/",
+    "remappings.txt",
+    "script/helpers/",
+    "sphinx.lock",
+    "src/",
+    "test/helpers/",
+    "test/mock/"
+  ],
   "engines": {
     "node": ">=20.0.0"
   },
@@ -26,13 +38,13 @@
     "artifacts": "source ./.env && npx sphinx artifacts --org-id 'ea165b21-7cdc-4d7b-be59-ecdd4c26bee4' --project-name 'nana-core-v6'"
   },
   "dependencies": {
-    "@bananapus/permission-ids-v6": "^0.0.17",
-    "@chainlink/contracts": "^1.5.0",
-    "@openzeppelin/contracts": "^5.6.1",
-    "@prb/math": "^4.1.1",
-    "@uniswap/permit2": "github:Uniswap/permit2"
+    "@bananapus/permission-ids-v6": "0.0.22",
+    "@chainlink/contracts": "1.5.0",
+    "@openzeppelin/contracts": "5.6.1",
+    "@prb/math": "4.1.1",
+    "@uniswap/permit2": "github:Uniswap/permit2#cc56ad0f3439c502c246fc5cfcc3db92bb8b7219"
   },
   "devDependencies": {
-    "@sphinx-labs/plugins": "^0.33.3"
+    "@sphinx-labs/plugins": "0.33.3"
   }
 }

package/src/JBController.sol

@@ -419,12 +419,14 @@ contract JBController is JBPermissioned, ERC2771Context, IJBController, IJBMigra
     /// @dev Each operation within this transaction can be done in sequence separately.
     /// @dev Can only be called by the project's owner or an address with the owner's permission to `LAUNCH_RULESETS`.
     /// @param projectId The ID of the project to launch rulesets for.
+    /// @param projectUri The project's metadata URI. Pass an empty string to leave it unchanged.
     /// @param rulesetConfigurations The rulesets to queue.
     /// @param terminalConfigurations The terminals to set up.
     /// @param memo A memo to pass along to the emitted event.
     /// @return rulesetId The ID of the last successfully queued ruleset.
     function launchRulesetsFor(
         uint256 projectId,
+        string calldata projectUri,
         JBRulesetConfig[] calldata rulesetConfigurations,
         JBTerminalConfig[] calldata terminalConfigurations,
         string calldata memo
@@ -455,11 +457,25 @@ contract JBController is JBPermissioned, ERC2771Context, IJBController, IJBMigra
             alsoGrantAccessIf: sender == OMNICHAIN_RULESET_OPERATOR
         });
 
+        if (bytes(projectUri).length > 0) {
+            _requirePermissionAllowingOverrideFrom({
+                account: PROJECTS.ownerOf(projectId),
+                projectId: projectId,
+                permissionId: JBPermissionIds.SET_PROJECT_URI,
+                alsoGrantAccessIf: sender == OMNICHAIN_RULESET_OPERATOR
+            });
+        }
+
         // If the project has already had rulesets, use `queueRulesetsOf(...)` instead.
         if (RULESETS.latestRulesetIdOf(projectId) > 0) {
             revert JBController_RulesetsAlreadyLaunched(projectId);
         }
 
+        // If provided, set the project's metadata URI.
+        if (bytes(projectUri).length > 0) {
+            uriOf[projectId] = projectUri;
+        }
+
         // Set this contract as the project's controller in the directory.
         DIRECTORY.setControllerOf({projectId: projectId, controller: IERC165(this)});
 
@@ -470,7 +486,9 @@ contract JBController is JBPermissioned, ERC2771Context, IJBController, IJBMigra
         // slither-disable-next-line reentrancy-events
         rulesetId = _queueRulesets({projectId: projectId, rulesetConfigurations: rulesetConfigurations});
 
-        emit LaunchRulesets({rulesetId: rulesetId, projectId: projectId, memo: memo, caller: _msgSender()});
+        emit LaunchRulesets({
+            rulesetId: rulesetId, projectId: projectId, projectUri: projectUri, memo: memo, caller: _msgSender()
+        });
     }
 
     /// @notice Migrate a project from this controller to another one.
@@ -525,6 +543,10 @@ contract JBController is JBPermissioned, ERC2771Context, IJBController, IJBMigra
         // Cache common values used in both permission checks.
         address sender = _msgSender();
         bool senderIsTerminal = _isTerminalOf(projectId, sender);
+        bool senderIsTerminalOrDataHook = senderIsTerminal || sender == ruleset.dataHook();
+        // Only query the data hook if the sender isn't already a terminal or the data hook itself.
+        bool senderHasDataHookMintPermission =
+            !senderIsTerminalOrDataHook && _hasDataHookMintPermissionFor(projectId, ruleset, sender);
 
         // Minting is restricted to: the project's owner, addresses with permission to `MINT_TOKENS`, the project's
         // terminals, and the project's data hook.
@@ -532,15 +554,14 @@ contract JBController is JBPermissioned, ERC2771Context, IJBController, IJBMigra
             account: PROJECTS.ownerOf(projectId),
             projectId: projectId,
             permissionId: JBPermissionIds.MINT_TOKENS,
-            alsoGrantAccessIf: senderIsTerminal || sender == ruleset.dataHook()
-                || _hasDataHookMintPermissionFor(projectId, ruleset, sender)
+            alsoGrantAccessIf: senderIsTerminalOrDataHook || senderHasDataHookMintPermission
         });
 
         // If the message sender is not the project's terminal or data hook, the ruleset must have `allowOwnerMinting`
         // set to `true`.
         if (
-            ruleset.id != 0 && !ruleset.allowOwnerMinting() && !senderIsTerminal && sender != ruleset.dataHook()
-                && !_hasDataHookMintPermissionFor(projectId, ruleset, sender)
+            ruleset.id != 0 && !ruleset.allowOwnerMinting() && !senderIsTerminalOrDataHook
+                && !senderHasDataHookMintPermission
         ) {
             revert JBController_MintNotAllowedAndNotTerminalOrHook(sender);
         }

package/src/JBMultiTerminal.sol

@@ -83,6 +83,9 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
     // ------------------------ internal constants ----------------------- //
     //*********************************************************************//
 
+    /// @notice Denominator for forward-calculating this terminal's fee from a pre-fee amount.
+    uint256 internal constant _FEE_AMOUNT_FROM_DENOMINATOR = JBConstants.MAX_FEE / FEE;
+
     /// @notice Project ID #1 receives fees. It should be the first project launched during the deployment process.
     uint256 internal constant _FEE_BENEFICIARY_PROJECT_ID = 1;
 
@@ -330,15 +333,18 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
             // This payout is eligible for a fee since the funds are leaving this contract and the split hook isn't a
             // feeless address.
             if (!_isFeeless(address(split.hook))) {
-                netPayoutAmount -= JBFees.feeAmountFrom({amountBeforeFee: amount, feePercent: FEE});
+                unchecked {
+                    netPayoutAmount -= _feeAmountFrom(amount);
+                }
             }
 
             // Create the context to send to the split hook.
             JBSplitHookContext memory context = JBSplitHookContext({
                 token: token,
                 amount: netPayoutAmount,
-                decimals: STORE.accountingContextOf({terminal: address(this), projectId: projectId, token: token})
-                .decimals,
+                decimals: STORE.accountingContextOf({
+                    terminal: address(this), projectId: projectId, token: token
+                }).decimals,
                 projectId: projectId,
                 groupId: uint256(uint160(token)),
                 split: split
@@ -370,7 +376,9 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
             // This payout is eligible for a fee if the funds are leaving this contract and the receiving terminal isn't
             // a feeless address.
             if (terminal != this && !_isFeeless(address(terminal))) {
-                netPayoutAmount -= JBFees.feeAmountFrom({amountBeforeFee: amount, feePercent: FEE});
+                unchecked {
+                    netPayoutAmount -= _feeAmountFrom(amount);
+                }
             }
 
             // Track the fee-free payout amount. During cashout at zero tax rate, fees apply
@@ -430,7 +438,9 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
             // This payout is eligible for a fee since the funds are leaving this contract and the recipient isn't a
             // feeless address.
             if (!_isFeeless(recipient)) {
-                netPayoutAmount -= JBFees.feeAmountFrom({amountBeforeFee: amount, feePercent: FEE});
+                unchecked {
+                    netPayoutAmount -= _feeAmountFrom(amount);
+                }
             }
 
             // If there's a beneficiary, send the funds directly to the beneficiary. Otherwise send to the
@@ -664,7 +674,7 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
             _processFee({
                 projectId: projectId,
                 token: token,
-                amount: JBFees.feeAmountFrom({amountBeforeFee: heldFee.amount, feePercent: FEE}),
+                amount: _feeAmountFrom(heldFee.amount),
                 beneficiary: heldFee.beneficiary,
                 feeTerminal: feeTerminal,
                 wasHeld: true
@@ -1150,20 +1160,24 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
         // Cache whether the beneficiary is feeless.
         bool beneficiaryIsFeeless = _isFeeless(beneficiary);
 
-        // Record the cash out.
-        (ruleset, reclaimAmount, cashOutTaxRate, hookSpecifications) = STORE.recordCashOutFor({
-            holder: holder,
-            projectId: projectId,
-            cashOutCount: cashOutCount,
-            tokenToReclaim: tokenToReclaim,
-            beneficiaryIsFeeless: beneficiaryIsFeeless,
-            metadata: metadata
-        });
+        {
+            // Cache the controller to avoid a redundant external call (also used inside STORE.recordCashOutFor).
+            IJBController controller = _controllerOf(projectId);
+
+            // Record the cash out.
+            (ruleset, reclaimAmount, cashOutTaxRate, hookSpecifications) = STORE.recordCashOutFor({
+                holder: holder,
+                projectId: projectId,
+                cashOutCount: cashOutCount,
+                tokenToReclaim: tokenToReclaim,
+                beneficiaryIsFeeless: beneficiaryIsFeeless,
+                metadata: metadata
+            });
 
-        // Burn the project tokens.
-        if (cashOutCount != 0) {
-            _controllerOf(projectId)
-                .burnTokensOf({holder: holder, projectId: projectId, tokenCount: cashOutCount, memo: ""});
+            // Burn the project tokens.
+            if (cashOutCount != 0) {
+                controller.burnTokensOf({holder: holder, projectId: projectId, tokenCount: cashOutCount, memo: ""});
+            }
         }
 
         // Keep a reference to the amount being reclaimed that is subject to fees.
@@ -1176,16 +1190,22 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
                 if (cashOutTaxRate != 0) {
                     // Non-zero tax: fees apply to the full reclaim amount.
                     amountEligibleForFees += reclaimAmount;
-                    reclaimAmount -= JBFees.feeAmountFrom({amountBeforeFee: reclaimAmount, feePercent: FEE});
+                    unchecked {
+                        reclaimAmount -= _feeAmountFrom(reclaimAmount);
+                    }
                 } else {
                     // Zero tax: fees apply only up to the fee-free surplus (round-trip prevention).
                     uint256 feeFreeSurplus = _feeFreeSurplusOf[projectId][tokenToReclaim];
                     if (feeFreeSurplus != 0) {
                         uint256 feeableAmount = reclaimAmount < feeFreeSurplus ? reclaimAmount : feeFreeSurplus;
                         // slither-disable-next-line reentrancy-no-eth,reentrancy-eth,reentrancy-benign
-                        _feeFreeSurplusOf[projectId][tokenToReclaim] = feeFreeSurplus - feeableAmount;
+                        unchecked {
+                            _feeFreeSurplusOf[projectId][tokenToReclaim] = feeFreeSurplus - feeableAmount;
+                        }
                         amountEligibleForFees += feeableAmount;
-                        reclaimAmount -= JBFees.feeAmountFrom({amountBeforeFee: feeableAmount, feePercent: FEE});
+                        unchecked {
+                            reclaimAmount -= _feeAmountFrom(feeableAmount);
+                        }
                     }
                 }
             }
@@ -1433,9 +1453,8 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
             }
 
             // Get the fee for the specified amount.
-            uint256 specificationAmountFee = _isFeeless(address(specification.hook))
-                ? 0
-                : JBFees.feeAmountFrom({amountBeforeFee: specification.amount, feePercent: FEE});
+            uint256 specificationAmountFee =
+                _isFeeless(address(specification.hook)) ? 0 : _feeAmountFrom(specification.amount);
 
             // Add the specification's amount to the amount eligible for fees.
             if (specificationAmountFee != 0) {
@@ -1611,12 +1630,12 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
             // slither-disable-next-line reentrancy-events
             newlyIssuedTokenCount = _controllerOf(projectId)
                 .mintTokensOf({
-                    projectId: projectId,
-                    tokenCount: tokenCount,
-                    beneficiary: beneficiary,
-                    memo: "",
-                    useReservedPercent: true
-                });
+                projectId: projectId,
+                tokenCount: tokenCount,
+                beneficiary: beneficiary,
+                memo: "",
+                useReservedPercent: true
+            });
         }
 
         emit Pay({
@@ -1706,8 +1725,8 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
     }
 
     /// @notice Returns held fees to the project who paid them based on the specified amount.
-    /// @dev Fee rounding during partial replenishment can zero out dust-level fee entries (< 40 wei at 2.5% fee).
-    /// This is accepted behavior — dust fees are economically insignificant.
+    /// @dev Partial replenishments use the raw floor calculation so repaying a dust amount cannot both credit the
+    /// payer project and leave the fee project owed the 1-unit minimum fee.
     /// @param projectId The project held fees are being returned to.
     /// @param token The token that the held fees are in.
     /// @param amount The amount to base the calculation on, as a fixed point number with the same number of decimals
@@ -1743,7 +1762,7 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
                 break;
             } else {
                 // Notice here we take `feeAmountFrom` on the stored `.amount`.
-                uint256 feeAmount = JBFees.feeAmountFrom({amountBeforeFee: heldFee.amount, feePercent: FEE});
+                uint256 feeAmount = _feeAmountFrom(heldFee.amount);
 
                 // Keep a reference to the amount from which the fee was taken.
                 uint256 amountPaidOut = heldFee.amount - feeAmount;
@@ -1757,8 +1776,9 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
                     // Move the start index forward to the held fee after the current one.
                     newStartIndex = startIndex + i + 1;
                 } else {
-                    // And here we overwrite with `feeAmountResultingIn` the `leftoverAmount`
-                    feeAmount = JBFees.feeAmountResultingIn({amountAfterFee: leftoverAmount, feePercent: FEE});
+                    // Use the floor variant here. The minimum 1-unit fee applies when a fee is created, not while
+                    // splitting an already-held fee entry across repayments.
+                    feeAmount = JBFees.feeAmountResultingInFloorForFee25(leftoverAmount);
 
                     // Get fee from `leftoverAmount`.
                     unchecked {
@@ -1813,10 +1833,6 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
         (ruleset, amountPaidOut) =
             STORE.recordPayoutFor({projectId: projectId, token: token, amount: amount, currency: currency});
 
-        // Cap fee-free surplus at remaining balance. Non-fee-free funds leave first.
-        // slither-disable-next-line reentrancy-no-eth,reentrancy-eth,reentrancy-benign
-        _capFeeFreeSurplus({projectId: projectId, token: token});
-
         // Get a reference to the project's owner.
         // The owner will receive tokens minted by paying the platform fee and receive any leftover funds not sent to
         // payout splits.
@@ -1845,17 +1861,20 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
         // Send any leftover funds to the project owner and update the fee tracking accordingly.
         if (leftoverPayoutAmount != 0) {
             // Keep a reference to the fee for the leftover payout amount.
-            uint256 fee = _isFeeless(projectOwner)
-                ? 0
-                : JBFees.feeAmountFrom({amountBeforeFee: leftoverPayoutAmount, feePercent: FEE});
+            uint256 fee = _isFeeless(projectOwner) ? 0 : _feeAmountFrom(leftoverPayoutAmount);
+
+            uint256 netLeftoverPayoutAmount;
+            unchecked {
+                netLeftoverPayoutAmount = leftoverPayoutAmount - fee;
+            }
 
             // Failed owner transfer consumes the payout limit by design. Same pattern as split payouts:
             // the try-catch prevents revert, failed amount is returned to project balance, and the owner can retry
             // via addToBalanceOf or in the next cycle.
-            try this.executeTransferTo({addr: projectOwner, token: token, amount: leftoverPayoutAmount - fee}) {
+            try this.executeTransferTo({addr: projectOwner, token: token, amount: netLeftoverPayoutAmount}) {
                 if (fee > 0) {
                     amountEligibleForFees += leftoverPayoutAmount;
-                    leftoverPayoutAmount -= fee;
+                    leftoverPayoutAmount = netLeftoverPayoutAmount;
                 }
             } catch (bytes memory reason) {
                 // slither-disable-next-line reentrancy-events
@@ -1863,7 +1882,7 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
                     projectId: projectId,
                     addr: projectOwner,
                     token: token,
-                    amount: leftoverPayoutAmount - fee,
+                    amount: netLeftoverPayoutAmount,
                     fee: fee,
                     reason: reason,
                     caller: sender
@@ -1874,6 +1893,11 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
             }
         }
 
+        // Cap fee-free surplus at remaining balance. Non-fee-free funds leave first.
+        // Placed after all payouts settle so the cap reflects post-payout state.
+        // slither-disable-next-line reentrancy-no-eth,reentrancy-eth,reentrancy-benign
+        _capFeeFreeSurplus({projectId: projectId, token: token});
+
         // Take the fee.
         uint256 feeTaken = _takeFeeFrom({
             projectId: projectId,
@@ -1914,7 +1938,7 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
         returns (uint256 feeAmount)
     {
         // Get a reference to the fee amount.
-        feeAmount = JBFees.feeAmountFrom({amountBeforeFee: amount, feePercent: FEE});
+        feeAmount = _feeAmountFrom(amount);
 
         if (shouldHoldFees) {
             // Store the held fee.
@@ -2166,4 +2190,18 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
         tokenAmount =
             JBTokenAmount({token: token, decimals: context.decimals, currency: context.currency, value: value});
     }
+
+    //*********************************************************************//
+    // -------------------------- private helpers ------------------------ //
+    //*********************************************************************//
+
+    /// @notice The terminal fee charged from a pre-fee `amount`.
+    /// @dev Returns at least 1 for nonzero feeable amounts so dust payouts cannot bypass protocol fees.
+    /// @param amount The amount before the fee is applied.
+    /// @return feeAmount The fee amount.
+    function _feeAmountFrom(uint256 amount) private pure returns (uint256 feeAmount) {
+        feeAmount = amount / _FEE_AMOUNT_FROM_DENOMINATOR;
+
+        return feeAmount == 0 && amount != 0 ? 1 : feeAmount;
+    }
 }

package/src/JBTerminalStore.sol

@@ -411,8 +411,8 @@ contract JBTerminalStore is IJBTerminalStore {
         // Validate BEFORE writing to storage to avoid wasting gas on SSTORE when the tx will revert.
         uint256 payoutLimit = IJBController(address(DIRECTORY.controllerOf(projectId))).FUND_ACCESS_LIMITS()
             .payoutLimitOf({
-                projectId: projectId, rulesetId: ruleset.id, terminal: msg.sender, token: token, currency: currency
-            });
+            projectId: projectId, rulesetId: ruleset.id, terminal: msg.sender, token: token, currency: currency
+        });
 
         // Make sure the new used amount is within the payout limit.
         if (newUsedPayoutLimitOf > payoutLimit || payoutLimit == 0) {
@@ -513,8 +513,8 @@ contract JBTerminalStore is IJBTerminalStore {
         // Validate BEFORE writing to storage to avoid wasting gas on SSTORE when the tx will revert.
         uint256 surplusAllowance = IJBController(address(DIRECTORY.controllerOf(projectId))).FUND_ACCESS_LIMITS()
             .surplusAllowanceOf({
-                projectId: projectId, rulesetId: ruleset.id, terminal: msg.sender, token: token, currency: currency
-            });
+            projectId: projectId, rulesetId: ruleset.id, terminal: msg.sender, token: token, currency: currency
+        });
 
         // Make sure the new used amount is within the allowance.
         if (newUsedSurplusAllowanceOf > surplusAllowance || surplusAllowance == 0) {
@@ -1332,8 +1332,8 @@ contract JBTerminalStore is IJBTerminalStore {
         JBCurrencyAmount[] memory payoutLimits = IJBController(address(DIRECTORY.controllerOf(projectId)))
             .FUND_ACCESS_LIMITS()
             .payoutLimitsOf({
-                projectId: projectId, rulesetId: ruleset.id, terminal: address(terminal), token: accountingContext.token
-            });
+            projectId: projectId, rulesetId: ruleset.id, terminal: address(terminal), token: accountingContext.token
+        });
 
         // Keep a reference to the number of payout limits being iterated on.
         uint256 numberOfPayoutLimits = payoutLimits.length;

package/src/interfaces/IJBController.sol

@@ -57,9 +57,10 @@ interface IJBController is IERC165, IJBProjectUriRegistry, IJBDirectoryAccessCon
     /// @notice Rulesets were launched for an existing project.
     /// @param rulesetId The ID of the first queued ruleset.
     /// @param projectId The ID of the project.
+    /// @param projectUri The metadata URI of the project.
     /// @param memo A memo associated with the launch.
     /// @param caller The address that called the launch function.
-    event LaunchRulesets(uint256 rulesetId, uint256 projectId, string memo, address caller);
+    event LaunchRulesets(uint256 rulesetId, uint256 projectId, string projectUri, string memo, address caller);
 
     /// @notice Tokens were minted for a beneficiary.
     /// @param beneficiary The address that received the minted tokens.
@@ -313,12 +314,14 @@ interface IJBController is IERC165, IJBProjectUriRegistry, IJBDirectoryAccessCon
 
     /// @notice Queues a project's initial rulesets and sets up terminals for it.
     /// @param projectId The ID of the project to launch rulesets for.
+    /// @param projectUri The project's metadata URI. Pass an empty string to leave it unchanged.
     /// @param rulesetConfigurations The rulesets to queue.
     /// @param terminalConfigurations The terminals to set up.
     /// @param memo A memo to pass along to the emitted event.
     /// @return rulesetId The ID of the last successfully queued ruleset.
     function launchRulesetsFor(
         uint256 projectId,
+        string calldata projectUri,
         JBRulesetConfig[] calldata rulesetConfigurations,
         JBTerminalConfig[] calldata terminalConfigurations,
         string calldata memo

package/src/libraries/JBFees.sol

@@ -7,24 +7,62 @@ import {JBConstants} from "./../libraries/JBConstants.sol";
 
 /// @notice Fee calculations.
 library JBFees {
+    /// @notice Returns the fee that would be taken from `amountBeforeFee`.
+    /// @dev Use this to forward-calculate the fee from a known pre-fee amount.
+    /// @dev If a nonzero amount and nonzero fee would otherwise produce a zero fee, returns 1 so feeable dust payouts
+    /// cannot bypass protocol fees by splitting across tiny transfers.
+    /// @param amountBeforeFee The amount before the fee is applied, as a fixed point number.
+    /// @param feePercent The fee percent, out of `JBConstants.MAX_FEE`.
+    /// @return The fee amount, as a fixed point number with the same number of decimals as the provided `amount`.
+    function feeAmountFrom(uint256 amountBeforeFee, uint256 feePercent) internal pure returns (uint256) {
+        uint256 feeAmount = feeAmountFromFloor({amountBeforeFee: amountBeforeFee, feePercent: feePercent});
+
+        return feeAmount == 0 && amountBeforeFee != 0 && feePercent != 0 ? 1 : feeAmount;
+    }
+
+    /// @notice Returns the floor-rounded fee that would be taken from `amountBeforeFee`.
+    /// @dev Fee rounding error is bounded by N-1 wei (N = number of splits). Economically insignificant. Rounds down
+    /// (mulDiv floors), so the fee beneficiary may receive up to 1 wei less per split.
+    /// @param amountBeforeFee The amount before the fee is applied, as a fixed point number.
+    /// @param feePercent The fee percent, out of `JBConstants.MAX_FEE`.
+    /// @return The floor-rounded fee amount, as a fixed point number with the same number of decimals as the provided
+    /// `amount`.
+    function feeAmountFromFloor(uint256 amountBeforeFee, uint256 feePercent) internal pure returns (uint256) {
+        return mulDiv(amountBeforeFee, feePercent, JBConstants.MAX_FEE);
+    }
+
     /// @notice Returns the fee amount that, when added to `amountAfterFee`, produces the gross amount needed to yield
     /// `amountAfterFee` after the fee is deducted.
     /// @dev Use this to back-calculate the fee from a desired post-fee payout.
+    /// @dev If a nonzero amount and nonzero fee would otherwise produce a zero fee, returns 1 so feeable dust payouts
+    /// cannot bypass protocol fees by splitting across tiny transfers.
     /// @param amountAfterFee The desired post-fee amount, as a fixed point number.
     /// @param feePercent The fee percent, out of `JBConstants.MAX_FEE`.
     /// @return The fee amount, as a fixed point number with the same number of decimals as the provided `amount`.
     function feeAmountResultingIn(uint256 amountAfterFee, uint256 feePercent) internal pure returns (uint256) {
-        return mulDiv(amountAfterFee, JBConstants.MAX_FEE, JBConstants.MAX_FEE - feePercent) - amountAfterFee;
+        uint256 feeAmount = feeAmountResultingInFloor({amountAfterFee: amountAfterFee, feePercent: feePercent});
+
+        return feeAmount == 0 && amountAfterFee != 0 && feePercent != 0 ? 1 : feeAmount;
     }
 
-    /// @notice Returns the fee that would be taken from `amountBeforeFee`.
-    /// @dev Use this to forward-calculate the fee from a known pre-fee amount.
-    /// @dev Fee rounding error is bounded by N-1 wei (N = number of splits). Economically
-    /// insignificant. Rounds down (mulDiv floors), so the fee beneficiary may receive up to 1 wei less per split.
-    /// @param amountBeforeFee The amount before the fee is applied, as a fixed point number.
+    /// @notice Returns the floor-rounded fee amount that, when added to `amountAfterFee`, produces the gross amount
+    /// needed to yield `amountAfterFee` after the fee is deducted.
+    /// @dev Use this when adjusting an existing held-fee entry, where applying the 1-unit minimum again would double
+    /// charge dust.
+    /// @param amountAfterFee The desired post-fee amount, as a fixed point number.
     /// @param feePercent The fee percent, out of `JBConstants.MAX_FEE`.
-    /// @return The fee amount, as a fixed point number with the same number of decimals as the provided `amount`.
-    function feeAmountFrom(uint256 amountBeforeFee, uint256 feePercent) internal pure returns (uint256) {
-        return mulDiv(amountBeforeFee, feePercent, JBConstants.MAX_FEE);
+    /// @return The floor-rounded fee amount, as a fixed point number with the same number of decimals as the provided
+    /// `amount`.
+    function feeAmountResultingInFloor(uint256 amountAfterFee, uint256 feePercent) internal pure returns (uint256) {
+        return mulDiv(amountAfterFee, JBConstants.MAX_FEE, JBConstants.MAX_FEE - feePercent) - amountAfterFee;
+    }
+
+    /// @notice Returns the floor-rounded fee amount resulting in `amountAfterFee` for a 2.5% fee.
+    /// @dev Equivalent to `feeAmountResultingInFloor(amountAfterFee, 25)`, but avoids the generic `mulDiv` path.
+    /// @param amountAfterFee The desired post-fee amount, as a fixed point number.
+    /// @return The floor-rounded fee amount.
+    function feeAmountResultingInFloorForFee25(uint256 amountAfterFee) internal pure returns (uint256) {
+        // The specialized denominator is `(JBConstants.MAX_FEE - 25) / 25`.
+        return amountAfterFee / 39;
     }
 }

package/src/libraries/JBPayoutSplitGroupLib.sol

@@ -140,8 +140,8 @@ library JBPayoutSplitGroupLib {
         // slither-disable-next-line reentrancy-events,calls-loop
         try IJBPayoutSplitGroupExecutor(address(this))
             .executePayout({
-                split: split, projectId: projectId, token: token, amount: amount, originalMessageSender: caller
-            }) returns (
+            split: split, projectId: projectId, token: token, amount: amount, originalMessageSender: caller
+        }) returns (
             uint256 payoutAmount
         ) {
             return payoutAmount;

package/src/periphery/JBMatchingPriceFeed.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 pragma solidity 0.8.28;
 
-import {IJBPriceFeed} from "src/interfaces/IJBPriceFeed.sol";
+import {IJBPriceFeed} from "../interfaces/IJBPriceFeed.sol";
 
 contract JBMatchingPriceFeed is IJBPriceFeed {
     constructor() {}

package/test/mock/MockMaliciousBeneficiary.sol

@@ -19,12 +19,12 @@ contract MaliciousPayoutBeneficiary is IERC721Receiver, Test {
 
         IJBMultiTerminal(_terminal)
             .sendPayoutsOf({
-                projectId: 2,
-                amount: 5 * 10 ** 18,
-                currency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
-                token: JBConstants.NATIVE_TOKEN,
-                minTokensPaidOut: 0
-            });
+            projectId: 2,
+            amount: 5 * 10 ** 18,
+            currency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+            token: JBConstants.NATIVE_TOKEN,
+            minTokensPaidOut: 0
+        });
     }
 
     receive() external payable {
@@ -46,15 +46,15 @@ contract MaliciousAllowanceBeneficiary is IERC721Receiver, Test {
 
         IJBMultiTerminal(_terminal)
             .useAllowanceOf({
-                projectId: 2,
-                amount: 5 * 10 ** 18,
-                currency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
-                token: JBConstants.NATIVE_TOKEN,
-                minTokensPaidOut: 0,
-                beneficiary: payable(address(this)),
-                feeBeneficiary: payable(0x000000000000000000000000000000000000007B),
-                memo: "MEMO"
-            });
+            projectId: 2,
+            amount: 5 * 10 ** 18,
+            currency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+            token: JBConstants.NATIVE_TOKEN,
+            minTokensPaidOut: 0,
+            beneficiary: payable(address(this)),
+            feeBeneficiary: payable(0x000000000000000000000000000000000000007B),
+            memo: "MEMO"
+        });
     }
 
     receive() external payable {