@bananapus/suckers-v6 0.0.34 → 0.0.36

package/package.json

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

package/src/JBArbitrumSucker.sol

@@ -151,7 +151,7 @@ contract JBArbitrumSucker is JBSucker, IJBArbitrumSucker {
     /// @notice Uses the L1/L2 gateway to send the root and assets over the bridge to the peer.
     /// @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.
-    /// @param remoteToken Information about the remote token being bridged to.
+    /// @param remoteToken Information about the remote token to bridge to.
     // forge-lint: disable-next-line(mixed-case-function)
     function _sendRootOverAMB(
         uint256 transportPayment,

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
@@ -201,7 +201,7 @@ contract JBCCIPSucker is JBSucker, IAny2EVMMessageReceiver {
     /// @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.
     /// @param amount The amount of tokens to bridge.
-    /// @param remoteToken Information about the remote token being bridged to.
+    /// @param remoteToken Information about the remote token to bridge to.
     /// @param sucker_message The message root to send to the remote peer.
     // forge-lint: disable-next-line(mixed-case-function)
     function _sendRootOverAMB(
@@ -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,11 +119,11 @@ 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.
-    /// @param remoteToken Information about the remote token being bridged to.
+    /// @param remoteToken Information about the remote token to bridge to.
     // forge-lint: disable-next-line(mixed-case-function)
     function _sendRootOverAMB(
         uint256 transportPayment,
@@ -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/JBOptimismSucker.sol

@@ -87,7 +87,7 @@ contract JBOptimismSucker is JBSucker, IJBOptimismSucker {
     /// over the `OPBRIDGE`.
     /// @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.
-    /// @param remoteToken Information about the remote token being bridged to.
+    /// @param remoteToken Information about the remote token to bridge to.
     // forge-lint: disable-next-line(mixed-case-function)
     function _sendRootOverAMB(
         uint256 transportPayment,

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
@@ -389,7 +389,7 @@ abstract contract JBSucker is ERC2771Context, JBPermissioned, Initializable, ERC
     /// messages time to arrive, accepting roots after deprecation provides a stronger guarantee that users can always
     /// claim their bridged tokens. Double-spend is not a concern because `toRemote` is already disabled in
     /// `SENDING_DISABLED` and `DEPRECATED` states, so no new outbound transfers can occur.
-    /// @param root The merkle root, token, and amount being received.
+    /// @param root The merkle root, token, and amount to receive.
     function fromRemote(JBMessageRoot calldata root) external payable {
         // Make sure that the message came from our peer.
         // Use msg.sender (not _msgSender()) because bridge messengers never use ERC2771 meta-transactions.
@@ -620,7 +620,7 @@ abstract contract JBSucker is ERC2771Context, JBPermissioned, Initializable, ERC
     /// for the original caller instead of being added back to `transportPayment`. This preserves
     /// `transportPayment = msg.value - fee`, which is critical for zero-cost bridges (OP, Base, Celo, Arb L2->L1)
     /// that revert on non-zero transport payment. The retained fee is excluded from `amountToAddToBalanceOf`.
-    /// @param token The terminal token being bridged.
+    /// @param token The terminal token to bridge.
     function toRemote(address token) external payable override {
         JBRemoteToken memory remoteToken = _remoteTokenFor[token];
 
@@ -963,7 +963,7 @@ abstract contract JBSucker is ERC2771Context, JBPermissioned, Initializable, ERC
     }
 
     /// @notice The action(s) to perform after a user has succesfully proven their claim.
-    /// @param terminalToken The terminal token being sucked.
+    /// @param terminalToken The terminal token to suck.
     /// @param terminalTokenAmount The amount of terminal tokens.
     /// @param projectTokenAmount The amount of project tokens.
     /// @param beneficiary The beneficiary of the project tokens (bytes32 for cross-VM compatibility).
@@ -1000,8 +1000,8 @@ abstract contract JBSucker is ERC2771Context, JBPermissioned, Initializable, ERC
     }
 
     /// @notice Inserts a new leaf into the outbox merkle tree for the specified `token`.
-    /// @param projectTokenCount The amount of project tokens being cashed out.
-    /// @param token The terminal token being cashed out for.
+    /// @param projectTokenCount The amount of project tokens to cash out.
+    /// @param token The terminal token to cash out for.
     /// @param terminalTokenAmount The amount of terminal tokens reclaimed by cashing out.
     /// @param beneficiary The beneficiary of the project tokens on the remote chain (bytes32 for cross-VM
     /// compatibility).
@@ -1127,7 +1127,7 @@ abstract contract JBSucker is ERC2771Context, JBPermissioned, Initializable, ERC
     }
 
     /// @notice Cash out project tokens for terminal tokens.
-    /// @param projectToken The project token being cashed out (unused, kept for interface compatibility).
+    /// @param projectToken The project token to cash out (unused, kept for interface compatibility).
     /// @param count The number of project tokens to cash out.
     /// @param token The terminal token to cash out for.
     /// @param minTokensReclaimed The minimum amount of terminal tokens to reclaim. If the amount reclaimed is less than
@@ -1245,8 +1245,8 @@ abstract contract JBSucker is ERC2771Context, JBPermissioned, Initializable, ERC
     /// @dev This is chain/sucker/bridge specific logic.
     /// @param transportPayment The amount of `msg.value` that is going to get paid for sending this message.
     /// @param index The index of the most recent message that is part of the root.
-    /// @param token The terminal token being bridged.
-    /// @param amount The amount of terminal tokens being bridged.
+    /// @param token The terminal token to bridge.
+    /// @param amount The amount of terminal tokens to bridge.
     /// @param remoteToken The remote token which the terminal token is mapped to.
     /// @param message The message/root to send to the remote chain.
     // forge-lint: disable-next-line(mixed-case-function)
@@ -1268,7 +1268,7 @@ abstract contract JBSucker is ERC2771Context, JBPermissioned, Initializable, ERC
     /// @param terminalToken The terminal token that the project tokens were cashed out for.
     /// @param terminalTokenAmount The amount of terminal tokens reclaimed by the cash out.
     /// @param beneficiary The beneficiary of the project tokens (bytes32 for cross-VM compatibility).
-    /// @param index The index of the leaf being proved in the terminal token's inbox tree.
+    /// @param index The index of the leaf to prove in the terminal token's inbox tree.
     /// @param leaves The leaves that prove that the leaf at the `index` is in the tree (i.e. the merkle branch that the
     /// leaf is on).
     function _validate(
@@ -1364,7 +1364,7 @@ abstract contract JBSucker is ERC2771Context, JBPermissioned, Initializable, ERC
     /// @param terminalToken The terminal token that the project tokens were cashed out for.
     /// @param terminalTokenAmount The amount of terminal tokens reclaimed by the cash out.
     /// @param beneficiary The beneficiary of the project tokens (bytes32 for cross-VM compatibility).
-    /// @param index The index of the leaf being proved in the terminal token's inbox tree.
+    /// @param index The index of the leaf to prove in the terminal token's inbox tree.
     /// @param leaves The leaves that prove that the leaf at the `index` is in the tree (i.e. the merkle branch that the
     /// leaf is on).
     function _validateForEmergencyExit(
@@ -1467,8 +1467,8 @@ abstract contract JBSucker is ERC2771Context, JBPermissioned, Initializable, ERC
     }
 
     /// @notice Builds a hash as they are stored in the merkle tree.
-    /// @param projectTokenCount The number of project tokens being cashed out.
-    /// @param terminalTokenAmount The amount of terminal tokens being reclaimed by the cash out.
+    /// @param projectTokenCount The number of project tokens to cash out.
+    /// @param terminalTokenAmount The amount of terminal tokens to reclaim from the cash out.
     /// @param beneficiary The beneficiary which will receive the project tokens (bytes32 for cross-VM compatibility).
     /// @return hash The keccak256 hash of the leaf data.
     function _buildTreeHash(
@@ -1605,9 +1605,9 @@ abstract contract JBSucker is ERC2771Context, JBPermissioned, Initializable, ERC
     /// @dev Delegates snapshot construction to JBSuckerLib (deployed library, called via DELEGATECALL) to reduce
     /// child contract bytecode.
     /// @param transportPayment The amount of `msg.value` that is going to get paid for sending this message.
-    /// @param token The terminal token being bridged.
+    /// @param token The terminal token to bridge.
     /// @param remoteToken The remote token which the terminal token is mapped to.
-    /// @param amount The amount of terminal tokens being bridged.
+    /// @param amount The amount of terminal tokens to bridge.
     /// @param nonce The outbox nonce for this send.
     /// @param root The merkle root of the outbox tree.
     /// @param index The index of the most recent message that is part of the root.

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);
@@ -401,8 +400,8 @@ contract JBSuckerRegistry is ERC2771Context, Ownable, JBPermissioned, IJBSuckerR
     /// @param values The aggregate values recorded so far.
     /// @param hasActiveValue Whether the recorded value for each index came from an active sucker.
     /// @param chainCount The number of populated chain entries.
-    /// @param chainId The peer-chain id being recorded.
-    /// @param value The value being recorded.
+    /// @param chainId The peer-chain id to record.
+    /// @param value The value to record.
     /// @param isActive Whether the value came from an active sucker.
     /// @return The updated number of populated chain entries.
     function _recordPeerValue(
@@ -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 -------------------- //
@@ -184,7 +185,7 @@ contract JBSwapCCIPSucker is JBCCIPSucker, IUnlockCallback, IUniswapV3SwapCallba
     // ------------------- transient stored properties ------------------- //
     //*********************************************************************//
 
-    /// @notice Leaf index + 1 of the claim currently being processed (set by `claim` override).
+    /// @notice Leaf index + 1 of the claim currently in progress (set by the `claim` override).
     /// @dev Transient storage — auto-resets to 0 each transaction, saving ~9,800 gas per claim vs SSTORE.
     /// Value 0 means no active claim (bypass scaling); non-zero means leafIndex = value - 1.
     uint256 transient _currentClaimLeafIndex;
@@ -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 {}
 
     //*********************************************************************//
@@ -370,8 +372,8 @@ contract JBSwapCCIPSucker is JBCCIPSucker, IUnlockCallback, IUniswapV3SwapCallba
     }
 
     /// @notice Uniswap V3 swap callback — delegates to JBSwapPoolLib (via DELEGATECALL) to reduce bytecode.
-    /// @param amount0Delta The amount of token0 being used for the swap.
-    /// @param amount1Delta The amount of token1 being used for the swap.
+    /// @param amount0Delta The amount of token0 used for the swap.
+    /// @param amount1Delta The amount of token1 used for the swap.
     /// @param data Encoded (originalTokenIn, normalizedTokenIn, normalizedTokenOut).
     function uniswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes calldata data) external override {
         JBSwapPoolLib.executeV3SwapCallback({
@@ -502,7 +504,7 @@ contract JBSwapCCIPSucker is JBCCIPSucker, IUnlockCallback, IUniswapV3SwapCallba
     /// Delegates CCIP message construction to JBCCIPLib (via DELEGATECALL) to reduce bytecode.
     /// @param transportPayment The ETH sent for CCIP fees.
     /// @param index The last leaf index in the current batch.
-    /// @param token The local token being bridged.
+    /// @param token The local token to bridge.
     /// @param amount The amount of local tokens to bridge.
     /// @param remoteToken The remote token configuration (including minGas).
     /// @param sucker_message The merkle root message to send to the remote chain.
@@ -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/IJBPeerChainAdjustedAccounts.sol

@@ -4,7 +4,7 @@ pragma solidity ^0.8.0;
 /// @notice Optional data-hook interface for adding project-specific adjusted accounts to peer-chain snapshots.
 interface IJBPeerChainAdjustedAccounts {
     /// @notice Extra supply, surplus, and balance that should be included in cross-chain peer snapshots.
-    /// @param projectId The ID of the project being snapshotted.
+    /// @param projectId The ID of the project to snapshot.
     /// @param decimals The decimals the returned surplus and balance should use.
     /// @param currency The currency the returned surplus and balance should be in terms of.
     /// @return supply The extra supply to include in `sourceTotalSupply`.

package/src/interfaces/IJBSucker.sol

@@ -61,8 +61,8 @@ interface IJBSucker is IERC165 {
     event NewInboxTreeRoot(address indexed token, uint64 nonce, bytes32 root, address caller);
 
     /// @notice Emitted when the outbox tree root and bridged assets are sent to the remote peer.
-    /// @param root The outbox tree root being sent.
-    /// @param token The terminal token being bridged.
+    /// @param root The outbox tree root sent to the remote peer.
+    /// @param token The terminal token to bridge.
     /// @param index The current outbox tree index.
     /// @param nonce The nonce assigned to this root message.
     /// @param caller The address that initiated the send.

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/interfaces/IL1ArbitrumGateway.sol

@@ -7,7 +7,7 @@ interface IL1ArbitrumGateway {
     /// @param _token The L1 token address.
     /// @param _from The sender on L1.
     /// @param _to The recipient on L2.
-    /// @param _amount The amount of tokens being bridged.
+    /// @param _amount The amount of tokens to bridge.
     /// @param _data Additional data (forwarded to the L2 gateway).
     /// @return The ABI-encoded calldata for `finalizeInboundTransfer` on the L2 gateway.
     function getOutboundCalldata(

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 being bridged (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/JBRelayBeneficiary.sol

@@ -19,7 +19,7 @@ library JBRelayBeneficiary {
     /// @dev Returns `beneficiary` unchanged if the payer is not a registered sucker or if no relay data is found.
     /// @param payer The address that called `terminal.pay()` (i.e. `context.payer`).
     /// @param beneficiary The beneficiary set in the payment context (i.e. `context.beneficiary`).
-    /// @param projectId The project being paid.
+    /// @param projectId The project to pay.
     /// @param metadata The payment metadata (`context.payerMetadata` or `context.metadata`).
     /// @param registry The sucker registry used to verify that `payer` is a legitimate sucker.
     /// @return effectiveBeneficiary The resolved beneficiary — the relay address if valid, or the original.

package/src/libraries/JBSuckerLib.sol

@@ -227,7 +227,7 @@ library JBSuckerLib {
     /// @param prices The price oracle to use for non-ETH terminal-token balances.
     /// @param projectId The project ID.
     /// @param remoteToken The remote token bytes32 address.
-    /// @param amount The amount of terminal tokens being bridged.
+    /// @param amount The amount of terminal tokens to bridge.
     /// @param nonce The outbox nonce for this send.
     /// @param root The merkle root of the outbox tree.
     /// @param messageVersion The message format version.
@@ -269,8 +269,8 @@ library JBSuckerLib {
     /// @notice Optional project-specific adjusted accounts to add to peer-chain snapshots.
     /// @dev Reads the current ruleset's data hook and asks it for extra supply/surplus. Non-supporting hooks,
     /// broken hooks, and short return data are ignored so a project's baseline snapshot remains usable.
-    /// @param controller The controller for the project being snapshotted.
-    /// @param projectId The project being snapshotted.
+    /// @param controller The controller for the project to snapshot.
+    /// @param projectId The project to snapshot.
     /// @return additionalSupply The supply to add to `sourceTotalSupply`.
     /// @return additionalSurplus The surplus to add to `sourceSurplus`, denominated in ETH at 18 decimals.
     /// @return additionalBalance The balance to add to `sourceBalance`, denominated in ETH at 18 decimals.
@@ -308,7 +308,7 @@ library JBSuckerLib {
     /// @notice Builds the local accounting values used in outbound peer-chain snapshots.
     /// @param directory The JB directory to look up controllers and terminals.
     /// @param prices The price oracle to use for non-ETH terminal-token balances.
-    /// @param projectId The project being snapshotted.
+    /// @param projectId The project to snapshot.
     /// @return localTotalSupply The total project token supply, including reserved tokens.
     /// @return ethSurplus The terminal surplus denominated in ETH at 18 decimals.
     /// @return ethBalance The terminal balance denominated in ETH at 18 decimals.

package/src/libraries/JBSwapLib.sol

@@ -54,7 +54,7 @@ library JBSwapLib {
     //*********************************************************************//
 
     /// @notice Estimate the price impact of a swap, scaled by IMPACT_PRECISION.
-    /// @param amountIn The amount of tokens being swapped in.
+    /// @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.
@@ -84,7 +84,7 @@ library JBSwapLib {
 
     /// @notice Compute a sqrtPriceLimitX96 from input/output amounts so the swap stops
     ///         if the execution price would be worse than the minimum acceptable rate.
-    /// @param amountIn The amount of tokens being swapped in.
+    /// @param amountIn The amount of tokens to swap in.
     /// @param minimumAmountOut The minimum acceptable output.
     /// @param zeroForOne True when selling token0 for token1 (price decreases).
     /// @return sqrtPriceLimit The V3-compatible sqrtPriceLimitX96.

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}();
@@ -260,8 +260,8 @@ library JBSwapPoolLib {
     /// `uniswapV3SwapCallback` so the V3 callback logic lives in library bytecode.
     /// @dev DELEGATECALL preserves msg.sender (the V3 pool), allowing pool verification.
     /// @param v3Factory The Uniswap V3 factory for pool verification.
-    /// @param amount0Delta The amount of token0 being used for the swap.
-    /// @param amount1Delta The amount of token1 being used for the swap.
+    /// @param amount0Delta The amount of token0 used for the swap.
+    /// @param amount1Delta The amount of token1 used for the swap.
     /// @param data Encoded (originalTokenIn, normalizedTokenIn, normalizedTokenOut).
     function executeV3SwapCallback(
         IUniswapV3Factory v3Factory,
@@ -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;

package/src/structs/JBMessageRoot.sol

@@ -6,7 +6,7 @@ import {JBInboxTreeRoot} from "./JBInboxTreeRoot.sol";
 /// @notice Information about the remote (inbox) tree's root, passed in a message from the remote chain.
 /// @custom:member version The message format version. Used to reject incompatible messages.
 /// @custom:member token The remote token address (bytes32 for cross-VM compatibility with SVM).
-/// @custom:member amount The amount of tokens being sent.
+/// @custom:member amount The amount of tokens to send.
 /// @custom:member remoteRoot The root of the merkle tree.
 /// @custom:member sourceTotalSupply The total token supply (including reserved tokens) on the source chain at the
 /// time the message was sent. Used by the receiving chain to track cross-chain supply for cash out tax calculations.