@bananapus/core-v6 0.0.61 → 0.0.62

package/package.json

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

package/script/helpers/CoreDeploymentLib.sol

@@ -97,8 +97,11 @@ library CoreDeploymentLib {
             })
         );
 
+        // Controller is loaded best-effort so the periphery deploy script can bootstrap on a fresh chain that
+        // hasn't yet produced `JBController.json` — that script is the one that creates the controller. Other
+        // core artifacts are still required.
         deployment.controller = JBController(
-            _getDeploymentAddress({
+            _tryGetDeploymentAddress({
                 path: path, projectName: PROJECT_NAME, networkName: networkName, contractName: "JBController"
             })
         );
@@ -164,4 +167,24 @@ library CoreDeploymentLib {
         vm.readFile(string.concat(path, projectName, "/", networkName, "/", contractName, ".json"));
         return stdJson.readAddress({json: deploymentJson, key: ".address"});
     }
+
+    /// @notice Best-effort variant of `_getDeploymentAddress`. Returns `address(0)` when the artifact file does
+    /// not exist on disk, rather than reverting. Used for fields that may legitimately be absent during a
+    /// fresh-chain bootstrap (e.g. the controller artifact when the periphery script is the one creating it).
+    function _tryGetDeploymentAddress(
+        string memory path,
+        string memory projectName,
+        string memory networkName,
+        string memory contractName
+    )
+        internal
+        view
+        returns (address)
+    {
+        string memory filePath = string.concat(path, projectName, "/", networkName, "/", contractName, ".json");
+        // forge-lint: disable-next-line(unsafe-cheatcode)
+        if (!vm.exists(filePath)) return address(0);
+        // forge-lint: disable-next-line(unsafe-cheatcode)
+        return stdJson.readAddress({json: vm.readFile(filePath), key: ".address"});
+    }
 }

package/src/JBController.sol

@@ -172,8 +172,10 @@ contract JBController is JBPermissioned, ERC2771Context, IJBController, IJBMigra
     //*********************************************************************//
 
     /// @notice Registers a price feed so the project can use a new currency for payout limits or surplus allowances.
-    /// @dev Can only be called by the project's owner or an operator with `ADD_PRICE_FEED` permission. The current
-    /// ruleset must have `allowAddPriceFeed` enabled.
+    /// @dev Can only be called by the project's owner or an operator with `ADD_PRICE_FEED` permission. When a current
+    /// ruleset exists, it must have `allowAddPriceFeed` enabled. If no current ruleset exists (`ruleset.id == 0`),
+    /// the call is allowed unconditionally — this is the symmetric counterpart to `setTokenFor`, which mirrors the
+    /// gap-state allowance so projects can configure prerequisites before their first ruleset activates.
     /// @param projectId The ID of the project to add the feed for.
     /// @param pricingCurrency The currency the feed's output price is in terms of.
     /// @param unitCurrency The currency the feed prices.
@@ -194,8 +196,12 @@ contract JBController is JBPermissioned, ERC2771Context, IJBController, IJBMigra
 
         JBRuleset memory ruleset = _currentRulesetOf(projectId);
 
-        // Make sure the project's ruleset allows adding price feeds.
-        if (!ruleset.allowAddPriceFeed()) revert JBController_AddingPriceFeedNotAllowed(projectId);
+        // When a current ruleset exists, it must allow adding price feeds. If no current ruleset exists
+        // (`ruleset.id == 0`), the call is allowed unconditionally so projects can register feeds during the
+        // pre-launch or gap state — matching the gap-state semantics of `setTokenFor`.
+        if (ruleset.id != 0 && !ruleset.allowAddPriceFeed()) {
+            revert JBController_AddingPriceFeedNotAllowed(projectId);
+        }
 
         PRICES.addPriceFeedFor({
             projectId: projectId, pricingCurrency: pricingCurrency, unitCurrency: unitCurrency, feed: feed
@@ -1102,7 +1108,9 @@ contract JBController is JBPermissioned, ERC2771Context, IJBController, IJBMigra
                             })
                         ) {}
                     catch (bytes memory reason) {
-                        emit SplitHookReverted({projectId: projectId, hook: address(split.hook), reason: reason});
+                        emit SplitHookReverted({
+                            projectId: projectId, hook: address(split.hook), reason: reason, caller: messageSender
+                        });
                     }
 
                     // For ERC-20 tokens, burn any tokens the hook did not consume.

package/src/JBMultiTerminal.sol

@@ -501,8 +501,11 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
     /// @param token The token the fee is paid in.
     /// @param amount The fee amount, as a fixed point number with the same number of decimals as the token's
     /// accounting context.
