@bananapus/core-v6 0.0.61 → 0.0.63

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bananapus/core-v6",
-  "version": "0.0.61",
+  "version": "0.0.63",
   "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.
@@ -613,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("")
@@ -677,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.
@@ -724,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:
@@ -1866,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;
+            }
         }
     }
 
@@ -1874,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});
     }
 
@@ -2158,7 +2185,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

@@ -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.
@@ -1442,7 +1455,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;