@bananapus/suckers-v6 0.0.35 → 0.0.36

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bananapus/suckers-v6",
-  "version": "0.0.35",
+  "version": "0.0.36",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/JBCCIPSucker.sol

@@ -174,7 +174,7 @@ contract JBCCIPSucker is JBSucker, IAny2EVMMessageReceiver {
             // Decode the root message from the payload.
             JBMessageRoot memory root = abi.decode(payload, (JBMessageRoot));
 
-            // Only unwrap WETH -> ETH when the root targets native token (not when claiming WETH as ERC-20).
+            // Only unwrap wrapped native token when the root targets native token (not when claiming it as ERC-20).
             if (root.token == bytes32(uint256(uint160(JBConstants.NATIVE_TOKEN)))) {
                 JBCCIPLib.unwrapReceivedTokens({
                     ccipRouter: CCIP_ROUTER, destTokenAmounts: any2EvmMessage.destTokenAmounts
@@ -224,7 +224,7 @@ contract JBCCIPSucker is JBSucker, IAny2EVMMessageReceiver {
             // Add extra gas for the ERC-20 token transfer on the remote chain.
             gasLimit += remoteToken.minGas;
 
-            // Wrap native ETH -> WETH if needed, build the CCIP token amounts array, and approve the router.
+            // Wrap native tokens if needed, build the CCIP token amounts array, and approve the router.
             // slither-disable-next-line unused-return
             (tokenAmounts,) = JBCCIPLib.prepareTokenAmounts({ccipRouter: CCIP_ROUTER, token: token, amount: amount});
         } else {
@@ -281,15 +281,15 @@ contract JBCCIPSucker is JBSucker, IAny2EVMMessageReceiver {
     ///
     /// Example: ETH mainnet (native = ETH) <-> Celo (native = CELO, ETH is an ERC-20).
     ///   - On mainnet: `mapToken({localToken: NATIVE_TOKEN, remoteToken: celoETH_address})`
-    ///   - Sending: `_sendRootOverAMB` wraps native ETH -> WETH, bridges WETH via CCIP.
-    ///   - Receiving: `ccipReceive` checks `root.token == NATIVE_TOKEN` to decide whether to unwrap WETH -> ETH.
+    ///   - Sending: `_sendRootOverAMB` wraps native tokens, bridges them via CCIP.
+    ///   - Receiving: `ccipReceive` checks `root.token == NATIVE_TOKEN` to decide whether to unwrap.
     ///     If `root.token` is an ERC-20 address (like celoETH), no unwrap occurs — tokens stay as ERC-20.
     ///
     /// The base class restriction (`NATIVE_TOKEN` can only map to `NATIVE_TOKEN` or `address(0)`) is intentionally
     /// removed here. The base class retains that restriction for OP/Arbitrum where both chains share ETH as native.
     function _validateTokenMapping(JBTokenMapping calldata map) internal pure virtual override {
         // Enforce a reasonable minimum gas limit for bridging. A minimum which is too low could lead to the loss of
-        // funds. CCIP wraps native tokens to WETH before bridging (see `_sendRootOverAMB`), so ALL tokens —
+        // funds. CCIP wraps native tokens before bridging (see `_sendRootOverAMB`), so ALL tokens —
         // including native — need sufficient gas for an ERC-20 transfer on the remote chain.
         if (map.minGas < MESSENGER_ERC20_MIN_GAS_LIMIT) {
             revert JBSucker_BelowMinGas({minGas: map.minGas, minGasLimit: MESSENGER_ERC20_MIN_GAS_LIMIT});

package/src/JBCeloSucker.sol

@@ -20,7 +20,7 @@ import {JBRemoteToken} from "./structs/JBRemoteToken.sol";
 import {JBTokenMapping} from "./structs/JBTokenMapping.sol";
 
 /// @notice A `JBSucker` implementation for Celo — an OP Stack chain with a custom gas token (CELO, not ETH).
-/// @dev ETH exists on Celo only as an ERC-20 (WETH). This sucker wraps native ETH → WETH before bridging
+/// @dev ETH exists on Celo only as an ERC-20. This sucker wraps native ETH before bridging
 /// as ERC-20 via the OP standard bridge, and removes the `NATIVE_TOKEN → NATIVE_TOKEN` restriction so that
 /// native ETH can map to a remote ERC-20.
 contract JBCeloSucker is JBOptimismSucker {
@@ -28,8 +28,8 @@ contract JBCeloSucker is JBOptimismSucker {
     // --------------- public immutable stored properties ---------------- //
     //*********************************************************************//
 
-    /// @notice The wrapped native token (WETH) on the local chain.
-    IWrappedNativeToken public immutable WRAPPED_NATIVE;
+    /// @notice The ERC-20 wrapper for the chain's native token on the local chain.
+    IWrappedNativeToken public immutable WRAPPED_NATIVE_TOKEN;
 
     //*********************************************************************//
     // ---------------------------- constructor -------------------------- //
@@ -53,7 +53,7 @@ contract JBCeloSucker is JBOptimismSucker {
         JBOptimismSucker(deployer, directory, permissions, prices, tokens, feeProjectId, registry, trustedForwarder)
     {
         // Fetch the wrapped native token by doing a callback to the deployer contract.
-        WRAPPED_NATIVE = JBCeloSuckerDeployer(deployer).wrappedNative();
+        WRAPPED_NATIVE_TOKEN = JBCeloSuckerDeployer(deployer).wrappedNative();
     }
 
     //*********************************************************************//
@@ -73,24 +73,25 @@ contract JBCeloSucker is JBOptimismSucker {
     // --------------------- internal transactions ----------------------- //
     //*********************************************************************//
 
-    /// @notice Unwraps WETH → native ETH before adding to the project's balance.
-    /// @dev When tokens are bridged from Celo → L1 via the OP bridge, L1 WETH (ERC-20) is released to the sucker.
-    /// But the L1 project's terminal accepts native ETH (NATIVE_TOKEN), not WETH. This override unwraps the WETH
+    /// @notice Unwraps wrapped native tokens before adding to the project's balance.
+    /// @dev When tokens are bridged from Celo → L1 via the OP bridge, wrapped native tokens (ERC-20) are released to
+    /// the sucker. But the L1 project's terminal accepts native ETH (NATIVE_TOKEN), not the wrapped form. This override
+    /// unwraps
     /// and adds native ETH to the project's balance.
     /// @param token The terminal token to add to the project's balance.
     /// @param amount The amount of terminal tokens to add to the project's balance.
     /// @param cachedProjectId The cached project ID to avoid redundant storage reads.
     function _addToBalance(address token, uint256 amount, uint256 cachedProjectId) internal override {
-        if (token == address(WRAPPED_NATIVE)) {
-            // Check addable amount against WETH balance before unwrapping.
+        if (token == address(WRAPPED_NATIVE_TOKEN)) {
+            // Check addable amount against wrapped native token balance before unwrapping.
             uint256 addableAmount = amountToAddToBalanceOf(token);
             if (amount > addableAmount) {
                 revert JBSucker_InsufficientBalance({amount: amount, balance: addableAmount});
             }
 
-            // Unwrap WETH → native ETH.
+            // Unwrap wrapped native tokens → native tokens.
             // slither-disable-next-line calls-loop
-            WRAPPED_NATIVE.withdraw(amount);
+            WRAPPED_NATIVE_TOKEN.withdraw(amount);
 
             // Get the project's primary terminal for native token.
             // slither-disable-next-line calls-loop
@@ -118,7 +119,7 @@ contract JBCeloSucker is JBOptimismSucker {
 
     /// @notice Use the `OPMESSENGER` to send the outbox tree for the `token` and the corresponding funds to the peer
     /// over the `OPBRIDGE`.
-    /// @dev For Celo, native ETH is wrapped to WETH and bridged as ERC-20. The messenger message is sent with
+    /// @dev For Celo, native ETH is wrapped and bridged as ERC-20. The messenger message is sent with
     /// `nativeValue = 0` because Celo's native token is CELO (not ETH), so we never attach ETH as msg.value.
     /// @param transportPayment the amount of `msg.value` that is going to get paid for sending this message.
     /// @param token The token to bridge the outbox tree for.
@@ -146,13 +147,13 @@ contract JBCeloSucker is JBOptimismSucker {
         address peerAddress = _toAddress(peer());
 
         if (amount != 0) {
-            // Determine the local token to bridge — native ETH is wrapped to WETH first.
+            // Determine the local token to bridge — native ETH is wrapped first.
             address bridgeToken = token;
             if (token == JBConstants.NATIVE_TOKEN) {
-                // Wrap native ETH → WETH so it can be bridged as ERC-20.
+                // Wrap native tokens so they can be bridged as ERC-20.
                 // slither-disable-next-line arbitrary-send-eth,calls-loop
-                WRAPPED_NATIVE.deposit{value: amount}();
-                bridgeToken = address(WRAPPED_NATIVE);
+                WRAPPED_NATIVE_TOKEN.deposit{value: amount}();
+                bridgeToken = address(WRAPPED_NATIVE_TOKEN);
             }
 
             // Approve the bridge to spend the token.
@@ -183,11 +184,11 @@ contract JBCeloSucker is JBOptimismSucker {
     }
 
     /// @notice Allow `NATIVE_TOKEN` to map to any remote token (not just `NATIVE_TOKEN`).
-    /// @dev Celo uses CELO as native gas token. ETH is an ERC-20 on Celo (WETH). So `NATIVE_TOKEN` on L1
+    /// @dev Celo uses CELO as native gas token. ETH is an ERC-20 on Celo. So `NATIVE_TOKEN` on L1
     /// maps to an ERC-20 address on Celo, not to `NATIVE_TOKEN`. The base class restriction is removed.
     function _validateTokenMapping(JBTokenMapping calldata map) internal pure virtual override {
         // Enforce a reasonable minimum gas limit for bridging. Since we always bridge as ERC-20
-        // (wrapping native ETH to WETH), all tokens need sufficient gas for an ERC-20 transfer.
+        // (wrapping native tokens), all tokens need sufficient gas for an ERC-20 transfer.
         if (map.minGas < MESSENGER_ERC20_MIN_GAS_LIMIT) {
             revert JBSucker_BelowMinGas({minGas: map.minGas, minGasLimit: MESSENGER_ERC20_MIN_GAS_LIMIT});
         }

package/src/JBSucker.sol

@@ -255,8 +255,8 @@ abstract contract JBSucker is ERC2771Context, JBPermissioned, Initializable, ERC
     /// @notice Accepts incoming native token (ETH) transfers.
     /// @dev This receive function is intentionally unrestricted. It must accept ETH from multiple sources:
     /// - Bridge contracts (e.g., Optimism's StandardBridge, Arbitrum's gateway) delivering bridged native tokens.
-    /// - WETH contracts during unwrapping (e.g., CCIP sucker unwraps WETH via `withdraw()` which sends ETH here).
-    /// - Terminals returning native tokens during `cashOutTokensOf` (backing asset pulls).
+    /// - Wrapped native token contracts during unwrapping (e.g., CCIP sucker unwraps via `withdraw()` which sends
+    /// native tokens here). - Terminals returning native tokens during `cashOutTokensOf` (backing asset pulls).
     /// @dev Restricting this to known senders would risk breaking bridge integrations, as bridge contracts may change
     /// addresses or use proxy patterns. The sucker's accounting (`_outboxOf[token].balance` and
     /// `amountToAddToBalanceOf`) already tracks expected native token amounts, so excess ETH sent here does not

package/src/JBSuckerRegistry.sol

@@ -20,9 +20,9 @@ import {JBSuckerDeployerConfig} from "./structs/JBSuckerDeployerConfig.sol";
 import {JBSuckersPair} from "./structs/JBSuckersPair.sol";
 
 /// @notice The canonical registry that deploys, tracks, and governs cross-chain suckers for Juicebox projects. It
-/// maintains an allowlist of approved deployer contracts, enforces one active sucker per peer chain per project,
-/// manages the global `toRemoteFee` (paid into the protocol fee project on each bridge send), and provides aggregate
-/// views of remote-chain balances, surplus, and token supply across all of a project's suckers.
+/// maintains an allowlist of approved deployer contracts, allows multiple active suckers per peer chain for bridge
+/// resilience, manages the global `toRemoteFee` (paid into the protocol fee project on each bridge send), and provides
+/// aggregate views of remote-chain balances, surplus, and token supply across all of a project's suckers.
 contract JBSuckerRegistry is ERC2771Context, Ownable, JBPermissioned, IJBSuckerRegistry {
     using EnumerableMap for EnumerableMap.AddressToUintMap;
 
@@ -30,7 +30,6 @@ contract JBSuckerRegistry is ERC2771Context, Ownable, JBPermissioned, IJBSuckerR
     // --------------------------- custom errors ------------------------- //
     //*********************************************************************//
 
-    error JBSuckerRegistry_DuplicatePeerChain(uint256 projectId, uint256 peerChainId);
     error JBSuckerRegistry_FeeExceedsMax(uint256 fee, uint256 max);
     error JBSuckerRegistry_InvalidDeployer(IJBSuckerDeployer deployer);
     error JBSuckerRegistry_SuckerDoesNotBelongToProject(uint256 projectId, address sucker);
@@ -420,8 +419,9 @@ contract JBSuckerRegistry is ERC2771Context, Ownable, JBPermissioned, IJBSuckerR
     {
         for (uint256 j; j < chainCount;) {
             if (chainIds[j] == chainId) {
-                // An active sucker is the live source for this chain. If several active suckers briefly exist during
-                // migration, keep the max value so a lower stale snapshot cannot undercount the project.
+                // Each sucker caches the entire remote chain's state (not a per-sucker share), so multiple
+                // suckers targeting the same chain report redundant snapshots. MAX picks the freshest value
+                // without double-counting — SUM would inflate bonding curve denominators.
                 if (isActive) {
                     if (!hasActiveValue[j] || value > values[j]) values[j] = value;
                     hasActiveValue[j] = true;
@@ -444,30 +444,6 @@ contract JBSuckerRegistry is ERC2771Context, Ownable, JBPermissioned, IJBSuckerR
         }
     }
 
-    /// @notice Reverts if any active sucker for the given project already targets the same peer chain as the new
-    /// sucker.
-    /// @param projectId The ID of the project to check.
-    /// @param newSucker The newly created sucker to validate.
-    function _revertIfDuplicatePeerChain(uint256 projectId, IJBSucker newSucker) internal view {
-        // The new sucker is registry-deployed and trusted for this validation.
-        // slither-disable-next-line calls-loop
-        uint256 newPeerChainId = newSucker.peerChainId();
-        address[] memory existing = _suckersOf[projectId].keys();
-        for (uint256 i; i < existing.length;) {
-            // slither-disable-next-line unused-return
-            (, uint256 val) = _suckersOf[projectId].tryGet(existing[i]);
-            if (val == _SUCKER_EXISTS) {
-                // slither-disable-next-line calls-loop
-                if (IJBSucker(existing[i]).peerChainId() == newPeerChainId) {
-                    revert JBSuckerRegistry_DuplicatePeerChain(projectId, newPeerChainId);
-                }
-            }
-            unchecked {
-                ++i;
-            }
-        }
-    }
-
     //*********************************************************************//
     // ---------------------- public transactions ----------------------- //
     //*********************************************************************//
@@ -502,9 +478,9 @@ contract JBSuckerRegistry is ERC2771Context, Ownable, JBPermissioned, IJBSuckerR
     }
 
     /// @notice Deploy one or more cross-chain suckers for a project in a single transaction. Each sucker is created via
-    /// its deployer, registered in this registry, checked for duplicate peer chains, and immediately configured with
-    /// its token mappings. The caller must have `DEPLOY_SUCKERS` permission, and this registry must hold
-    /// `MAP_SUCKER_TOKEN` permission for the project.
+    /// its deployer, registered in this registry, and immediately configured with its token mappings. Multiple suckers
+    /// targeting the same peer chain are allowed for bridge resilience. The caller must have `DEPLOY_SUCKERS`
+    /// permission, and this registry must hold `MAP_SUCKER_TOKEN` permission for the project.
     /// @param projectId The ID of the project to deploy suckers for.
     /// @param salt The salt used to deploy the contract. For the suckers to be peers, this must be the same value on
     /// each chain where suckers are deployed.
@@ -551,10 +527,6 @@ contract JBSuckerRegistry is ERC2771Context, Ownable, JBPermissioned, IJBSuckerR
             .createForSender({localProjectId: projectId, salt: salt, peer: configuration.peer});
             suckers[i] = address(sucker);
 
-            // Make sure no active sucker already targets the same peer chain.
-            // slither-disable-next-line calls-loop
-            _revertIfDuplicatePeerChain({projectId: projectId, newSucker: sucker});
-
             // Store the sucker as being deployed for this project.
             // slither-disable-next-line unused-return
             _suckersOf[projectId].set({key: address(sucker), value: _SUCKER_EXISTS});

package/src/JBSwapCCIPSucker.sol

@@ -121,8 +121,9 @@ contract JBSwapCCIPSucker is JBCCIPSucker, IUnlockCallback, IUniswapV3SwapCallba
     /// @notice The Uniswap V3 factory for pool discovery and callback verification. Can be address(0).
     IUniswapV3Factory public immutable V3_FACTORY;
 
-    /// @notice The wrapped native token (e.g., WETH on Ethereum). Used for V3 native swaps.
-    IWrappedNativeToken public immutable WETH;
+    /// @notice The ERC-20 wrapper for the chain's native token (e.g. WETH on Ethereum, WCELO on Celo). Used for V3
+    /// native swaps.
+    IWrappedNativeToken public immutable WRAPPED_NATIVE_TOKEN;
 
     //*********************************************************************//
     // ------------------- internal stored properties -------------------- //
@@ -223,11 +224,11 @@ contract JBSwapCCIPSucker is JBCCIPSucker, IUnlockCallback, IUniswapV3SwapCallba
         POOL_MANAGER = swapDeployer.poolManager();
         V3_FACTORY = swapDeployer.v3Factory();
         UNIV4_HOOK = swapDeployer.univ4Hook();
-        WETH = IWrappedNativeToken(swapDeployer.weth());
+        WRAPPED_NATIVE_TOKEN = IWrappedNativeToken(swapDeployer.weth());
 
         if (address(BRIDGE_TOKEN) == address(0)) revert JBSwapCCIPSucker_InvalidBridgeToken();
-        // BRIDGE_TOKEN must not be WETH — native/WETH wrapping and CCIP ERC-20 bridging conflict.
-        if (address(BRIDGE_TOKEN) == address(WETH) && address(WETH) != address(0)) {
+        // BRIDGE_TOKEN must not be the wrapped native token — wrapping and CCIP ERC-20 bridging conflict.
+        if (address(BRIDGE_TOKEN) == address(WRAPPED_NATIVE_TOKEN) && address(WRAPPED_NATIVE_TOKEN) != address(0)) {
             revert JBSwapCCIPSucker_InvalidBridgeToken();
         }
         // NOTE: V3_FACTORY and POOL_MANAGER can both be address(0) on chains where the local terminal token
@@ -239,7 +240,8 @@ contract JBSwapCCIPSucker is JBCCIPSucker, IUnlockCallback, IUniswapV3SwapCallba
     // ------------------------- receive / fallback ---------------------- //
     //*********************************************************************//
 
-    /// @notice Allow this contract to receive ETH (from V4 swaps, WETH unwrap, and CCIP refunds).
+    /// @notice Allow this contract to receive native tokens (from V4 swaps, wrapped-native-token unwrap, and CCIP
+    /// refunds).
     receive() external payable override {}
 
     //*********************************************************************//
@@ -593,7 +595,10 @@ contract JBSwapCCIPSucker is JBCCIPSucker, IUnlockCallback, IUniswapV3SwapCallba
     function _executeSwap(address tokenIn, address tokenOut, uint256 amount) internal returns (uint256 amountOut) {
         return JBSwapPoolLib.executeSwap({
             config: JBSwapPoolLib.SwapConfig({
-                v3Factory: V3_FACTORY, poolManager: POOL_MANAGER, univ4Hook: UNIV4_HOOK, weth: address(WETH)
+                v3Factory: V3_FACTORY,
+                poolManager: POOL_MANAGER,
+                univ4Hook: UNIV4_HOOK,
+                weth: address(WRAPPED_NATIVE_TOKEN)
             }),
             tokenIn: tokenIn,
             tokenOut: tokenOut,

package/src/deployers/JBCeloSuckerDeployer.sol

@@ -22,7 +22,7 @@ contract JBCeloSuckerDeployer is JBOptimismSuckerDeployer, IJBCeloSuckerDeployer
     // ---------------------- public stored properties ------------------- //
     //*********************************************************************//
 
-    /// @notice The wrapped native token (WETH) on the local chain.
+    /// @notice The ERC-20 wrapper for the chain's native token on the local chain.
     IWrappedNativeToken public override wrappedNative;
 
     //*********************************************************************//
@@ -63,7 +63,7 @@ contract JBCeloSuckerDeployer is JBOptimismSuckerDeployer, IJBCeloSuckerDeployer
     /// @notice Handles layer specific configuration including the wrapped native token.
     /// @param messenger The OPMessenger on this layer.
     /// @param bridge The OPStandardBridge on this layer.
-    /// @param _wrappedNative The wrapped native token (WETH) on this layer.
+    /// @param _wrappedNative The ERC-20 wrapper for the chain's native token on this layer.
     function setChainSpecificConstants(
         IOPMessenger messenger,
         IOPStandardBridge bridge,

package/src/deployers/JBSwapCCIPSuckerDeployer.sol

@@ -41,7 +41,7 @@ contract JBSwapCCIPSuckerDeployer is JBCCIPSuckerDeployer, IJBSwapCCIPSuckerDepl
     /// @notice The Uniswap V4 hook address for pool discovery (optional).
     address public univ4Hook;
 
-    /// @notice The wrapped native token address (e.g., WETH).
+    /// @notice The ERC-20 wrapper address for the chain's native token (e.g. WETH on Ethereum).
     address public weth;
 
     //*********************************************************************//
@@ -72,7 +72,7 @@ contract JBSwapCCIPSuckerDeployer is JBCCIPSuckerDeployer, IJBSwapCCIPSuckerDepl
     /// @param _poolManager The Uniswap V4 PoolManager (can be address(0) if V4 unavailable).
     /// @param _v3Factory The Uniswap V3 factory (can be address(0) if V3 unavailable).
     /// @param _univ4Hook The V4 hook for pool discovery (optional, address(0) if none).
-    /// @param _weth The wrapped native token address (e.g., WETH).
+    /// @param _weth The ERC-20 wrapper address for the chain's native token (e.g. WETH on Ethereum).
     function setSwapConstants(
         IERC20 _bridgeToken,
         IPoolManager _poolManager,

package/src/interfaces/IJBCeloSuckerDeployer.sol

@@ -10,7 +10,7 @@ import {IOPStandardBridge} from "./IOPStandardBridge.sol";
 interface IJBCeloSuckerDeployer is IJBOpSuckerDeployer {
     // View functions
 
-    /// @notice The wrapped native token (WETH) on the local chain.
+    /// @notice The ERC-20 wrapper for the chain's native token on the local chain.
     function wrappedNative() external view returns (IWrappedNativeToken);
 
     // State-changing functions

package/src/interfaces/IJBSwapCCIPSuckerDeployer.sol

@@ -22,6 +22,7 @@ interface IJBSwapCCIPSuckerDeployer is IJBCCIPSuckerDeployer {
     /// @notice The Uniswap V4 hook address used during pool discovery (optional).
     function univ4Hook() external view returns (address);
 
-    /// @notice The wrapped native token address (e.g., WETH). Used for V3 native swaps.
+    /// @notice The ERC-20 wrapper address for the chain's native token (e.g. WETH on Ethereum). Used for V3 native
+    /// swaps.
     function weth() external view returns (address);
 }

package/src/libraries/CCIPHelper.sol

@@ -61,7 +61,7 @@ library CCIPHelper {
     address public constant TEMPO_LINK = 0x15C03488B29e27d62BAf10E30b0c474bf60E0264;
     address public constant TEMPO_MOD_LINK = 0xEAB080c724587fFC9F2EFF82e36EE4Fb27774959;
 
-    /// @notice The WETH address of each chain
+    /// @notice The wrapped native token address of each chain
     address public constant ETH_WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
     address public constant ETH_SEP_WETH = 0x097D90c9d3E0B50Ca60e1ae45F6A81010f9FB534;
     address public constant OP_WETH = 0x4200000000000000000000000000000000000006;
@@ -146,9 +146,9 @@ library CCIPHelper {
         }
     }
 
-    /// @notice Returns the WETH address for a given chain ID.
+    /// @notice Returns the wrapped native token address for a given chain ID.
     /// @param chainId The EVM chain ID to look up.
-    /// @return weth The WETH address.
+    /// @return weth The wrapped native token address.
     function wethOfChain(uint256 chainId) public pure returns (address weth) {
         if (chainId == ETH_ID) {
             return ETH_WETH;

package/src/libraries/JBCCIPLib.sol

@@ -19,13 +19,13 @@ library JBCCIPLib {
     // ---------------------- external transactions ---------------------- //
     //*********************************************************************//
 
-    /// @notice Prepare token amounts for CCIP: wrap native ETH -> WETH, build token amounts array, approve router.
+    /// @notice Prepare token amounts for CCIP: wrap native tokens, build token amounts array, approve router.
     /// @dev Runs via DELEGATECALL so native ETH wrapping uses the caller's balance.
     /// @param ccipRouter The CCIP router.
     /// @param token The token to bridge (may be NATIVE_TOKEN).
     /// @param amount The amount to bridge.
     /// @return tokenAmounts The CCIP token amounts array (length 0 or 1).
-    /// @return bridgeToken The actual ERC-20 token address to bridge (WETH if native was wrapped).
+    /// @return bridgeToken The actual ERC-20 token address to bridge (wrapped native token if native was wrapped).
     function prepareTokenAmounts(
         ICCIPRouter ccipRouter,
         address token,
@@ -42,13 +42,13 @@ library JBCCIPLib {
         // Start with the original token as the bridge token.
         bridgeToken = token;
 
-        // Wrap native ETH -> WETH for CCIP bridging. CCIP only transports ERC-20s.
+        // Wrap native tokens for CCIP bridging. CCIP only transports ERC-20s.
         if (token == JBConstants.NATIVE_TOKEN) {
             // Get the wrapped native token address from the CCIP router.
             // slither-disable-next-line calls-loop
             IWrappedNativeToken wrappedNative = ccipRouter.getWrappedNative();
 
-            // Deposit ETH to receive WETH.
+            // Deposit native tokens to receive wrapped native tokens.
             // slither-disable-next-line calls-loop,arbitrary-send-eth
             wrappedNative.deposit{value: amount}();
 
@@ -157,8 +157,8 @@ library JBCCIPLib {
         }
     }
 
-    /// @notice Unwrap WETH -> ETH from received CCIP tokens if the delivered token is the router's wrapped native.
-    /// @dev Runs via DELEGATECALL so `address(this).balance` refers to the calling contract.
+    /// @notice Unwrap wrapped native tokens from received CCIP tokens if the delivered token matches the wrapped
+    /// native. @dev Runs via DELEGATECALL so `address(this).balance` refers to the calling contract.
     /// @param ccipRouter The CCIP router (used to look up wrapped native token).
     /// @param destTokenAmounts The token amounts delivered by CCIP (length 0 or 1).
     function unwrapReceivedTokens(ICCIPRouter ccipRouter, Client.EVMTokenAmount[] calldata destTokenAmounts) external {
@@ -171,12 +171,12 @@ library JBCCIPLib {
             // slither-disable-next-line calls-loop
             IWrappedNativeToken wrappedNative = ccipRouter.getWrappedNative();
 
-            // If the delivered token is WETH and the amount is non-zero, unwrap it.
+            // If the delivered token is the wrapped native token and the amount is non-zero, unwrap it.
             if (tokenAmount.token == address(wrappedNative) && tokenAmount.amount > 0) {
                 // Record the ETH balance before unwrapping.
                 uint256 balanceBefore = address(this).balance;
 
-                // Withdraw WETH to receive ETH.
+                // Withdraw wrapped native tokens to receive native tokens.
                 wrappedNative.withdraw(tokenAmount.amount);
 
                 // Assert the ETH balance increased by the expected amount.

package/src/libraries/JBSwapPoolLib.sol

@@ -77,7 +77,7 @@ library JBSwapPoolLib {
     /// @custom:member v3Factory The Uniswap V3 factory used for pool discovery.
     /// @custom:member poolManager The Uniswap V4 pool manager used for V4 pool queries and swaps.
     /// @custom:member univ4Hook The address of the Uniswap V4 hook contract to search for hooked pools.
-    /// @custom:member weth The address of the wrapped native token (WETH) on this chain.
+    /// @custom:member weth The address of the ERC-20 wrapper for the chain's native token (e.g. WETH on Ethereum).
     struct SwapConfig {
         IUniswapV3Factory v3Factory;
         IPoolManager poolManager;
@@ -91,7 +91,7 @@ library JBSwapPoolLib {
 
     /// @notice Execute a full swap: discover the best V3/V4 pool, quote via TWAP, execute the swap.
     /// @dev Runs via DELEGATECALL so the calling contract's balance and callbacks are used.
-    /// @param config The swap configuration (factory, pool manager, hook, WETH addresses).
+    /// @param config The swap configuration (factory, pool manager, hook, wrapped native token addresses).
     /// @param tokenIn The input token (raw address, may be NATIVE_TOKEN sentinel).
     /// @param tokenOut The output token (raw address).
     /// @param amount The amount of input tokens to swap.
@@ -108,11 +108,11 @@ library JBSwapPoolLib {
         external
         returns (uint256 amountOut)
     {
-        // Normalize NATIVE_TOKEN sentinel to WETH for pool lookups.
+        // Normalize NATIVE_TOKEN sentinel to the wrapped native token for pool lookups.
         address normalizedIn = _normalize({token: tokenIn, weth: config.weth});
         address normalizedOut = _normalize({token: tokenOut, weth: config.weth});
 
-        // No swap needed if tokens are the same after normalization (e.g., NATIVE_TOKEN and WETH).
+        // No swap needed if tokens are the same after normalization (e.g., NATIVE_TOKEN and wrapped native token).
         if (normalizedIn == normalizedOut) return amount;
 
         // Discover the most liquid pool across V3 and V4.
@@ -163,16 +163,16 @@ library JBSwapPoolLib {
                     originalTokenIn: tokenIn
                 });
             }
-            // V3 outputs WETH for native pairs — unwrap to raw ETH.
+            // V3 outputs wrapped native token for native pairs — unwrap to raw native token.
             if (tokenOut == JBConstants.NATIVE_TOKEN) {
                 IWrappedNativeToken(config.weth).withdraw(amountOut);
             }
         }
 
-        // V4 outputs native ETH for WETH-paired pools. If the caller requested WETH (not NATIVE_TOKEN),
-        // wrap the received ETH so the caller gets the token they expect.
+        // V4 outputs native tokens for wrapped-native-paired pools. If the caller requested the wrapped form
+        // (not NATIVE_TOKEN), wrap the received native tokens so the caller gets the token they expect.
         if (isV4 && tokenOut != JBConstants.NATIVE_TOKEN && normalizedOut == config.weth) {
-            // Wrap through the configured WETH contract; this is not a user-selected ETH recipient.
+            // Wrap through the configured wrapped native token contract.
             // slither-disable-next-line arbitrary-send-eth
             IWrappedNativeToken(config.weth).deposit{value: amountOut}();
         }
@@ -236,7 +236,7 @@ library JBSwapPoolLib {
         // Settle input (pay what we owe to the PoolManager).
         Currency inputCurrency = zeroForOne ? key.currency0 : key.currency1;
         if (Currency.unwrap(inputCurrency) == address(0)) {
-            // Native ETH: unwrap WETH if needed, then settle by sending ETH value directly.
+            // Native token: unwrap if needed, then settle by sending native value directly.
             if (weth != address(0)) IWrappedNativeToken(weth).withdraw(amountIn);
             // slither-disable-next-line unused-return,arbitrary-send-eth
             poolManager.settle{value: amountIn}();
@@ -286,8 +286,8 @@ library JBSwapPoolLib {
         // forge-lint: disable-next-line(unsafe-typecast)
         uint256 amountToSend = amount0Delta < 0 ? uint256(amount1Delta) : uint256(amount0Delta);
 
-        // If input is native ETH, wrap to WETH for V3.
-        // When originalTokenIn == NATIVE_TOKEN, normalizedIn is already the WETH address.
+        // If input is the native token, wrap for V3.
+        // When originalTokenIn == NATIVE_TOKEN, normalizedIn is already the wrapped native address.
         if (originalTokenIn == JBConstants.NATIVE_TOKEN) {
             IWrappedNativeToken(normalizedIn).deposit{value: amountToSend}();
         }
@@ -302,7 +302,7 @@ library JBSwapPoolLib {
 
     /// @notice Externally accessible pool discovery for testing and off-chain queries.
     /// @param config The swap configuration (factory, pool manager, etc.).
-    /// @param normalizedTokenIn The normalized input token address (WETH, not NATIVE_TOKEN).
+    /// @param normalizedTokenIn The normalized input token address (wrapped native token, not NATIVE_TOKEN).
     /// @param normalizedTokenOut The normalized output token address.
     /// @return isV4 Whether the best pool is a V4 pool.
     /// @return v3Pool The best V3 pool (or address(0) if V4 is better).
@@ -327,8 +327,8 @@ library JBSwapPoolLib {
     //*********************************************************************//
 
     /// @notice Find the highest liquidity pool across all V3 fee tiers and V4 pool configurations.
-    /// @param config The swap configuration (factory, pool manager, hook, WETH addresses).
-    /// @param normalizedTokenIn The normalized input token address (WETH, not NATIVE_TOKEN).
+    /// @param config The swap configuration (factory, pool manager, hook, wrapped native token addresses).
+    /// @param normalizedTokenIn The normalized input token address (wrapped native token, not NATIVE_TOKEN).
     /// @param normalizedTokenOut The normalized output token address.
     /// @return isV4 Whether the best pool is a V4 pool.
     /// @return v3Pool The best V3 pool (or address(0) if V4 is better).
@@ -419,7 +419,7 @@ library JBSwapPoolLib {
 
     /// @notice Search V4 pools across 4 fee tiers and 2 hook configs for the best eligible liquidity.
     /// @dev TWAP-capable hooked pools are preferred over hookless spot pools. Broken hooked pools are skipped.
-    /// @param config The swap configuration (pool manager, hook, WETH addresses).
+    /// @param config The swap configuration (pool manager, hook, wrapped native token addresses).
     /// @param normalizedTokenIn The normalized input token address.
     /// @param normalizedTokenOut The normalized output token address.
     /// @return bestKey The selected V4 pool key.
@@ -439,8 +439,8 @@ library JBSwapPoolLib {
         PoolKey memory bestSpotKey;
         uint128 bestSpotLiquidity;
 
-        // Convert to V4 convention before sorting: WETH represents native ETH in the calling code, while V4 pool
-        // keys use address(0) for native ETH.
+        // Convert to V4 convention before sorting: the wrapped native token represents native tokens in the calling
+        // code, while V4 pool keys use address(0) for native tokens.
         address sorted0;
         address sorted1;
         {
@@ -604,7 +604,7 @@ library JBSwapPoolLib {
     }
 
     /// @notice Get a V4 quote with dynamic slippage. Hooked pools must serve TWAP; hookless pools use spot fallback.
-    /// @param config The swap configuration (pool manager, WETH addresses).
+    /// @param config The swap configuration (pool manager, wrapped native token addresses).
     /// @param key The V4 pool key to quote against.
     /// @param normalizedTokenIn The normalized input token address.
     /// @param normalizedTokenOut The normalized output token address.
@@ -867,7 +867,7 @@ library JBSwapPoolLib {
     //*********************************************************************//
 
     /// @notice Quote via V4 TWAP/spot and execute swap. Separate function for stack isolation.
-    /// @param config The swap configuration (pool manager, WETH addresses).
+    /// @param config The swap configuration (pool manager, wrapped native token addresses).
     /// @param key The V4 pool key to swap through.
     /// @param normalizedTokenIn The normalized input token address.
     /// @param normalizedTokenOut The normalized output token address.
@@ -976,7 +976,7 @@ library JBSwapPoolLib {
     }
 
     /// @notice Execute a swap through a V4 pool via `PoolManager.unlock()`.
-    /// @param config The swap configuration (pool manager, WETH addresses).
+    /// @param config The swap configuration (pool manager, wrapped native token addresses).
     /// @param key The V4 pool key to swap through.
     /// @param normalizedTokenIn The normalized input token address.
     /// @param amount The amount of input tokens to swap.
@@ -992,7 +992,7 @@ library JBSwapPoolLib {
         internal
         returns (uint256 amountOut)
     {
-        // Convert WETH to address(0) for V4's native ETH convention.
+        // Convert wrapped native token to address(0) for V4's native token convention.
         address v4In = normalizedTokenIn == config.weth ? address(0) : normalizedTokenIn;
 
         // Determine swap direction based on currency ordering in the pool key.
@@ -1021,9 +1021,9 @@ library JBSwapPoolLib {
         amountOut = abi.decode(result, (uint256));
     }
 
-    /// @notice Normalize a token address, converting the NATIVE_TOKEN sentinel to WETH.
+    /// @notice Normalize a token address, converting the NATIVE_TOKEN sentinel to the wrapped native token.
     /// @param token The token address to normalize.
-    /// @param weth The WETH address on this chain.
+    /// @param weth The wrapped native token address on this chain.
     /// @return The normalized token address.
     function _normalize(address token, address weth) internal pure returns (address) {
         return token == JBConstants.NATIVE_TOKEN ? weth : token;