@bananapus/core-v6 0.0.62 → 0.0.64

package/package.json

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

package/src/JBController.sol

@@ -62,6 +62,7 @@ contract JBController is JBPermissioned, ERC2771Context, IJBController, IJBMigra
     error JBController_AddingPriceFeedNotAllowed(uint256 projectId);
     error JBController_CreditTransfersPaused(uint256 projectId, uint256 rulesetId);
     error JBController_InvalidCashOutTaxRate(uint256 rate, uint256 limit);
+    error JBController_InvalidCreationFee(uint256 value, uint256 requiredFee);
     error JBController_InvalidReservedPercent(uint256 percent, uint256 limit);
     error JBController_MintNotAllowedAndNotTerminalOrHook(address caller);
     error JBController_NoReservedTokens(uint256 projectId);
@@ -408,11 +409,18 @@ contract JBController is JBPermissioned, ERC2771Context, IJBController, IJBMigra
         string calldata memo
     )
         external
+        payable
         override
         returns (uint256 projectId)
     {
+        // Forward the exact project creation fee to `JBProjects`.
+        uint256 creationFee = PROJECTS.creationFee();
+        if (msg.value != creationFee) {
+            revert JBController_InvalidCreationFee({value: msg.value, requiredFee: creationFee});
+        }
+
         // Mint the project ERC-721 into the owner's wallet.
-        projectId = PROJECTS.createFor(owner);
+        projectId = PROJECTS.createFor{value: creationFee}(owner);
 
         // If provided, set the project's metadata URI.
         if (bytes(projectUri).length > 0) {

package/src/JBMultiTerminal.sol

@@ -626,7 +626,11 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
             }
 
             // Transfer the balance minus the fee to the new terminal.
-            uint256 migrationAmount = balance - feeAmount;
+            uint256 migrationAmount;
+            // `_takeFeeFrom` calculated `feeAmount` from `balance`, so it cannot exceed `balance`.
+            unchecked {
+                migrationAmount = balance - feeAmount;
+            }
 
             _externalAddToBalance({
                 terminal: to, projectId: projectId, token: token, amount: migrationAmount, metadata: bytes("")
@@ -690,7 +694,10 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
 
         // Set the beneficiary token count.
         if (beneficiaryBalanceAfter > beneficiaryBalanceBefore) {
-            beneficiaryTokenCount = beneficiaryBalanceAfter - beneficiaryBalanceBefore;
+            // Guarded by the comparison above.
+            unchecked {
+                beneficiaryTokenCount = beneficiaryBalanceAfter - beneficiaryBalanceBefore;
+            }
         }
 
         // The token count for the beneficiary must be greater than or equal to the specified minimum.
@@ -737,7 +744,10 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
             // reverting.
             //    A `FeeReverted` event is emitted so the forgiveness is observable off-chain.
             delete _heldFeesOf[projectId][token][currentIndex];
-            _nextHeldFeeIndexOf[projectId][token] = currentIndex + 1;
+            // `currentIndex` was proven to be within the held-fee array.
+            unchecked {
+                _nextHeldFeeIndexOf[projectId][token] = currentIndex + 1;
+            }
 
             // Restore the originating fee-paying call's referral project for the duration of this fee's processing
             // so the credit in `_processFee` attributes to the right (chain, project) pair. No save needed:
@@ -1879,6 +1889,10 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
             });
 
             _recordAddedBalanceFor({projectId: projectId, token: token, amount: amount});
+            // The store balance was credited first; this mirrors that bounded increase for fee recovery.
+            unchecked {
+                _feeFreeSurplusOf[projectId][token] += amount;
+            }
         }
     }
 
@@ -1887,7 +1901,7 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
     /// @param token The token to record the added balance for.
     /// @param amount The amount of the token to record, as a fixed point number with the same number of decimals as
     /// this terminal.
