Etherex Contracts

/// @dev set the new fees in the pair to 95/5- ramsesV3PoolFactory.setPoolFeeProtocol(pair, 5);+ ramsesV3PoolFactory.setPoolFeeProtocol(pair, 50_000);

function test_killGaugeAndDistribute() public {        address gauge = IVoter(VOTER).gaugeForPool(ETH_USDC_POOL);        address OWNER = ETHEREX_TEAM_MULTISIG;        vm.startPrank(OWNER);        address[] memory pairs = new address[](1);        pairs[0] = ETH_USDC_POOL;        IAccessHub(ACCESS_HUB).killGauge(pairs);        // move time forward to next period        vm.warp(block.timestamp + 1 weeks);        IVoter(VOTER).distribute(gauge);}

0xAe334f70A7FC44FCC2df9e6A37BC032497Cf80f1::76734e3e(00000000000000000000000090e8a5b881d211f418d77ba8978788b62544914b0000000000000000000000000000000000000000000000000000000000000005)    │   │   │   └─ ← [Revert] EvmError: Revert    │   │   └─ ← [Revert] EvmError: Revert    │   └─ ← [Revert] EvmError: Revert    └─ ← [Revert] EvmError: Revert

function test_killGaugeAndDistribute() public {        vm.etch(VOTER, address(new Voter()).code); // changed uint8 to uint24        address gauge = IVoter(VOTER).gaugeForPool(ETH_USDC_POOL);        address OWNER = ETHEREX_TEAM_MULTISIG;        vm.startPrank(OWNER);        address[] memory pairs = new address[](1);        pairs[0] = ETH_USDC_POOL;        IAccessHub(ACCESS_HUB).killGauge(pairs);        // move time forward to next period        vm.warp(block.timestamp + 1 weeks);        IVoter(VOTER).distribute(gauge);}

0xAe334f70A7FC44FCC2df9e6A37BC032497Cf80f1::setPoolFeeProtocol(0x90E8a5b881D211f418d77Ba8978788b62544914B, 5)   │   │   └─ ← [Revert] NOT_ACCESSHUB()   │   └─ ← [Revert] NOT_ACCESSHUB()   └─ ← [Revert] NOT_ACCESSHUB()

- $.grossFeeGrowthGlobal0X128 += FullMath.mulDiv(paid1, FixedPoint128.Q128, _liquidity);+ $.grossFeeGrowthGlobal1X128 += FullMath.mulDiv(paid1, FixedPoint128.Q128, _liquidity);

function updatePeriodAndRebase() external {        updatePeriod();@>      rebase();    }        function rebase() public {        /// @dev fetch the data from encoding        bytes memory data = abi.encodeWithSignature("rebase()");        /// @dev call the rebase function@>      (bool success,) = xRex.call(data);        require(success, "REBASE_UNSUCCESSFUL");    }        function rebase() external whenNotPaused {        ...        if (            /// @dev if the rebase is greater than the rebaseThreshold            period > lastDistributedPeriod && pendingRebase >= rebaseThreshold        ) {            ...            /// @dev notify the REX rebase@>          IVoteModule(VOTE_MODULE).notifyRewardAmount(_temp);        }    }        function notifyRewardAmount(uint256 amount) external nonReentrant {        ...
        /// @dev take the REX from the contract to the voteModule        underlying.transferFrom(xRex, address(this), amount);
        /// @dev record rewards to the period that just got finalized        uint256 period = getPeriod();        rewardSupply[period] += amount;
        /// @dev the timestamp of when people can withdraw next        /// @dev not DoSable because only xREX can notify@>      unlockTime = cooldown + block.timestamp;    }

function test_getRewardsViaFastDepositWithdraw() public {        address RANDOM_USER = makeAddr("random_user");        uint256 userXRexAmount = 1_000_000e18;        deal(XREX, RANDOM_USER, userXRexAmount);
        // warp to a minute prior to next period        uint256 currentTimestamp = vm.getBlockTimestamp();        uint256 nextPeriod = (currentTimestamp / 1 weeks + 1);        uint256 nextPeriodTimestamp = nextPeriod * 1 weeks;        vm.warp(nextPeriodTimestamp - 60);        vm.startPrank(RANDOM_USER);        IERC20(XREX).approve(address(VOTE_MODULE), userXRexAmount);        VoteModule(VOTE_MODULE).depositAll();
        // cast vote        address[] memory pools = new address[](1);        pools[0] = ETH_USDC_POOL;        uint256[] memory weights = new uint256[](1);        weights[0] = 1;        IVoter(VOTER).vote(RANDOM_USER, pools, weights);
        // fast forward to next period and withdraw        skip(60);        VoteModule(VOTE_MODULE).withdrawAll();        uint256 xRexBalanceAfterWithdraw = IERC20(XREX).balanceOf(RANDOM_USER);        // should have received capital back        assertEq(xRexBalanceAfterWithdraw, userXRexAmount);
        Minter(MINTER).updatePeriodAndRebase();        // then claim reward, verify that user received rewards        uint256 rewardAmount = VoteModule(VOTE_MODULE).periodEarned(nextPeriod, RANDOM_USER);        assertGt(rewardAmount, 0);        // can claim        uint256 xRexBalanceBefore = IERC20(XREX).balanceOf(RANDOM_USER);        VoteModule(VOTE_MODULE).getPeriodReward(nextPeriod);        uint256 xRexBalanceAfter = IERC20(XREX).balanceOf(RANDOM_USER);        assertGt(xRexBalanceAfter, xRexBalanceBefore);        console.log("xREX claimed from reward:", xRexBalanceAfter - xRexBalanceBefore);        vm.stopPrank();}

function poke(address user) external {    VoterStorage.VoterState storage $ = VoterStorage.getStorage();
    // <<< Block if Minter.UpdatePeriod hasn't been called yet >>>    if (msg.sender == $.voteModule) {        uint256 currentPeriod = getPeriod();        uint256 minterActivePeriod = IMinter($.minter).activePeriod();                if (currentPeriod > minterActivePeriod) {            revert("NEED_UPDATE_PERIOD");        }    }    // <<< rest of code >>>}

function _onlyGovernance() internal view {    require(msg.sender == VoterStorage.getStorage().accessHub, Errors.NOT_AUTHORIZED(msg.sender));}

/// @dev Ensures the address is an authorized NFP managermodifier onlyAuthorized(address manager) {    require(_isValidNfpManager(manager), Errors.NOT_AUTHORIZED_CLAIMER(manager));    _;}
/// @dev Allows either voter or authorized NFP managersmodifier onlyAuthorizedOrVoter() {    require(        msg.sender == voter || _isValidNfpManager(msg.sender),         Errors.NOT_AUTHORIZED(msg.sender)    );    _;}

function getReward(    address owner,    uint256 index,    int24 tickLower,    int24 tickUpper,    address[] memory tokens,    address receiver) external lock onlyAuthorized(owner) {    require(msg.sender == owner, Errors.NOT_AUTHORIZED(msg.sender));    _getAllRewards(owner, index, tickLower, tickUpper, tokens, receiver);}

address destinationGauge = $.gaugeRedirect[_gauge];if (destinationGauge == address(0)) {    destinationGauge = _gauge;}

/// @dev check RAM "claimable"if (_claimable > 0) {    /// @dev notify emissions    IGauge(destinationGauge).notifyRewardAmount($.ram, _claimable);}/// @dev check xRAM "claimable"if (_xRamClaimable > 0) {    /// @dev convert, then notify the xRam    IXRex(_xRam).convertEmissionsToken(_xRamClaimable);    IGauge(destinationGauge).notifyRewardAmount(_xRam, _xRamClaimable);}

+   $.gaugeRedirect[_gauge] = address(0);

-   address destinationGauge = $.gaugeRedirect[_gauge];-   if (destinationGauge == address(0)) {-       destinationGauge = _gauge;-   }

deviation = emissionsMultiplier > _emissionsMultiplier            ? (emissionsMultiplier - _emissionsMultiplier)            : (_emissionsMultiplier - emissionsMultiplier);
// deviation = 2000-1000 = 1000
        require(deviation <= MAX_DEVIATION, Errors.TOO_HIGH());         // 2000<=2500 which is true
        emissionsMultiplier = _emissionsMultiplier;         // emissionsMultiplier = 2000

@>      rewards.push(token0);@>      rewards.push(token1);        (isReward[token0], isReward[token1], isReward[xrex]) = (            true,            true,            true        );        /// @dev if token0 and token1 aren't shadow add shadow in the records        if (token0 != rex && token1 != rex) {            rewards.push(rex);            isReward[rex] = true;        }

function addRewards(address reward) external {        require(msg.sender == voter, Errors.NOT_VOTER(msg.sender));@>      if (!isReward[reward]) {            rewards.push(reward);            isReward[reward] = true;            emit RewardAdded(reward);        }    }

rewards.push(token0);        rewards.push(token1);+       rewards.push(xRex);        (isReward[token0], isReward[token1], isReward[xrex]) = (            true,            true,            true        );

// SPDX-License-Identifier: MITpragma solidity ^0.8.0;
import {Test} from "forge-std/Test.sol";import {console} from "forge-std/console.sol";import {RamsesV3Pool} from "../contracts/CL/core/RamsesV3Pool.sol";import {RamsesV3Factory} from "../contracts/CL/core/RamsesV3Factory.sol";import {RamsesV3PoolDeployer} from "../contracts/CL/core/RamsesV3PoolDeployer.sol";import {NonfungiblePositionManager} from "../contracts/CL/periphery/NonfungiblePositionManager.sol";import {INonfungiblePositionManager} from "../contracts/CL/periphery/interfaces/INonfungiblePositionManager.sol";import {TickMath} from "../contracts/CL/core/libraries/TickMath.sol";import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
contract TestERC20 is ERC20 {    constructor(uint256 _totalSupply) ERC20("Test Token", "TEST") {        _mint(msg.sender, _totalSupply);    }
    function mint(address to, uint256 amount) external {        _mint(to, amount);    }}
contract FullPeriodPositionTest is Test {    RamsesV3Factory factory;    RamsesV3Pool pool;    NonfungiblePositionManager nfpManager;    TestERC20 token0;    TestERC20 token1;        address user = address(0x1234);    uint256 constant WEEK = 7 days;        int24 tickLower = 0;    int24 tickUpper = 210;            function setUp() public {        _setupInfrastructure();    }        function testFullPeriodPosition() public {        vm.warp(10000000);                uint256 startTime = block.timestamp / WEEK * WEEK;        uint256 initialPeriod = startTime / WEEK;
        vm.warp(startTime);                uint256 tokenId1 = _createPosition();                vm.warp(startTime + 2 days);        _burnPosition(tokenId1);                vm.warp(startTime + 3 days);        uint256 tokenId2 = _createPosition();                vm.warp(startTime + 4 days);        _burnPosition(tokenId2);                vm.warp(startTime + 7 days - 1);                uint256 result1 = pool.positionPeriodSecondsInRange(            initialPeriod,            address(nfpManager),            tokenId1,            tickLower,            tickUpper        );                uint256 result2 = pool.positionPeriodSecondsInRange(            initialPeriod,            address(nfpManager),            tokenId2,            tickLower,            tickUpper        );                // Calculate emission shares        uint256 weekX96 = WEEK * (2**96);        uint256 totalResult = result1 + result2;                uint256 emissionShare1 = result1 * 10000 / weekX96; // basis points        uint256 emissionShare2 = result2 * 10000 / weekX96; // basis points        uint256 totalEmissionShare = totalResult * 10000 / weekX96; // basis points                    console.log("Position 1 emission share:", emissionShare1 / 100, "%");        console.log("Position 2 emission share:", emissionShare2 / 100, "%");        console.log("Total emission share:", totalEmissionShare / 100, "%");                    uint256 lostEmission = 10000 - totalEmissionShare;        console.log("Lost emission:", lostEmission / 100, "%");    }        function _setupInfrastructure() internal {        token0 = new TestERC20(1000000e18);        token1 = new TestERC20(1000000e18);                if (address(token0) > address(token1)) {            (token0, token1) = (token1, token0);        }                factory = new RamsesV3Factory(address(0));        RamsesV3PoolDeployer poolDeployer = new RamsesV3PoolDeployer(address(factory));        factory.initialize(address(poolDeployer));                nfpManager = new NonfungiblePositionManager(address(poolDeployer), address(0), address(0), address(0));                pool = RamsesV3Pool(            factory.createPool(address(token0), address(token1), 10, TickMath.getSqrtRatioAtTick(200))        );                token0.mint(user, 1000000e18);        token1.mint(user, 1000000e18);                vm.startPrank(user);        token0.approve(address(nfpManager), type(uint256).max);        token1.approve(address(nfpManager), type(uint256).max);        vm.stopPrank();    }        function _createPosition() internal returns (uint256 tokenId) {        vm.prank(user);        (tokenId,,,) = nfpManager.mint(            INonfungiblePositionManager.MintParams({                token0: address(token0),                token1: address(token1),                tickSpacing: 10,                tickLower: tickLower,                tickUpper: tickUpper,                amount0Desired: 1000e18,                amount1Desired: 1000e18,                amount0Min: 0,                amount1Min: 0,                recipient: user,                deadline: block.timestamp + 1000            })        );                return tokenId;    }        function _burnPosition(uint256 tokenId) internal {        (uint128 positionLiquidity,,,,) = pool.positions(            keccak256(abi.encodePacked(address(nfpManager), tokenId, tickLower, tickUpper))        );                vm.prank(user);        nfpManager.decreaseLiquidity(            INonfungiblePositionManager.DecreaseLiquidityParams({                tokenId: tokenId,                liquidity: positionLiquidity,                amount0Min: 0,                amount1Min: 0,                deadline: block.timestamp + 1000            })        );            }}

/// @notice Get the period seconds in range of a specific position/// @return periodSecondsInsideX96 seconds the position was in range for the periodfunction positionPeriodSecondsInRange(PositionPeriodSecondsInRangeParams memory params)    public    view    returns (uint256 periodSecondsInsideX96){    PoolStorage.PoolState storage $ = PoolStorage.getStorage();
    uint256 currentPeriod = $.lastPeriod;>>  if (params.period > currentPeriod) revert FTR();
    bytes32 _positionHash = positionHash(params.owner, params.index, params.tickLower, params.tickUpper);

function validateReward(...) external view returns (bool) {        ...                // time-based validation (only for the new RamsesV3PositionManager)        if (_owner == address(nfpManager)) {            // nft position - use NFPManager's griefing-resistant checkpoint@>          uint32 lastModified = nfpManager.positionLastModified(_index);                        // new positions (never modified) are valid            if (lastModified == 0) {                return false; // valid, not slashed            }                        uint256 elapsedTime = block.timestamp - lastModified;@>          return elapsedTime <= timeThreshold; // slash if modified too recently        }    }

/// @dev create a FeeDistributor if neededaddress _feeDistributor = $.feeDistributorForClPair[token0][token1];if (_feeDistributor == address(0)) {    _feeDistributor = IFeeDistributorFactory($.feeDistributorFactory).createFeeDistributor(_feeCollector);    $.feeDistributorForClPair[token0][token1] = _feeDistributor;}

function removeFeeDistributorReward(address _feeDistributor, address reward) external {    VoterStorage.VoterState storage $ = VoterStorage.getStorage();
    /// @dev ensure the feeDist exists    require($.feeDistributors.contains(_feeDistributor));    IFeeDistributor(_feeDistributor).removeReward(reward);}

- /// @return periodSecondsInsideX96 seconds the position was not in range for the period+ /// @return periodSecondsInsideX96 seconds the position was in range for the period

function getPeriodReward(        uint256 period,        address[] calldata tokens,        address owner,        uint256 index,        int24 tickLower,        int24 tickUpper,        address receiver    ) external override lock onlyAuthorized(owner) {@>      require(msg.sender == owner, Errors.NOT_AUTHORIZED(msg.sender));                bytes32 _positionHash = positionHash(owner, index, tickLower, tickUpper);
        for (uint256 i = 0; i < tokens.length; ++i) {            if (period < _blockTimestamp() / WEEK) {                lastClaimByToken[tokens[i]][_positionHash] = period;            }
            _getReward(period, tokens[i], owner, index, tickLower, tickUpper, _positionHash, receiver);        }    }

function _getAllRewards(        address owner,        uint256 index,        int24 tickLower,        int24 tickUpper,        address[] memory tokens,        address receiver    ) internal {        bytes32 _positionHash = positionHash(owner, index, tickLower, tickUpper);        uint256 currentPeriod = _blockTimestamp() / WEEK;        uint256 lastClaim;
        for (uint256 i = 0; i < tokens.length; ++i) {            lastClaim = Math.max(lastClaimByToken[tokens[i]][_positionHash], firstPeriod);@>          for (uint256 period = lastClaim; period <= currentPeriod; ++period) {                _getReward(period, tokens[i], owner, index, tickLower, tickUpper, _positionHash, receiver);            }            lastClaimByToken[tokens[i]][_positionHash] = currentPeriod - 1;        }    }

function getPeriodReward(        uint256 period,        address[] calldata tokens,        address owner,        uint256 index,        int24 tickLower,        int24 tickUpper,        address receiver    ) external override lock onlyAuthorized(owner) {        require(msg.sender == owner, Errors.NOT_AUTHORIZED(msg.sender));                bytes32 _positionHash = positionHash(owner, index, tickLower, tickUpper);
        for (uint256 i = 0; i < tokens.length; ++i) {            if (period < _blockTimestamp() / WEEK) {@>              lastClaimByToken[tokens[i]][_positionHash] = period;            }
            _getReward(period, tokens[i], owner, index, tickLower, tickUpper, _positionHash, receiver);        }    }

function vote(address user, address[] calldata _pools, uint256[] calldata _weights) external {        VoterStorage.VoterState storage $ = VoterStorage.getStorage();
        /// @dev ensure that the arrays length matches and that the length is > 0        require(_pools.length > 0 && _pools.length == _weights.length, Errors.LENGTH_MISMATCH());        /// @dev if the caller isn't the user...        if (msg.sender != user) {            /// @dev ...require they are authorized to be a delegate            require(                IVoteModule($.voteModule).isDelegateFor(msg.sender, user) || msg.sender == $.accessHub,                Errors.NOT_AUTHORIZED(msg.sender)            );        }        /// @dev make a memory array of votedPools@>      address[] memory votedPools = new address[](_pools.length);        /// @dev loop through and populate the array@>      for (uint256 i = 0; i < _pools.length; ++i) {            votedPools[i] = _pools[i];        }
        /// @dev cast new votes        _vote(user, votedPools, _weights);    }

- IFeeRecipient(IFeeRecipientFactory($.feeRecipientFactory).feeRecipientForPair(pool)).notifyFees();+ IFeeRecipient(IPair(pool).feeRecipient()).notifyFees();

/// @inheritdoc IAccessHub    function setTreasuryInFeeCollector(address newTreasury) external onlyRole(PROTOCOL_OPERATOR) {        feeCollector.setTreasury(newTreasury);    }
    /// @inheritdoc IAccessHub    function setTreasuryFeesInFeeCollector(uint256 _treasuryFees) external onlyRole(PROTOCOL_OPERATOR) {        feeCollector.setTreasuryFees(_treasuryFees);    }

/// @dev Prevents calling a function from anyone except the treasury    modifier onlyTreasury() {        require(msg.sender == treasury, Errors.NOT_AUTHORIZED(msg.sender));        _;    }
    /// @inheritdoc IFeeCollector    function setTreasury(address _treasury) external override onlyTreasury {        emit TreasuryChanged(treasury, _treasury);
        treasury = _treasury;    }
    /// @inheritdoc IFeeCollector    function setTreasuryFees(uint256 _treasuryFees) external override onlyTreasury {        require(_treasuryFees <= BASIS, Errors.FEE_TOO_LARGE());        emit TreasuryFeesChanged(treasuryFees, _treasuryFees);
        treasuryFees = _treasuryFees;    }

/// @return true if the position should be slashed (blacklisted or too recently modified)    function validateReward(

/// @dev require the destination gauge to be of the same token0/token1 pairrequire(_gaugesForClPair.contains(destinationGauge), Errors.NO_GAUGE(destinationGauge));

/// @notice Thrown when pool doesn't have an associated gauge/// @param pool The address of the poolerror NO_GAUGE(address pool);

/// @notice Thrown when token is not whitelisted/// @param token The address of the non-whitelisted tokenerror NOT_WHITELISTED(address token);

amount = ((votingPowerUsed * PRECISION * periodRewardSupply) / (totalVotesPerPeriod * PRECISION))

/// @notice Thrown when attempting to interact with an inactive gauge/// @param gauge The address of the gaugeerror GAUGE_INACTIVE(address gauge);

- lastClaimByToken[tokens[i]][_positionHash] = currentPeriod - 1;+ lastClaimByToken[tokens[i]][_positionHash] = currentPeriod;

- emit IVoter.WhitelistRevoked(msg.sender, _token, true);+ emit IVoter.WhitelistRevoked(msg.sender, _token);// in IVoter- event WhitelistRevoked(address indexed forbidder, address indexed token, bool status);+ event WhitelistRevoked(address indexed forbidder, address indexed token);

- require(voter.isWhitelisted(token) || voter.isFeeDistributor(msg.sender), Errors.NOT_WHITELISTED(token));+ require(voter.isWhitelisted(token) , Errors.NOT_WHITELISTED(token));

- for (uint256 period = lastClaim; period <= currentPeriod; ++period)+ for (uint256 period = lastClaim+1; period <= currentPeriod; ++period)...
- lastClaimByToken[tokens[i]][owner] = currentPeriod - 1;+ lastClaimByToken[tokens[i]][owner] = currentPeriod;

- address private voter;+ IVoter private voter;

diff --git a/contracts/CL/periphery/RamsesV3PositionManager.sol b/contracts/CL/periphery/RamsesV3PositionManager.solindex ca807a6..a45c93e 100644--- a/contracts/CL/periphery/RamsesV3PositionManager.sol+++ b/contracts/CL/periphery/RamsesV3PositionManager.sol@@ -40,7 +40,9 @@ contract RamsesV3PositionManager is     /// @dev details about the Ramses position     struct Position {         /// @dev the ID of the pool with which this token is connected-        uint80 poolId;+        uint48 poolId;+        /// @dev last updated timestamp+        uint32 lastModified;         /// @dev the tick range of the position         int24 tickLower;         int24 tickUpper;@@ -55,10 +57,10 @@ contract RamsesV3PositionManager is     }      /// @dev IDs of pools assigned by this contract-    mapping(address pool => uint80 id) private _poolIds;+    mapping(address pool => uint48 id) private _poolIds;      /// @dev Pool keys by pool ID, to save on SSTOREs for position data-    mapping(uint80 id => PoolAddress.PoolKey key) private _poolIdToPoolKey;+    mapping(uint48 id => PoolAddress.PoolKey key) private _poolIdToPoolKey;      /// @dev The token ID position data     mapping(uint256 tokenId => Position position) private _positions;@@ -66,7 +68,7 @@ contract RamsesV3PositionManager is     /// @dev The ID of the next token that will be minted. Skips 0     uint176 private _nextId = 1;     /// @dev The ID of the next pool that is used for the first time. Skips 0-    uint80 private _nextPoolId = 1;+    uint48 private _nextPoolId = 1;      /// @dev The address of the token descriptor contract, which handles generating token URIs for position tokens     address private immutable _tokenDescriptor;@@ -75,13 +77,10 @@ contract RamsesV3PositionManager is     IAccessHub private immutable accessHub;      /// @dev the address of the voter contract-    address private voter;+    IVoter private voter;     address private ram;     address private xRam; -    /// @dev cache the last modified timestamp for each tokenId-    mapping(uint256 => uint32) public positionLastModified;-     constructor(         address _deployer,         address _WETH9,@@ -130,7 +129,7 @@ contract RamsesV3PositionManager is     }      /// @dev Caches a pool key-    function cachePoolKey(address pool, PoolAddress.PoolKey memory poolKey) private returns (uint80 poolId) {+    function cachePoolKey(address pool, PoolAddress.PoolKey memory poolKey) private returns (uint48 poolId) {         poolId = _poolIds[pool];         if (poolId == 0) {             _poolIds[pool] = (poolId = _nextPoolId++);@@ -174,13 +173,14 @@ contract RamsesV3PositionManager is         (, uint256 feeGrowthInside0LastX128, uint256 feeGrowthInside1LastX128, , ) = pool.positions(positionKey);          /// @dev idempotent set-        uint80 poolId = cachePoolKey(+        uint48 poolId = cachePoolKey(             address(pool),             PoolAddress.PoolKey({token0: params.token0, token1: params.token1, tickSpacing: params.tickSpacing})         );          _positions[tokenId] = Position({             poolId: poolId,+            lastModified: uint32(block.timestamp),             tickLower: params.tickLower,             tickUpper: params.tickUpper,             liquidity: liquidity,@@ -190,8 +190,6 @@ contract RamsesV3PositionManager is             tokensOwed1: 0         }); -        positionLastModified[tokenId] = uint32(block.timestamp);-         emit IncreaseLiquidity(tokenId, liquidity, amount0, amount1);     } @@ -207,8 +205,8 @@ contract RamsesV3PositionManager is     }      function _tryClaimRewards(uint256 tokenId, IRamsesV3Pool pool) private {-        if (voter != address(0)) {-            address gauge = IVoter(voter).gaugeForPool(address(pool));+        if (voter != IVoter(address(0))) {+            address gauge = voter.gaugeForPool(address(pool));             if (gauge != address(0)) {                 // only claim protocol tokens to prevent gas bomb attacks                 address[] memory rewardTokens = new address[](2);@@ -290,7 +288,7 @@ contract RamsesV3PositionManager is         }                  // checkpoint-        positionLastModified[params.tokenId] = uint32(block.timestamp);+        position.lastModified = uint32(block.timestamp);          emit IncreaseLiquidity(params.tokenId, liquidity, amount0, amount1);     }@@ -360,7 +358,7 @@ contract RamsesV3PositionManager is         }          // checkpoint-        positionLastModified[params.tokenId] = uint32(block.timestamp);+        position.lastModified = uint32(block.timestamp);          emit DecreaseLiquidity(params.tokenId, params.liquidity, amount0, amount1);     }@@ -441,7 +439,7 @@ contract RamsesV3PositionManager is           PoolAddress.PoolKey memory poolKey = _poolIdToPoolKey[position.poolId];-        IGaugeV3 gauge = IGaugeV3(IVoter(voter).gaugeForPool(PoolAddress.computeAddress(deployer, poolKey)));+        IGaugeV3 gauge = IGaugeV3(voter.gaugeForPool(PoolAddress.computeAddress(deployer, poolKey)));                  gauge.getRewardForOwner(tokenId, tokens);     }@@ -456,11 +454,16 @@ contract RamsesV3PositionManager is         Position storage position = _positions[tokenId];                  PoolAddress.PoolKey memory poolKey = _poolIdToPoolKey[position.poolId];-        address gauge = IVoter(voter).gaugeForPool(PoolAddress.computeAddress(deployer, poolKey));+        address gauge = voter.gaugeForPool(PoolAddress.computeAddress(deployer, poolKey));                      IGaugeV3(gauge).getPeriodReward(period, tokens, address(this), tokenId, position.tickLower, position.tickUpper, receiver);     } +    /// @inheritdoc IRamsesV3PositionManager+    function positionLastModified(uint256 tokenId) external view returns (uint32) {+        return _positions[tokenId].lastModified;+    }+     /// @inheritdoc INonfungiblePositionManager     function burn(uint256 tokenId) external payable override isAuthorizedForToken(tokenId) {         Position storage position = _positions[tokenId];@@ -471,13 +474,13 @@ contract RamsesV3PositionManager is      /// @notice extra function that allows for the 2-step deployment of CL first, then governance later     /// @dev gated to the timelock-    function setVoter(address _voter) external {+    function setVoter(IVoter _voter) external {         require(msg.sender == accessHub.timelock());         voter = _voter;                  // cache rex and xrex addresses to save gas on every claim-        ram = IVoter(_voter).ram();-        xRam = IVoter(_voter).xRam();+        ram = _voter.ram();+        xRam = _voter.xRam();     }      //** Overrides */