@pendle/core-v2 0.11.10-testnet → 0.12.0-testnet

package/contracts/SuperComposableYield/base-implementations/SCYBase.sol

@@ -7,9 +7,10 @@ import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
 import "../../libraries/math/Math.sol";
 import "../../libraries/SCY/SCYUtils.sol";
 import "../../libraries/helpers/TokenHelper.sol";
-import "../../../contracts/core/PendleERC20.sol";
+import "../../libraries/Errors.sol";
+import "../../../contracts/core/PendleERC20Permit.sol";
 
-abstract contract SCYBase is ISuperComposableYield, PendleERC20, TokenHelper {
+abstract contract SCYBase is ISuperComposableYield, PendleERC20Permit, TokenHelper {
     using Math for uint256;
 
     address public immutable yieldToken;
@@ -18,7 +19,7 @@ abstract contract SCYBase is ISuperComposableYield, PendleERC20, TokenHelper {
         string memory _name,
         string memory _symbol,
         address _yieldToken
-    ) PendleERC20(_name, _symbol, IERC20Metadata(_yieldToken).decimals()) {
+    ) PendleERC20Permit(_name, _symbol, IERC20Metadata(_yieldToken).decimals()) {
         yieldToken = _yieldToken;
     }
 
@@ -38,14 +39,14 @@ abstract contract SCYBase is ISuperComposableYield, PendleERC20, TokenHelper {
         uint256 amountTokenToDeposit,
         uint256 minSharesOut
     ) external payable nonReentrant returns (uint256 amountSharesOut) {
-        require(isValidTokenIn(tokenIn), "SCY: Invalid tokenIn");
-        require(amountTokenToDeposit != 0, "SCY: amountTokenToDeposit cannot be 0");
+        if (!isValidTokenIn(tokenIn)) revert Errors.SCYInvalidTokenIn(tokenIn);
+        if (amountTokenToDeposit == 0) revert Errors.SCYZeroDeposit();
 
-        if (tokenIn == NATIVE) require(msg.value == amountTokenToDeposit, "SCY: eth mismatch");
-        else _transferIn(tokenIn, msg.sender, amountTokenToDeposit);
+        _transferIn(tokenIn, msg.sender, amountTokenToDeposit);
 
         amountSharesOut = _deposit(tokenIn, amountTokenToDeposit);
-        require(amountSharesOut >= minSharesOut, "SCY: insufficient out");
+        if (amountSharesOut < minSharesOut)
+            revert Errors.SCYInsufficientSharesOut(amountSharesOut, minSharesOut);
 
         _mint(receiver, amountSharesOut);
         emit Deposit(msg.sender, receiver, tokenIn, amountTokenToDeposit, amountSharesOut);
@@ -58,36 +59,21 @@ abstract contract SCYBase is ISuperComposableYield, PendleERC20, TokenHelper {
         address receiver,
         uint256 amountSharesToRedeem,
         address tokenOut,
-        uint256 minTokenOut
+        uint256 minTokenOut,
+        bool burnFromInternalBalance
     ) external nonReentrant returns (uint256 amountTokenOut) {
-        _burn(msg.sender, amountSharesToRedeem);
-        amountTokenOut = _redeem(receiver, amountSharesToRedeem, tokenOut, minTokenOut);
-    }
-
-    function redeemAfterTransfer(
-        address receiver,
-        address tokenOut,
-        uint256 minTokenOut
-    ) external nonReentrant returns (uint256 amountTokenOut) {
-        uint256 amountSharesToRedeem = balanceOf(address(this));
-        _burn(address(this), amountSharesToRedeem);
-        amountTokenOut = _redeem(receiver, amountSharesToRedeem, tokenOut, minTokenOut);
-    }
-
-    function _redeem(
-        address receiver,
-        uint256 amountSharesToRedeem,
-        address tokenOut,
-        uint256 minTokenOut
-    ) internal returns (uint256 amountTokenOut) {
-        require(isValidTokenOut(tokenOut), "SCY: invalid tokenOut");
-        require(amountSharesToRedeem != 0, "SCY: amountSharesToRedeem cannot be 0");
-
-        amountTokenOut = _redeem(tokenOut, amountSharesToRedeem);
-        require(amountTokenOut >= minTokenOut, "SCY: insufficient out");
-
-        _transferOut(tokenOut, receiver, amountTokenOut);
-
+        if (!isValidTokenOut(tokenOut)) revert Errors.SCYInvalidTokenOut(tokenOut);
+        if (amountSharesToRedeem == 0) revert Errors.SCYZeroRedeem();
+
+        if (burnFromInternalBalance) {
+            _burn(address(this), amountSharesToRedeem);
+        } else {
+            _burn(msg.sender, amountSharesToRedeem);
+        }
+
+        amountTokenOut = _redeem(receiver, tokenOut, amountSharesToRedeem);
+        if (amountTokenOut < minTokenOut)
+            revert Errors.SCYInsufficientTokenOut(amountTokenOut, minTokenOut);
         emit Redeem(msg.sender, receiver, tokenOut, amountSharesToRedeem, amountTokenOut);
     }
 
@@ -108,10 +94,11 @@ abstract contract SCYBase is ISuperComposableYield, PendleERC20, TokenHelper {
      * @param amountSharesToRedeem amount of shares to be burned
      * @return amountTokenOut amount of base tokens redeemed
      */
-    function _redeem(address tokenOut, uint256 amountSharesToRedeem)
-        internal
-        virtual
-        returns (uint256 amountTokenOut);
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal virtual returns (uint256 amountTokenOut);
 
     /*///////////////////////////////////////////////////////////////
                                EXCHANGE-RATE
@@ -181,7 +168,7 @@ abstract contract SCYBase is ISuperComposableYield, PendleERC20, TokenHelper {
         virtual
         returns (uint256 amountSharesOut)
     {
-        require(isValidTokenIn(tokenIn), "SCY: Invalid tokenIn");
+        if (!isValidTokenIn(tokenIn)) revert Errors.SCYInvalidTokenIn(tokenIn);
         return _previewDeposit(tokenIn, amountTokenToDeposit);
     }
 
@@ -191,7 +178,7 @@ abstract contract SCYBase is ISuperComposableYield, PendleERC20, TokenHelper {
         virtual
         returns (uint256 amountTokenOut)
     {
-        require(isValidTokenOut(tokenOut), "SCY: Invalid tokenOut");
+        if (!isValidTokenOut(tokenOut)) revert Errors.SCYInvalidTokenOut(tokenOut);
         return _previewRedeem(tokenOut, amountSharesToRedeem);
     }
 

package/contracts/core/LiquidityMining/CrossChainMsg/PendleMsgReceiveEndpointUpg.sol

@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+import "../../../interfaces/ICelerMessageReceiverApp.sol";
+import "../../../interfaces/IPMsgReceiverApp.sol";
+import "../../../interfaces/ICelerMessageBus.sol";
+import "../../../periphery/BoringOwnableUpgradeable.sol";
+import "../../../libraries/Errors.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+
+contract PendleMsgReceiveEndpointUpg is
+    ICelerMessageReceiverApp,
+    Initializable,
+    UUPSUpgradeable,
+    BoringOwnableUpgradeable
+{
+    ICelerMessageBus public immutable celerMessageBus;
+    address public immutable sendEndpointAddr;
+    uint64 public immutable sendEndpointChainId;
+
+    modifier onlyCelerMessageBus() {
+        if (msg.sender != address(celerMessageBus)) revert Errors.OnlyCelerBus();
+        _;
+    }
+
+    modifier mustOriginateFromSendEndpoint(address srcAddress, uint64 srcChainId) {
+        if (srcAddress != sendEndpointAddr || srcChainId != sendEndpointChainId)
+            revert Errors.MsgNotFromSendEndpoint(msg.sender);
+        _;
+    }
+
+    constructor(
+        ICelerMessageBus _celerMessageBus,
+        address _sendEndpointAddr,
+        uint64 _sendEndpointChainId
+    ) initializer {
+        celerMessageBus = _celerMessageBus;
+        sendEndpointAddr = _sendEndpointAddr;
+        sendEndpointChainId = _sendEndpointChainId;
+    }
+
+    function initialize() external initializer {
+        __BoringOwnable_init();
+    }
+
+    // @notice for Celer
+    function executeMessage(
+        address srcAddress,
+        uint64 srcChainId,
+        bytes calldata message,
+        address /*_executor*/
+    )
+        external
+        payable
+        onlyCelerMessageBus
+        mustOriginateFromSendEndpoint(srcAddress, srcChainId)
+        returns (ExecutionStatus)
+    {
+        (address receiver, bytes memory actualMessage) = abi.decode(message, (address, bytes));
+        IPMsgReceiverApp(receiver).executeMessage(actualMessage);
+        return ExecutionStatus.Success;
+    }
+
+    function govExecuteMessage(address receiver, bytes calldata message)
+        external
+        payable
+        onlyOwner
+    {
+        IPMsgReceiverApp(receiver).executeMessage(message);
+    }
+
+    //solhint-disable-next-line
+    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
+}

package/contracts/core/LiquidityMining/CrossChainMsg/PendleMsgReceiverAppUpg.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+import "../../../interfaces/IPMsgReceiverApp.sol";
+import "../../../periphery/BoringOwnableUpgradeable.sol";
+import "../../../libraries/Errors.sol";
+
+// solhint-disable no-empty-blocks
+/// This contract is upgradable because
+/// - its constructor only sets immutable variables
+/// - it has storage gaps for safe addition of future variables
+/// - it inherits only upgradable contract
+abstract contract PendleMsgReceiverAppUpg is IPMsgReceiverApp, BoringOwnableUpgradeable {
+    address public immutable pendleMsgReceiveEndpoint;
+
+    uint256[100] private __gap;
+
+    modifier onlyFromPendleMsgReceiveEndpoint() {
+        if (msg.sender != pendleMsgReceiveEndpoint)
+            revert Errors.MsgNotFromReceiveEndpoint(msg.sender);
+        _;
+    }
+
+    constructor(address _pendleMsgReceiveEndpoint) {
+        pendleMsgReceiveEndpoint = _pendleMsgReceiveEndpoint;
+    }
+
+    function executeMessage(bytes calldata message)
+        external
+        payable
+        virtual
+        onlyFromPendleMsgReceiveEndpoint
+    {
+        _executeMessage(message);
+    }
+
+    function _executeMessage(bytes memory message) internal virtual;
+}

package/contracts/core/LiquidityMining/CrossChainMsg/PendleMsgSendEndpointUpg.sol

@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+import "../../../interfaces/IPMsgSendEndpoint.sol";
+import "../../../interfaces/ICelerMessageBus.sol";
+import "../../../periphery/BoringOwnableUpgradeable.sol";
+import "../../../libraries/Errors.sol";
+import "@openzeppelin/contracts/utils/structs/EnumerableMap.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+
+contract PendleMsgSendEndpointUpg is
+    IPMsgSendEndpoint,
+    Initializable,
+    UUPSUpgradeable,
+    BoringOwnableUpgradeable
+{
+    using EnumerableMap for EnumerableMap.UintToAddressMap;
+
+    ICelerMessageBus public immutable celerMessageBus;
+    EnumerableMap.UintToAddressMap internal receiveEndpoints;
+    mapping(address => bool) public isWhitelisted;
+
+    modifier onlyWhitelisted() {
+        if (!isWhitelisted[msg.sender]) revert Errors.OnlyWhitelisted();
+        _;
+    }
+
+    constructor(ICelerMessageBus _celerMessageBus) initializer {
+        celerMessageBus = _celerMessageBus;
+    }
+
+    function initialize() external initializer {
+        __BoringOwnable_init();
+    }
+
+    function calcFee(
+        address dstAddress,
+        uint256, /*dstChainId*/
+        bytes memory message
+    ) external view returns (uint256) {
+        return celerMessageBus.calcFee(abi.encode(dstAddress, message));
+    }
+
+    function sendMessage(
+        address dstAddress,
+        uint256 dstChainId,
+        bytes calldata message
+    ) external payable onlyWhitelisted {
+        celerMessageBus.sendMessage{ value: msg.value }(
+            receiveEndpoints.get(dstChainId),
+            dstChainId,
+            abi.encode(dstAddress, message)
+        );
+    }
+
+    function addReceiveEndpoints(address endpointAddr, uint256 endpointChainId)
+        external
+        payable
+        onlyOwner
+    {
+        receiveEndpoints.set(endpointChainId, endpointAddr);
+    }
+
+    function setWhitelisted(address addr, bool status) external onlyOwner {
+        isWhitelisted[addr] = status;
+    }
+
+    function getAllReceiveEndpoints()
+        external
+        view
+        returns (uint256[] memory chainIds, address[] memory addrs)
+    {
+        uint256 length = receiveEndpoints.length();
+        chainIds = new uint256[](length);
+        addrs = new address[](length);
+
+        for (uint256 i = 0; i < length; ++i) {
+            (chainIds[i], addrs[i]) = receiveEndpoints.at(i);
+        }
+    }
+
+    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
+}

package/contracts/core/LiquidityMining/{CelerAbstracts/CelerSenderUpg.sol → CrossChainMsg/PendleMsgSenderAppUpg.sol}

@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.15;
 
-import "../../../interfaces/ICelerMessageBus.sol";
+import "../../../interfaces/IPMsgSendEndpoint.sol";
 import "../../../periphery/BoringOwnableUpgradeable.sol";
-import "@openzeppelin/contracts/utils/Address.sol";
+import "../../../libraries/Errors.sol";
 import "@openzeppelin/contracts/utils/structs/EnumerableMap.sol";
 
 // solhint-disable no-empty-blocks
@@ -11,10 +11,10 @@ import "@openzeppelin/contracts/utils/structs/EnumerableMap.sol";
 /// - its constructor only sets immutable variables
 /// - it has storage gaps for safe addition of future variables
 /// - it inherits only upgradable contract
-abstract contract CelerSenderUpg is BoringOwnableUpgradeable {
+abstract contract PendleMsgSenderAppUpg is BoringOwnableUpgradeable {
     using EnumerableMap for EnumerableMap.UintToAddressMap;
 
-    ICelerMessageBus public celerMessageBus;
+    IPMsgSendEndpoint public immutable pendleMsgSendEndpoint;
 
     // destinationContracts mapping contains one address for each chainId only
     EnumerableMap.UintToAddressMap internal destinationContracts;
@@ -28,23 +28,20 @@ abstract contract CelerSenderUpg is BoringOwnableUpgradeable {
         }
     }
 
-    constructor() {}
-
-    function setCelerMessageBus(address _celerMessageBus) external onlyOwner {
-        celerMessageBus = ICelerMessageBus(_celerMessageBus);
+    constructor(address _pendleMsgSendEndpoint) {
+        pendleMsgSendEndpoint = IPMsgSendEndpoint(_pendleMsgSendEndpoint);
     }
 
     function _sendMessage(uint256 chainId, bytes memory message) internal {
         assert(destinationContracts.contains(chainId));
         address toAddr = destinationContracts.get(chainId);
-        uint256 fee = celerMessageBus.calcFee(message);
+        uint256 fee = pendleMsgSendEndpoint.calcFee(toAddr, chainId, message);
         // LM contracts won't hold ETH on its own so this is fine
-        require(address(this).balance >= fee, "Insufficient celer fee");
-        celerMessageBus.sendMessage{ value: fee }(toAddr, chainId, message);
+        if (address(this).balance < fee)
+            revert Errors.InsufficientFeeToSendMsg(address(this).balance, fee);
+        pendleMsgSendEndpoint.sendMessage{ value: fee }(toAddr, chainId, message);
     }
 
-    function _afterAddDestinationContract(address addr, uint256 chainId) internal virtual {}
-
     function addDestinationContract(address _address, uint256 _chainId)
         external
         payable
@@ -67,4 +64,6 @@ abstract contract CelerSenderUpg is BoringOwnableUpgradeable {
             (chainIds[i], addrs[i]) = destinationContracts.at(i);
         }
     }
+
+    function _afterAddDestinationContract(address addr, uint256 chainId) internal virtual {}
 }

package/contracts/core/LiquidityMining/FeeDistributor/EpochResultManager.sol

@@ -0,0 +1,159 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+import "./PendleFeeDistributor.sol";
+import "../../../interfaces/IPVotingEscrowMainchain.sol";
+import "../../../interfaces/IPVotingController.sol";
+import "../../../interfaces/IPFeeDistributorFactory.sol";
+import "../../../periphery/BoringOwnableUpgradeable.sol";
+import "../../../libraries/VeHistoryLib.sol";
+import "../../../libraries/math/WeekMath.sol";
+
+abstract contract EpochResultManager is IPFeeDistributorFactory {
+    using Math for uint256;
+    using ArrayLib for address[];
+    using VeBalanceLib for VeBalance;
+    using CheckpointHelper for Checkpoint;
+
+    struct UserInfo {
+        uint128 timestamp;
+        uint128 iter;
+    }
+
+    address public immutable votingController;
+    address public immutable vePendle;
+
+    // [user, pool] => UserInfo
+    mapping(address => mapping(address => UserInfo)) public userInfo;
+
+    // [user, pool, epoch] => share
+    mapping(address => mapping(address => mapping(uint256 => uint256))) internal userShareAtEpoch;
+
+    constructor(address _votingController, address _vePendle) {
+        votingController = _votingController;
+        vePendle = _vePendle;
+    }
+
+    function updateUserShare(address user, address pool) external {
+        _updateExternalGlobalShares(pool);
+        _updateUserShare(user, pool);
+    }
+
+    function getUserAndTotalSharesAt(
+        address user,
+        address pool,
+        uint256 epoch
+    ) external view returns (uint256 userShare, uint256 totalShare) {
+        userShare = userShareAtEpoch[user][pool][epoch];
+        totalShare = _getExternalTotalShares(pool, epoch.Uint128());
+    }
+
+    function _updateUserShare(address user, address pool) internal {
+        uint128 currentEpoch = WeekMath.getCurrentWeekStart();
+        uint128 userEpoch = userInfo[user][pool].timestamp;
+
+        if (userEpoch == currentEpoch) return;
+        if (userEpoch == 0) userEpoch = _getPoolStartTime(pool);
+
+        uint256 length = _getExternalUserHistoryLength(user, pool);
+        if (length == 0) {
+            userInfo[user][pool].timestamp = currentEpoch;
+            return;
+        }
+
+        uint128 iter = userInfo[user][pool].iter;
+        Checkpoint memory lowerCheckpoint = _getExternalUserCheckpointAt(user, pool, iter);
+        Checkpoint memory upperCheckpoint;
+
+        if (iter + 1 < length) {
+            upperCheckpoint = _getExternalUserCheckpointAt(user, pool, iter + 1);
+        }
+
+        while (userEpoch < currentEpoch) {
+            userEpoch += WeekMath.WEEK;
+
+            iter = _moveIterToNextEpoch(
+                user,
+                pool,
+                length,
+                iter,
+                lowerCheckpoint,
+                upperCheckpoint,
+                userEpoch
+            );
+
+            if (userEpoch >= lowerCheckpoint.timestamp) {
+                userShareAtEpoch[user][pool][userEpoch] = lowerCheckpoint.value.getValueAt(
+                    userEpoch
+                );
+            }
+        }
+
+        userInfo[user][pool] = UserInfo({ timestamp: currentEpoch, iter: iter });
+    }
+
+    function _moveIterToNextEpoch(
+        address user,
+        address pool,
+        uint256 userHistoryLength,
+        uint128 iter,
+        Checkpoint memory lowerCheckpoint,
+        Checkpoint memory upperCheckpoint,
+        uint128 nextEpoch
+    ) internal view returns (uint128) {
+        while (iter + 1 < userHistoryLength && nextEpoch > upperCheckpoint.timestamp) {
+            lowerCheckpoint.assignWith(upperCheckpoint);
+            if (iter + 2 < userHistoryLength) {
+                upperCheckpoint.assignWith(_getExternalUserCheckpointAt(user, pool, iter + 2));
+            }
+            ++iter;
+        }
+        return iter;
+    }
+
+    function _updateExternalGlobalShares(address pool) internal {
+        if (pool == vePendle) {
+            IPVeToken(vePendle).totalSupplyCurrent();
+        } else {
+            IPVotingController(votingController).applyPoolSlopeChanges(pool);
+        }
+    }
+
+    function _getExternalTotalShares(address pool, uint128 timestamp)
+        internal
+        view
+        returns (uint256)
+    {
+        if (pool == vePendle) {
+            return IPVotingEscrowMainchain(vePendle).totalSupplyAt(timestamp);
+        } else {
+            return IPVotingController(votingController).getPoolTotalVoteAt(pool, timestamp);
+        }
+    }
+
+    function _getExternalUserCheckpointAt(
+        address user,
+        address pool,
+        uint256 index
+    ) internal view returns (Checkpoint memory) {
+        if (pool == vePendle) {
+            return IPVotingEscrowMainchain(vePendle).getUserHistoryAt(user, index);
+        } else {
+            return IPVotingController(votingController).getUserPoolHistoryAt(user, pool, index);
+        }
+    }
+
+    function _getExternalUserHistoryLength(address user, address pool)
+        internal
+        view
+        returns (uint256)
+    {
+        if (pool == vePendle) {
+            return IPVotingEscrowMainchain(vePendle).getUserHistoryLength(user);
+        } else {
+            return IPVotingController(votingController).getUserPoolHistoryLength(user, pool);
+        }
+    }
+
+    function _getPoolStartTime(address pool) internal view virtual returns (uint64);
+}

package/contracts/core/LiquidityMining/FeeDistributor/PendleFeeDistributor.sol

@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+import "../../../libraries/math/Math.sol";
+import "../../../libraries/helpers/ArrayLib.sol";
+import "../../../libraries/helpers/MiniHelpers.sol";
+import "../../../libraries/math/WeekMath.sol";
+import "../../../libraries/Errors.sol";
+import "../../../libraries/VeHistoryLib.sol";
+import "../../../interfaces/IPFeeDistributor.sol";
+import "../../../interfaces/IPFeeDistributorFactory.sol";
+import "../../../periphery/BoringOwnableUpgradeable.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+contract PendleFeeDistributor is IPFeeDistributor, BoringOwnableUpgradeable {
+    using Math for uint256;
+    using SafeERC20 for IERC20;
+    using ArrayLib for address[];
+    using VeBalanceLib for VeBalance;
+
+    address public immutable factory;
+    address public immutable pool;
+    address public immutable rewardToken;
+    uint256 public immutable startEpoch;
+
+    uint256 public lastFinishedEpoch;
+
+    // [user] => [epoch]
+    mapping(address => uint256) public userLastClaimedEpoch;
+
+    // [epoch] => [incentive]
+    mapping(uint256 => uint256) public incentivesForEpoch;
+
+    constructor(
+        address _pool,
+        address _rewardToken,
+        uint256 _startEpoch
+    ) initializer {
+        pool = _pool;
+        factory = msg.sender;
+        rewardToken = _rewardToken;
+        startEpoch = _startEpoch;
+        lastFinishedEpoch = _startEpoch;
+        __BoringOwnable_init();
+    }
+
+    function fund(uint256[] calldata rewardsForEpoch) external onlyOwner {
+        uint256 epoch = lastFinishedEpoch;
+        uint256 totalRewardFunding = 0;
+        for (uint256 i = 0; i < rewardsForEpoch.length; ++i) {
+            epoch += WeekMath.WEEK;
+            uint256 incentive = rewardsForEpoch[i];
+
+            incentivesForEpoch[epoch] += incentive;
+            totalRewardFunding += incentive;
+
+            emit Fund(epoch, incentive);
+        }
+
+        if (epoch > WeekMath.getCurrentWeekStart()) revert Errors.FDCantFundFutureEpoch();
+
+        IERC20(rewardToken).transferFrom(msg.sender, address(this), totalRewardFunding);
+        lastFinishedEpoch = epoch;
+    }
+
+    function claimReward(address user) external returns (uint256 amountRewardOut) {
+        IPFeeDistributorFactory(factory).updateUserShare(user, pool);
+
+        uint256 finishedEpoch = lastFinishedEpoch;
+        uint256 userEpoch = userLastClaimedEpoch[user];
+
+        if (userEpoch == finishedEpoch) return 0;
+        if (userEpoch == 0) userEpoch = startEpoch;
+
+        while (userEpoch < finishedEpoch) {
+            userEpoch += WeekMath.WEEK;
+
+            uint256 incentive = incentivesForEpoch[userEpoch];
+            if (incentive == 0) continue;
+
+            (uint256 userShare, uint256 totalShare) = IPFeeDistributorFactory(factory)
+                .getUserAndTotalSharesAt(user, pool, userEpoch);
+
+            if (userShare == 0) continue;
+
+            amountRewardOut += (userShare * incentive) / totalShare;
+        }
+
+        userLastClaimedEpoch[user] = finishedEpoch;
+        if (amountRewardOut > 0) {
+            IERC20(rewardToken).safeTransfer(user, amountRewardOut);
+        }
+
+        emit ClaimReward(user, rewardToken, finishedEpoch, amountRewardOut);
+    }
+}