diff --git a/contracts/staking/RewardRouter.sol b/contracts/staking/RewardRouter.sol
index 0feb00d..b7a8052 100644
--- a/contracts/staking/RewardRouter.sol
+++ b/contracts/staking/RewardRouter.sol
@@ -12,22 +12,22 @@ import {Governable} from "../core/Governable.sol";
 contract RewardRouter is ReentrancyGuard, Governable {
   using SafeERC20 for IERC20;
 
-  address public gmx;
-  address public esGmx;
+  address public cec;
+  address public esCec;
 
-  address public stakedGmxTracker;
-  address public gmxVester;
+  address public stakedCecTracker;
+  address public cecVester;
 
   mapping(address sender => address receiver) public pendingReceivers;
 
-  event StakeGmx(address account, address token, uint256 amount);
-  event UnstakeGmx(address account, address token, uint256 amount);
+  event StakeCec(address account, address token, uint256 amount);
+  event UnstakeCec(address account, address token, uint256 amount);
 
-  constructor(address _gmx, address _esGmx, address _stakedGmxTracker, address _gmxVester) {
-    gmx = _gmx;
-    esGmx = _esGmx;
-    stakedGmxTracker = _stakedGmxTracker;
-    gmxVester = _gmxVester;
+  constructor(address _cec, address _esCec, address _stakedCecTracker, address _cecVester) {
+    cec = _cec;
+    esCec = _esCec;
+    stakedCecTracker = _stakedCecTracker;
+    cecVester = _cecVester;
   }
 
   // to help users who accidentally send their tokens to this contract
@@ -35,45 +35,45 @@ contract RewardRouter is ReentrancyGuard, Governable {
     IERC20(_token).safeTransfer(_account, _amount);
   }
 
-  function batchStakeGmxForAccount(
+  function batchStakeCecForAccount(
     address[] memory _accounts,
     uint256[] memory _amounts
   ) external nonReentrant onlyGov {
-    address _gmx = gmx;
+    address _cec = cec;
     for (uint256 i = 0; i < _accounts.length; i++) {
-      _stakeGmx(msg.sender, _accounts[i], _gmx, _amounts[i]);
+      _stakeCec(msg.sender, _accounts[i], _cec, _amounts[i]);
     }
   }
 
-  function stakeGmxForAccount(address _account, uint256 _amount) external nonReentrant onlyGov {
-    _stakeGmx(msg.sender, _account, gmx, _amount);
+  function stakeCecForAccount(address _account, uint256 _amount) external nonReentrant onlyGov {
+    _stakeCec(msg.sender, _account, cec, _amount);
   }
 
-  function stakeGmx(uint256 _amount) external nonReentrant {
-    _stakeGmx(msg.sender, msg.sender, gmx, _amount);
+  function stakeCec(uint256 _amount) external nonReentrant {
+    _stakeCec(msg.sender, msg.sender, cec, _amount);
   }
 
-  function stakeEsGmx(uint256 _amount) external nonReentrant {
-    _stakeGmx(msg.sender, msg.sender, esGmx, _amount);
+  function stakeEsCec(uint256 _amount) external nonReentrant {
+    _stakeCec(msg.sender, msg.sender, esCec, _amount);
   }
 
-  function unstakeGmx(uint256 _amount) external nonReentrant {
-    _unstakeGmx(msg.sender, gmx, _amount);
+  function unstakeCec(uint256 _amount) external nonReentrant {
+    _unstakeCec(msg.sender, cec, _amount);
   }
 
-  function unstakeEsGmx(uint256 _amount) external nonReentrant {
-    _unstakeGmx(msg.sender, esGmx, _amount);
+  function unstakeEsCec(uint256 _amount) external nonReentrant {
+    _unstakeCec(msg.sender, esCec, _amount);
   }
 
   function claim() external nonReentrant {
     address account = msg.sender;
 
-    IRewardTracker(stakedGmxTracker).claimForAccount(account, account);
+    IRewardTracker(stakedCecTracker).claimForAccount(account, account);
   }
 
-  function claimEsGmx() external nonReentrant {
+  function claimEsCec() external nonReentrant {
     address account = msg.sender;
-    IRewardTracker(stakedGmxTracker).claimForAccount(account, account);
+    IRewardTracker(stakedCecTracker).claimForAccount(account, account);
   }
 
   function compound() external nonReentrant {
@@ -85,29 +85,29 @@ contract RewardRouter is ReentrancyGuard, Governable {
   }
 
   function handleRewards(
-    bool _shouldClaimGmx,
-    bool _shouldStakeGmx,
-    bool _shouldClaimEsGmx,
-    bool _shouldStakeEsGmx
+    bool _shouldClaimCec,
+    bool _shouldStakeCec,
+    bool _shouldClaimEsCec,
+    bool _shouldStakeEsCec
   ) external nonReentrant {
     address account = msg.sender;
 
-    uint256 gmxAmount = 0;
-    if (_shouldClaimGmx) {
-      gmxAmount = IVester(gmxVester).claimForAccount(account, account);
+    uint256 cecAmount = 0;
+    if (_shouldClaimCec) {
+      cecAmount = IVester(cecVester).claimForAccount(account, account);
     }
 
-    if (_shouldStakeGmx && gmxAmount > 0) {
-      _stakeGmx(account, account, gmx, gmxAmount);
+    if (_shouldStakeCec && cecAmount > 0) {
+      _stakeCec(account, account, cec, cecAmount);
     }
 
-    uint256 esGmxAmount = 0;
-    if (_shouldClaimEsGmx) {
-      esGmxAmount = IRewardTracker(stakedGmxTracker).claimForAccount(account, account);
+    uint256 esCecAmount = 0;
+    if (_shouldClaimEsCec) {
+      esCecAmount = IRewardTracker(stakedCecTracker).claimForAccount(account, account);
     }
 
-    if (_shouldStakeEsGmx && esGmxAmount > 0) {
-      _stakeGmx(account, account, esGmx, esGmxAmount);
+    if (_shouldStakeEsCec && esCecAmount > 0) {
+      _stakeCec(account, account, esCec, esCecAmount);
     }
   }
 
@@ -118,7 +118,7 @@ contract RewardRouter is ReentrancyGuard, Governable {
   }
 
   function signalTransfer(address _receiver) external nonReentrant {
-    require(IERC20(gmxVester).balanceOf(msg.sender) == 0, "sender has vested tokens");
+    require(IERC20(cecVester).balanceOf(msg.sender) == 0, "sender has vested tokens");
 
     _validateReceiver(_receiver);
 
@@ -126,7 +126,7 @@ contract RewardRouter is ReentrancyGuard, Governable {
   }
 
   function acceptTransfer(address _sender) external nonReentrant {
-    require(IERC20(gmxVester).balanceOf(_sender) == 0, "sender has vested tokens");
+    require(IERC20(cecVester).balanceOf(_sender) == 0, "sender has vested tokens");
 
     address receiver = msg.sender;
     require(pendingReceivers[_sender] == receiver, "transfer not signalled");
@@ -135,72 +135,72 @@ contract RewardRouter is ReentrancyGuard, Governable {
     _validateReceiver(receiver);
     _compound(_sender);
 
-    uint256 stakedGmx = IRewardTracker(stakedGmxTracker).depositBalances(_sender, gmx);
-    if (stakedGmx > 0) {
-      _unstakeGmx(_sender, gmx, stakedGmx);
-      _stakeGmx(_sender, receiver, gmx, stakedGmx);
+    uint256 stakedCec = IRewardTracker(stakedCecTracker).depositBalances(_sender, cec);
+    if (stakedCec > 0) {
+      _unstakeCec(_sender, cec, stakedCec);
+      _stakeCec(_sender, receiver, cec, stakedCec);
     }
 
-    uint256 stakedEsGmx = IRewardTracker(stakedGmxTracker).depositBalances(_sender, esGmx);
-    if (stakedEsGmx > 0) {
-      _unstakeGmx(_sender, esGmx, stakedEsGmx);
-      _stakeGmx(_sender, receiver, esGmx, stakedEsGmx);
+    uint256 stakedEsCec = IRewardTracker(stakedCecTracker).depositBalances(_sender, esCec);
+    if (stakedEsCec > 0) {
+      _unstakeCec(_sender, esCec, stakedEsCec);
+      _stakeCec(_sender, receiver, esCec, stakedEsCec);
     }
 
-    uint256 esGmxBalance = IERC20(esGmx).balanceOf(_sender);
-    if (esGmxBalance > 0) {
-      IERC20(esGmx).transferFrom(_sender, receiver, esGmxBalance);
+    uint256 esCecBalance = IERC20(esCec).balanceOf(_sender);
+    if (esCecBalance > 0) {
+      IERC20(esCec).transferFrom(_sender, receiver, esCecBalance);
     }
 
-    IVester(gmxVester).transferStakeValues(_sender, receiver);
+    IVester(cecVester).transferStakeValues(_sender, receiver);
   }
 
   function _validateReceiver(address _receiver) private view {
     require(
-      IRewardTracker(stakedGmxTracker).averageStakedAmounts(_receiver) == 0,
-      "stakedGmxTracker.averageStakedAmounts > 0"
+      IRewardTracker(stakedCecTracker).averageStakedAmounts(_receiver) == 0,
+      "stakedCecTracker.averageStakedAmounts > 0"
     );
     require(
-      IRewardTracker(stakedGmxTracker).cumulativeRewards(_receiver) == 0,
-      "stakedGmxTracker.cumulativeRewards > 0"
+      IRewardTracker(stakedCecTracker).cumulativeRewards(_receiver) == 0,
+      "stakedCecTracker.cumulativeRewards > 0"
     );
 
     require(
-      IVester(gmxVester).transferredAverageStakedAmounts(_receiver) == 0,
-      "gmxVester.transferredAverageStakedAmounts > 0"
+      IVester(cecVester).transferredAverageStakedAmounts(_receiver) == 0,
+      "cecVester.transferredAverageStakedAmounts > 0"
     );
     require(
-      IVester(gmxVester).transferredCumulativeRewards(_receiver) == 0,
-      "gmxVester.transferredCumulativeRewards > 0"
+      IVester(cecVester).transferredCumulativeRewards(_receiver) == 0,
+      "cecVester.transferredCumulativeRewards > 0"
     );
 
-    require(IERC20(gmxVester).balanceOf(_receiver) == 0, "gmxVester.balance > 0");
+    require(IERC20(cecVester).balanceOf(_receiver) == 0, "cecVester.balance > 0");
   }
 
   function _compound(address _account) private {
-    _compoundGmx(_account);
+    _compoundCec(_account);
   }
 
-  function _compoundGmx(address _account) private {
-    uint256 esGmxAmount = IRewardTracker(stakedGmxTracker).claimForAccount(_account, _account);
-    if (esGmxAmount > 0) {
-      _stakeGmx(_account, _account, esGmx, esGmxAmount);
+  function _compoundCec(address _account) private {
+    uint256 esCecAmount = IRewardTracker(stakedCecTracker).claimForAccount(_account, _account);
+    if (esCecAmount > 0) {
+      _stakeCec(_account, _account, esCec, esCecAmount);
     }
   }
 
-  function _stakeGmx(address _fundingAccount, address _account, address _token, uint256 _amount) private {
+  function _stakeCec(address _fundingAccount, address _account, address _token, uint256 _amount) private {
     require(_amount > 0, "invalid _amount");
 
-    IRewardTracker(stakedGmxTracker).stakeForAccount(_fundingAccount, _account, _token, _amount);
+    IRewardTracker(stakedCecTracker).stakeForAccount(_fundingAccount, _account, _token, _amount);
 
-    emit StakeGmx(_account, _token, _amount);
+    emit StakeCec(_account, _token, _amount);
   }
 
-  function _unstakeGmx(address _account, address _token, uint256 _amount) private {
+  function _unstakeCec(address _account, address _token, uint256 _amount) private {
     require(_amount > 0, "invalid _amount");
-    // uint256 balance = IRewardTracker(stakedGmxTracker).stakedAmounts(_account);
-    IRewardTracker(stakedGmxTracker).unstakeForAccount(_account, _token, _amount, _account);
+    // uint256 balance = IRewardTracker(stakedCecTracker).stakedAmounts(_account);
+    IRewardTracker(stakedCecTracker).unstakeForAccount(_account, _token, _amount, _account);
 
-    emit UnstakeGmx(_account, _token, _amount);
+    emit UnstakeCec(_account, _token, _amount);
   }
 }