@bananapus/router-terminal-v6 0.0.10 → 0.0.11

package/STYLE_GUIDE.md

@@ -197,7 +197,7 @@ interface IJBExample is IJBBase {
 | Public/external function | `camelCase` | `cashOutTokensOf` |
 | Internal/private function | `_camelCase` | `_processFee` |
 | Internal storage | `_camelCase` | `_accountingContextForTokenOf` |
-| Function parameter | `camelCase` | `projectId`, `cashOutCount` |
+| Function parameter | `camelCase` (no underscores) | `projectId`, `cashOutCount` |
 
 ## NatSpec
 
@@ -253,9 +253,12 @@ uint256 public constant MAX_RESERVED_PERCENT = 10_000;
 
 ## Function Calls
 
-Use named parameters for readability when calling functions with 3+ arguments:
+Use named arguments for all function calls with 2 or more arguments — in both `src/` and `script/`:
 
 ```solidity
+// Good — named arguments
+token.mint({account: beneficiary, amount: count});
+_transferOwnership({newOwner: address(0), projectId: 0});
 PERMISSIONS.hasPermission({
     operator: sender,
     account: account,
@@ -264,8 +267,18 @@ PERMISSIONS.hasPermission({
     includeRoot: true,
     includeWildcardProjectId: true
 });
+
+// Bad — positional arguments with 2+ args
+token.mint(beneficiary, count);
+_transferOwnership(address(0), 0);
 ```
 
+Single-argument calls use positional style: `_burn(amount)`.
+
+This also applies to constructor calls, struct literals, and inherited/library calls (e.g., OZ `_mint`, `_safeMint`, `safeTransfer`, `allowance`, `Clones.cloneDeterministic`).
+
+Named argument keys must use **camelCase** — never underscores. If a function's parameter names use underscores, rename them to camelCase first.
+
 ## Multiline Signatures
 
 ```solidity

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bananapus/router-terminal-v6",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -17,8 +17,8 @@
     "artifacts": "source ./.env && npx sphinx artifacts --org-id 'ea165b21-7cdc-4d7b-be59-ecdd4c26bee4' --project-name 'nana-router-terminal-v6'"
   },
   "dependencies": {
-    "@bananapus/core-v6": "^0.0.15",
-    "@bananapus/permission-ids-v6": "^0.0.7",
+    "@bananapus/core-v6": "^0.0.16",
+    "@bananapus/permission-ids-v6": "^0.0.9",
     "@openzeppelin/contracts": "^5.6.1",
     "@uniswap/permit2": "github:Uniswap/permit2",
     "@uniswap/v3-core": "github:Uniswap/v3-core#0.8",

package/script/Deploy.s.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 pragma solidity 0.8.26;
 
-import "@bananapus/core-v6/script/helpers/CoreDeploymentLib.sol";
+import {CoreDeployment, CoreDeploymentLib} from "@bananapus/core-v6/script/helpers/CoreDeploymentLib.sol";
 
 import {Sphinx} from "@sphinx-labs/contracts/contracts/foundry/SphinxPlugin.sol";
 import {Script} from "forge-std/Script.sol";
@@ -18,8 +18,8 @@ contract DeployScript is Script, Sphinx {
     CoreDeployment core;
 
     /// @notice the salts that are used to deploy the contracts.
-    bytes32 ROUTER_TERMINAL = "JBRouterTerminalV6";
-    bytes32 ROUTER_TERMINAL_REGISTRY = "JBRouterTerminalRegistryV6";
+    bytes32 constant ROUTER_TERMINAL = "JBRouterTerminalV6";
+    bytes32 constant ROUTER_TERMINAL_REGISTRY = "JBRouterTerminalRegistryV6";
 
     /// @notice tracks the addresses that are required for the chain we are deploying to.
     address weth;
@@ -38,7 +38,9 @@ contract DeployScript is Script, Sphinx {
         // Get the deployment addresses for the nana CORE for this chain.
         // We want to do this outside of the `sphinx` modifier.
         core = CoreDeploymentLib.getDeployment(
-            vm.envOr("NANA_CORE_DEPLOYMENT_PATH", string("node_modules/@bananapus/core-v6/deployments/"))
+            vm.envOr({
+                name: "NANA_CORE_DEPLOYMENT_PATH", defaultValue: string("node_modules/@bananapus/core-v6/deployments/")
+            })
         );
 
         trustedForwarder = core.permissions.trustedForwarder();
@@ -95,22 +97,26 @@ contract DeployScript is Script, Sphinx {
     }
 
     function deploy() public sphinx {
-        JBRouterTerminalRegistry registry = new JBRouterTerminalRegistry{salt: ROUTER_TERMINAL_REGISTRY}(
-            core.permissions, core.projects, IPermit2(permit2), safeAddress(), trustedForwarder
-        );
+        JBRouterTerminalRegistry registry = new JBRouterTerminalRegistry{salt: ROUTER_TERMINAL_REGISTRY}({
+            permissions: core.permissions,
+            projects: core.projects,
+            permit2: IPermit2(permit2),
+            owner: safeAddress(),
+            trustedForwarder: trustedForwarder
+        });
 
-        JBRouterTerminal terminal = new JBRouterTerminal{salt: ROUTER_TERMINAL}(
-            core.directory,
-            core.permissions,
-            core.projects,
-            core.tokens,
-            IPermit2(permit2),
-            safeAddress(),
-            IWETH9(weth),
-            IUniswapV3Factory(factory),
-            IPoolManager(poolManager),
-            trustedForwarder
-        );
+        JBRouterTerminal terminal = new JBRouterTerminal{salt: ROUTER_TERMINAL}({
+            directory: core.directory,
+            permissions: core.permissions,
+            projects: core.projects,
+            tokens: core.tokens,
+            permit2: IPermit2(permit2),
+            owner: safeAddress(),
+            weth: IWETH9(weth),
+            factory: IUniswapV3Factory(factory),
+            poolManager: IPoolManager(poolManager),
+            trustedForwarder: trustedForwarder
+        });
 
         // Set the terminal as the default for the registry.
         registry.setDefaultTerminal(terminal);

package/script/helpers/RouterTerminalDeploymentLib.sol

@@ -17,6 +17,7 @@ struct RouterTerminalDeployment {
 library RouterTerminalDeploymentLib {
     // Cheat code address, 0x7109709ECfa91a80626fF3989D68f67F5b1DD12D.
     address internal constant VM_ADDRESS = address(uint160(uint256(keccak256("hevm cheat code"))));
+    // forge-lint: disable-next-line(screaming-snake-case-const)
     Vm internal constant vm = Vm(VM_ADDRESS);
 
     function getDeployment(string memory path) internal returns (RouterTerminalDeployment memory deployment) {
@@ -30,7 +31,7 @@ library RouterTerminalDeploymentLib {
 
         for (uint256 _i; _i < networks.length; _i++) {
             if (networks[_i].chainId == chainId) {
-                return getDeployment(path, networks[_i].name);
+                return getDeployment({path: path, networkName: networks[_i].name});
             }
         }
 
@@ -39,17 +40,28 @@ library RouterTerminalDeploymentLib {
 
     function getDeployment(
         string memory path,
-        string memory network_name
+        string memory networkName
     )
         internal
         view
         returns (RouterTerminalDeployment memory deployment)
     {
-        deployment.terminal =
-            IJBRouterTerminal(_getDeploymentAddress(path, "nana-router-terminal-v6", network_name, "JBRouterTerminal"));
+        deployment.terminal = IJBRouterTerminal(
+            _getDeploymentAddress({
+                path: path,
+                projectName: "nana-router-terminal-v6",
+                networkName: networkName,
+                contractName: "JBRouterTerminal"
+            })
+        );
 
         deployment.registry = IJBRouterTerminalRegistry(
-            _getDeploymentAddress(path, "nana-router-terminal-v6", network_name, "JBRouterTerminalRegistry")
+            _getDeploymentAddress({
+                path: path,
+                projectName: "nana-router-terminal-v6",
+                networkName: networkName,
+                contractName: "JBRouterTerminalRegistry"
+            })
         );
     }
 
@@ -60,8 +72,8 @@ library RouterTerminalDeploymentLib {
     /// @return The address of the contract.
     function _getDeploymentAddress(
         string memory path,
-        string memory project_name,
-        string memory network_name,
+        string memory projectName,
+        string memory networkName,
         string memory contractName
     )
         internal
@@ -69,7 +81,8 @@ library RouterTerminalDeploymentLib {
         returns (address)
     {
         string memory deploymentJson =
-            vm.readFile(string.concat(path, project_name, "/", network_name, "/", contractName, ".json"));
-        return stdJson.readAddress(deploymentJson, ".address");
+        // forge-lint: disable-next-line(unsafe-cheatcode)
+        vm.readFile(string.concat(path, projectName, "/", networkName, "/", contractName, ".json"));
+        return stdJson.readAddress({json: deploymentJson, key: ".address"});
     }
 }

package/src/JBRouterTerminal.sol

@@ -98,10 +98,13 @@ contract JBRouterTerminal is
 
     /// @notice The fee tiers to search when auto-discovering V3 pools, ordered by commonality.
     /// 3000 = 0.3%, 500 = 0.05%, 10000 = 1%, 100 = 0.01%.
+    // forge-lint: disable-next-line(mixed-case-variable)
     uint24[4] internal _FEE_TIERS = [uint24(3000), uint24(500), uint24(10_000), uint24(100)];
 
     /// @notice The fee/tickSpacing pairings to search for V4 vanilla pools.
+    // forge-lint: disable-next-line(mixed-case-variable)
     uint24[4] internal _V4_FEES = [uint24(3000), uint24(500), uint24(10_000), uint24(100)];
+    // forge-lint: disable-next-line(mixed-case-variable)
     int24[4] internal _V4_TICK_SPACINGS = [int24(60), int24(10), int24(200), int24(1)];
 
     //*********************************************************************//
@@ -186,6 +189,7 @@ contract JBRouterTerminal is
         override
         returns (JBAccountingContext memory context)
     {
+        // forge-lint: disable-next-line(unsafe-typecast)
         context = JBAccountingContext({token: token, decimals: 18, currency: uint32(uint160(token))});
     }
 
@@ -339,7 +343,7 @@ contract JBRouterTerminal is
     }
 
     /// @notice Empty implementation to satisfy the interface. This terminal has no balance to migrate.
-    function migrateBalanceOf(uint256, address, IJBTerminal) external override returns (uint256 balance) {
+    function migrateBalanceOf(uint256, address, IJBTerminal) external pure override returns (uint256 balance) {
         return 0;
     }
 
@@ -408,17 +412,18 @@ contract JBRouterTerminal is
 
         // Verify caller is a legitimate pool via the factory.
         uint24 fee = IUniswapV3Pool(msg.sender).fee();
-        address expectedPool = FACTORY.getPool(normalizedTokenIn, normalizedTokenOut, fee);
+        address expectedPool = FACTORY.getPool({tokenA: normalizedTokenIn, tokenB: normalizedTokenOut, fee: fee});
         if (msg.sender != expectedPool) revert JBRouterTerminal_CallerNotPool(msg.sender);
 
         // Calculate the amount of tokens to send to the pool (the positive delta).
+        // forge-lint: disable-next-line(unsafe-typecast)
         uint256 amountToSendToPool = amount0Delta < 0 ? uint256(amount1Delta) : uint256(amount0Delta);
 
         // Wrap native tokens if needed.
         if (tokenIn == JBConstants.NATIVE_TOKEN) WETH.deposit{value: amountToSendToPool}();
 
         // Transfer the tokens to the pool.
-        IERC20(normalizedTokenIn).safeTransfer(msg.sender, amountToSendToPool);
+        IERC20(normalizedTokenIn).safeTransfer({to: msg.sender, value: amountToSendToPool});
     }
 
     /// @notice The Uniswap V4 unlock callback. Called by the PoolManager during `unlock()`.
@@ -447,10 +452,14 @@ contract JBRouterTerminal is
             int128 delta0 = delta.amount0();
             int128 delta1 = delta.amount1();
             if (zeroForOne) {
+                // forge-lint: disable-next-line(unsafe-typecast)
                 amountIn = uint256(uint128(-delta0));
+                // forge-lint: disable-next-line(unsafe-typecast)
                 amountOut = uint256(uint128(delta1));
             } else {
+                // forge-lint: disable-next-line(unsafe-typecast)
                 amountIn = uint256(uint128(-delta1));
+                // forge-lint: disable-next-line(unsafe-typecast)
                 amountOut = uint256(uint128(delta0));
             }
         }
@@ -459,11 +468,11 @@ contract JBRouterTerminal is
 
         // Settle input (pay what we owe to the PoolManager).
         Currency inputCurrency = zeroForOne ? key.currency0 : key.currency1;
-        _settleV4(inputCurrency, amountIn);
+        _settleV4({currency: inputCurrency, amount: amountIn});
 
         // Take output (receive what the PoolManager owes us).
         Currency outputCurrency = zeroForOne ? key.currency1 : key.currency0;
-        _takeV4(outputCurrency, amountOut);
+        _takeV4({currency: outputCurrency, amount: amountOut});
 
         return abi.encode(amountOut);
     }
@@ -554,7 +563,7 @@ contract JBRouterTerminal is
         if (token == JBConstants.NATIVE_TOKEN) return amount;
 
         // Otherwise, set the appropriate allowance for the recipient.
-        IERC20(token).safeIncreaseAllowance(to, amount);
+        IERC20(token).safeIncreaseAllowance({spender: to, value: amount});
 
         return 0;
     }
@@ -758,7 +767,8 @@ contract JBRouterTerminal is
         // Search V3.
         for (uint256 i; i < 4; i++) {
             // slither-disable-next-line calls-loop
-            address poolAddr = FACTORY.getPool(normalizedTokenIn, normalizedTokenOut, _FEE_TIERS[i]);
+            address poolAddr =
+                FACTORY.getPool({tokenA: normalizedTokenIn, tokenB: normalizedTokenOut, fee: _FEE_TIERS[i]});
 
             if (poolAddr == address(0)) continue;
 
@@ -851,11 +861,7 @@ contract JBRouterTerminal is
 
         if (pool.isV4) {
             return _executeV4Swap({
-                key: pool.v4Key,
-                normalizedTokenIn: normalizedTokenIn,
-                normalizedTokenOut: normalizedTokenOut,
-                amount: amount,
-                minAmountOut: minAmountOut
+                key: pool.v4Key, normalizedTokenIn: normalizedTokenIn, amount: amount, minAmountOut: minAmountOut
             });
         } else {
             return _executeV3Swap({
@@ -886,8 +892,11 @@ contract JBRouterTerminal is
         (int256 amount0, int256 amount1) = pool.swap({
             recipient: address(this),
             zeroForOne: zeroForOne,
+            // forge-lint: disable-next-line(unsafe-typecast)
             amountSpecified: int256(amount),
-            sqrtPriceLimitX96: JBSwapLib.sqrtPriceLimitFromAmounts(amount, minAmountOut, zeroForOne),
+            sqrtPriceLimitX96: JBSwapLib.sqrtPriceLimitFromAmounts({
+                amountIn: amount, minimumAmountOut: minAmountOut, zeroForOne: zeroForOne
+            }),
             data: callbackData
         });
 
@@ -899,7 +908,6 @@ contract JBRouterTerminal is
     function _executeV4Swap(
         PoolKey memory key,
         address normalizedTokenIn,
-        address normalizedTokenOut,
         uint256 amount,
         uint256 minAmountOut
     )
@@ -911,11 +919,14 @@ contract JBRouterTerminal is
         bool zeroForOne = Currency.unwrap(key.currency0) == v4In;
 
         // Use sqrtPriceLimitFromAmounts for partial-fill protection, consistent with V3 path.
-        uint160 sqrtPriceLimitX96 = JBSwapLib.sqrtPriceLimitFromAmounts(amount, minAmountOut, zeroForOne);
+        uint160 sqrtPriceLimitX96 = JBSwapLib.sqrtPriceLimitFromAmounts({
+            amountIn: amount, minimumAmountOut: minAmountOut, zeroForOne: zeroForOne
+        });
 
         // V4 sign convention: negative = exact input, positive = exact output.
         bytes memory result =
-            POOL_MANAGER.unlock(abi.encode(key, zeroForOne, -int256(amount), sqrtPriceLimitX96, minAmountOut));
+        // forge-lint: disable-next-line(unsafe-typecast)
+        POOL_MANAGER.unlock(abi.encode(key, zeroForOne, -int256(amount), sqrtPriceLimitX96, minAmountOut));
 
         amountOut = abi.decode(result, (uint256));
     }
@@ -1022,8 +1033,9 @@ contract JBRouterTerminal is
         uint160 sqrtP = TickMath.getSqrtRatioAtTick(arithmeticMeanTick);
         if (sqrtP == 0) return SLIPPAGE_DENOMINATOR;
 
-        uint256 impact = JBSwapLib.calculateImpact(amountIn, liquidity, sqrtP, zeroForOne);
-        return JBSwapLib.getSlippageTolerance(impact, poolFeeBps);
+        uint256 impact =
+            JBSwapLib.calculateImpact({amountIn: amountIn, liquidity: liquidity, sqrtP: sqrtP, zeroForOne: zeroForOne});
+        return JBSwapLib.getSlippageTolerance({impact: impact, poolFeeBps: poolFeeBps});
     }
 
     /// @notice Get a TWAP-based quote with dynamic slippage for a V3 pool.
@@ -1044,8 +1056,11 @@ contract JBRouterTerminal is
         uint256 twapWindow = DEFAULT_TWAP_WINDOW;
         if (oldestObservation < twapWindow) twapWindow = oldestObservation;
 
-        (int24 arithmeticMeanTick, uint128 liquidity) =
-            OracleLibrary.consult({pool: address(pool), secondsAgo: uint32(twapWindow)});
+        (
+            int24 arithmeticMeanTick,
+            uint128 liquidity
+            // forge-lint: disable-next-line(unsafe-typecast)
+        ) = OracleLibrary.consult({pool: address(pool), secondsAgo: uint32(twapWindow)});
 
         if (liquidity == 0) revert JBRouterTerminal_NoLiquidity();
 
@@ -1064,6 +1079,7 @@ contract JBRouterTerminal is
             if (amount > type(uint128).max) revert JBRouterTerminal_AmountOverflow(amount);
             minAmountOut = OracleLibrary.getQuoteAtTick({
                 tick: arithmeticMeanTick,
+                // forge-lint: disable-next-line(unsafe-typecast)
                 baseAmount: uint128(amount),
                 baseToken: normalizedTokenIn,
                 quoteToken: normalizedTokenOut
@@ -1124,7 +1140,11 @@ contract JBRouterTerminal is
 
         if (amount > type(uint128).max) revert JBRouterTerminal_AmountOverflow(amount);
         minAmountOut = OracleLibrary.getQuoteAtTick({
-            tick: tick, baseAmount: uint128(amount), baseToken: normalizedTokenIn, quoteToken: normalizedTokenOut
+            tick: tick,
+            // forge-lint: disable-next-line(unsafe-typecast)
+            baseAmount: uint128(amount),
+            baseToken: normalizedTokenIn,
+            quoteToken: normalizedTokenOut
         });
 
         minAmountOut -= (minAmountOut * slippageTolerance) / SLIPPAGE_DENOMINATOR;
@@ -1357,7 +1377,7 @@ contract JBRouterTerminal is
         } else {
             // ERC20: sync then transfer then settle.
             POOL_MANAGER.sync(currency);
-            IERC20(Currency.unwrap(currency)).safeTransfer(address(POOL_MANAGER), amount);
+            IERC20(Currency.unwrap(currency)).safeTransfer({to: address(POOL_MANAGER), value: amount});
             // slither-disable-next-line unused-return
             POOL_MANAGER.settle();
         }
@@ -1365,7 +1385,7 @@ contract JBRouterTerminal is
 
     /// @notice Take the output side of a V4 swap (receive tokens from PoolManager).
     function _takeV4(Currency currency, uint256 amount) internal {
-        POOL_MANAGER.take(currency, address(this), amount);
+        POOL_MANAGER.take({currency: currency, to: address(this), amount: amount});
 
         // If native ETH output, wrap to WETH (downstream _handleSwap unwraps if needed).
         if (Currency.unwrap(currency) == address(0)) {
@@ -1381,19 +1401,20 @@ contract JBRouterTerminal is
     function _transferFrom(address from, address payable to, address token, uint256 amount) internal {
         if (from == address(this)) {
             // If the token is native token, assume the `sendValue` standard.
-            if (token == JBConstants.NATIVE_TOKEN) return Address.sendValue(to, amount);
+            if (token == JBConstants.NATIVE_TOKEN) return Address.sendValue({recipient: to, amount: amount});
 
             // If the transfer is from this terminal, use `safeTransfer`.
-            return IERC20(token).safeTransfer(to, amount);
+            return IERC20(token).safeTransfer({to: to, value: amount});
         }
 
         // If there's sufficient approval, transfer normally.
         if (IERC20(token).allowance({owner: address(from), spender: address(this)}) >= amount) {
-            return IERC20(token).safeTransferFrom(from, to, amount);
+            return IERC20(token).safeTransferFrom({from: from, to: to, value: amount});
         }
 
         // Otherwise, attempt to use the `permit2` method.
-        PERMIT2.transferFrom(from, to, uint160(amount), token);
+        // forge-lint: disable-next-line(unsafe-typecast)
+        PERMIT2.transferFrom({from: from, to: to, amount: uint160(amount), token: token});
     }
 
     //*********************************************************************//

package/src/JBRouterTerminalRegistry.sol

@@ -442,7 +442,7 @@ contract JBRouterTerminalRegistry is IJBRouterTerminalRegistry, JBPermissioned,
         if (token == JBConstants.NATIVE_TOKEN) return amount;
 
         // Otherwise, set the appropriate allowance for the recipient.
-        IERC20(token).safeIncreaseAllowance(to, amount);
+        IERC20(token).safeIncreaseAllowance({spender: to, value: amount});
 
         return 0;
     }
@@ -455,18 +455,19 @@ contract JBRouterTerminalRegistry is IJBRouterTerminalRegistry, JBPermissioned,
     function _transferFrom(address from, address payable to, address token, uint256 amount) internal virtual {
         if (from == address(this)) {
             // If the token is native token, assume the `sendValue` standard.
-            if (token == JBConstants.NATIVE_TOKEN) return Address.sendValue(to, amount);
+            if (token == JBConstants.NATIVE_TOKEN) return Address.sendValue({recipient: to, amount: amount});
 
             // If the transfer is from this terminal, use `safeTransfer`.
-            return IERC20(token).safeTransfer(to, amount);
+            return IERC20(token).safeTransfer({to: to, value: amount});
         }
 
         // If there's sufficient approval, transfer normally.
         if (IERC20(token).allowance({owner: address(from), spender: address(this)}) >= amount) {
-            return IERC20(token).safeTransferFrom(from, to, amount);
+            return IERC20(token).safeTransferFrom({from: from, to: to, value: amount});
         }
 
         // Otherwise, attempt to use the `permit2` method.
-        PERMIT2.transferFrom(from, to, uint160(amount), token);
+        // forge-lint: disable-next-line(unsafe-typecast)
+        PERMIT2.transferFrom({from: from, to: to, amount: uint160(amount), token: token});
     }
 }

package/src/libraries/JBSwapLib.sol

@@ -54,7 +54,7 @@ library JBSwapLib {
 
         // Sigmoid: minSlippage + (maxSlippage - minSlippage) * impact / (impact + K)
         uint256 range = MAX_SLIPPAGE - minSlippage;
-        uint256 tolerance = minSlippage + mulDiv(range, impact, impact + SIGMOID_K);
+        uint256 tolerance = minSlippage + mulDiv({x: range, y: impact, denominator: impact + SIGMOID_K});
 
         return tolerance;
     }
@@ -82,11 +82,11 @@ library JBSwapLib {
     {
         if (liquidity == 0 || sqrtP == 0) return 0;
 
-        uint256 base = mulDiv(amountIn, IMPACT_PRECISION, uint256(liquidity));
+        uint256 base = mulDiv({x: amountIn, y: IMPACT_PRECISION, denominator: uint256(liquidity)});
 
         impact = zeroForOne
-            ? mulDiv(base, uint256(sqrtP), uint256(1) << 96)
-            : mulDiv(base, uint256(1) << 96, uint256(sqrtP));
+            ? mulDiv({x: base, y: uint256(sqrtP), denominator: uint256(1) << 96})
+            : mulDiv({x: base, y: uint256(1) << 96, denominator: uint256(sqrtP)});
     }
 
     //*********************************************************************//
@@ -130,11 +130,11 @@ library JBSwapLib {
             return zeroForOne ? TickMath.MIN_SQRT_RATIO + 1 : TickMath.MAX_SQRT_RATIO - 1;
         } else if (num / den >= (uint256(1) << 64)) {
             // Extended range: use ratioX128 to avoid mulDiv overflow, then shift.
-            uint256 ratioX128 = mulDiv(num, uint256(1) << 128, den);
+            uint256 ratioX128 = mulDiv({x: num, y: uint256(1) << 128, denominator: den});
             sqrtResult = Math.sqrt(ratioX128) * (uint256(1) << 32);
         } else {
             // Normal range: full precision via ratioX192.
-            uint256 ratioX192 = mulDiv(num, uint256(1) << 192, den);
+            uint256 ratioX192 = mulDiv({x: num, y: uint256(1) << 192, denominator: den});
             sqrtResult = Math.sqrt(ratioX192);
         }
 
@@ -145,6 +145,7 @@ library JBSwapLib {
             if (sqrtResult >= uint256(TickMath.MAX_SQRT_RATIO)) {
                 return TickMath.MAX_SQRT_RATIO - 1;
             }
+            // forge-lint: disable-next-line(unsafe-typecast)
             return uint160(sqrtResult);
         } else {
             if (sqrtResult >= uint256(TickMath.MAX_SQRT_RATIO)) {
@@ -153,6 +154,7 @@ library JBSwapLib {
             if (sqrtResult <= uint256(TickMath.MIN_SQRT_RATIO)) {
                 return TickMath.MIN_SQRT_RATIO + 1;
             }
+            // forge-lint: disable-next-line(unsafe-typecast)
             return uint160(sqrtResult);
         }
     }