Penalty Curve

r     = priority_fee / M                        // M = reference median priority fee
f(r)  = min((r - 2.7) / 7.3, 1)                  // 2.7 = threshold, 7.3 = saturation range

penalty(r) = 0                                   if r < 2.7
penalty(r) = 10% * f(r)^1.5                      if r >= 2.7

fee = 0.1% + penalty(r)                          // 0.1% = basic fee

frac^1.5 = frac * frac^0.5 = frac * sqrt(frac)

function getDynamicFee_(uint256 priorityFee, int256 referenceMedian) internal virtual returns (uint24) {
    // No reference data yet, fall back to the baseline fee to avoid
    // dividing by zero (mirrors the old medianPriorityFee == 0 check).
    if (referenceMedian <= 0) return BASIC_FEE;

    uint256 medianPriorityFee = uint256(referenceMedian);

    // How many times (scaled by PRECISION) this swap's priority fee
    // exceeds the smoothed reference. E.g. 2700 means "2.7x the
    // reference".
    uint256 priorityFeeRatioScaled = (priorityFee * PRECISION) / medianPriorityFee;

    uint256 penaltyPpm;
    if (priorityFeeRatioScaled < RATIO_THRESHOLD) {
        // Priority fee is within the tolerated range, no penalty.
        penaltyPpm = 0;
    } else {
        // How far above the threshold this swap's ratio is, scaled by
        // PRECISION (e.g. ratio 3.7 with threshold 2.7 gives an
        // excess of 1.0 * PRECISION).
        uint256 excessRatioScaled = priorityFeeRatioScaled - RATIO_THRESHOLD;

        // Fraction of the way through the penalty range [0, D_CAP],
        // expressed in WAD (1e18 = "fully saturated"). Clamped to
        // WAD instead of computed further once excess reaches D_CAP,
        // both to save gas and to guarantee no overflow regardless
        // of how large priorityFeeRatioScaled is.
        uint256 fracWad = excessRatioScaled >= D_CAP ? WAD : (excessRatioScaled * WAD) / D_CAP;

        // frac^1.5 = frac * sqrt(frac), computed in WAD fixed point.
        // Math.sqrt(fracWad * WAD) rescales sqrt(x/1e18) back to a
        // 1e18-scaled result (sqrt(1e36) == 1e18).
        uint256 sqrtFracWad = Math.sqrt(fracWad * WAD);
        uint256 frac1_5Wad = (fracWad * sqrtFracWad) / WAD;

        penaltyPpm = (frac1_5Wad * MAX_PENALTY_PERCENT * PENALTY_UNIT) / WAD;
    }

    // Final fee = baseline fee + penalty, in ppm.
    uint24 totalFee = BASIC_FEE + penaltyPpm.toUint24();

    return totalFee;
}