Review fixes II

contracts/PolygonZkEVMGlobalExitRootL2.sol

@@ -27,6 +27,12 @@ contract PolygonZkEVMGlobalExitRootL2 is IBasePolygonZkEVMGlobalExitRoot {
     // PolygonZkEVM Bridge address
     address public immutable bridgeAddress;
 
+    /**
+     * @dev This empty reserved space is put in place to allow future versions to add new
+     * variables without shifting down storage in the inheritance chain.
+     */
+    uint256[50] private _gap;
+
     /**
      * @param _bridgeAddress PolygonZkEVMBridge contract address
      */

contracts/v2/PolygonZkEVMBridgeV2.sol

@@ -319,36 +319,6 @@ contract PolygonZkEVMBridgeV2 is
         }
     }
 
-    /**
-     * @notice Burn tokens from wrapped token to execute the bridge
-     * note This  function has been extracted to be able to override it by other contracts like Bridge2SovereignChain
-     * @param tokenWrapped Wrapped token to burnt
-     * @param amount Amount of tokens
-     */
-    function _bridgeWrappedAsset(
-        TokenWrapped tokenWrapped,
-        uint256 amount
-    ) internal virtual {
-        // Burn tokens
-        tokenWrapped.burn(msg.sender, amount);
-    }
-
-    /**
-     * @notice Mints tokens from wrapped token to proceed with the claim
-     * note This  function has been extracted to be able to override it by other contracts like Bridge2SovereignChain
-     * @param tokenWrapped Wrapped token to mint
-     * @param destinationAddress Minted token receiver
-     * @param amount Amount of tokens
-     */
-    function _claimWrappedAsset(
-        TokenWrapped tokenWrapped,
-        address destinationAddress,
-        uint256 amount
-    ) internal virtual {
-        // Burn tokens
-        tokenWrapped.mint(destinationAddress, amount);
-    }
-
     /**
      * @notice Bridge message and send ETH value
      * note User/UI must be aware of the existing/available networks when choosing the destination network
@@ -571,7 +541,11 @@ contract PolygonZkEVMBridgeV2 is
                         );
 
                         // Mint tokens for the destination address
-                        _claimWrappedAsset(newWrappedToken, destinationAddress, amount);
+                        _claimWrappedAsset(
+                            newWrappedToken,
+                            destinationAddress,
+                            amount
+                        );
 
                         // Create mappings
                         tokenInfoToWrappedToken[tokenInfoHash] = address(
@@ -590,7 +564,11 @@ contract PolygonZkEVMBridgeV2 is
                         );
                     } else {
                         // Use the existing wrapped erc20
-                        _claimWrappedAsset(TokenWrapped(wrappedToken), destinationAddress, amount);
+                        _claimWrappedAsset(
+                            TokenWrapped(wrappedToken),
+                            destinationAddress,
+                            amount
+                        );
                     }
                 }
             }
@@ -927,6 +905,36 @@ contract PolygonZkEVMBridgeV2 is
         globalExitRootManager.updateExitRoot(getRoot());
     }
 
+    /**
+     * @notice Burn tokens from wrapped token to execute the bridge
+     * note This  function has been extracted to be able to override it by other contracts like Bridge2SovereignChain
+     * @param tokenWrapped Wrapped token to burnt
+     * @param amount Amount of tokens
+     */
+    function _bridgeWrappedAsset(
+        TokenWrapped tokenWrapped,
+        uint256 amount
+    ) internal virtual {
+        // Burn tokens
+        tokenWrapped.burn(msg.sender, amount);
+    }
+
+    /**
+     * @notice Mints tokens from wrapped token to proceed with the claim
+     * note This  function has been extracted to be able to override it by other contracts like Bridge2SovereignChain
+     * @param tokenWrapped Wrapped token to mint
+     * @param destinationAddress Minted token receiver
+     * @param amount Amount of tokens
+     */
+    function _claimWrappedAsset(
+        TokenWrapped tokenWrapped,
+        address destinationAddress,
+        uint256 amount
+    ) internal virtual {
+        // Burn tokens
+        tokenWrapped.mint(destinationAddress, amount);
+    }
+
     /**
      * @notice Function decode an index into a wordPos and bitPos
      * @param index Index

contracts/v2/PolygonZkEVMGlobalExitRootV2.sol

@@ -25,12 +25,6 @@ contract PolygonZkEVMGlobalExitRootV2 is
     // Store every l1InfoLeaf
     mapping(uint32 leafCount => bytes32 l1InfoRoot) public l1InfoRootMap;
 
-    /**
-     * @dev This empty reserved space is put in place to allow future versions to add new
-     * variables without shifting down storage in the inheritance chain.
-     */
-    uint256[50] private _gap;
-
     /**
      * @dev Emitted when the global exit root is updated
      */
