@bananapus/core-v6 0.0.14 → 0.0.16

package/test/fork/TestChainlinkPriceFeedFork.sol

@@ -0,0 +1,254 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+import {Test} from "forge-std/Test.sol";
+
+import {AggregatorV3Interface} from "@chainlink/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol";
+
+import {JBChainlinkV3PriceFeed} from "../../src/JBChainlinkV3PriceFeed.sol";
+import {JBPrices} from "../../src/JBPrices.sol";
+import {IJBDirectory} from "../../src/interfaces/IJBDirectory.sol";
+import {IJBPermissions} from "../../src/interfaces/IJBPermissions.sol";
+import {IJBPriceFeed} from "../../src/interfaces/IJBPriceFeed.sol";
+import {IJBProjects} from "../../src/interfaces/IJBProjects.sol";
+
+/// @notice Fork tests for JBChainlinkV3PriceFeed and JBPrices against live Chainlink oracles on Ethereum mainnet.
+contract TestChainlinkPriceFeedFork is Test {
+    // Chainlink feed addresses (Ethereum mainnet).
+    address constant ETH_USD_FEED = 0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419;
+    address constant BTC_USD_FEED = 0xF4030086522a5bEEa4988F8cA5B36dbC97BeE88c;
+
+    // Staleness threshold (1 hour).
+    uint256 constant THRESHOLD = 3600;
+
+    // Currency identifiers (arbitrary nonzero values for JBPrices mapping keys).
+    uint256 constant CURRENCY_ETH = 1;
+    uint256 constant CURRENCY_USD = 2;
+    uint256 constant CURRENCY_BTC = 3;
+
+    // Pinned block for reproducibility.
+    uint256 constant FORK_BLOCK = 22_000_000;
+
+    JBChainlinkV3PriceFeed ethUsdPriceFeed;
+    JBChainlinkV3PriceFeed btcUsdPriceFeed;
+    JBPrices prices;
+    address owner;
+
+    function setUp() public {
+        vm.createSelectFork("ethereum", FORK_BLOCK);
+
+        owner = makeAddr("owner");
+
+        // Deploy price feeds against real Chainlink aggregators.
+        ethUsdPriceFeed = new JBChainlinkV3PriceFeed(AggregatorV3Interface(ETH_USD_FEED), THRESHOLD);
+        btcUsdPriceFeed = new JBChainlinkV3PriceFeed(AggregatorV3Interface(BTC_USD_FEED), THRESHOLD);
+
+        // Deploy JBPrices with mock directory/permissions/projects (only price resolution is tested).
+        prices = new JBPrices(
+            IJBDirectory(makeAddr("directory")),
+            IJBPermissions(makeAddr("permissions")),
+            IJBProjects(makeAddr("projects")),
+            owner,
+            address(0)
+        );
+    }
+
+    // ------------------------------------------------------------------
+    // Live feed sanity checks
+    // ------------------------------------------------------------------
+
+    /// @notice Verify currentUnitPrice returns a sane ETH/USD price at the pinned block.
+    function test_currentUnitPrice_liveEthUsd() public view {
+        uint256 price18 = ethUsdPriceFeed.currentUnitPrice(18);
+
+        // ETH price should be between $500 and $50,000.
+        assertGt(price18, 500e18, "ETH price too low");
+        assertLt(price18, 50_000e18, "ETH price too high");
+
+        // Cross-check against raw latestRoundData.
+        (, int256 rawPrice,,,) = AggregatorV3Interface(ETH_USD_FEED).latestRoundData();
+        uint256 feedDecimals = AggregatorV3Interface(ETH_USD_FEED).decimals();
+        // forge-lint: disable-next-line(unsafe-typecast)
+        uint256 expected18 = uint256(rawPrice) * 10 ** (18 - feedDecimals);
+        assertEq(price18, expected18, "Price mismatch vs raw feed");
+    }
+
+    // ------------------------------------------------------------------
+    // Decimal scaling
+    // ------------------------------------------------------------------
+
+    /// @notice Verify correct scaling across 6, 8, 18, and 27 decimals.
+    function test_currentUnitPrice_differentDecimals() public view {
+        uint256 price6 = ethUsdPriceFeed.currentUnitPrice(6);
+        uint256 price8 = ethUsdPriceFeed.currentUnitPrice(8);
+        uint256 price18 = ethUsdPriceFeed.currentUnitPrice(18);
+        uint256 price27 = ethUsdPriceFeed.currentUnitPrice(27);
+
+        // Raw feed is 8 decimals — price8 should match it exactly.
+        (, int256 rawPrice,,,) = AggregatorV3Interface(ETH_USD_FEED).latestRoundData();
+        // forge-lint: disable-next-line(unsafe-typecast)
+        assertEq(price8, uint256(rawPrice), "8-decimal mismatch");
+
+        // 6 decimals = raw / 100 (truncated).
+        // forge-lint: disable-next-line(unsafe-typecast)
+        assertEq(price6, uint256(rawPrice) / 1e2, "6-decimal mismatch");
+
+        // 18 decimals = raw * 1e10.
+        // forge-lint: disable-next-line(unsafe-typecast)
+        assertEq(price18, uint256(rawPrice) * 1e10, "18-decimal mismatch");
+
+        // 27 decimals = raw * 1e19.
+        // forge-lint: disable-next-line(unsafe-typecast)
+        assertEq(price27, uint256(rawPrice) * 1e19, "27-decimal mismatch");
+    }
+
+    // ------------------------------------------------------------------
+    // JBPrices integration — direct feed
+    // ------------------------------------------------------------------
+
+    /// @notice Register ETH/USD feed and resolve via pricePerUnitOf.
+    function test_pricePerUnitOf_directFeed() public {
+        vm.prank(owner);
+        prices.addPriceFeedFor(0, CURRENCY_USD, CURRENCY_ETH, IJBPriceFeed(address(ethUsdPriceFeed)));
+
+        uint256 priceFromPrices = prices.pricePerUnitOf(0, CURRENCY_USD, CURRENCY_ETH, 18);
+        uint256 priceFromFeed = ethUsdPriceFeed.currentUnitPrice(18);
+
+        assertEq(priceFromPrices, priceFromFeed, "Direct feed mismatch");
+    }
+
+    // ------------------------------------------------------------------
+    // JBPrices integration — inverse feed
+    // ------------------------------------------------------------------
+
+    /// @notice Register ETH/USD feed but query USD/ETH — verify inverse calculation.
+    function test_pricePerUnitOf_inverseFeed() public {
+        vm.prank(owner);
+        prices.addPriceFeedFor(0, CURRENCY_USD, CURRENCY_ETH, IJBPriceFeed(address(ethUsdPriceFeed)));
+
+        uint256 inversePrice = prices.pricePerUnitOf(0, CURRENCY_ETH, CURRENCY_USD, 18);
+
+        // inverse = (1e18 * 1e18) / ethUsdPrice. For ETH ~$2000, inverse ~0.0005e18 = 5e14.
+        // Sane range: $500–$50k → inverse 2e13–2e15.
+        assertGt(inversePrice, 2e13, "Inverse price too low");
+        assertLt(inversePrice, 2e15, "Inverse price too high");
+
+        // Verify round-trip: price * inverse ≈ 1e18 (within mulDiv rounding).
+        uint256 directPrice = ethUsdPriceFeed.currentUnitPrice(18);
+        uint256 product = (directPrice * inversePrice) / 1e18;
+        // mulDiv truncation can cause up to ~1e4 wei error at these magnitudes.
+        assertApproxEqAbs(product, 1e18, 1e4, "Round-trip mismatch");
+    }
+
+    // ------------------------------------------------------------------
+    // JBPrices — same currency
+    // ------------------------------------------------------------------
+
+    /// @notice pricePerUnitOf(X, X, 18) should return 1e18 without any feed.
+    function test_pricePerUnitOf_sameCurrency() public view {
+        uint256 price = prices.pricePerUnitOf(0, CURRENCY_ETH, CURRENCY_ETH, 18);
+        assertEq(price, 1e18, "Same currency should be 1e18");
+    }
+
+    // ------------------------------------------------------------------
+    // JBPrices — default fallback
+    // ------------------------------------------------------------------
+
+    /// @notice Feed registered at projectId=0 should be used when querying projectId=99.
+    function test_pricePerUnitOf_defaultFallback() public {
+        vm.prank(owner);
+        prices.addPriceFeedFor(0, CURRENCY_USD, CURRENCY_ETH, IJBPriceFeed(address(ethUsdPriceFeed)));
+
+        uint256 defaultPrice = prices.pricePerUnitOf(0, CURRENCY_USD, CURRENCY_ETH, 18);
+        uint256 fallbackPrice = prices.pricePerUnitOf(99, CURRENCY_USD, CURRENCY_ETH, 18);
+
+        assertEq(fallbackPrice, defaultPrice, "Fallback should match default");
+    }
+
+    // ------------------------------------------------------------------
+    // Stale price revert
+    // ------------------------------------------------------------------
+
+    /// @notice Warping past the threshold should cause a StalePrice revert.
+    function test_stalePriceReverts() public {
+        // Snapshot updatedAt from the feed at this block.
+        (,,, uint256 updatedAt,) = AggregatorV3Interface(ETH_USD_FEED).latestRoundData();
+
+        // Warp far enough that the feed's updatedAt + threshold < block.timestamp.
+        uint256 warpTo = block.timestamp + 7200;
+        vm.warp(warpTo);
+
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                JBChainlinkV3PriceFeed.JBChainlinkV3PriceFeed_StalePrice.selector, warpTo, THRESHOLD, updatedAt
+            )
+        );
+        ethUsdPriceFeed.currentUnitPrice(18);
+    }
+
+    // ------------------------------------------------------------------
+    // Feed immutability
+    // ------------------------------------------------------------------
+
+    /// @notice Registering the same currency pair twice should revert.
+    function test_feedImmutability() public {
+        vm.prank(owner);
+        prices.addPriceFeedFor(0, CURRENCY_USD, CURRENCY_ETH, IJBPriceFeed(address(ethUsdPriceFeed)));
+
+        vm.prank(owner);
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                JBPrices.JBPrices_PriceFeedAlreadyExists.selector, IJBPriceFeed(address(ethUsdPriceFeed))
+            )
+        );
+        prices.addPriceFeedFor(0, CURRENCY_USD, CURRENCY_ETH, IJBPriceFeed(address(btcUsdPriceFeed)));
+    }
+
+    // ------------------------------------------------------------------
+    // Multiple feeds
+    // ------------------------------------------------------------------
+
+    /// @notice Register both ETH/USD and BTC/USD and verify independent resolution.
+    function test_multipleFeeds_ethUsd_btcUsd() public {
+        vm.startPrank(owner);
+        prices.addPriceFeedFor(0, CURRENCY_USD, CURRENCY_ETH, IJBPriceFeed(address(ethUsdPriceFeed)));
+        prices.addPriceFeedFor(0, CURRENCY_USD, CURRENCY_BTC, IJBPriceFeed(address(btcUsdPriceFeed)));
+        vm.stopPrank();
+
+        uint256 ethUsd = prices.pricePerUnitOf(0, CURRENCY_USD, CURRENCY_ETH, 18);
+        uint256 btcUsd = prices.pricePerUnitOf(0, CURRENCY_USD, CURRENCY_BTC, 18);
+
+        // ETH/USD: $500–$50,000.
+        assertGt(ethUsd, 500e18, "ETH/USD too low");
+        assertLt(ethUsd, 50_000e18, "ETH/USD too high");
+
+        // BTC/USD: $10,000–$500,000.
+        assertGt(btcUsd, 10_000e18, "BTC/USD too low");
+        assertLt(btcUsd, 500_000e18, "BTC/USD too high");
+
+        // BTC should be more expensive than ETH.
+        assertGt(btcUsd, ethUsd, "BTC should cost more than ETH");
+    }
+
+    // ------------------------------------------------------------------
+    // Cross-price derivation
+    // ------------------------------------------------------------------
+
+    /// @notice Derive ETH/BTC price from ETH/USD and BTC/USD feeds.
+    function test_crossPriceDerived() public {
+        vm.startPrank(owner);
+        prices.addPriceFeedFor(0, CURRENCY_USD, CURRENCY_ETH, IJBPriceFeed(address(ethUsdPriceFeed)));
+        prices.addPriceFeedFor(0, CURRENCY_USD, CURRENCY_BTC, IJBPriceFeed(address(btcUsdPriceFeed)));
+        vm.stopPrank();
+
+        uint256 ethUsd = prices.pricePerUnitOf(0, CURRENCY_USD, CURRENCY_ETH, 18);
+        uint256 btcUsd = prices.pricePerUnitOf(0, CURRENCY_USD, CURRENCY_BTC, 18);
+
+        // ETH/BTC = ethUsd / btcUsd (how many BTC per 1 ETH).
+        uint256 ethPerBtc = (ethUsd * 1e18) / btcUsd;
+
+        // Should be between 0.01 and 0.1 (at 18 decimals: 1e16–1e17).
+        assertGt(ethPerBtc, 1e16, "ETH/BTC ratio too low");
+        assertLt(ethPerBtc, 1e17, "ETH/BTC ratio too high");
+    }
+}

