@bananapus/core-v6 0.0.40 → 0.0.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bananapus/core-v6",
-  "version": "0.0.40",
+  "version": "0.0.42",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/JBController.sol

@@ -1238,7 +1238,7 @@ contract JBController is JBPermissioned, ERC2771Context, IJBController, IJBMigra
 
     /// @notice Splits a token count into beneficiary and reserved portions.
     /// @param tokenCount The total token count, including reserved tokens.
-    /// @param reservedPercent The reserved percent to apply.
+    /// @param reservedPercent The reserved percent to apply, out of `JBConstants.MAX_RESERVED_PERCENT`.
     /// @return beneficiaryTokenCount The number of tokens for the beneficiary.
     /// @return reservedTokenCount The number of tokens to reserve.
     function _splitTokenCount(

package/src/JBFundAccessLimits.sol

@@ -159,7 +159,7 @@ contract JBFundAccessLimits is JBControlled, IJBFundAccessLimits {
 
     /// @notice Look up how much a project can distribute (via `sendPayoutsOf`) from a specific terminal and token,
     /// denominated in a specific currency. Returns 0 if no limit is configured for that currency.
-    /// @dev The fixed point return amount uses the same number of decimals as the terminal.
+    /// @dev The fixed point return amount uses the same number of decimals as the token's accounting context.
     /// @param projectId The project's ID.
     /// @param rulesetId The ruleset's ID.
     /// @param terminal The terminal the payout limit applies to.
@@ -203,7 +203,7 @@ contract JBFundAccessLimits is JBControlled, IJBFundAccessLimits {
 
     /// @notice Get all payout limits for a project's terminal and token during a ruleset. A project can have multiple
     /// payout limits denominated in different currencies (e.g. 10,000 USD + 5 ETH). Each is enforced independently.
-    /// @dev The fixed point `amount`s returned use the same number of decimals as the terminal.
+    /// @dev The fixed point `amount`s returned use the same number of decimals as the token's accounting context.
     /// @param projectId The project's ID.
     /// @param rulesetId The ruleset's ID.
     /// @param terminal The terminal the payout limits apply to.
@@ -250,7 +250,7 @@ contract JBFundAccessLimits is JBControlled, IJBFundAccessLimits {
 
     /// @notice Look up how much a project's owner can withdraw from the surplus (via `useAllowanceOf`) from a specific
     /// terminal and token, denominated in a specific currency. Returns 0 if no allowance is configured.
-    /// @dev The fixed point return amount uses the same number of decimals as the terminal.
+    /// @dev The fixed point return amount uses the same number of decimals as the token's accounting context.
     /// @param projectId The project's ID.
     /// @param rulesetId The ruleset's ID.
     /// @param terminal The terminal the surplus allowance applies to.
@@ -295,7 +295,7 @@ contract JBFundAccessLimits is JBControlled, IJBFundAccessLimits {
 
     /// @notice Get all surplus allowances for a project's terminal and token during a ruleset. Like payout limits, a
     /// project can have multiple surplus allowances in different currencies, each enforced independently.
-    /// @dev The fixed point `amount`s returned use the same number of decimals as the terminal.
+    /// @dev The fixed point `amount`s returned use the same number of decimals as the token's accounting context.
     /// @param projectId The project's ID.
     /// @param rulesetId The ruleset's ID.
     /// @param terminal The terminal the surplus allowances apply to.

package/src/JBMultiTerminal.sol

@@ -88,9 +88,6 @@ 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;
 
@@ -229,7 +226,8 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
     /// @dev If `shouldReturnHeldFees` is true, the added amount offsets held fees proportionally.
     /// @param projectId The ID of the project to add funds to the balance of.
     /// @param amount The amount of tokens to add to the balance, as a fixed point number with the same number of
-    /// decimals as this terminal. If this is a native token terminal, this is ignored and `msg.value` is used instead.
+    /// decimals as the token's accounting context. If this is a native token terminal, this is ignored and `msg.value`
+    /// is used instead.
     /// @param token The token to add to the balance.
     /// @param shouldReturnHeldFees If true, return held fees proportional to the amount added.
     /// @param memo A memo to pass along to the emitted event.
@@ -266,8 +264,8 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
     /// decimals.
     /// @param tokenToReclaim The token to reclaim.
     /// @param minTokensReclaimed The minimum number of terminal tokens expected in return, as a fixed point number with
-    /// the same number of decimals as this terminal. If the amount of tokens minted for the beneficiary would be less
-    /// than this amount, the cash out is reverted.
+    /// the same number of decimals as the token's accounting context. If the amount of tokens minted for the
+    /// beneficiary would be less than this amount, the cash out is reverted.
     /// @param beneficiary The address to send the cashed out terminal tokens to, and to pass along to the ruleset's
     /// data hook and cash out hook if applicable.
     /// @param metadata Bytes to send along to the emitted event, as well as the data hook and cash out hook if
@@ -310,7 +308,7 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
     /// @param projectId The ID of the project the split belongs to.
     /// @param token The address of the token to pay to the split.
     /// @param amount The total amount to pay to the split, as a fixed point number with the same number of
-    /// decimals as this terminal.
+    /// decimals as the token's accounting context.
     /// @return netPayoutAmount The amount sent to the split after subtracting fees.
     function executePayout(
         JBSplit calldata split,
@@ -572,14 +570,14 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
     /// beneficiary will receive.
     /// @param projectId The ID of the project to pay.
     /// @param amount The amount of tokens to send, as a fixed point number with the same number of
-    /// decimals as this terminal. If this terminal's token is native, this is ignored and `msg.value` is used in its
-    /// place.
+    /// decimals as the token's accounting context. If this terminal's token is native, this is ignored and `msg.value`
+    /// is used in its place.
     /// @param token The token to pay with.
     /// @param beneficiary The address to mint tokens to, and pass along to the ruleset's data hook and pay hook if
     /// applicable.
     /// @param minReturnedTokens The minimum number of project tokens expected in return for this payment, as a fixed
-    /// point number with the same number of decimals as this terminal. If the amount of tokens minted for the
-    /// beneficiary would be less than this amount, the payment is reverted.
+    /// point number with the same number of decimals as the token's accounting context. If the amount of tokens minted
+    /// for the beneficiary would be less than this amount, the payment is reverted.
     /// @param memo A memo to pass along to the emitted event.
     /// @param metadata Bytes to pass along to the emitted event, as well as the data hook and pay hook if applicable.
     /// @return beneficiaryTokenCount The number of tokens minted to the beneficiary, as a fixed point number with 18
@@ -703,13 +701,14 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
     /// exempt.
     /// @param projectId The ID of the project having its payouts sent.
     /// @param token The token to send.
-    /// @param amount The total number of terminal tokens to send, as a fixed point number with same number of decimals
-    /// as this terminal.
+    /// @param amount The total number of terminal tokens to send, as a fixed point number with the same number of
+    /// decimals as the token's accounting context.
     /// @param currency The expected currency of the payouts. Must match the currency of one of the
     /// project's current ruleset's payout limits.
     /// @param minTokensPaidOut The minimum number of terminal tokens that the `amount` should be worth (if expressed
-    /// in terms of this terminal's currency), as a fixed point number with the same number of decimals as this
-    /// terminal. If the amount of tokens paid out would be less than this amount, the send is reverted.
+    /// in terms of the token's accounting context currency), as a fixed point number with the same number of decimals
+    /// as the token's accounting context. If the amount of tokens paid out would be less than this amount, the send is
+    /// reverted.
     /// @return amountPaidOut The total amount paid out.
     function sendPayoutsOf(
         uint256 projectId,
@@ -735,7 +734,7 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
     /// @param projectId The ID of the project to use the surplus allowance of.
     /// @param token The token to pay out from the surplus.
     /// @param amount The amount of terminal tokens to use from the project's current surplus allowance, as a fixed
-    /// point number with the same amount of decimals as this terminal.
+    /// point number with the same number of decimals as the token's accounting context.
     /// @param currency The expected currency of the amount to pay out. Must match the currency of one of the
     /// project's current ruleset's surplus allowances.
     /// @param minTokensPaidOut The minimum number of terminal tokens that should be returned from the surplus allowance
@@ -745,7 +744,7 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
     /// @param feeBeneficiary The address to send the tokens resulting from paying the fee.
     /// @param memo A memo to pass along to the emitted event.
     /// @return netAmountPaidOut The number of tokens that were sent to the beneficiary, as a fixed point number with
-    /// the same amount of decimals as the terminal.
+    /// the same number of decimals as the token's accounting context.
     function useAllowanceOf(
         uint256 projectId,
         address token,
@@ -1408,8 +1407,9 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
     /// @param cashOutCount The number of tokens to cash out.
     /// @param metadata Bytes to send along to the emitted event and cash out hooks as applicable.
     /// @param ruleset The ruleset active during this cash out as a `JBRuleset` struct.
-    /// @param cashOutTaxRate The cash out tax rate influencing the reclaim amount.
-    /// @param beneficiary The address which will receive any terminal tokens that are cashed out.
+    /// @param cashOutTaxRate The cash out tax rate influencing the reclaim amount, out of
+    /// `JBConstants.MAX_CASH_OUT_TAX_RATE`. @param beneficiary The address which will receive any terminal tokens that
+    /// are cashed out.
     /// @param specifications The hook specifications to fulfill.
     /// @return amountEligibleForFees The amount of funds which were allocated to cash out hooks and are eligible for
     /// fees.
@@ -1593,8 +1593,8 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
     /// @param projectId The ID of the project to pay.
     /// @param token The address of the token to pay the project with.
     /// @param amount The amount of tokens to send, as a fixed point number with the same number of
-    /// decimals as this terminal. If this terminal's token is the native token, `amount` is ignored and `msg.value` is
-    /// used in its place.
+    /// decimals as the token's accounting context. If this terminal's token is the native token, `amount` is ignored
+    /// and `msg.value` is used in its place.
     /// @param payer The address making the payment.
     /// @param beneficiary The address to mint tokens to, and pass along to the ruleset's data hook and pay hook if
     /// applicable.
@@ -1733,9 +1733,9 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
     /// @param projectId The project to return held fees 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
-    /// as this terminal.
+    /// as the token's accounting context.
     /// @return returnedFees The amount of held fees that were returned, as a fixed point number with the same number of
-    /// decimals as this terminal
+    /// decimals as the token's accounting context.
     function _returnHeldFees(uint256 projectId, address token, uint256 amount) internal returns (uint256 returnedFees) {
         // Keep a reference to the start index.
         uint256 startIndex = _nextHeldFeeIndexOf[projectId][token];
@@ -1779,9 +1779,7 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
                     // Move the start index forward to the held fee after the current one.
                     newStartIndex = startIndex + i + 1;
                 } else {
-                    // 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);
+                    feeAmount = JBFees.feeAmountResultingIn({amountAfterFee: leftoverAmount, feePercent: FEE});
 
                     // Get fee from `leftoverAmount`.
                     unchecked {
@@ -1812,8 +1810,8 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
     /// @notice Sends payouts to a project's payout split group using the specified ruleset.
     /// @param projectId The ID of the project to send the payouts of.
     /// @param token The token to pay out.
-    /// @param amount The number of terminal tokens to pay out, as a fixed point number with same number of decimals as
-    /// this terminal.
+    /// @param amount The number of terminal tokens to pay out, as a fixed point number with the same number of decimals
+    /// as the token's accounting context.
     /// @param currency The expected currency of the amount to pay out. Must match the currency of one of the
     /// project's current ruleset's payout limits.
     /// @return amountPaidOut The total amount that was paid out.
@@ -2013,7 +2011,7 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
     /// @param owner The project's owner.
     /// @param token The token to pay out from the surplus.
     /// @param amount The amount of terminal tokens to use from the project's current surplus allowance, as a fixed
-    /// point number with the same amount of decimals as this terminal.
+    /// point number with the same number of decimals as the token's accounting context.
     /// @param currency The expected currency of the amount to pay out. Must match the currency of one of the
     /// project's current ruleset's surplus allowances.
     /// @param beneficiary The address to send the funds to.
@@ -2199,12 +2197,9 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
     //*********************************************************************//
 
     /// @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;
+    /// @return The fee amount.
+    function _feeAmountFrom(uint256 amount) private pure returns (uint256) {
+        return JBFees.feeAmountFrom({amountBeforeFee: amount, feePercent: FEE});
     }
 }

package/src/JBRulesets.sol

@@ -96,8 +96,9 @@ contract JBRulesets is JBControlled, IJBRulesets {
     /// replaced). When a duration ends without a queued replacement, the ruleset rolls over with decayed weight.
     /// @param weight Tokens minted per unit paid (18 decimals). Terminals divide payment amount by weight to determine
     /// issuance. A value of 1 means "inherit decayed weight from previous ruleset".
-    /// @param weightCutPercent How much to reduce weight each auto-cycle (out of 1,000,000,000). Only applies when no
-    /// explicit replacement is queued. 0 = no decay. 100,000,000 = 10% cut per cycle.
+    /// @param weightCutPercent How much to reduce weight each auto-cycle, out of
+    /// `JBConstants.MAX_WEIGHT_CUT_PERCENT`. Only applies when no explicit replacement is queued. 0 = no decay.
+    /// 100,000,000 = 10% cut per cycle.
     /// @param approvalHook A contract that gates whether the *next* queued ruleset can take effect (e.g. `JBDeadline`
     /// for minimum notice periods). Set to address(0) for no approval gate.
     /// @param metadata Packed 256-bit field decoded by `JBRulesetMetadataResolver`. Not used by `JBRulesets` itself.
@@ -614,7 +615,8 @@ contract JBRulesets is JBControlled, IJBRulesets {
     /// @param baseRulesetStart The start time of the base ruleset.
     /// @param baseRulesetDuration The duration of the base ruleset.
     /// @param baseRulesetWeight The weight of the base ruleset.
-    /// @param baseRulesetWeightCutPercent The weight cut percent of the base ruleset.
+    /// @param baseRulesetWeightCutPercent The weight cut percent of the base ruleset, out of
+    /// `JBConstants.MAX_WEIGHT_CUT_PERCENT`.
     /// @param baseRulesetCacheId The ID of the ruleset to base the calculation on (the previous ruleset).
     /// @param start The start time of the ruleset to derive a weight for.
     /// @return weight The derived weight, as a fixed point number with 18 decimals.

package/src/interfaces/IJBCashOutTerminal.sol

@@ -16,7 +16,7 @@ interface IJBCashOutTerminal is IJBTerminal {
     /// @param holder The address whose tokens were cashed out.
     /// @param beneficiary The address that received the reclaimed funds.
     /// @param cashOutCount The number of tokens cashed out.
-    /// @param cashOutTaxRate The cash out tax rate applied.
+    /// @param cashOutTaxRate The cash out tax rate applied, out of `JBConstants.MAX_CASH_OUT_TAX_RATE`.
     /// @param reclaimAmount The amount of funds reclaimed.
     /// @param metadata Extra metadata associated with the cash out.
     /// @param caller The address that called the cash out function.

package/src/interfaces/IJBController.sol

@@ -69,7 +69,7 @@ interface IJBController is IERC165, IJBProjectUriRegistry, IJBDirectoryAccessCon
     /// @param tokenCount The total number of tokens minted, including reserved tokens.
     /// @param beneficiaryTokenCount The number of tokens minted for the beneficiary.
     /// @param memo A memo associated with the mint.
-    /// @param reservedPercent The reserved percent applied to the mint.
+    /// @param reservedPercent The reserved percent applied to the mint, out of `JBConstants.MAX_RESERVED_PERCENT`.
     /// @param caller The address that called the mint function.
     event MintTokens(
         address indexed beneficiary,

package/src/interfaces/IJBRulesets.sol

@@ -22,7 +22,8 @@ interface IJBRulesets {
     /// @param projectId The ID of the project the ruleset was queued for.
     /// @param duration The duration of the ruleset in seconds.
     /// @param weight The weight of the ruleset.
-    /// @param weightCutPercent The percent by which the weight decreases each cycle.
+    /// @param weightCutPercent The percent by which the weight decreases each cycle, out of
+    /// `JBConstants.MAX_WEIGHT_CUT_PERCENT`.
     /// @param approvalHook The approval hook for the ruleset.
     /// @param metadata The packed ruleset metadata.
     /// @param mustStartAtOrAfter The earliest time the ruleset can start.
@@ -89,7 +90,8 @@ interface IJBRulesets {
     /// @param baseRulesetStart The start time of the base ruleset.
     /// @param baseRulesetDuration The duration of the base ruleset.
     /// @param baseRulesetWeight The weight of the base ruleset.
-    /// @param baseRulesetWeightCutPercent The weight cut percent of the base ruleset.
+    /// @param baseRulesetWeightCutPercent The weight cut percent of the base ruleset, out of
+    /// `JBConstants.MAX_WEIGHT_CUT_PERCENT`.
     /// @param baseRulesetCacheId The cache ID of the base ruleset.
     /// @param start The start time to derive the weight for.
     /// @return weight The derived weight.
@@ -150,7 +152,8 @@ interface IJBRulesets {
     /// @param projectId The ID of the project to queue the ruleset for.
     /// @param duration The duration of the ruleset in seconds.
     /// @param weight The weight of the ruleset.
-    /// @param weightCutPercent The percent by which the weight decreases each cycle.
+    /// @param weightCutPercent The percent by which the weight decreases each cycle, out of
+    /// `JBConstants.MAX_WEIGHT_CUT_PERCENT`.
     /// @param approvalHook The approval hook for the ruleset.
     /// @param metadata The packed ruleset metadata.
     /// @param mustStartAtOrAfter The earliest time the ruleset can start.

package/src/libraries/JBCashOuts.sol

@@ -20,7 +20,7 @@ library JBCashOuts {
     /// @param surplus The total amount of surplus terminal tokens.
     /// @param cashOutCount The number of tokens to cash out, as a fixed point number with 18 decimals.
     /// @param totalSupply The total token supply, as a fixed point number with 18 decimals.
-    /// @param cashOutTaxRate The current ruleset's cash out tax rate.
+    /// @param cashOutTaxRate The current ruleset's cash out tax rate, out of `JBConstants.MAX_CASH_OUT_TAX_RATE`.
     /// @return reclaimableSurplus The amount of surplus tokens that can be reclaimed.
     function cashOutFrom(
         uint256 surplus,
@@ -64,7 +64,7 @@ library JBCashOuts {
     /// @param surplus The total amount of surplus terminal tokens.
     /// @param desiredOutput The minimum amount of surplus tokens the caller wants to receive.
     /// @param totalSupply The total token supply, as a fixed point number with 18 decimals.
-    /// @param cashOutTaxRate The current ruleset's cash out tax rate.
+    /// @param cashOutTaxRate The current ruleset's cash out tax rate, out of `JBConstants.MAX_CASH_OUT_TAX_RATE`.
     /// @return count The minimum number of tokens to cash out.
     function minCashOutCountFor(
         uint256 surplus,

package/src/libraries/JBFees.sol

@@ -5,68 +5,26 @@ import {mulDiv} from "@prb/math/src/Common.sol";
 
 import {JBConstants} from "./../libraries/JBConstants.sol";
 
-/// @notice Utility functions for calculating the protocol fee (2.5%) in both directions: forward (fee from a pre-fee
-/// amount) and backward (the pre-fee amount that would yield a given post-fee amount). Used by `JBMultiTerminal`
-/// during payouts, surplus allowance usage, and cash outs.
-/// @dev Fee dust protection: if a nonzero amount with a nonzero fee would otherwise round to 0, returns 1 wei to
-/// prevent fee bypass via many tiny transfers.
+/// @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) {
-        uint256 feeAmount = feeAmountResultingInFloor({amountAfterFee: amountAfterFee, feePercent: feePercent});
-
-        return feeAmount == 0 && amountAfterFee != 0 && feePercent != 0 ? 1 : feeAmount;
-    }
-
-    /// @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 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;
+    /// @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.
+    /// @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);
     }
 }

package/src/structs/JBAfterCashOutRecordedContext.sol

@@ -7,7 +7,8 @@ import {JBTokenAmount} from "./JBTokenAmount.sol";
 /// @custom:member projectId The ID of the project to cash out from.
 /// @custom:member rulesetId The ID of the ruleset the cash out is made during.
 /// @custom:member cashOutCount The number of project tokens to cash out.
-/// @custom:member cashOutTaxRate The current ruleset's cash out tax rate.
+/// @custom:member cashOutTaxRate The current ruleset's cash out tax rate, out of
+/// `JBConstants.MAX_CASH_OUT_TAX_RATE`.
 /// @custom:member reclaimedAmount The token amount reclaimed from the project's terminal balance. Includes the
 /// token
 /// reclaimed, the value, the number of decimals included, and the currency of the amount.

package/src/structs/JBBeforeCashOutRecordedContext.sol

@@ -15,7 +15,8 @@ import {JBTokenAmount} from "./JBTokenAmount.sol";
 /// Includes the token of the surplus, the surplus value, the number of decimals
 /// included, and the currency of the surplus.
 /// @custom:member useTotalSurplus If true, use surplus across all of a project's terminals when calculating cash outs.
-/// @custom:member cashOutTaxRate The cash out tax rate of the ruleset the cash out is made during.
+/// @custom:member cashOutTaxRate The cash out tax rate of the ruleset the cash out is made during, out of
+/// `JBConstants.MAX_CASH_OUT_TAX_RATE`.
 /// @custom:member beneficiaryIsFeeless Whether the cash out's beneficiary is a feeless address. Useful for data hooks
 /// that charge their own fees — they can skip fees when value stays in the protocol (e.g. project-to-project
 /// routing).

package/src/structs/JBBeforePayRecordedContext.sol

@@ -13,7 +13,8 @@ import {JBTokenAmount} from "./JBTokenAmount.sol";
 /// @custom:member beneficiary The specified address that should be the beneficiary of anything that this payment
 /// yields.
 /// @custom:member weight The weight of the ruleset during which the payment is made.
-/// @custom:member reservedPercent The reserved percent of the ruleset the payment is made during.
+/// @custom:member reservedPercent The reserved percent of the ruleset the payment is made during, out of
+/// `JBConstants.MAX_RESERVED_PERCENT`.
 /// @custom:member metadata Extra data specified by the payer.
 struct JBBeforePayRecordedContext {
     address terminal;

package/src/structs/JBFee.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.0;
 
 /// @custom:member amount The total amount the fee was taken from, as a fixed point number with the same number of
-/// decimals as the terminal in which this struct was created.
+/// decimals as the token's accounting context.
 /// @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.
 struct JBFee {

package/src/structs/JBRuleset.sol

@@ -15,8 +15,9 @@ import {IJBRulesetApprovalHook} from "./../interfaces/IJBRulesetApprovalHook.sol
 /// @custom:member duration How many seconds the ruleset lasts. 0 = no auto-cycling (must be explicitly replaced).
 /// @custom:member weight Tokens minted per unit paid (18 decimals). The terminal divides payment amount by weight to
 /// determine token issuance. Higher weight = more tokens per unit of payment.
-/// @custom:member weightCutPercent How much to reduce weight each cycle (out of 1,000,000,000). 100,000,000 = 10% cut
-/// per cycle. 0 = no decay. Only applies when a cycle auto-rolls without an explicitly queued replacement.
+/// @custom:member weightCutPercent How much to reduce weight each cycle, out of
+/// `JBConstants.MAX_WEIGHT_CUT_PERCENT`. 100,000,000 = 10% cut per cycle. 0 = no decay. Only applies when a cycle
+/// auto-rolls without an explicitly queued replacement.
 /// @custom:member approvalHook A contract that gates whether queued rulesets can take effect (e.g. `JBDeadline` for
 /// minimum notice periods). If the hook rejects a queued ruleset, the current one continues.
 /// @custom:member metadata Packed 256-bit field containing reservedPercent, cashOutTaxRate, baseCurrency, boolean

package/src/structs/JBRulesetConfig.sol

@@ -14,7 +14,8 @@ import {JBSplitGroup} from "./JBSplitGroup.sol";
 /// @custom:member duration How long the ruleset lasts in seconds. 0 = stays active until explicitly replaced.
 /// @custom:member weight Tokens minted per unit of payment (18 decimals). Pass 1 to inherit decayed weight from the
 /// previous ruleset. Pass 0 for no token issuance.
-/// @custom:member weightCutPercent Decay rate per cycle (out of 1,000,000,000). 100,000,000 = 10% cut. 0 = no decay.
+/// @custom:member weightCutPercent Decay rate per cycle, out of `JBConstants.MAX_WEIGHT_CUT_PERCENT`. 100,000,000 =
+/// 10% cut. 0 = no decay.
 /// @custom:member approvalHook Contract that must approve the *next* queued ruleset for it to take effect.
 /// @custom:member metadata The ruleset's behavioral flags and parameters (see `JBRulesetMetadata`).
 /// @custom:member splitGroups How payouts and reserved tokens are distributed during this ruleset.

package/src/structs/JBRulesetMetadata.sol

@@ -3,10 +3,11 @@ pragma solidity ^0.8.0;
 
 /// @notice Human-readable configuration for a ruleset's behavioral flags and parameters. This struct is packed into
 /// 256 bits for on-chain storage (see `JBRulesetMetadataResolver` for the packing layout).
-/// @custom:member reservedPercent Percentage of newly minted tokens set aside for the reserved token split group
-/// (0–10,000 basis points). 5,000 = 50% reserved.
-/// @custom:member cashOutTaxRate Tax applied when holders cash out tokens (0–10,000 basis points). Higher rate = less
-/// reclaim per token. 0 = proportional, 10,000 = no reclaim (100% tax).
+/// @custom:member reservedPercent Percentage of newly minted tokens set aside for the reserved token split group,
+/// out of `JBConstants.MAX_RESERVED_PERCENT`. 5,000 = 50% reserved.
+/// @custom:member cashOutTaxRate Tax applied when holders cash out tokens, out of
+/// `JBConstants.MAX_CASH_OUT_TAX_RATE`. Higher rate = less reclaim per token. 0 = proportional, 10,000 = no reclaim
+/// (100% tax).
 /// @custom:member baseCurrency The currency used to interpret the ruleset's weight for token issuance. Convention:
 /// `uint32(uint160(tokenAddress))` for tokens, or `JBCurrencyIds.ETH`/`JBCurrencyIds.USD` for well-known currencies.
 /// @custom:member pausePay If `true`, the project cannot receive payments during this ruleset.