@bananapus/router-terminal-v6 0.0.54 → 0.0.56

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@bananapus/router-terminal-v6",
-  "version": "0.0.54",
+  "version": "0.0.56",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/Bananapus/nana-router-terminal-v6"
+    "url": "git+https://github.com/Bananapus/nana-router-terminal-v6.git"
   },
   "files": [
     "foundry.toml",
@@ -24,10 +24,10 @@
     "artifacts": "source ./.env && npx sphinx artifacts --org-id 'ea165b21-7cdc-4d7b-be59-ecdd4c26bee4' --project-name 'nana-router-terminal-v6'"
   },
   "dependencies": {
-    "@bananapus/buyback-hook-v6": "^0.0.55",
-    "@bananapus/core-v6": "^0.0.68",
+    "@bananapus/buyback-hook-v6": "^0.0.58",
+    "@bananapus/core-v6": "^0.0.72",
     "@bananapus/permission-ids-v6": "^0.0.27",
-    "@bananapus/univ4-router-v6": "^0.0.40",
+    "@bananapus/univ4-router-v6": "^0.0.46",
     "@openzeppelin/contracts": "5.6.1",
     "@uniswap/permit2": "github:Uniswap/permit2#cc56ad0f3439c502c246fc5cfcc3db92bb8b7219",
     "@uniswap/v3-core": "github:Uniswap/v3-core#6562c52e8f75f0c10f9deaf44861847585fc8129",

package/src/JBRouterTerminal.sol

@@ -2532,6 +2532,7 @@ contract JBRouterTerminal is
                 sourceProjectId: sourceProjectId,
                 destProjectId: destProjectId,
                 amount: amount,
+                metadata: i == 0 ? metadata : bytes(""),
                 preferredToken: preferredToken
             });
 
@@ -2559,12 +2560,14 @@ contract JBRouterTerminal is
     /// @param sourceProjectId The project to cash out tokens from.
     /// @param destProjectId The final destination project to pay.
     /// @param amount The amount of source-project tokens to cash out.
+    /// @param metadata Metadata forwarded into the source terminal preview for this hop.
     /// @return tokenToReclaim The token that would be reclaimed from the source terminal.
     /// @return reclaimAmount The amount of that token that would be reclaimed.
     function _previewCashOutStep(
         uint256 sourceProjectId,
         uint256 destProjectId,
         uint256 amount,
+        bytes memory metadata,
         address preferredToken
     )
         internal
@@ -2587,7 +2590,7 @@ contract JBRouterTerminal is
             cashOutCount: amount,
             tokenToReclaim: tokenToReclaim,
             beneficiary: payable(address(this)),
-            metadata: ""
+            metadata: metadata
         });
 
         // Deployment config makes this router a feeless cash-out beneficiary, so previews use the terminal's raw

package/src/libraries/JBForwardingCheck.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.0;
+pragma solidity 0.8.28;
 
 import {IJBTerminal} from "@bananapus/core-v6/src/interfaces/IJBTerminal.sol";
 import {IJBForwardingTerminal} from "../interfaces/IJBForwardingTerminal.sol";

package/src/libraries/JBSwapLib.sol

