@pendle/core-v2 0.8.0-beta-12 → 0.8.1-gamma

package/contracts/SuperComposableYield/SCY-implementations/PendleStargateSCY.sol

@@ -0,0 +1,194 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+import "../base-implementations/SCYBaseWithRewards.sol";
+import "../../interfaces/IStargateRouter.sol";
+import "../../interfaces/IStargatePool.sol";
+import "../../interfaces/IStargateLPStaking.sol";
+
+contract PendleStargateSCY is SCYBaseWithRewards {
+    address public immutable stgRouter;
+    uint16 public immutable stgRouterPoolId;
+
+    address public immutable stgStakingLP;
+    uint256 public immutable pid;
+
+    address public immutable underlying;
+    address public immutable stgPool;
+    address public immutable stgToken;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _stgRouter,
+        address _stgStakingLP,
+        uint256 _pid,
+        address _stgPool
+    ) SCYBaseWithRewards(_name, _symbol, _stgPool) {
+        stgRouter = _stgRouter;
+
+        // I dont think we need safecast for a trusted call like this
+        stgRouterPoolId = uint16(IStargatePool(_stgPool).poolId());
+
+        stgStakingLP = _stgStakingLP;
+        pid = _pid;
+
+        stgPool = _stgPool;
+        stgToken = IStargateLPStaking(_stgStakingLP).stargate();
+        underlying = IStargatePool(stgPool).token();
+
+        // verify _pid
+        require(
+            IStargateLPStaking(_stgStakingLP).poolInfo(_pid).lpToken == _stgPool,
+            "invalid pid"
+        );
+
+        _safeApprove(underlying, _stgRouter, type(uint256).max);
+        // There is not a need to approve LP for router since stargate uses direct burn
+        // _safeApprove(stgPool, _stgRouter, type(uint256).max);
+        _safeApprove(stgPool, _stgStakingLP, type(uint256).max);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {SCYBase-_deposit}
+     *
+     * The underlying yield token is stargateLP. If the base token deposited is underlying, the function addLiquidity
+     * using stargateRouter first. Then the amount of LP out will be taken into calculation.
+     *
+     * The exchange rate of stargateLP to shares is 1:1
+     */
+    function _deposit(address tokenIn, uint256 amountDeposited)
+        internal
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
+        if (tokenIn == stgPool) {
+            amountSharesOut = amountDeposited;
+        } else {
+            uint256 preBalanceStgPool = _selfBalance(stgPool);
+            IStargateRouter(stgRouter).addLiquidity(
+                stgRouterPoolId,
+                amountDeposited,
+                address(this)
+            );
+            amountSharesOut = _selfBalance(stgPool) - preBalanceStgPool;
+        }
+        IStargateLPStaking(stgStakingLP).deposit(pid, amountSharesOut);
+    }
+
+    /**
+     * @dev See {SCYBase-_redeem}
+     *
+     * The staked tokens are firstly withdraw from staking
+     *
+     * The shares are redeemed into underlying using router if necessary.
+     */
+    function _redeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        virtual
+        override
+        returns (uint256 amountTokenOut)
+    {
+        IStargateLPStaking(stgStakingLP).withdraw(pid, amountSharesToRedeem);
+        if (tokenOut == stgPool) {
+            amountTokenOut = amountSharesToRedeem;
+        } else {
+            uint256 preBalanceStgLp = IERC20(stgPool).balanceOf(address(this));
+            amountTokenOut = IStargateRouter(stgRouter).instantRedeemLocal(
+                stgRouterPoolId,
+                amountSharesToRedeem,
+                address(this)
+            );
+
+            uint256 amountLpUsed = preBalanceStgLp - IERC20(stgPool).balanceOf(address(this));
+
+            // Since stargate is a bridge, sometime there might not be enough fund in the pool to redeem
+            // In this case, stargate contract doesn't revert
+            require(amountLpUsed == amountSharesToRedeem, "insufficient fund to redeem");
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @notice Calculates and updates the exchange rate of shares to underlying asset token
+     * @dev It is the exchange rate of stgPool to underlying
+     */
+    function exchangeRate() public view virtual override returns (uint256 currentRate) {
+        return IStargatePool(stgPool).amountLPtoLD(SCYUtils.ONE);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = stgPool;
+        res[1] = underlying;
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = stgPool;
+        res[1] = underlying;
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == stgPool || token == underlying;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == stgPool || token == underlying;
+    }
+
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        override
+        returns (uint256 amountSharesOut)
+    {
+        if (tokenIn == stgPool) amountSharesOut = amountTokenToDeposit;
+        else amountSharesOut = (amountTokenToDeposit * SCYUtils.ONE) / exchangeRate();
+    }
+
+    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        view
+        override
+        returns (uint256 amountTokenOut)
+    {
+        if (tokenOut == stgPool) amountTokenOut = amountSharesToRedeem;
+        else amountTokenOut = (amountSharesToRedeem * exchangeRate()) / SCYUtils.ONE;
+    }
+
+    function assetInfo()
+        external
+        view
+        returns (
+            AssetType assetType,
+            address assetAddress,
+            uint8 assetDecimals
+        )
+    {
+        return (AssetType.TOKEN, stgPool, IERC20Metadata(stgPool).decimals());
+    }
+
+    function _redeemExternalReward() internal override {
+        IStargateLPStaking(stgStakingLP).withdraw(pid, 0);
+    }
+
+    /**
+     * @dev See {ISuperComposableYield-getRewardTokens}
+     */
+    function _getRewardTokens() internal view override returns (address[] memory res) {
+        res = new address[](1);
+        res[0] = stgToken;
+    }
+}

package/contracts/SuperComposableYield/SCY-implementations/PendleWstEthSCY.sol

@@ -2,16 +2,21 @@
 pragma solidity 0.8.15;
 import "../base-implementations/SCYBase.sol";
 import "../../interfaces/IWstETH.sol";
+import "../../interfaces/IWETH.sol";
+import "../../interfaces/IStETH.sol";
 
 contract PendleWstEthSCY is SCYBase {
+    address public immutable wETH;
     address public immutable stETH;
     address public immutable wstETH;
 
     constructor(
         string memory _name,
         string memory _symbol,
+        address _wETH,
         address _wstETH
     ) SCYBase(_name, _symbol, _wstETH) {
+        wETH = _wETH;
         wstETH = _wstETH;
         stETH = IWstETH(wstETH).stETH();
         _safeApprove(stETH, wstETH, type(uint256).max);
@@ -38,7 +43,18 @@ contract PendleWstEthSCY is SCYBase {
         if (tokenIn == wstETH) {
             amountSharesOut = amountDeposited;
         } else {
-            amountSharesOut = IWstETH(wstETH).wrap(amountDeposited); // .wrap returns amount of wstETH out
+            uint256 amountStETH;
+            if (tokenIn == stETH) {
+                amountStETH = amountDeposited;
+            } else {
+                uint256 stETHBalanceBefore = _selfBalance(stETH);
+                if (tokenIn == wETH) {
+                    IWETH(wETH).withdraw(amountDeposited);
+                }
+                IStETH(stETH).submit{ value: amountDeposited }(address(0));
+                amountStETH = _selfBalance(stETH) - stETHBalanceBefore;
+            }
+            amountSharesOut = IWstETH(wstETH).wrap(amountStETH);
         }
     }
 
@@ -84,7 +100,15 @@ contract PendleWstEthSCY is SCYBase {
         returns (uint256 amountSharesOut)
     {
         if (tokenIn == wstETH) amountSharesOut = amountTokenToDeposit;
-        else amountSharesOut = (amountTokenToDeposit * 1e18) / exchangeRate();
+        else {
+            uint256 amountStETH;
+            if (tokenIn == stETH) {
+                amountStETH = amountTokenToDeposit; 
+            } else {
+                amountStETH = IStETH(stETH).getSharesByPooledEth(amountTokenToDeposit);
+            }
+            amountSharesOut = (amountTokenToDeposit * 1e18) / exchangeRate();
+        }
     }
 
     function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
@@ -97,19 +121,26 @@ contract PendleWstEthSCY is SCYBase {
         else amountTokenOut = (amountSharesToRedeem * exchangeRate()) / 1e18;
     }
 
-    /**
-     * @dev See {ISuperComposableYield-getBaseTokens}
-     */
-    function getBaseTokens() public view virtual override returns (address[] memory res) {
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        res = new address[](4);
+        res[0] = NATIVE;
+        res[1] = wETH;        
+        res[2] = stETH;
+        res[3] = wstETH;
+
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
         res = new address[](2);
         res[0] = stETH;
         res[1] = wstETH;
     }
 
-    /**
-     * @dev See {ISuperComposableYield-isValidBaseToken}
-     */
-    function isValidBaseToken(address token) public view virtual override returns (bool) {
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == stETH || token == wstETH || token == NATIVE || token == wETH;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
         return token == stETH || token == wstETH;
     }
 

package/contracts/SuperComposableYield/SCY-implementations/PendleYearnVaultScy.sol

@@ -121,19 +121,23 @@ contract PendleYearnVaultSCY is SCYBase {
         else amountTokenOut = (amountSharesToRedeem * exchangeRate()) / 1e18;
     }
 
-    /**
-     * @dev See {ISuperComposableYield-getBaseTokens}
-     */
-    function getBaseTokens() public view virtual override returns (address[] memory res) {
+    function getTokensIn() public view virtual override returns (address[] memory res) {
         res = new address[](2);
         res[0] = underlying;
         res[1] = yvToken;
     }
 
-    /**
-     * @dev See {ISuperComposableYield-isValidBaseToken}
-     */
-    function isValidBaseToken(address token) public view virtual override returns (bool) {
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = underlying;
+        res[1] = yvToken;
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == underlying || token == yvToken;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
         return token == underlying || token == yvToken;
     }
 

package/contracts/SuperComposableYield/SCY-implementations/TraderJoe/PendleSJoeSCY.sol

@@ -0,0 +1,184 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+import "../../base-implementations/SCYBaseWithRewards.sol";
+import "../../../interfaces/ISJoe.sol";
+
+/*
+sJOE Staking
+sJOE Staking is a highly accessible Staking option. Users can Stake into sJOE and unstake from sJOE at any time. There is however a deposit fee mechanism to prevent over-saturation.
+
+Deposit Fee
+Staking into sJOE may come with a fee
+The fee can scale up to 3% Max, depending on the number of JOEs already Staked
+The 3% Fee is taken from the JOEs that you deposit into the sJOE Pool
+Currently any deposit fee taken will be sent to the Treasury
+
+
+Yield Generating Mechanism - Stake JOE into SJOE Contract
+
+Asset - JOE
+
+Shares - Shares (in contract *take note of deduction of fees after depositing)
+
+Exchange Rate - Increases with sJOE rewards
+
+
+*/
+// sJOE -> Staking contract that accepts JOE and yields USDC as the ONLY reward token
+// sJOE Contract Address on Avalanche -> 0x1a731B2299E22FbAC282E7094EdA41046343Cb51
+
+// JOE Contract Address on Avalanche -> 0x6e84a6216ea6dacc71ee8e6b0a5b7322eebc0fdd
+
+contract PendleSJoeSCY is SCYBaseWithRewards {
+    using SafeERC20 for IERC20;
+
+    address public immutable SJOE;
+    address public immutable JOE;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _sJOE
+    ) SCYBaseWithRewards(_name, _symbol, _sJOE) {
+        require(_sJOE != address(0), "zero address");
+        SJOE = _sJOE;
+        JOE = ISJoe(SJOE).joe();
+
+        _safeApprove(JOE, SJOE, type(uint256).max);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {SCYBase-_deposit}
+     *
+     * The underlying yield token is JOE (Since the amount of rewards is based on how much staked JOE inside sJOE contract). Only the base token JOE should be accepted. Then the corresponding amount of shares is returned.
+     *
+     * The exchange rate of JOE to shares is 1:1
+
+    * Each time deposit() is called, any pending rewards will be sent back to the SCY by default.
+     */
+    function _deposit(address, uint256 amount)
+        internal
+        override
+        returns (uint256 amountSharesOut)
+    {
+        uint256 preBalanceSJoe = ISJoe(SJOE).internalJoeBalance();
+
+        ISJoe(SJOE).deposit(amount);
+
+        // Depositing JOE will incur deposit fee, hence amountSharesOut has to be calculated like this for accurate amount of SCY exchanged.
+        amountSharesOut = ISJoe(SJOE).internalJoeBalance() - preBalanceSJoe;
+    }
+
+    /**
+     * @dev See {SCYBase-_redeem}
+     *
+     * The shares are redeemed into the same amount of JOE Tokens. Hence `tokenOut` will only be the underlying asset (JOE) in this case. Since there will NOT be any withdrawal fee from sJOE, amountSharesToRedeem will always correspond amountTokenOut.
+     */
+    function _redeem(address, uint256 amountSharesToRedeem)
+        internal
+        override
+        returns (uint256 amountTokenOut)
+    {
+        ISJoe(SJOE).withdraw(amountSharesToRedeem);
+        amountTokenOut = amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @notice Exchange rate for JOE to SCY is 1:1
+     * @dev It is the exchange rate of Shares in sJOE to its underlying asset (JOE)
+     */
+    function exchangeRate() public pure override returns (uint256) {
+        return SCYUtils.ONE;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {ISuperComposableYield-getRewardTokens}
+     */
+    function _getRewardTokens() internal view override returns (address[] memory res) {
+        ISJoe SJOEContract = ISJoe(SJOE);
+
+        uint256 length = SJOEContract.rewardTokensLength();
+
+        res = new address[](length);
+        for (uint256 i = 0; i < length; ) {
+            res[i] = SJOEContract.rewardTokens(i);
+            unchecked {
+                i++;
+            }
+        }
+    }
+
+    function _redeemExternalReward() internal override {
+        // Since sJOE contract has no 'claimRewards' function, call withdraw() with a 0 amount to claim the rewards - Same as how sJOE pool is doing for their frontend.
+        ISJoe(SJOE).withdraw(0);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        override
+        returns (uint256 amountSharesOut)
+    {
+        uint256 sJoeDepositFeePrecision = ISJoe(SJOE).depositFeePercent();
+
+        amountSharesOut =
+            (((1e18 - sJoeDepositFeePrecision / 1e18) * amountTokenToDeposit) * 1e18) /
+            exchangeRate();
+    }
+
+    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        pure
+        override
+        returns (uint256 amountTokenOut)
+    {
+        amountTokenOut = (amountSharesToRedeem * exchangeRate()) / 1e18;
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        res = new address[](1);
+        res[0] = JOE;
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](1);
+        res[0] = JOE;
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == JOE;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == JOE;
+    }
+
+    function assetInfo()
+        external
+        view
+        returns (
+            AssetType assetType,
+            address assetAddress,
+            uint8 assetDecimals
+        )
+    {
+        return (AssetType.TOKEN, JOE, IERC20Metadata(JOE).decimals());
+    }
+}

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

@@ -38,7 +38,7 @@ abstract contract SCYBase is ISuperComposableYield, PendleERC20, TokenHelper {
         uint256 amountTokenToDeposit,
         uint256 minSharesOut
     ) external payable nonReentrant returns (uint256 amountSharesOut) {
-        require(isValidBaseToken(tokenIn), "SCY: Invalid tokenIn");
+        require(isValidTokenIn(tokenIn), "SCY: Invalid tokenIn");
         require(amountTokenToDeposit != 0, "SCY: amountTokenToDeposit cannot be 0");
 
         if (tokenIn == NATIVE) require(msg.value == amountTokenToDeposit, "SCY: eth mismatch");
@@ -80,7 +80,7 @@ abstract contract SCYBase is ISuperComposableYield, PendleERC20, TokenHelper {
         address tokenOut,
         uint256 minTokenOut
     ) internal returns (uint256 amountTokenOut) {
-        require(isValidBaseToken(tokenOut), "SCY: invalid tokenOut");
+        require(isValidTokenOut(tokenOut), "SCY: invalid tokenOut");
         require(amountSharesToRedeem != 0, "SCY: amountSharesToRedeem cannot be 0");
 
         amountTokenOut = _redeem(tokenOut, amountSharesToRedeem);
@@ -181,7 +181,7 @@ abstract contract SCYBase is ISuperComposableYield, PendleERC20, TokenHelper {
         virtual
         returns (uint256 amountSharesOut)
     {
-        require(isValidBaseToken(tokenIn), "SCY: Invalid tokenIn");
+        require(isValidTokenIn(tokenIn), "SCY: Invalid tokenIn");
         return _previewDeposit(tokenIn, amountTokenToDeposit);
     }
 
@@ -191,7 +191,7 @@ abstract contract SCYBase is ISuperComposableYield, PendleERC20, TokenHelper {
         virtual
         returns (uint256 amountTokenOut)
     {
-        require(isValidBaseToken(tokenOut), "SCY: Invalid tokenOut");
+        require(isValidTokenOut(tokenOut), "SCY: Invalid tokenOut");
         return _previewRedeem(tokenOut, amountSharesToRedeem);
     }
 
@@ -207,13 +207,11 @@ abstract contract SCYBase is ISuperComposableYield, PendleERC20, TokenHelper {
         virtual
         returns (uint256 amountTokenOut);
 
-    /**
-     * @notice See {ISuperComposableYield-getBaseTokens}
-     */
-    function getBaseTokens() external view virtual override returns (address[] memory res);
+    function getTokensIn() public view virtual returns (address[] memory res);
 
-    /**
-     * @dev See {ISuperComposableYield-isValidBaseToken}
-     */
-    function isValidBaseToken(address token) public view virtual override returns (bool);
+    function getTokensOut() public view virtual returns (address[] memory res);
+
+    function isValidTokenIn(address token) public view virtual returns (bool);
+
+    function isValidTokenOut(address token) public view virtual returns (bool);
 }

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

@@ -6,8 +6,7 @@ import "./SCYBase.sol";
 import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 import "../../libraries/math/Math.sol";
 
-/// This contract makes an important assumption that yieldToken is never a rewardToken
-/// Please make sure that assumption always holds
+/// NOTE: yieldToken MUST NEVER BE a rewardToken, else the rewardManager will behave erroneously
 abstract contract SCYBaseWithRewards is SCYBase, RewardManager {
     using Math for uint256;
     using ArrayLib for address[];

package/contracts/core/LiquidityMining/CelerAbstracts/CelerSenderUpg.sol

@@ -3,6 +3,7 @@ pragma solidity 0.8.15;
 
 import "../../../interfaces/ICelerMessageBus.sol";
 import "../../../periphery/PermissionsV2Upg.sol";
+import "@openzeppelin/contracts/utils/Address.sol";
 import "@openzeppelin/contracts/utils/structs/EnumerableMap.sol";
 
 // solhint-disable no-empty-blocks
@@ -15,10 +16,18 @@ abstract contract CelerSenderUpg is PermissionsV2Upg {
 
     ICelerMessageBus public celerMessageBus;
 
-    EnumerableMap.UintToAddressMap internal sidechainContracts;
+    // destinationContracts mapping contains one address for each chainId only
+    EnumerableMap.UintToAddressMap internal destinationContracts;
 
     uint256[100] private __gap;
 
+    modifier refundUnusedEth() {
+        _;
+        if (address(this).balance > 0) {
+            Address.sendValue(payable(msg.sender), address(this).balance);
+        }
+    }
+
     constructor(address _governanceManager) PermissionsV2Upg(_governanceManager) {}
 
     function setCelerMessageBus(address _celerMessageBus) external onlyGovernance {
@@ -26,34 +35,35 @@ abstract contract CelerSenderUpg is PermissionsV2Upg {
     }
 
     function _sendMessage(uint256 chainId, bytes memory message) internal {
-        assert(sidechainContracts.contains(chainId));
-        address toAddr = sidechainContracts.get(chainId);
+        assert(destinationContracts.contains(chainId));
+        address toAddr = destinationContracts.get(chainId);
         uint256 fee = celerMessageBus.calcFee(message);
+        require(msg.value >= fee, "Insufficient celer fee");
         celerMessageBus.sendMessage{ value: fee }(toAddr, chainId, message);
     }
 
-    function _afterAddSidechainContract(address addr, uint256 chainId) internal virtual {}
+    function _afterAddDestinationContract(address addr, uint256 chainId) internal virtual {}
 
-    function addSidechainContract(address _address, uint256 _chainId)
+    function addDestinationContract(address _address, uint256 _chainId)
         external
         payable
         onlyGovernance
     {
-        sidechainContracts.set(_chainId, _address);
-        _afterAddSidechainContract(_address, _chainId);
+        destinationContracts.set(_chainId, _address);
+        _afterAddDestinationContract(_address, _chainId);
     }
 
-    function getAllSidechainContracts()
+    function getAllDestinationContracts()
         public
         view
         returns (uint256[] memory chainIds, address[] memory addrs)
     {
-        uint256 length = sidechainContracts.length();
+        uint256 length = destinationContracts.length();
         chainIds = new uint256[](length);
         addrs = new address[](length);
 
         for (uint256 i = 0; i < length; ++i) {
-            (chainIds[i], addrs[i]) = sidechainContracts.at(i);
+            (chainIds[i], addrs[i]) = destinationContracts.at(i);
         }
     }
 }

package/contracts/core/LiquidityMining/GaugeController/PendleGaugeControllerBaseUpg.sol

@@ -7,6 +7,7 @@ import "../../../libraries/math/Math.sol";
 import "../../../libraries/math/WeekMath.sol";
 import "../../../interfaces/IPGaugeController.sol";
 import "../../../interfaces/IPMarketFactory.sol";
+import "../../../interfaces/IPMarket.sol";
 import "../../../periphery/PermissionsV2Upg.sol";
 import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
 
@@ -101,7 +102,8 @@ abstract contract PendleGaugeControllerBaseUpg is IPGaugeController, Permissions
         epochRewardReceived[wTime] = true;
 
         for (uint256 i = 0; i < markets.length; ++i) {
-            _addRewardsToMarket(markets[i], uint128(pendleAmounts[i]));
+            if (!IPMarket(markets[i]).isExpired())
+                _addRewardsToMarket(markets[i], pendleAmounts[i].Uint128());
         }
 
         emit ReceiveVotingResults(wTime, markets, pendleAmounts);