@@ -83,7 +77,7 @@ contract PolygonZkEVMGlobalExitRootV2 is
      * @notice Update the exit root of one of the networks and the global exit root
      * @param newRoot new exit tree root
      */
-    function updateExitRoot(bytes32 newRoot) external virtual {
+    function updateExitRoot(bytes32 newRoot) external {
         // Store storage variables into temporal variables since will be used multiple times
         bytes32 cacheLastRollupExitRoot;
         bytes32 cacheLastMainnetExitRoot;

contracts/v2/sovereignChains/BridgeL2SovereignChain.sol

@@ -76,49 +76,6 @@ contract BridgeL2SovereignChain is
         _;
     }
 
-    /**
-     * @notice Burn tokens from wrapped token to execute the bridge
-     * note This  function has been extracted to be able to override it by other contracts like Bridge2SovereignChain
-     * @param tokenWrapped Wrapped token to burnt
-     * @param amount Amount of tokens
-     */
-    function _bridgeWrappedAsset(
-        TokenWrapped tokenWrapped,
-        uint256 amount
-    ) internal override {
-        // The token is either (1) a correctly wrapped token from another network
-        // or (2) wrapped with custom contract from origin network
-        if (wrappedAddressIsNotMintable[address(tokenWrapped)]) {
-            // Don't use burn but transfer to bridge
-            IERC20Upgradeable(address(tokenWrapped)).safeTransferFrom(msg.sender, address(this), amount);
-        } else {
-            // Burn tokens
-            tokenWrapped.burn(msg.sender, amount);
-        }
-    }
-
-    /**
-     * @notice Mints tokens from wrapped token to proceed with the claim
-     * note This  function has been extracted to be able to override it by other contracts like Bridge2SovereignChain
-     * @param tokenWrapped Wrapped token to mint
-     * @param destinationAddress Minted token receiver
-     * @param amount Amount of tokens
-     */
-    function _claimWrappedAsset(
-        TokenWrapped tokenWrapped,
-        address destinationAddress,
-        uint256 amount
-    ) internal override {
-        // If is not mintable transfer instead of mint
-        if (wrappedAddressIsNotMintable[address(tokenWrapped)]) {
-            // Transfer wETH
-            IERC20Upgradeable(address(tokenWrapped)).safeTransfer(destinationAddress, amount);
-        } else {
-            // Claim wETH
-            tokenWrapped.mint(destinationAddress, amount);
-        }
-    }
-
     /**
      * @notice Updated bridge manager address
      * @param _bridgeManager Bridge manager address
@@ -209,4 +166,48 @@ contract BridgeL2SovereignChain is
         WETHToken = TokenWrapped(sovereignWETHTokenAddress);
         wrappedAddressIsNotMintable[sovereignWETHTokenAddress] = isNotMintable;
     }
+
+
+    /**
+     * @notice Burn tokens from wrapped token to execute the bridge
+     * note This  function has been extracted to be able to override it by other contracts like Bridge2SovereignChain
+     * @param tokenWrapped Wrapped token to burnt
+     * @param amount Amount of tokens
+     */
+    function _bridgeWrappedAsset(
+        TokenWrapped tokenWrapped,
+        uint256 amount
+    ) internal override {
+        // The token is either (1) a correctly wrapped token from another network
+        // or (2) wrapped with custom contract from origin network
+        if (wrappedAddressIsNotMintable[address(tokenWrapped)]) {
+            // Don't use burn but transfer to bridge
+            IERC20Upgradeable(address(tokenWrapped)).safeTransferFrom(msg.sender, address(this), amount);
+        } else {
+            // Burn tokens
+            tokenWrapped.burn(msg.sender, amount);
+        }
+    }
+
+    /**
+     * @notice Mints tokens from wrapped token to proceed with the claim
+     * note This  function has been extracted to be able to override it by other contracts like Bridge2SovereignChain
+     * @param tokenWrapped Wrapped token to mint
+     * @param destinationAddress Minted token receiver
+     * @param amount Amount of tokens
+     */
+    function _claimWrappedAsset(
+        TokenWrapped tokenWrapped,
+        address destinationAddress,
+        uint256 amount
+    ) internal override {
+        // If is not mintable transfer instead of mint
+        if (wrappedAddressIsNotMintable[address(tokenWrapped)]) {
+            // Transfer wETH
+            IERC20Upgradeable(address(tokenWrapped)).safeTransfer(destinationAddress, amount);
+        } else {
+            // Claim wETH
+            tokenWrapped.mint(destinationAddress, amount);
+        }
+    }
 }

contracts/v2/sovereignChains/GlobalExitRootManagerL2SovereignChain.sol

@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: AGPL-3.0
 
 pragma solidity 0.8.20;
-import {PolygonAccessControlUpgradeable} from "../lib/PolygonAccessControlUpgradeable.sol";
 import "../../PolygonZkEVMGlobalExitRootL2.sol";
 
 /**