package/test/formal/BondingCurveProperties.t.sol

@@ -1,8 +1,7 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.17;
 
-import "forge-std/Test.sol";
-import {mulDiv} from "@prb/math/src/Common.sol";
+import {Test} from "forge-std/Test.sol";
 import {JBCashOuts} from "../../src/libraries/JBCashOuts.sol";
 import {JBFees} from "../../src/libraries/JBFees.sol";
 import {JBConstants} from "../../src/libraries/JBConstants.sol";
@@ -22,6 +21,7 @@ contract BondingCurveProperties is Test {
     // Property 1: Boundedness — cashOutFrom never exceeds surplus
     // =========================================================================
     /// @notice cashOutFrom(S, c, T, r) <= S for all valid inputs.
+    // forge-lint: disable-next-line(mixed-case-function)
     function check_cashOut_boundedness(
         uint256 surplus,
         uint256 cashOutCount,
@@ -63,6 +63,7 @@ contract BondingCurveProperties is Test {
     // Property 2: Monotonicity — more tokens → more reclaim
     // =========================================================================
     /// @notice cashOutFrom(S, c1, T, r) <= cashOutFrom(S, c2, T, r) when c1 <= c2.
+    // forge-lint: disable-next-line(mixed-case-function)
     function check_cashOut_monotonicity(
         uint256 surplus,
         uint256 c1,
@@ -113,6 +114,7 @@ contract BondingCurveProperties is Test {
     // Property 3: Full redemption — when c >= T, result is S (full surplus)
     // =========================================================================
     /// @notice When cashOutCount >= totalSupply, the full surplus is returned.
+    // forge-lint: disable-next-line(mixed-case-function)
     function check_cashOut_fullRedemption(uint256 surplus, uint256 totalSupply, uint256 cashOutTaxRate) public pure {
         vm.assume(surplus > 0 && surplus <= type(uint128).max);
         vm.assume(totalSupply > 0 && totalSupply <= type(uint128).max);
@@ -137,6 +139,7 @@ contract BondingCurveProperties is Test {
     // Property 4: Max tax → zero reclaim
     // =========================================================================
     /// @notice When cashOutTaxRate == MAX_CASH_OUT_TAX_RATE, result is 0.
+    // forge-lint: disable-next-line(mixed-case-function)
     function check_cashOut_maxTaxIsZero(uint256 surplus, uint256 cashOutCount, uint256 totalSupply) public pure {
         vm.assume(surplus > 0 && surplus <= type(uint128).max);
         vm.assume(totalSupply > 0 && totalSupply <= type(uint128).max);
@@ -161,6 +164,7 @@ contract BondingCurveProperties is Test {
     /// @notice Splitting a cash out into two parts should never yield more than a single cash out.
     ///         cashOutFrom(S, a, T, r) + cashOutFrom(S', b, T', r) <= cashOutFrom(S, a+b, T, r)
     ///         where S' = S - cashOutFrom(S, a, T, r) and T' = T - a
+    // forge-lint: disable-next-line(mixed-case-function)
     function check_cashOut_noArbitrage(
         uint256 surplus,
         uint256 a,
@@ -245,6 +249,7 @@ contract BondingCurveProperties is Test {
     /// @notice The forward and reverse fee functions should be consistent:
     ///         amount - feeAmountFrom(amount, fee) + feeAmountResultingIn(net, fee) >= feeAmountFrom(amount, fee)
     ///         where net = amount - feeAmountFrom(amount, fee)
+    // forge-lint: disable-next-line(mixed-case-function)
     function check_fee_roundTrip(uint256 amount, uint256 feePercent) public pure {
         vm.assume(amount > 0 && amount <= type(uint128).max);
         vm.assume(feePercent > 0 && feePercent < MAX_FEE);
@@ -276,6 +281,7 @@ contract BondingCurveProperties is Test {
     // Property 7: Metadata packing round-trip
     // =========================================================================
     /// @notice packRulesetMetadata(m) → expandMetadata should return the original metadata.
+    // forge-lint: disable-next-line(mixed-case-function)
     function check_metadataPacking_roundTrip(
         uint16 reservedPercent,
         uint16 cashOutTaxRate,

package/test/formal/FeeProperties.t.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.17;
 
-import "forge-std/Test.sol";
+import {Test} from "forge-std/Test.sol";
 import {JBFees} from "../../src/libraries/JBFees.sol";
 import {JBConstants} from "../../src/libraries/JBConstants.sol";
 
@@ -17,6 +17,7 @@ contract FeeProperties is Test {
     // =========================================================================
     /// @notice feeAmountFrom(a+b, fee) vs feeAmountFrom(a, fee) + feeAmountFrom(b, fee)
     ///         differ by at most 1 wei due to mulDiv rounding.
+    // forge-lint: disable-next-line(mixed-case-function)
     function check_fee_additivity(uint256 a, uint256 b, uint256 feePercent) public pure {
         vm.assume(a > 0 && b > 0);
         vm.assume(a <= type(uint128).max && b <= type(uint128).max);
@@ -53,6 +54,7 @@ contract FeeProperties is Test {
     /// @notice feeAmountResultingIn(netAmount, fee) >= feeAmountFrom(netAmount + feeAmountResultingIn(netAmount, fee),
     // fee) /         The reverse fee is always >= the forward fee on the gross amount, ensuring
     ///         the protocol never undercharges when returning held fees.
+    // forge-lint: disable-next-line(mixed-case-function)
     function check_fee_returnConsistency(uint256 netAmount, uint256 feePercent) public pure {
         vm.assume(netAmount > 0 && netAmount <= type(uint128).max);
         vm.assume(feePercent > 0 && feePercent < MAX_FEE);
@@ -91,6 +93,7 @@ contract FeeProperties is Test {
     ///         The overshoot is bounded by MAX_FEE / (MAX_FEE - feePercent): the rounding
     ///         error in fee1 (at most 1 wei of net) gets amplified by the fee ratio when
     ///         computing the reverse fee, plus 1 for the reverse mulDiv rounding itself.
+    // forge-lint: disable-next-line(mixed-case-function)
     function check_fee_roundTrip(uint256 amount, uint256 feePercent) public pure {
         vm.assume(amount > 0 && amount <= type(uint128).max);
         vm.assume(feePercent > 0 && feePercent < MAX_FEE);
@@ -133,6 +136,7 @@ contract FeeProperties is Test {
     // Property 4: Partial return monotonicity
     // =========================================================================
     /// @notice feeAmountResultingIn(a, fee) <= feeAmountResultingIn(b, fee) when a <= b.
+    // forge-lint: disable-next-line(mixed-case-function)
     function check_fee_partialReturnMonotonicity(uint256 a, uint256 b, uint256 feePercent) public pure {
         vm.assume(a > 0 && b > 0);
         vm.assume(a <= type(uint128).max && b <= type(uint128).max);
@@ -163,6 +167,7 @@ contract FeeProperties is Test {
     ///         fee = feeAmountFrom(heldFeeAmount, feePercent) <= heldFeeAmount.
     ///         This guarantees leftover = heldFeeAmount - fee never underflows, and
     ///         leftover + fee == heldFeeAmount (exact decomposition).
+    // forge-lint: disable-next-line(mixed-case-function)
     function check_fee_subtractionSafety(uint256 heldFeeAmount, uint256 feePercent) public pure {
         vm.assume(heldFeeAmount > 0 && heldFeeAmount <= type(uint128).max);
         vm.assume(feePercent > 0 && feePercent < MAX_FEE);
@@ -195,6 +200,7 @@ contract FeeProperties is Test {
     /// @notice After N splits each paying fee, total fee error vs single-payment fee
     ///         is bounded by N wei. For N=10: sum(feeAmountFrom(amount/N, fee), N times)
     ///         vs feeAmountFrom(amount, fee) differ by at most N.
+    // forge-lint: disable-next-line(mixed-case-function)
     function check_fee_multiSplitAccumulation(uint256 amount, uint256 feePercent) public pure {
         vm.assume(amount >= 10); // Must be divisible into 10 parts
         vm.assume(amount <= type(uint128).max);

package/test/helpers/JBTest.sol

@@ -1,12 +1,12 @@
 // SPDX-License-Identifier: MIT
 pragma solidity 0.8.26;
 
-import {JBRuleset} from "src/structs/JBRuleset.sol";
-import {JBRulesetMetadata} from "src/structs/JBRulesetMetadata.sol";
-import {JBRulesetMetadataResolver} from "src/libraries/JBRulesetMetadataResolver.sol";
-import {JBConstants} from "src/libraries/JBConstants.sol";
-import {IJBRulesetApprovalHook} from "src/interfaces/IJBRulesetApprovalHook.sol";
-import "lib/forge-std/src/Test.sol";
+import {JBRuleset} from "../../src/structs/JBRuleset.sol";
+import {JBRulesetMetadata} from "../../src/structs/JBRulesetMetadata.sol";
+import {JBRulesetMetadataResolver} from "../../src/libraries/JBRulesetMetadataResolver.sol";
+import {JBConstants} from "../../src/libraries/JBConstants.sol";
+import {IJBRulesetApprovalHook} from "../../src/interfaces/IJBRulesetApprovalHook.sol";
+import {Test} from "lib/forge-std/src/Test.sol";
 
 contract JBTest is Test {
     using JBRulesetMetadataResolver for JBRulesetMetadata;
@@ -65,7 +65,7 @@ contract JBTest is Test {
         });
     }
 
-    function generateEmptyMetadata() public view returns (JBRulesetMetadata memory) {
+    function generateEmptyMetadata() public pure returns (JBRulesetMetadata memory) {
         return JBRulesetMetadata({
             reservedPercent: 0,
             cashOutTaxRate: 0,

package/test/helpers/TestBaseWorkflow.sol

@@ -1,18 +1,32 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.6;
 
-import "forge-std/Test.sol";
+// forge-lint: disable-next-line(unused-import)
+import {Test} from "forge-std/Test.sol";
+// forge-lint: disable-next-line(unused-import)
+import {StdStorage, stdStorage} from "forge-std/StdStorage.sol";
 
+// forge-lint: disable-next-line(unused-import)
 import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
+// forge-lint: disable-next-line(unused-import)
 import {IERC721Metadata} from "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
+// forge-lint: disable-next-line(unused-import)
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+// forge-lint: disable-next-line(unused-import)
 import {IERC20Permit} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol";
+// forge-lint: disable-next-line(unused-import)
 import {Clones} from "@openzeppelin/contracts/proxy/Clones.sol";
+// forge-lint: disable-next-line(unused-import)
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+// forge-lint: disable-next-line(unused-import)
 import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+// forge-lint: disable-next-line(unused-import)
 import {ERC165, IERC165} from "@openzeppelin/contracts/utils/introspection/ERC165.sol";
+// forge-lint: disable-next-line(unused-import)
 import {JBPermissionIds} from "@bananapus/permission-ids-v6/src/JBPermissionIds.sol";
+// forge-lint: disable-next-line(unused-import)
 import {JBControlled} from "../../src/abstract/JBControlled.sol";
+// forge-lint: disable-next-line(unused-import)
 import {JBPermissioned} from "../../src/abstract/JBPermissioned.sol";
 import {JBController} from "../../src/JBController.sol";
 import {JBDirectory} from "../../src/JBDirectory.sol";
@@ -26,70 +40,132 @@ import {JBProjects} from "../../src/JBProjects.sol";
 import {JBSplits} from "../../src/JBSplits.sol";
 import {JBERC20} from "../../src/JBERC20.sol";
 import {JBTokens} from "../../src/JBTokens.sol";
+// forge-lint: disable-next-line(unused-import)
 import {JBDeadline} from "../../src/JBDeadline.sol";
+// forge-lint: disable-next-line(unused-import)
 import {JBApprovalStatus} from "../../src/enums/JBApprovalStatus.sol";
 import {JBMultiTerminal} from "../../src/JBMultiTerminal.sol";
+// forge-lint: disable-next-line(unused-import)
 import {JBAccountingContext} from "../../src/structs/JBAccountingContext.sol";
+// forge-lint: disable-next-line(unused-import)
 import {JBCurrencyAmount} from "../../src/structs/JBCurrencyAmount.sol";
+// forge-lint: disable-next-line(unused-import)
 import {JBAfterPayRecordedContext} from "../../src/structs/JBAfterPayRecordedContext.sol";
+// forge-lint: disable-next-line(unused-import)
 import {JBAfterCashOutRecordedContext} from "../../src/structs/JBAfterCashOutRecordedContext.sol";
+// forge-lint: disable-next-line(unused-import)
 import {JBFee} from "../../src/structs/JBFee.sol";
+// forge-lint: disable-next-line(unused-import)
 import {JBFees} from "../../src/libraries/JBFees.sol";
+// forge-lint: disable-next-line(unused-import)
 import {JBMetadataResolver} from "../../src/libraries/JBMetadataResolver.sol";
+// forge-lint: disable-next-line(unused-import)
 import {JBCashOuts} from "../../src/libraries/JBCashOuts.sol";
+// forge-lint: disable-next-line(unused-import)
 import {JBFundAccessLimitGroup} from "../../src/structs/JBFundAccessLimitGroup.sol";
+// forge-lint: disable-next-line(unused-import)
 import {JBRuleset} from "../../src/structs/JBRuleset.sol";
+// forge-lint: disable-next-line(unused-import)
 import {JBRulesetWithMetadata} from "../../src/structs/JBRulesetWithMetadata.sol";
+// forge-lint: disable-next-line(unused-import)
 import {JBRulesetMetadata} from "../../src/structs/JBRulesetMetadata.sol";
+// forge-lint: disable-next-line(unused-import)
 import {JBRulesetConfig} from "../../src/structs/JBRulesetConfig.sol";
+// forge-lint: disable-next-line(unused-import)
 import {JBSplitGroup} from "../../src/structs/JBSplitGroup.sol";
+// forge-lint: disable-next-line(unused-import)
 import {JBPermissionsData} from "../../src/structs/JBPermissionsData.sol";
+// forge-lint: disable-next-line(unused-import)
 import {JBBeforePayRecordedContext} from "../../src/structs/JBBeforePayRecordedContext.sol";
+// forge-lint: disable-next-line(unused-import)
 import {JBBeforeCashOutRecordedContext} from "../../src/structs/JBBeforeCashOutRecordedContext.sol";
+// forge-lint: disable-next-line(unused-import)
 import {JBSplit} from "../../src/structs/JBSplit.sol";
+// forge-lint: disable-next-line(unused-import)
 import {JBTerminalConfig} from "../../src/structs/JBTerminalConfig.sol";
+// forge-lint: disable-next-line(unused-import)
 import {JBPayHookSpecification} from "../../src/structs/JBPayHookSpecification.sol";
+// forge-lint: disable-next-line(unused-import)
 import {JBCashOutHookSpecification} from "../../src/structs/JBCashOutHookSpecification.sol";
+// forge-lint: disable-next-line(unused-import)
 import {JBTokenAmount} from "../../src/structs/JBTokenAmount.sol";
+// forge-lint: disable-next-line(unused-import)
 import {JBSplitHookContext} from "../../src/structs/JBSplitHookContext.sol";
+// forge-lint: disable-next-line(unused-import)
 import {IJBToken} from "../../src/interfaces/IJBToken.sol";
+// forge-lint: disable-next-line(unused-import)
 import {JBSingleAllowance} from "../../src/structs/JBSingleAllowance.sol";
+// forge-lint: disable-next-line(unused-import)
 import {IJBController} from "../../src/interfaces/IJBController.sol";
+// forge-lint: disable-next-line(unused-import)
 import {IJBFeelessAddresses} from "../../src/interfaces/IJBFeelessAddresses.sol";
+// forge-lint: disable-next-line(unused-import)
 import {IJBFundAccessLimits} from "../../src/interfaces/IJBFundAccessLimits.sol";
+// forge-lint: disable-next-line(unused-import)
 import {IJBMigratable} from "../../src/interfaces/IJBMigratable.sol";
+// forge-lint: disable-next-line(unused-import)
 import {IJBPermissions} from "../../src/interfaces/IJBPermissions.sol";
+// forge-lint: disable-next-line(unused-import)
 import {IJBDirectoryAccessControl} from "../../src/interfaces/IJBDirectoryAccessControl.sol";
+// forge-lint: disable-next-line(unused-import)
 import {IJBTerminalStore} from "../../src/interfaces/IJBTerminalStore.sol";
+// forge-lint: disable-next-line(unused-import)
 import {IJBProjects} from "../../src/interfaces/IJBProjects.sol";
+// forge-lint: disable-next-line(unused-import)
 import {IJBRulesetApprovalHook} from "../../src/interfaces/IJBRulesetApprovalHook.sol";
+// forge-lint: disable-next-line(unused-import)
 import {IJBDirectory} from "../../src/interfaces/IJBDirectory.sol";
+// forge-lint: disable-next-line(unused-import)
 import {IJBRulesets} from "../../src/interfaces/IJBRulesets.sol";
+// forge-lint: disable-next-line(unused-import)
 import {IJBSplits} from "../../src/interfaces/IJBSplits.sol";
+// forge-lint: disable-next-line(unused-import)
 import {IJBTokenUriResolver} from "../../src/interfaces/IJBTokenUriResolver.sol";
+// forge-lint: disable-next-line(unused-import)
 import {IJBTokens} from "../../src/interfaces/IJBTokens.sol";
+// forge-lint: disable-next-line(unused-import)
 import {IJBSplitHook} from "../../src/interfaces/IJBSplitHook.sol";
+// forge-lint: disable-next-line(unused-import)
 import {IJBPayHook} from "../../src/interfaces/IJBPayHook.sol";
+// forge-lint: disable-next-line(unused-import)
 import {IJBRulesetDataHook} from "../../src/interfaces/IJBRulesetDataHook.sol";
+// forge-lint: disable-next-line(unused-import)
 import {IJBCashOutHook} from "../../src/interfaces/IJBCashOutHook.sol";
+// forge-lint: disable-next-line(unused-import)
 import {IJBRulesetDataHook} from "../../src/interfaces/IJBRulesetDataHook.sol";
+// forge-lint: disable-next-line(unused-import)
 import {IJBMultiTerminal} from "../../src/interfaces/IJBMultiTerminal.sol";
+// forge-lint: disable-next-line(unused-import)
 import {IJBCashOutTerminal} from "../../src/interfaces/IJBCashOutTerminal.sol";
+// forge-lint: disable-next-line(unused-import)
 import {IJBPayoutTerminal} from "../../src/interfaces/IJBPayoutTerminal.sol";
+// forge-lint: disable-next-line(unused-import)
 import {IJBPermitTerminal} from "../../src/interfaces/IJBPermitTerminal.sol";
+// forge-lint: disable-next-line(unused-import)
 import {IJBFeeTerminal} from "../../src/interfaces/IJBFeeTerminal.sol";
+// forge-lint: disable-next-line(unused-import)
 import {IJBTerminal} from "../../src/interfaces/IJBTerminal.sol";
+// forge-lint: disable-next-line(unused-import)
 import {IJBPriceFeed} from "../../src/interfaces/IJBPriceFeed.sol";
+// forge-lint: disable-next-line(unused-import)
 import {IJBPermissioned} from "../../src/interfaces/IJBPermissioned.sol";
+// forge-lint: disable-next-line(unused-import)
 import {IJBProjectUriRegistry} from "../../src/interfaces/IJBProjectUriRegistry.sol";
+// forge-lint: disable-next-line(unused-import)
 import {IJBRulesetApprovalHook} from "../../src/interfaces/IJBRulesetApprovalHook.sol";
+// forge-lint: disable-next-line(unused-import)
 import {IJBPrices} from "../../src/interfaces/IJBPrices.sol";
 
+// forge-lint: disable-next-line(unused-import)
 import {JBConstants} from "../../src/libraries/JBConstants.sol";
+// forge-lint: disable-next-line(unused-import)
 import {JBCurrencyIds} from "../../src/libraries/JBCurrencyIds.sol";
+// forge-lint: disable-next-line(unused-import)
 import {JBRulesetMetadataResolver} from "../../src/libraries/JBRulesetMetadataResolver.sol";
+// forge-lint: disable-next-line(unused-import)
 import {JBSplitGroupIds} from "../../src/libraries/JBSplitGroupIds.sol";
 
+// forge-lint: disable-next-line(unused-import)
 import {IPermit2, IAllowanceTransfer} from "@uniswap/permit2/src/interfaces/IPermit2.sol";
 import {DeployPermit2} from "@uniswap/permit2/test/utils/DeployPermit2.sol";
 
@@ -98,7 +174,9 @@ import {JBTest} from "./JBTest.sol";
 
 import {MockERC20} from "./../mock/MockERC20.sol";
 
+// forge-lint: disable-next-line(unused-import)
 import {mulDiv} from "@prb/math/src/Common.sol";
+// forge-lint: disable-next-line(unused-import)
 import {mul as UD60x18mul, wrap as UD60x18wrap, unwrap as UD60x18unwrap} from "@prb/math/src/UD60x18.sol";
 
 // Base contract for Juicebox system tests.
@@ -294,14 +372,19 @@ contract TestBaseWorkflow is JBTest, DeployPermit2 {
         if (_nonce == 0x00) {
             data = abi.encodePacked(bytes1(0xd6), bytes1(0x94), _origin, bytes1(0x80));
         } else if (_nonce <= 0x7f) {
+            // forge-lint: disable-next-line(unsafe-typecast)
             data = abi.encodePacked(bytes1(0xd6), bytes1(0x94), _origin, uint8(_nonce));
         } else if (_nonce <= 0xff) {
+            // forge-lint: disable-next-line(unsafe-typecast)
             data = abi.encodePacked(bytes1(0xd7), bytes1(0x94), _origin, bytes1(0x81), uint8(_nonce));
         } else if (_nonce <= 0xffff) {
+            // forge-lint: disable-next-line(unsafe-typecast)
             data = abi.encodePacked(bytes1(0xd8), bytes1(0x94), _origin, bytes1(0x82), uint16(_nonce));
         } else if (_nonce <= 0xffffff) {
+            // forge-lint: disable-next-line(unsafe-typecast)
             data = abi.encodePacked(bytes1(0xd9), bytes1(0x94), _origin, bytes1(0x83), uint24(_nonce));
         } else {
+            // forge-lint: disable-next-line(unsafe-typecast)
             data = abi.encodePacked(bytes1(0xda), bytes1(0x94), _origin, bytes1(0x84), uint32(_nonce));
         }
         bytes32 hash = keccak256(data);

package/test/invariants/Phase3DeepInvariant.t.sol

@@ -1,13 +1,22 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.6;
 
-import "forge-std/StdInvariant.sol";
-import /* {*} from */ "../helpers/TestBaseWorkflow.sol";
+import {StdInvariant} from "forge-std/StdInvariant.sol";
+import {TestBaseWorkflow} from "../helpers/TestBaseWorkflow.sol";
+import {IJBRulesetApprovalHook} from "../../src/interfaces/IJBRulesetApprovalHook.sol";
+import {IJBSplitHook} from "../../src/interfaces/IJBSplitHook.sol";
+import {JBRulesetMetadataResolver} from "../../src/libraries/JBRulesetMetadataResolver.sol";
+import {JBCurrencyAmount} from "../../src/structs/JBCurrencyAmount.sol";
+import {JBFundAccessLimitGroup} from "../../src/structs/JBFundAccessLimitGroup.sol";
+import {JBRuleset} from "../../src/structs/JBRuleset.sol";
+import {JBRulesetConfig} from "../../src/structs/JBRulesetConfig.sol";
+import {JBRulesetMetadata} from "../../src/structs/JBRulesetMetadata.sol";
+import {JBSplit} from "../../src/structs/JBSplit.sol";
+import {JBSplitGroup} from "../../src/structs/JBSplitGroup.sol";
+import {JBTerminalConfig} from "../../src/structs/JBTerminalConfig.sol";
 import {Phase3Handler} from "./handlers/Phase3Handler.sol";
 import {JBAccountingContext} from "../../src/structs/JBAccountingContext.sol";
 import {JBConstants} from "../../src/libraries/JBConstants.sol";
-import {JBFee} from "../../src/structs/JBFee.sol";
-import {JBSplitGroupIds} from "../../src/libraries/JBSplitGroupIds.sol";
 
 /// @title Phase3DeepInvariant
 /// @notice Multi-project deep invariant tests with strict equality checks.
@@ -362,7 +371,6 @@ contract Phase3DeepInvariant_Local is StdInvariant, TestBaseWorkflow {
     /// @notice After addToBalance(shouldReturn=true), returned fees must not exceed held fees.
     function invariant_P3_6_heldFeeReturnBounded() public view {
         uint256 returned = handler.ghost_totalReturnedFees(project2);
-        uint256 heldTotal = handler.ghost_totalHeldFeeAmounts(project2);
 
         // Returned fees should never exceed what was held
         // (heldTotal may be 0 if we never tracked, so only check when both nonzero)