@@ -11,22 +11,22 @@ import {TickMath} from "@uniswap/v3-core/contracts/libraries/TickMath.sol";
 /// @dev Uses continuous sigmoid formula instead of stepped if/else brackets for smoother slippage tolerance across all
 /// swap sizes. Floor of 2% (or pool fee + 1%), ceiling of 88%.
 library JBSwapLib {
-    /// @notice The denominator used for slippage tolerance basis points.
-    uint256 internal constant SLIPPAGE_DENOMINATOR = 10_000;
-
-    /// @notice The maximum slippage ceiling (88%).
-    uint256 internal constant MAX_SLIPPAGE = 8800;
-
     /// @notice The precision multiplier for impact calculations.
-    /// @dev Using 1e18 instead of 1e5 (10 * SLIPPAGE_DENOMINATOR) gives 13 extra orders of magnitude,
+    /// @dev Using 1e18 instead of 1e5 (10 * _SLIPPAGE_DENOMINATOR) gives 13 extra orders of magnitude,
     ///      preventing small-swap-in-deep-pool impacts from rounding to zero.
-    uint256 internal constant IMPACT_PRECISION = 1e18;
+    uint256 internal constant _IMPACT_PRECISION = 1e18;
 
-    /// @notice The K parameter for the sigmoid curve, scaled to match IMPACT_PRECISION.
+    /// @notice The maximum slippage ceiling (88%).
+    uint256 internal constant _MAX_SLIPPAGE = 8800;
+
+    /// @notice The K parameter for the sigmoid curve, scaled to match _IMPACT_PRECISION.
     /// @dev Preserves the same sigmoid shape as the original K=5000 with amplifier=1e5:
-    ///      K_new / IMPACT_PRECISION = K_old / (10 * SLIPPAGE_DENOMINATOR)
+    ///      K_new / _IMPACT_PRECISION = K_old / (10 * _SLIPPAGE_DENOMINATOR)
     ///      → K_new = 5000 * 1e18 / 1e5 = 5e16
-    uint256 internal constant SIGMOID_K = 5e16;
+    uint256 internal constant _SIGMOID_K = 5e16;
+
+    /// @notice The denominator used for slippage tolerance basis points.
+    uint256 internal constant _SLIPPAGE_DENOMINATOR = 10_000;
 
     //*********************************************************************//
     // -------------------- Slippage Tolerance -------------------------- //
@@ -35,27 +35,27 @@ library JBSwapLib {
     /// @notice Compute a continuous sigmoid slippage tolerance based on swap impact and pool fee.
     /// @dev tolerance = minSlippage + (maxSlippage - minSlippage) * impact / (impact + K)
     ///      When impact is 0 (negligible swap in deep pool), returns minSlippage.
-    /// @param impact The estimated price impact from calculateImpact (scaled by IMPACT_PRECISION).
+    /// @param impact The estimated price impact from calculateImpact (scaled by _IMPACT_PRECISION).
     /// @param poolFeeBps The pool fee in basis points (e.g., 30 for 0.3%).
-    /// @return tolerance The slippage tolerance in basis points of SLIPPAGE_DENOMINATOR.
+    /// @return tolerance The slippage tolerance in basis points of _SLIPPAGE_DENOMINATOR.
     function getSlippageTolerance(uint256 impact, uint256 poolFeeBps) internal pure returns (uint256) {
         // If pool fee alone meets/exceeds the ceiling, return the ceiling.
-        if (poolFeeBps >= MAX_SLIPPAGE) return MAX_SLIPPAGE;
+        if (poolFeeBps >= _MAX_SLIPPAGE) return _MAX_SLIPPAGE;
 
         // Minimum slippage: at least pool fee + 1% buffer, with a floor of 2%.
         uint256 minSlippage = poolFeeBps + 100;
         if (minSlippage < 200) minSlippage = 200;
-        if (minSlippage >= MAX_SLIPPAGE) return MAX_SLIPPAGE;
+        if (minSlippage >= _MAX_SLIPPAGE) return _MAX_SLIPPAGE;
 
         // When impact is 0, sigmoid returns minSlippage directly.
         if (impact == 0) return minSlippage;
 
         // For extreme impact values, cap to prevent overflow in (impact + K).
-        if (impact > type(uint256).max - SIGMOID_K) return MAX_SLIPPAGE;
+        if (impact > type(uint256).max - _SIGMOID_K) return _MAX_SLIPPAGE;
 
         // Sigmoid: minSlippage + (maxSlippage - minSlippage) * impact / (impact + K)
-        uint256 range = MAX_SLIPPAGE - minSlippage;
-        uint256 tolerance = minSlippage + mulDiv({x: range, y: impact, denominator: impact + SIGMOID_K});
+        uint256 range = _MAX_SLIPPAGE - minSlippage;
+        uint256 tolerance = minSlippage + mulDiv({x: range, y: impact, denominator: impact + _SIGMOID_K});
 
         // Return the bounded tolerance implied by the sigmoid curve.
         return tolerance;
@@ -65,13 +65,13 @@ library JBSwapLib {
     // -------------------- Impact Calculation -------------------------- //
     //*********************************************************************//
 
-    /// @notice Estimate the price impact of a swap, scaled by IMPACT_PRECISION.
+    /// @notice Estimate the price impact of a swap, scaled by _IMPACT_PRECISION.
     /// @dev Uses 1e18 precision to capture sub-basis-point impacts for small swaps in deep pools.
     /// @param amountIn The amount of tokens to swap in.
     /// @param liquidity The pool's in-range liquidity.
     /// @param sqrtP The sqrt price in Q96 format.
     /// @param zeroForOne Whether the swap is token0 → token1.
-    /// @return impact The estimated price impact scaled by IMPACT_PRECISION.
+    /// @return impact The estimated price impact scaled by _IMPACT_PRECISION.
     function calculateImpact(
         uint256 amountIn,
         uint128 liquidity,
@@ -86,7 +86,7 @@ library JBSwapLib {
         if (liquidity == 0 || sqrtP == 0) return 0;
 
         // Scale the input amount against the pool liquidity so impact is expressed in the library's precision space.
-        uint256 base = mulDiv({x: amountIn, y: IMPACT_PRECISION, denominator: uint256(liquidity)});
+        uint256 base = mulDiv({x: amountIn, y: _IMPACT_PRECISION, denominator: uint256(liquidity)});
 
         // Convert the liquidity-scaled input into a direction-aware price impact estimate.
         impact = zeroForOne