-    /// @param beneficiary The address to mint tokens to (from the project which receives fees), and pass along to the
-    /// ruleset's data hook and pay hook if applicable.
+    /// @param beneficiary The address to mint fee-project tokens to (and pass along to the fee project's
+    /// data/pay hooks). If `address(0)`, the fee is routed via `addToBalanceOf` instead of `pay`, crediting the
+    /// fee project's balance directly without minting fee-project tokens. This honors the protocol-fee intent
+    /// (the fee project still receives the value) when no beneficiary is specified, instead of letting `pay`
+    /// revert inside `mintTokensOf` and having the catch path forgive the fee.
     /// @param feeTerminal The terminal that'll receive the fees.
     function executeProcessFee(
         uint256 projectId,
@@ -523,14 +526,24 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
         // Send the projectId in the metadata.
         bytes memory metadata = bytes(abi.encodePacked(projectId));
 
-        _efficientPay({
-            terminal: feeTerminal,
-            projectId: JBConstants.FEE_BENEFICIARY_PROJECT_ID,
-            token: token,
-            amount: amount,
-            beneficiary: beneficiary,
-            metadata: metadata
-        });
+        if (beneficiary == address(0)) {
+            _efficientAddToBalance({
+                terminal: feeTerminal,
+                projectId: JBConstants.FEE_BENEFICIARY_PROJECT_ID,
+                token: token,
+                amount: amount,
+                metadata: metadata
+            });
+        } else {
+            _efficientPay({
+                terminal: feeTerminal,
+                projectId: JBConstants.FEE_BENEFICIARY_PROJECT_ID,
+                token: token,
+                amount: amount,
+                beneficiary: beneficiary,
+                metadata: metadata
+            });
+        }
     }
 
     /// @notice Transfer funds to an address.
@@ -2158,7 +2171,8 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
                         projectId: projectId,
                         token: token,
                         amount: amountPaidOut,
-                        // The project owner will receive tokens minted by paying the platform fee.
+                        // The `feeBeneficiary` will receive the fee-project tokens minted in exchange for the
+                        // platform fee paid in terminal tokens.
                         beneficiary: feeBeneficiary,
                         shouldHoldFees: ruleset.holdFees()
                     }));

package/src/JBTerminalStore.sol

@@ -1442,7 +1442,8 @@ contract JBTerminalStore is IJBTerminalStore {
             referralChainId: referralChainId,
             referralProjectId: bareProjectId,
             amount: amount,
-            newTotal: newTotal
+            newTotal: newTotal,
+            caller: msg.sender
         });
     }
 

package/src/interfaces/IJBController.sol

@@ -102,7 +102,8 @@ interface IJBController is IERC165, IJBProjectUriRegistry, IJBDirectoryAccessCon
     /// @param projectId The ID of the project.
     /// @param hook The split hook that reverted.
     /// @param reason The revert reason.
-    event SplitHookReverted(uint256 indexed projectId, address hook, bytes reason);
+    /// @param caller The address that called the distribution function.
+    event SplitHookReverted(uint256 indexed projectId, address hook, bytes reason, address caller);
 
     /// @notice Reserved tokens were sent to a specific split.
     /// @param projectId The ID of the project.

package/src/interfaces/IJBTerminalStore.sol

@@ -25,12 +25,14 @@ interface IJBTerminalStore {
     /// @param referralProjectId The referrer's bare project ID on `referralChainId` (no chain bits).
     /// @param amount The fee amount credited, in the terminal's accounting-context units.
     /// @param newTotal The new value of `totalFeeVolumeOf[terminal]` after this credit.
+    /// @param caller The address that recorded the credit.
     event ReferralCredit(
         address indexed terminal,
         uint256 indexed referralChainId,
         uint256 indexed referralProjectId,
         uint256 amount,
-        uint256 newTotal
+        uint256 newTotal,
+        address caller
     );
 
     /// @notice The directory of terminals and controllers for projects.

package/src/libraries/JBRulesetMetadataResolver.sol

@@ -92,7 +92,10 @@ library JBRulesetMetadataResolver {
 
     /// @notice Pack the funding cycle metadata.
     /// @param rulesetMetadata The ruleset metadata to validate and pack.
-    /// @return packed The packed uint256 of all metadata params. The first 8 bits specify the version.
+    /// @return packed The packed uint256 of all metadata params. The first 4 bits (bits 0-3) specify the version;
+    /// supported values are 0-15. A future protocol version that needs more than 16 distinct metadata layouts must
+    /// widen this field before assigning a new version number, otherwise the high bits will silently spill into
+    /// the `reservedPercent` field that begins at bit 4.
     function packRulesetMetadata(JBRulesetMetadata memory rulesetMetadata) internal pure returns (uint256 packed) {
         // version 1 in the bits 0-3 (4 bits).
         packed = 1;