-    function _recordAddedBalanceFor(uint256 projectId, address token, uint256 amount) internal {
+    function _recordAddedBalanceFor(uint256 projectId, address token, uint256 amount) private {
         STORE.recordAddedBalanceFor({projectId: projectId, token: token, amount: amount});
     }
 

package/src/JBPrices.sol

@@ -2,7 +2,7 @@
 pragma solidity 0.8.28;
 
 import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
-import {ERC2771Context, Context} from "@openzeppelin/contracts/metatx/ERC2771Context.sol";
+import {Context, ERC2771Context} from "@openzeppelin/contracts/metatx/ERC2771Context.sol";
 import {mulDiv} from "@prb/math/src/Common.sol";
 
 import {JBControlled} from "./abstract/JBControlled.sol";
@@ -13,21 +13,19 @@ import {IJBPriceFeed} from "./interfaces/IJBPriceFeed.sol";
 import {IJBPrices} from "./interfaces/IJBPrices.sol";
 import {IJBProjects} from "./interfaces/IJBProjects.sol";
 
-/// @notice Provides currency conversion for the protocol. When a project's payout limits or surplus allowances are
-/// denominated in a currency different from the token held in its terminal (e.g. USD limits with ETH held), this
-/// contract resolves the exchange rate via registered price feeds (typically Chainlink oracles).
-/// @dev Price feeds are immutable once set — they cannot be replaced or removed. This protects against oracle
-/// manipulation via admin-key attacks. If a feed is misconfigured, operations using that pair will revert (DoS, not
-/// fund loss). The inverse of any registered feed is auto-calculated. Projects can have their own feeds; project ID 0
-/// holds protocol-wide defaults.
+/// @notice Resolves protocol currency conversions from append-only project and default price feeds.
+/// @dev Each feed prices one unit of `unitCurrency` in `pricingCurrency`. Feeds cannot be changed or removed once
+/// added. Later feeds for the same exact pair act as backups when earlier feeds revert or return zero. Project-specific
+/// feeds are checked before project ID 0 defaults, and inverse prices are derived at read time when only the opposite
+/// direction is configured. If no configured feed returns a non-zero price, the read reverts instead of guessing.
 contract JBPrices is JBControlled, JBPermissioned, ERC2771Context, Ownable, IJBPrices {
     //*********************************************************************//
     // --------------------------- custom errors ------------------------- //
     //*********************************************************************//
 
-    error JBPrices_PriceFeedAlreadyExists(IJBPriceFeed feed);
+    error JBPrices_PriceFeedAlreadyAdded(IJBPriceFeed feed);
     error JBPrices_PriceFeedNotFound(uint256 projectId, uint256 pricingCurrency, uint256 unitCurrency);
-    error JBPrices_ZeroPrice(uint256 projectId, uint256 pricingCurrency, uint256 unitCurrency, IJBPriceFeed feed);
+    error JBPrices_ZeroPriceFeed();
     error JBPrices_ZeroPricingCurrency(uint256 projectId, uint256 pricingCurrency);
     error JBPrices_ZeroUnitCurrency(uint256 projectId, uint256 unitCurrency);
 
@@ -46,23 +44,23 @@ contract JBPrices is JBControlled, JBPermissioned, ERC2771Context, Ownable, IJBP
     IJBProjects public immutable override PROJECTS;
 
     //*********************************************************************//
-    // --------------------- public stored properties -------------------- //
+    // -------------------- internal stored properties ------------------- //
     //*********************************************************************//
 
-    /// @notice The available price feeds.
-    /// @dev The feed returns the `pricingCurrency` cost for one unit of the `unitCurrency`.
-    /// @custom:param projectId The ID of the project the feed applies to. Feeds stored in ID 0 are used by default for
-    /// all projects.
-    /// @custom:param pricingCurrency The currency the feed's resulting price is in terms of.
-    /// @custom:param unitCurrency The currency the feed prices.
-    mapping(uint256 projectId => mapping(uint256 pricingCurrency => mapping(uint256 unitCurrency => IJBPriceFeed)))
-        public
-        override priceFeedFor;
+    /// @notice Price feeds available to each project for each exact currency pair.
+    /// @dev The array is append-only. Index 0 remains the primary feed, and later indexes are backups.
+    /// @custom:param projectId The ID of the project the feed applies to. Project ID 0 stores protocol defaults.
+    /// @custom:param pricingCurrency The currency the feed's returned price is denominated in.
+    /// @custom:param unitCurrency The currency whose unit is priced by the feed.
+    mapping(
+        uint256 projectId => mapping(uint256 pricingCurrency => mapping(uint256 unitCurrency => IJBPriceFeed[]))
+    ) internal _priceFeedsFor;
 
     //*********************************************************************//
     // ---------------------------- constructor -------------------------- //
     //*********************************************************************//
 
+    /// @notice Initializes the price registry and its permissioned dependencies.
     /// @param directory A contract storing directories of terminals and controllers for each project.
     /// @param permissions A contract storing permissions.
     /// @param projects A contract which mints ERC-721s that represent project ownership and transfers.
@@ -87,17 +85,16 @@ contract JBPrices is JBControlled, JBPermissioned, ERC2771Context, Ownable, IJBP
     // ---------------------- external transactions ---------------------- //
     //*********************************************************************//
 
-    /// @notice Register a price feed that provides the exchange rate between two currencies. For example, registering
-    /// an ETH/USD feed allows payout limits denominated in USD to be enforced against ETH balances.
-    /// @dev Price feeds are immutable — once set for a currency pair, they cannot be replaced or removed. This
-    /// prevents
-    /// admin-key oracle manipulation. The inverse rate is auto-calculated, so registering A→B also provides B→A.
-    /// @dev Pass `projectId` = 0 to set a protocol-wide default (owner only). Non-zero project IDs require controller
-    /// authorization. A default feed for a pair blocks per-project overrides for that same pair.
-    /// @param projectId The ID of the project to add a feed for. Pass 0 for a protocol-wide default.
-    /// @param pricingCurrency The currency the feed's output price is in terms of.
-    /// @param unitCurrency The currency the feed prices.
-    /// @param feed The address of the price feed to add.
+    /// @notice Adds an append-only price feed for a project's exact currency pair.
+    /// @dev Project ID 0 stores protocol defaults and can only be configured by this contract's owner. Non-zero
+    /// project IDs can only be configured by that project's controller. The feed is stored only for the exact
+    /// `pricingCurrency`/`unitCurrency` direction; the opposite direction is derived by `pricePerUnitOf` when needed.
+    /// @dev Later feeds for the same exact pair are backups. The existing feeds remain preferred, and this function
+    /// rejects duplicate feed addresses for the exact pair.
+    /// @param projectId The ID of the project to add the feed for, or 0 to add a protocol default.
+    /// @param pricingCurrency The currency that the feed's returned price is denominated in.
+    /// @param unitCurrency The currency whose unit is priced by the feed.
+    /// @param feed The price feed to add.
     function addPriceFeedFor(
         uint256 projectId,
         uint256 pricingCurrency,
@@ -107,48 +104,26 @@ contract JBPrices is JBControlled, JBPermissioned, ERC2771Context, Ownable, IJBP
         external
         override
     {
-        // Ensure default price feeds can only be set by this contract's owner, and that other `projectId`s can only be
-        // set by the controller
+        // Project 0 configures defaults for every project; each other project delegates feed configuration to its
+        // controller.
         projectId == DEFAULT_PROJECT_ID ? _checkOwner() : _onlyControllerOf(projectId);
 
-        // Make sure the pricing currency isn't 0.
         if (pricingCurrency == 0) {
             revert JBPrices_ZeroPricingCurrency({projectId: projectId, pricingCurrency: pricingCurrency});
         }
 
-        // Make sure the unit currency isn't 0.
         if (unitCurrency == 0) revert JBPrices_ZeroUnitCurrency({projectId: projectId, unitCurrency: unitCurrency});
 
-        // Make sure there isn't already a default price feed for the pair or its inverse.
-        if (
-            priceFeedFor[DEFAULT_PROJECT_ID][pricingCurrency][unitCurrency] != IJBPriceFeed(address(0))
-                || priceFeedFor[DEFAULT_PROJECT_ID][unitCurrency][pricingCurrency] != IJBPriceFeed(address(0))
-        ) {
-            revert JBPrices_PriceFeedAlreadyExists({
-                feed: priceFeedFor[DEFAULT_PROJECT_ID][pricingCurrency][unitCurrency] != IJBPriceFeed(address(0))
-                    ? priceFeedFor[DEFAULT_PROJECT_ID][pricingCurrency][unitCurrency]
-                    : priceFeedFor[DEFAULT_PROJECT_ID][unitCurrency][pricingCurrency]
-            });
-        }
+        if (feed == IJBPriceFeed(address(0))) revert JBPrices_ZeroPriceFeed();
 
-        // Make sure this project doesn't already have a price feed for the pair or its inverse.
-        if (
-            priceFeedFor[projectId][pricingCurrency][unitCurrency] != IJBPriceFeed(address(0))
-                || priceFeedFor[projectId][unitCurrency][pricingCurrency] != IJBPriceFeed(address(0))
-        ) {
-            revert JBPrices_PriceFeedAlreadyExists({
-                feed: priceFeedFor[projectId][pricingCurrency][unitCurrency] != IJBPriceFeed(address(0))
-                    ? priceFeedFor[projectId][pricingCurrency][unitCurrency]
-                    : priceFeedFor[projectId][unitCurrency][pricingCurrency]
-            });
-        }
+        // Only exact-direction duplicates are rejected. Opposite-direction feeds can coexist and are used when deriving
+        // inverse prices.
+        _requireNewPriceFeed({
+            projectId: projectId, pricingCurrency: pricingCurrency, unitCurrency: unitCurrency, feed: feed
+        });
 
-        // Price feed immutability is by design to prevent admin-key attacks on price oracles.
-        // If a feed fails, operations using that currency pair revert (DoS but not fund loss). Projects can use
-        // alternative currency pairs. A default feed for a currency pair prevents per-project overrides to ensure
-        // price consistency; projects should use unused currency IDs for custom pricing.
-        // Store the feed.
-        priceFeedFor[projectId][pricingCurrency][unitCurrency] = feed;
+        // Keep existing feeds immutable: appending preserves the primary feed and adds this feed as the last fallback.
+        _priceFeedsFor[projectId][pricingCurrency][unitCurrency].push(feed);
 
         emit AddPriceFeed({
             projectId: projectId,
@@ -159,21 +134,86 @@ contract JBPrices is JBControlled, JBPermissioned, ERC2771Context, Ownable, IJBP
         });
     }
 
+    //*********************************************************************//
+    // ----------------------- external views ---------------------------- //
+    //*********************************************************************//
+
+    /// @notice Returns the feed stored at an exact pair's index.
+    /// @dev This view does not apply inverse or project-default fallback lookup. It reverts with Solidity's default
+    /// array bounds check if `index` is not configured.
+    /// @param projectId The ID of the project whose feed should be returned.
+    /// @param pricingCurrency The currency that the feed's returned price is denominated in.
+    /// @param unitCurrency The currency whose unit is priced by the feed.
+    /// @param index The index of the feed to return.
+    /// @return feed The configured price feed for the exact pair at `index`.
+    function priceFeedAt(
+        uint256 projectId,
+        uint256 pricingCurrency,
+        uint256 unitCurrency,
+        uint256 index
+    )
+        external
+        view
+        override
+        returns (IJBPriceFeed feed)
+    {
+        return _priceFeedsFor[projectId][pricingCurrency][unitCurrency][index];
+    }
+
+    /// @notice Returns the number of feeds configured for an exact currency pair.
+    /// @dev This count does not include feeds configured for the inverse direction or project ID 0 defaults.
+    /// @param projectId The ID of the project whose feed count should be returned.
+    /// @param pricingCurrency The currency that the feeds' returned prices are denominated in.
+    /// @param unitCurrency The currency whose unit is priced by the feeds.
+    /// @return count The number of configured price feeds for the exact pair.
+    function priceFeedCountFor(
+        uint256 projectId,
+        uint256 pricingCurrency,
+        uint256 unitCurrency
+    )
+        external
+        view
+        override
+        returns (uint256 count)
+    {
+        return _priceFeedsFor[projectId][pricingCurrency][unitCurrency].length;
+    }
+
+    /// @notice Returns the primary feed for an exact currency pair, or zero if none is configured.
+    /// @dev This view does not apply inverse or project-default fallback lookup. Use `pricePerUnitOf` to resolve a
+    /// usable price through the full backup path.
+    /// @param projectId The ID of the project whose primary feed should be returned.
+    /// @param pricingCurrency The currency that the feed's returned price is denominated in.
+    /// @param unitCurrency The currency whose unit is priced by the feed.
+    /// @return feed The first configured price feed for the exact pair, or the zero address if none exists.
+    function priceFeedFor(
+        uint256 projectId,
+        uint256 pricingCurrency,
+        uint256 unitCurrency
+    )
+        external
+        view
+        override
+        returns (IJBPriceFeed feed)
+    {
+        return _priceFeedsFor[projectId][pricingCurrency][unitCurrency].length == 0
+            ? IJBPriceFeed(address(0))
+            : _priceFeedsFor[projectId][pricingCurrency][unitCurrency][0];
+    }
+
     //*********************************************************************//
     // -------------------------- public views --------------------------- //
     //*********************************************************************//
 
-    /// @notice Convert between currencies — returns how much of `pricingCurrency` one unit of `unitCurrency` is
-    /// worth.
-    /// For example, `pricePerUnitOf(id, USD, ETH, 18)` returns the USD price of 1 ETH with 18 decimals.
-    /// @dev Lookup order: project-specific feed → inverse of project feed → default feed (project 0) → inverse of
-    /// default. Reverts with `JBPrices_PriceFeedNotFound` if no feed exists in any direction.
-    /// @param projectId The ID of the project to check the feed for. Falls back to project 0 (protocol defaults).
-    /// @param pricingCurrency The currency the result is denominated in.
-    /// @param unitCurrency The currency to price.
-    /// @param decimals The number of decimals the returned fixed point price should include.
-    /// @return The `pricingCurrency` price of 1 `unitCurrency`, as a fixed point number with the specified number of
-    /// decimals.
+    /// @notice Returns the price of one `unitCurrency` unit denominated in `pricingCurrency`.
+    /// @dev Lookup order is project direct feeds, project inverse feeds, default direct feeds, then default inverse
+    /// feeds. Each feed list is tried in registration order, skipping feeds that revert or return zero. Reverts with
+    /// `JBPrices_PriceFeedNotFound` if no configured feed in that lookup path returns a non-zero price.
+    /// @param projectId The ID of the project to check first. Project ID 0 feeds are used as defaults.
+    /// @param pricingCurrency The currency that the returned price is denominated in.
+    /// @param unitCurrency The currency whose unit is being priced.
+    /// @param decimals The number of decimals the returned fixed point price should use.
+    /// @return price The `pricingCurrency` price of one `unitCurrency`, using `decimals` fixed point precision.
     function pricePerUnitOf(
         uint256 projectId,
         uint256 pricingCurrency,
@@ -183,71 +223,84 @@ contract JBPrices is JBControlled, JBPermissioned, ERC2771Context, Ownable, IJBP
         public
         view
         override
-        returns (uint256)
+        returns (uint256 price)
     {
-        // If the `pricingCurrency` is the `unitCurrency`, return 1 since they have the same price. Include the
-        // desired number of decimals.
+        // Same-currency conversions are always 1 in the requested fixed-point precision.
         if (pricingCurrency == unitCurrency) return 10 ** decimals;
 
-        // Get a reference to the price feed.
-        IJBPriceFeed feed = priceFeedFor[projectId][pricingCurrency][unitCurrency];
+        bool found;
 
-        // If the feed exists, return its non-zero price.
-        if (feed != IJBPriceFeed(address(0))) {
-            uint256 price = feed.currentUnitPrice(decimals);
-            if (price == 0) {
-                revert JBPrices_ZeroPrice({
-                    projectId: projectId, pricingCurrency: pricingCurrency, unitCurrency: unitCurrency, feed: feed
-                });
-            }
-            return price;
-        }
-
-        // Try getting the inverse feed.
-        feed = priceFeedFor[projectId][unitCurrency][pricingCurrency];
-
-        // If it exists, return the inverse of its price.
-        // @dev The inverse calculation `(10^d * 10^d) / price` has acceptable precision when the feed price
-        // is in the range of ~1e9 to ~1e27 (for 18 decimals). Extreme prices outside this range may lose
-        // significant precision due to fixed-point division truncation.
-        if (feed != IJBPriceFeed(address(0))) {
-            uint256 inversePrice = feed.currentUnitPrice(decimals);
-            if (inversePrice == 0) {
-                revert JBPrices_ZeroPrice({
-                    projectId: projectId, pricingCurrency: unitCurrency, unitCurrency: pricingCurrency, feed: feed
-                });
-            }
-            return mulDiv({x: 10 ** decimals, y: 10 ** decimals, denominator: inversePrice});
-        }
+        // Project-specific feeds take priority over defaults, including their configured backups.
+        (price, found) = _pricePerUnitOf({
+            projectId: projectId, pricingCurrency: pricingCurrency, unitCurrency: unitCurrency, decimals: decimals
+        });
+        if (found) return price;
 
-        // Check for a default feed (project ID 0) if not found.
         if (projectId != DEFAULT_PROJECT_ID) {
-            return pricePerUnitOf({
+            // Project 0 feeds are the shared defaults. Avoid checking them twice when project ID 0 was requested.
+            (price, found) = _pricePerUnitOf({
                 projectId: DEFAULT_PROJECT_ID,
                 pricingCurrency: pricingCurrency,
                 unitCurrency: unitCurrency,
                 decimals: decimals
             });
+            if (found) return price;
         }
 
-        // No price feed available, revert.
         revert JBPrices_PriceFeedNotFound({
             projectId: projectId, pricingCurrency: pricingCurrency, unitCurrency: unitCurrency
         });
     }
 
     //*********************************************************************//
-    // -------------------------- internal views ------------------------- //
+    // ----------------------- internal helpers -------------------------- //
     //*********************************************************************//
 
+    /// @notice Reverts if `feed` is already configured for an exact currency pair.
+    /// @param projectId The ID of the project whose pair should be checked.
+    /// @param pricingCurrency The currency that the feed's returned price is denominated in.
+    /// @param unitCurrency The currency whose unit is priced by the feed.
+    /// @param feed The price feed to check.
+    function _requireNewPriceFeed(
+        uint256 projectId,
+        uint256 pricingCurrency,
+        uint256 unitCurrency,
+        IJBPriceFeed feed
+    )
+        internal
+        view
+    {
+        IJBPriceFeed[] storage feeds = _priceFeedsFor[projectId][pricingCurrency][unitCurrency];
+        uint256 numberOfFeeds = feeds.length;
+
+        for (uint256 i; i < numberOfFeeds;) {
+            if (feeds[i] == feed) revert JBPrices_PriceFeedAlreadyAdded({feed: feed});
+
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    //*********************************************************************//
+    // ----------------------- internal views ---------------------------- //
+    //*********************************************************************//
+
+    /// @notice Returns the ERC-2771 context suffix length.
     /// @dev `ERC-2771` specifies the context as being a single address (20 bytes).
-    function _contextSuffixLength() internal view override(ERC2771Context, Context) returns (uint256) {
+    /// @return contextSuffixLength The context suffix length.
+    function _contextSuffixLength()
+        internal
+        view
+        override(ERC2771Context, Context)
+        returns (uint256 contextSuffixLength)
+    {
         return super._contextSuffixLength();
     }
 
     /// @notice The calldata. Preferred to use over `msg.data`.
-    /// @return calldata The `msg.data` of this call.
-    function _msgData() internal view override(ERC2771Context, Context) returns (bytes calldata) {
+    /// @return data The `msg.data` of this call.
+    function _msgData() internal view override(ERC2771Context, Context) returns (bytes calldata data) {
         return ERC2771Context._msgData();
     }
 
@@ -256,4 +309,89 @@ contract JBPrices is JBControlled, JBPermissioned, ERC2771Context, Ownable, IJBP
     function _msgSender() internal view override(ERC2771Context, Context) returns (address sender) {
         return ERC2771Context._msgSender();
     }
+
+    /// @notice Returns the first non-zero direct price from `feeds`.
+    /// @dev Feeds are tried in registration order. A feed that reverts or returns zero is treated as unavailable.
+    /// @param feeds The direct price feeds to try.
+    /// @param decimals The number of decimals the returned fixed point price should use.
+    /// @return price The first non-zero price returned by the feeds.
+    /// @return found Whether a usable price was found.
+    function _priceFrom(
+        IJBPriceFeed[] storage feeds,
+        uint256 decimals
+    )
+        internal
+        view
+        returns (uint256 price, bool found)
+    {
+        uint256 numberOfFeeds = feeds.length;
+        for (uint256 i; i < numberOfFeeds;) {
+            // Try each feed independently so one unavailable oracle does not block later backups.
+            try feeds[i].currentUnitPrice(decimals) returns (uint256 returnedPrice) {
+                if (returnedPrice != 0) return (returnedPrice, true);
+            } catch {}
+
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    /// @notice Returns the first non-zero inverse price from `feeds`.
+    /// @dev Feeds are tried in registration order. A feed that reverts, returns zero, or inverts to zero at the
+    /// requested precision is treated as unavailable.
+    /// @param feeds The opposite-direction price feeds to invert.
+    /// @param decimals The number of decimals the returned fixed point price should use.
+    /// @return price The first non-zero inverse price returned by the feeds.
+    /// @return found Whether a usable inverse price was found.
+    function _priceFromInverse(
+        IJBPriceFeed[] storage feeds,
+        uint256 decimals
+    )
+        internal
+        view
+        returns (uint256 price, bool found)
+    {
+        uint256 numberOfFeeds = feeds.length;
+        for (uint256 i; i < numberOfFeeds;) {
+            // Each opposite-direction feed is optional; continue to backups if it cannot produce a usable price.
+            try feeds[i].currentUnitPrice(decimals) returns (uint256 inversePrice) {
+                if (inversePrice != 0) {
+                    // Convert "unit per pricing" into "pricing per unit" using the same fixed-point precision.
+                    uint256 invertedPrice = mulDiv({x: 10 ** decimals, y: 10 ** decimals, denominator: inversePrice});
+                    if (invertedPrice != 0) return (invertedPrice, true);
+                }
+            } catch {}
+
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    /// @notice Returns a non-zero price from a project's direct or inverse feeds.
+    /// @dev Direct feeds are preferred over inverse feeds for the same project and pair.
+    /// @param projectId The ID of the project whose feeds should be checked.
+    /// @param pricingCurrency The currency that the returned price should be denominated in.
+    /// @param unitCurrency The currency whose unit is being priced.
+    /// @param decimals The number of decimals the returned fixed point price should use.
+    /// @return price The first usable direct or inverse price.
+    /// @return found Whether a usable price was found.
+    function _pricePerUnitOf(
+        uint256 projectId,
+        uint256 pricingCurrency,
+        uint256 unitCurrency,
+        uint256 decimals
+    )
+        internal
+        view
+        returns (uint256 price, bool found)
+    {
+        (price, found) =
+            _priceFrom({feeds: _priceFeedsFor[projectId][pricingCurrency][unitCurrency], decimals: decimals});
+        if (found) return (price, true);
+
+        (price, found) =
+            _priceFromInverse({feeds: _priceFeedsFor[projectId][unitCurrency][pricingCurrency], decimals: decimals});
+    }
 }

package/src/JBProjects.sol

@@ -4,6 +4,7 @@ pragma solidity 0.8.28;
 import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
 import {ERC2771Context} from "@openzeppelin/contracts/metatx/ERC2771Context.sol";
 import {ERC721, Context} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
 import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 
 import {IJBProjects} from "./interfaces/IJBProjects.sol";
@@ -13,10 +14,23 @@ import {IJBTokenUriResolver} from "./interfaces/IJBTokenUriResolver.sol";
 /// rulesets, terminals, and permissions. Projects are created with `createFor` and the resulting token ID is used as
 /// the project's ID across the entire protocol.
 contract JBProjects is ERC721, ERC2771Context, Ownable, IJBProjects {
+    //*********************************************************************//
+    // --------------------------- custom errors ------------------------- //
+    //*********************************************************************//
+
+    error JBProjects_InvalidCreationFee(uint256 value, uint256 requiredFee);
+    error JBProjects_ZeroCreationFeeReceiver();
+
     //*********************************************************************//
     // --------------------- public stored properties -------------------- //
     //*********************************************************************//
 
+    /// @notice The native-token fee required to create a project.
+    uint256 public override creationFee;
+
+    /// @notice The address that receives project creation fees.
+    address payable public override creationFeeReceiver;
+
     /// @notice The number of projects that have been created using this contract.
     /// @dev The count is incremented with each new project created.
     /// @dev The resulting ERC-721 token ID for each project is the newly incremented count value.
@@ -51,6 +65,21 @@ contract JBProjects is ERC721, ERC2771Context, Ownable, IJBProjects {
     // ---------------------- external transactions ---------------------- //
     //*********************************************************************//
 
+    /// @notice Set the native-token fee required to create a project and the address that receives it.
+    /// @dev Only this contract's owner can change the fee. A non-zero fee requires a non-zero receiver.
+    /// @param fee The required creation fee. Set to 0 to disable creation fees.
+    /// @param receiver The address that receives project creation fees.
+    function setCreationFee(uint256 fee, address payable receiver) external override onlyOwner {
+        // Non-zero fees need somewhere to go.
+        if (fee != 0 && receiver == address(0)) revert JBProjects_ZeroCreationFeeReceiver();
+
+        // Store the fee configuration.
+        creationFee = fee;
+        creationFeeReceiver = receiver;
+
+        emit SetCreationFee({fee: fee, receiver: receiver, caller: _msgSender()});
+    }
+
     /// @notice Set the contract that resolves project NFT metadata (the `tokenURI`). This controls what artwork and
     /// JSON metadata is returned for each project's ERC-721 token.
     /// @dev Only this contract's owner can change the resolver.
@@ -68,9 +97,14 @@ contract JBProjects is ERC721, ERC2771Context, Ownable, IJBProjects {
 
     /// @notice Create a new project for the specified owner, which mints an NFT (ERC-721) into their wallet.
     /// @dev Anyone can create a project on an owner's behalf.
+    /// @dev Requires exactly `creationFee` native tokens. The fee is forwarded after the project NFT is minted.
     /// @param owner The address that will be the owner of the project.
     /// @return projectId The token ID of the newly created project.
-    function createFor(address owner) public override returns (uint256 projectId) {
+    function createFor(address owner) public payable override returns (uint256 projectId) {
+        // Keep a reference to the fee. It must be paid exactly to avoid accidental overpayment.
+        uint256 fee = creationFee;
+        if (msg.value != fee) revert JBProjects_InvalidCreationFee({value: msg.value, requiredFee: fee});
+
         // Increment the count, which will be used as the ID.
         projectId = ++count;
 
@@ -78,6 +112,13 @@ contract JBProjects is ERC721, ERC2771Context, Ownable, IJBProjects {
 
         // Mint the project.
         _safeMint({to: owner, tokenId: projectId});
+
+        // Forward the fee if one is configured.
+        if (fee != 0) {
+            address payable receiver = creationFeeReceiver;
+            if (receiver == address(0)) revert JBProjects_ZeroCreationFeeReceiver();
+            Address.sendValue({recipient: receiver, amount: fee});
+        }
     }
 
     //*********************************************************************//

package/src/JBTerminalStore.sol

@@ -43,6 +43,7 @@ contract JBTerminalStore is IJBTerminalStore {
     error JBTerminalStore_AccountingContextDecimalsMismatch(
         address token, uint256 providedDecimals, uint256 expectedDecimals
     );
+    error JBTerminalStore_AccountingContextDecimalsOutOfRange(address token, uint256 decimals);
     error JBTerminalStore_AddingAccountingContextNotAllowed(uint256 projectId, uint256 rulesetId, address terminal);
     error JBTerminalStore_InadequateControllerAllowance(uint256 amount, uint256 allowance);
 
@@ -212,6 +213,12 @@ contract JBTerminalStore is IJBTerminalStore {
                 revert JBTerminalStore_AccountingContextAlreadySet({token: context.token});
             }
 
+            if (context.decimals > 36) {
+                revert JBTerminalStore_AccountingContextDecimalsOutOfRange({
+                    token: context.token, decimals: context.decimals
+                });
+            }
+
             // Keep track of a flag indicating if we know the provided decimals are incorrect.
             bool knownInvalidDecimals;
             uint256 expectedDecimals;
@@ -222,16 +229,22 @@ contract JBTerminalStore is IJBTerminalStore {
                 expectedDecimals = 18;
             } else if (context.token != JBConstants.NATIVE_TOKEN && context.token.code.length > 0) {
                 try IERC20Metadata(context.token).decimals() returns (uint8 decimals) {
-                    if (context.decimals != decimals) {
-                        knownInvalidDecimals = true;
-                        expectedDecimals = decimals;
-                    }
+                    expectedDecimals = decimals;
                 } catch {
                     // The token didn't support `decimals`.
                     // @dev Non-standard ERC20s that revert on `decimals()` will bypass decimal validation.
                     // The caller is responsible for providing the correct decimals for such tokens.
                     knownInvalidDecimals = false;
+                    expectedDecimals = context.decimals;
                 }
+
+                if (expectedDecimals > 36) {
+                    revert JBTerminalStore_AccountingContextDecimalsOutOfRange({
+                        token: context.token, decimals: expectedDecimals
+                    });
+                }
+
+                if (context.decimals != expectedDecimals) knownInvalidDecimals = true;
             }
 
             // Make sure the decimals are correct.

package/src/interfaces/IJBController.sol

@@ -306,6 +306,7 @@ interface IJBController is IERC165, IJBProjectUriRegistry, IJBDirectoryAccessCon
         string calldata memo
     )
         external
+        payable
         returns (uint256 projectId);
 
     /// @notice Queues a project's initial rulesets and sets up terminals for it.

package/src/interfaces/IJBPrices.sol

@@ -4,14 +4,12 @@ pragma solidity ^0.8.0;
 import {IJBPriceFeed} from "./IJBPriceFeed.sol";
 import {IJBProjects} from "./IJBProjects.sol";
 
-/// @notice Interface for the price feed registry. Resolves exchange rates between currencies via immutable price feeds
-/// (typically Chainlink). Used when payout limits or surplus allowances are denominated in a different currency than
-/// the token held in the terminal.
+/// @notice Resolves protocol currency conversions from append-only project and default price feeds.
 interface IJBPrices {
-    /// @notice A price feed was added for a project's currency pair.
-    /// @param projectId The ID of the project the price feed was added for.
-    /// @param pricingCurrency The currency the feed's output price is in terms of.
-    /// @param unitCurrency The currency the feed prices.
+    /// @notice Emitted when a price feed is added for an exact currency pair.
+    /// @param projectId The ID of the project the price feed was added for. Project ID 0 stores protocol defaults.
+    /// @param pricingCurrency The currency that the feed's returned price is denominated in.
+    /// @param unitCurrency The currency whose unit is priced by the feed.
     /// @param feed The price feed that was added.
     /// @param caller The address that added the price feed.
     event AddPriceFeed(
@@ -22,17 +20,54 @@ interface IJBPrices {
         address caller
     );
 
-    /// @notice The project ID used as a fallback when no project-specific price feed is set.
-    function DEFAULT_PROJECT_ID() external view returns (uint256);
+    /// @notice The project ID used to store protocol default price feeds.
+    /// @return projectId The project ID used to store protocol defaults.
+    function DEFAULT_PROJECT_ID() external view returns (uint256 projectId);
 
     /// @notice Mints ERC-721s that represent project ownership and transfers.
-    function PROJECTS() external view returns (IJBProjects);
+    /// @return projects The project NFT contract.
+    function PROJECTS() external view returns (IJBProjects projects);
 
-    /// @notice Returns the price feed for a project's currency pair.
-    /// @param projectId The ID of the project to get the price feed of.
-    /// @param pricingCurrency The currency the feed's output price is in terms of.
-    /// @param unitCurrency The currency the feed prices.
-    /// @return The price feed for the currency pair.
+    /// @notice Returns the feed stored at an exact pair's index.
+    /// @dev This view does not apply inverse or project-default fallback lookup. It reverts with Solidity's default
+    /// array bounds check if `index` is not configured.
+    /// @param projectId The ID of the project whose feed should be returned.
+    /// @param pricingCurrency The currency that the feed's returned price is denominated in.
+    /// @param unitCurrency The currency whose unit is priced by the feed.
+    /// @param index The index of the feed to return.
+    /// @return feed The configured price feed for the exact pair at `index`.
+    function priceFeedAt(
+        uint256 projectId,
+        uint256 pricingCurrency,
+        uint256 unitCurrency,
+        uint256 index
+    )
+        external
+        view
+        returns (IJBPriceFeed);
+
+    /// @notice Returns the number of feeds configured for an exact currency pair.
+    /// @dev This count does not include feeds configured for the inverse direction or project ID 0 defaults.
+    /// @param projectId The ID of the project whose feed count should be returned.
+    /// @param pricingCurrency The currency that the feeds' returned prices are denominated in.
+    /// @param unitCurrency The currency whose unit is priced by the feeds.
+    /// @return count The number of configured price feeds for the exact pair.
+    function priceFeedCountFor(
+        uint256 projectId,
+        uint256 pricingCurrency,
+        uint256 unitCurrency
+    )
+        external
+        view
+        returns (uint256 count);
+
+    /// @notice Returns the primary feed for an exact currency pair, or zero if none is configured.
+    /// @dev This view only returns the stored primary feed address. It does not call the feed, skip unavailable feeds,
+    /// derive inverse feeds, or fall back to project ID 0 defaults.
+    /// @param projectId The ID of the project whose primary feed should be returned.
+    /// @param pricingCurrency The currency that the feed's returned price is denominated in.
+    /// @param unitCurrency The currency whose unit is priced by the feed.
+    /// @return feed The first configured price feed for the exact pair, or the zero address if none exists.
     function priceFeedFor(
         uint256 projectId,
         uint256 pricingCurrency,
@@ -40,14 +75,16 @@ interface IJBPrices {
     )
         external
         view
-        returns (IJBPriceFeed);
+        returns (IJBPriceFeed feed);
 
-    /// @notice Returns the unit price for a currency pair.
-    /// @param projectId The ID of the project to get the price for.
-    /// @param pricingCurrency The currency the returned price is in terms of.
-    /// @param unitCurrency The currency to price.
-    /// @param decimals The number of decimals the returned price should use.
-    /// @return The unit price.
+    /// @notice Returns the price of one `unitCurrency` unit denominated in `pricingCurrency`.
+    /// @dev Lookup order is project direct feeds, project inverse feeds, default direct feeds, then default inverse
+    /// feeds. Each feed list is tried in registration order, skipping feeds that revert or return zero.
+    /// @param projectId The ID of the project to check first. Project ID 0 feeds are used as defaults.
+    /// @param pricingCurrency The currency that the returned price is denominated in.
+    /// @param unitCurrency The currency whose unit is being priced.
+    /// @param decimals The number of decimals the returned fixed point price should use.
+    /// @return price The `pricingCurrency` price of one `unitCurrency`, using `decimals` fixed point precision.
     function pricePerUnitOf(
         uint256 projectId,
         uint256 pricingCurrency,
@@ -56,12 +93,14 @@ interface IJBPrices {
     )
         external
         view
-        returns (uint256);
+        returns (uint256 price);
 
-    /// @notice Adds a price feed for a project's currency pair.
-    /// @param projectId The ID of the project to add the price feed for.
-    /// @param pricingCurrency The currency the feed's output price is in terms of.
-    /// @param unitCurrency The currency the feed prices.
+    /// @notice Adds an append-only price feed for a project's exact currency pair.
+    /// @dev Project ID 0 stores protocol defaults and can only be configured by this contract's owner. Non-zero
+    /// project IDs can only be configured by that project's controller.
+    /// @param projectId The ID of the project to add the feed for, or 0 to add a protocol default.
+    /// @param pricingCurrency The currency that the feed's returned price is denominated in.
+    /// @param unitCurrency The currency whose unit is priced by the feed.
     /// @param feed The price feed to add.
     function addPriceFeedFor(
         uint256 projectId,

package/src/interfaces/IJBProjects.sol

@@ -13,11 +13,23 @@ interface IJBProjects is IERC721 {
     /// @param caller The address that created the project.
     event Create(uint256 indexed projectId, address indexed owner, address caller);
 
+    /// @notice The native-token fee required to create a project was set.
+    /// @param fee The required creation fee.
+    /// @param receiver The address that receives the fee.
+    /// @param caller The address that set the fee.
+    event SetCreationFee(uint256 fee, address payable receiver, address caller);
+
     /// @notice The token URI resolver was set.
     /// @param resolver The new token URI resolver.
     /// @param caller The address that set the resolver.
     event SetTokenUriResolver(IJBTokenUriResolver indexed resolver, address caller);
 
+    /// @notice Returns the native-token fee required to create a project.
+    function creationFee() external view returns (uint256);
+
+    /// @notice Returns the address that receives project creation fees.
+    function creationFeeReceiver() external view returns (address payable);
+
     /// @notice Returns the total number of projects that have been created.
     function count() external view returns (uint256);
 
@@ -27,7 +39,12 @@ interface IJBProjects is IERC721 {
     /// @notice Creates a new project and mints the project's ERC-721 to the specified owner.
     /// @param owner The address that will own the new project's ERC-721.
     /// @return projectId The ID of the newly created project.
-    function createFor(address owner) external returns (uint256 projectId);
+    function createFor(address owner) external payable returns (uint256 projectId);
+
+    /// @notice Sets the native-token fee required to create a project and the address that receives it.
+    /// @param fee The required creation fee. Set to 0 to disable creation fees.
+    /// @param receiver The address that receives creation fees. Must be non-zero when `fee` is non-zero.
+    function setCreationFee(uint256 fee, address payable receiver) external;
 
     /// @notice Sets the token URI resolver used to retrieve project token URIs.
     /// @param resolver The new token URI resolver.