@pendle/core-v2 5.0.0 → 5.0.3

package/contracts/LiquidityMining/GaugeController/PendleGaugeControllerSidechainUpg.sol

@@ -12,9 +12,10 @@ contract PendleGaugeControllerSidechainUpg is PendleGaugeControllerBaseUpg, Pend
         address _marketFactory,
         address _marketFactory2,
         address _marketFactory3,
+        address _marketFactory4,
         address _PendleMsgReceiveEndpointUpg
     )
-        PendleGaugeControllerBaseUpg(_pendle, _marketFactory, _marketFactory2, _marketFactory3)
+        PendleGaugeControllerBaseUpg(_pendle, _marketFactory, _marketFactory2, _marketFactory3, _marketFactory4)
         PendleMsgReceiverAppUpg(_PendleMsgReceiveEndpointUpg)
     {
         _disableInitializers();

package/contracts/core/RewardManager/RewardManager.sol

@@ -39,12 +39,15 @@ abstract contract RewardManager is RewardManagerAbstract {
 
                 RewardState memory _state = rewardState[token];
                 (uint256 lastBalance, uint256 index) = (_state.lastBalance, _state.index);
+
+                uint256 accrued = _selfBalance(tokens[i]) - lastBalance;
+
                 if (index == 0) index = INITIAL_REWARD_INDEX;
+                if (totalShares != 0) index += accrued.divDown(totalShares);
 
-                (uint256 consumedIndex, uint256 consumedReward) = _getConsumedReward(token, lastBalance, totalShares);
                 rewardState[token] = RewardState({
-                    index: (index + consumedIndex).Uint128(),
-                    lastBalance: (lastBalance + consumedReward).Uint128()
+                    index: index.Uint128(),
+                    lastBalance: (lastBalance + accrued).Uint128()
                 });
                 indexes[i] = index;
             }
@@ -55,20 +58,6 @@ abstract contract RewardManager is RewardManagerAbstract {
         }
     }
 
-    function _getConsumedReward(
-        address token,
-        uint256 lastBalance,
-        uint256 totalShares
-    ) private view returns (uint256 consumedIndex, uint256 consumedReward) {
-        if (totalShares == 0) {
-            return (0, 0);
-        }
-
-        uint256 accrued = _selfBalance(token) - lastBalance;
-        consumedIndex = accrued.divDown(totalShares);
-        consumedReward = (consumedIndex * totalShares + PMath.ONE - 1) / PMath.ONE;
-    }
-
     /// @dev this function doesn't need redeemExternal since redeemExternal is bundled in updateRewardIndex
     /// @dev this function also has to update rewardState.lastBalance
     function _doTransferOutRewards(

package/contracts/core/StandardizedYield/implementations/Gains/PendleGTokenSY.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../PendleERC4626SY.sol";
+import "../../../../interfaces/IERC4626.sol";
+
+contract PendleGTokenSY is PendleERC4626SY {
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _erc4626
+    ) PendleERC4626SY(_name, _symbol, _erc4626) {}
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](1);
+        res[0] = yieldToken;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == yieldToken;
+    }
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return IERC4626(yieldToken).convertToAssets(1e18);
+    }
+}

package/contracts/core/StandardizedYield/implementations/Gains/PendleGUSDCSY.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "./PendleGTokenSY.sol";
+
+contract PendleGUSDCSY is PendleGTokenSY {
+    address public constant gUSDC = 0xd3443ee1e91aF28e5FB858Fbd0D72A63bA8046E0;
+
+    constructor() PendleGTokenSY("SY gUSDC", "SY-gUSDC", gUSDC) {}
+}

package/contracts/core/StandardizedYield/implementations/{PendleGdaiSY.sol → Gains/PendleGdaiSY.sol}

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "../SYBase.sol";
-import "../../../interfaces/IERC4626.sol";
+import "../../SYBase.sol";
+import "../../../../interfaces/IERC4626.sol";
 
 contract PendleGDaiSY is SYBase {
     address public immutable DAI;

package/contracts/core/StandardizedYield/implementations/Mantle/PendleMETHSY.sol

@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../SYBase.sol";
+import "../../../../interfaces/IPExchangeRateOracle.sol";
+
+contract PendleMETHSY is SYBase {
+    using PMath for int256;
+
+    address public exchangeRateOracle = 0x1E2Ad9764cfAc60876486A7c714bc71f5b55f5C2;
+    address public constant METH = 0xcDA86A272531e8640cD7F1a92c01839911B90bb0;
+    address public constant WETH = 0xdEAddEaDdeadDEadDEADDEAddEADDEAddead1111;
+
+    constructor() SYBase("SY mETH", "SY-mETH", METH) {}
+
+    function setExchangeRateOracle(address newOracle) external onlyOwner {
+        exchangeRateOracle = newOracle;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(address, uint256 amountDeposited) internal pure override returns (uint256 /*amountSharesOut*/) {
+        return amountDeposited;
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal override returns (uint256 /*amountTokenOut*/) {
+        _transferOut(tokenOut, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view override returns (uint256) {
+        return IPExchangeRateOracle(exchangeRateOracle).getExchangeRate();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address,
+        uint256 amountTokenToDeposit
+    ) internal pure override returns (uint256 /*amountSharesOut*/) {
+        return amountTokenToDeposit;
+    }
+
+    function _previewRedeem(
+        address,
+        uint256 amountSharesToRedeem
+    ) internal pure override returns (uint256 /*amountTokenOut*/) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view override returns (address[] memory res) {
+        return ArrayLib.create(yieldToken);
+    }
+
+    function getTokensOut() public view override returns (address[] memory res) {
+        return ArrayLib.create(yieldToken);
+    }
+
+    function isValidTokenIn(address token) public view override returns (bool) {
+        return token == yieldToken;
+    }
+
+    function isValidTokenOut(address token) public view override returns (bool) {
+        return token == yieldToken;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, WETH, 18);
+    }
+}

package/contracts/core/StandardizedYield/implementations/Mellow/PendleAmphorWstETHVaultSY.sol

@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../SYBase.sol";
+import "../../StEthHelper.sol";
+import "../../../../interfaces/IERC4626.sol";
+
+contract PendleAmphorWstETHVaultSY is SYBase, StEthHelper {
+    address public constant VAULT = 0x06824C27C8a0DbDe5F72f770eC82e3c0FD4DcEc3;
+
+    constructor() SYBase("SY Amphor LRT", "SY-amphrLRT", VAULT) {
+        _safeApproveInf(WSTETH, VAULT);
+    }
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 amountSharesOut) {
+        if (tokenIn == NATIVE) {
+            (amountDeposited, tokenIn) = (_depositWstETH(NATIVE, amountDeposited), WSTETH);
+        }
+        if (tokenIn == WSTETH) {
+            return IERC4626(VAULT).deposit(amountDeposited, address(this));
+        }
+        return amountDeposited;
+    }
+
+    function _redeem(
+        address receiver,
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal override returns (uint256) {
+        _transferOut(VAULT, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return PMath.ONE;
+    }
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == NATIVE) {
+            return _previewDepositWstETH(NATIVE, amountTokenToDeposit);
+        }
+        return amountTokenToDeposit;
+    }
+
+    function _previewRedeem(
+        address,
+        uint256 amountSharesToRedeem
+    ) internal pure override returns (uint256 /*amountTokenOut*/) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public pure override returns (address[] memory res) {
+        return ArrayLib.create(NATIVE, WSTETH, VAULT);
+    }
+
+    function getTokensOut() public pure override returns (address[] memory res) {
+        return ArrayLib.create(VAULT);
+    }
+
+    function isValidTokenIn(address token) public pure override returns (bool) {
+        return token == NATIVE || token == WSTETH || token == VAULT;
+    }
+
+    function isValidTokenOut(address token) public pure override returns (bool) {
+        return token == VAULT;
+    }
+
+    function assetInfo() external pure returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, VAULT, 18);
+    }
+}

package/contracts/core/StandardizedYield/implementations/Mellow/PendleMellowVaultERC20SYUpg.sol

@@ -62,7 +62,7 @@ contract PendleMellowVaultERC20SYUpg is PendleMellowVaultSYBaseUpg {
 
     function exchangeRate() public view virtual override returns (uint256 res) {
         (uint256 tvl, uint256 supply) = _getMellowVaultTvl();
-        return tvl * PMath.ONE / supply;
+        return (tvl * PMath.ONE) / supply;
     }
 
     function _previewDeposit(

package/contracts/core/StandardizedYield/implementations/Mellow/PendleMellowVaultERC4626SYUpg.sol

@@ -69,7 +69,7 @@ contract PendleMellowVaultERC4626SYUpg is PendleMellowVaultSYBaseUpg {
 
     function exchangeRate() public view virtual override returns (uint256 res) {
         (uint256 tvl, uint256 supply) = _getMellowVaultTvl();
-        return IERC4626(erc4626).convertToAssets(tvl * PMath.ONE / supply);
+        return IERC4626(erc4626).convertToAssets((tvl * PMath.ONE) / supply);
     }
 
     function _previewDeposit(

package/contracts/core/StandardizedYield/implementations/PendleERC4626SY.sol

@@ -79,7 +79,12 @@ contract PendleERC4626SY is SYBase {
         return token == yieldToken || token == asset;
     }
 
-    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+    function assetInfo()
+        external
+        view
+        virtual
+        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
+    {
         return (AssetType.TOKEN, asset, IERC20Metadata(asset).decimals());
     }
 }

package/contracts/core/StandardizedYield/implementations/Sophon/PendleSophonFarmingSY.sol

@@ -0,0 +1,116 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../SYBaseWithRewards.sol";
+import "../../../../interfaces/Sophon/ISophonFarming.sol";
+import "../../../../interfaces/Sophon/IPSophonPointManager.sol";
+
+contract PendleSophonFarmingSY is SYBaseWithRewards {
+    using Address for address;
+
+    address public immutable sophonFarming;
+    uint256 public immutable pid;
+    address public immutable pointManager;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _sophonFarming,
+        uint256 _pid,
+        address _pointManager
+    ) SYBaseWithRewards(_name, _symbol, __getPoolDepositToken(_sophonFarming, _pid)) {
+        sophonFarming = _sophonFarming;
+        pid = _pid;
+        pointManager = _pointManager;
+        _safeApproveInf(yieldToken, _sophonFarming);
+    }
+
+    function __getPoolDepositToken(address _sophonFarming, uint256 _pid) internal view returns (address) {
+        (address lp, , , , , , , , , ) = ISophonFarming(_sophonFarming).poolInfo(_pid);
+        return lp;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(address /*tokenIn*/, uint256 amountDeposited) internal virtual override returns (uint256) {
+        ISophonFarming(sophonFarming).deposit(pid, amountDeposited, 0);
+        return amountDeposited;
+    }
+
+    function _redeem(
+        address receiver,
+        address,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256) {
+        ISophonFarming(sophonFarming).withdraw(pid, amountSharesToRedeem);
+        _transferOut(yieldToken, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return PMath.ONE;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    function _getRewardTokens() internal view override returns (address[] memory) {
+        return ArrayLib.create(pointManager);
+    }
+
+    function _redeemExternalReward() internal override {
+        uint256 owningPoints = _getOwningPoints();
+        if (owningPoints == 0) return;
+        ISophonFarming(sophonFarming).transferPoints(pid, address(this), pointManager, owningPoints);
+        IPSophonPointManager(pointManager).claimPointReceiptToken();
+    }
+
+    function _getOwningPoints() internal view returns (uint256) {
+        return ISophonFarming(sophonFarming).pendingPoints(pid, address(this));
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address /*tokenIn*/,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256) {
+        return amountTokenToDeposit;
+    }
+
+    function _previewRedeem(
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal view override returns (uint256) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        return ArrayLib.create(yieldToken);
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        return ArrayLib.create(yieldToken);
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == yieldToken;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == yieldToken;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, yieldToken, IERC20Metadata(yieldToken).decimals());
+    }
+}

package/contracts/core/StandardizedYield/implementations/Sophon/PendleSophonPointManager.sol

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import "../../../erc20/PendleERC20.sol";
+import "../../../libraries/BoringOwnableUpgradeable.sol";
+import "../../../../interfaces/Sophon/ISophonFarming.sol";
+import "../../../../interfaces/Sophon/IPSophonPointManager.sol";
+import "@openzeppelin/contracts/utils/Strings.sol";
+
+contract PendleSophonPointManager is PendleERC20, BoringOwnableUpgradeable, IPSophonPointManager {
+    // solhint-disable immutable-vars-naming
+    address public immutable sophonFarming;
+    uint256 public immutable pid;
+    address public immutable sy;
+
+    mapping(address => bool) public isAddressWhitelisted;
+
+    constructor(
+        address _sophonFarming,
+        uint256 _pid,
+        address _sy
+    ) PendleERC20("Sophon Point Receipt Token", __getSpointSymbol(_pid), 18) initializer {
+        sophonFarming = _sophonFarming;
+        pid = _pid;
+        sy = _sy;
+        __BoringOwnable_init();
+    }
+
+    function __getSpointSymbol(uint256 _pid) internal pure returns (string memory) {
+        string memory id = Strings.toString(_pid);
+        return string(abi.encodePacked("SPOINT-", id));
+    }
+
+    function claimPointReceiptToken() external {
+        uint256 floatingPoints = _getOwningPoints() - totalSupply();
+        _mint(sy, floatingPoints);
+    }
+
+    function addWhitelistedAddress(address addr) external onlyOwner {
+        isAddressWhitelisted[addr] = true;
+    }
+
+    function _getOwningPoints() internal view returns (uint256) {
+        return ISophonFarming(sophonFarming).pendingPoints(pid, address(this));
+    }
+
+    function _afterTokenTransfer(address, address to, uint256 amount) internal virtual override {
+        if (amount != 0 && to != address(0) && _shouldBurnReceiptToken(to)) {
+            _burn(to, amount);
+            ISophonFarming(sophonFarming).transferPoints(pid, address(this), to, amount);
+        }
+    }
+
+    function _shouldBurnReceiptToken(address addr) internal view returns (bool) {
+        return addr != sy && !isAddressWhitelisted[addr];
+    }
+}

package/contracts/core/libraries/math/PMath.sol

@@ -67,6 +67,14 @@ library PMath {
         return (a + b - 1) / b;
     }
 
+    function slipUp(uint256 a, uint256 factor) internal pure returns (uint256) {
+        return mulDown(a, ONE + factor);
+    }
+
+    function slipDown(uint256 a, uint256 factor) internal pure returns (uint256) {
+        return mulDown(a, ONE - factor);
+    }
+
     // @author Uniswap
     function sqrt(uint256 y) internal pure returns (uint256 z) {
         if (y > 3) {

package/contracts/interfaces/IPActionMarketAuxStatic.sol

@@ -1,6 +1,7 @@
 pragma solidity ^0.8.0;
 
 import "./IPMarket.sol";
+import {ApproxParams} from "../router/base/MarketApproxLib.sol";
 
 interface IPActionMarketAuxStatic {
     function calcPriceImpactPY(address market, int256 netPtOut) external view returns (uint256);
@@ -31,7 +32,45 @@ interface IPActionMarketAuxStatic {
 
     function getPtToSyRate(address market) external view returns (uint256);
 
+    function getYtToSyRate(address market) external view returns (uint256);
+
     function getLpToAssetRate(address market) external view returns (uint256);
 
     function getPtToAssetRate(address market) external view returns (uint256);
+
+    function getYtToAssetRate(address market) external view returns (uint256);
+
+    /// @param slippage A fixed-point number with 18 decimal places
+    function swapExactSyForPtStaticAndGenerateApproxParams(
+        address market,
+        uint256 exactSyIn,
+        uint256 slippage
+    )
+        external
+        view
+        returns (
+            uint256 netPtOut,
+            uint256 netSyFee,
+            uint256 priceImpact,
+            uint256 exchangeRateAfter,
+            ApproxParams memory approxParams
+        );
+
+    /// @param slippage A fixed-point number with 18 decimal places
+    function swapExactTokenForPtStaticAndGenerateApproxParams(
+        address market,
+        address tokenIn,
+        uint256 amountTokenIn,
+        uint256 slippage
+    )
+        external
+        view
+        returns (
+            uint256 netPtOut,
+            uint256 netSyMinted,
+            uint256 netSyFee,
+            uint256 priceImpact,
+            uint256 exchangeRateAfter,
+            ApproxParams memory approxParams
+        );
 }

package/contracts/interfaces/Sophon/IPSophonPointManager.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IPSophonPointManager {
+    function claimPointReceiptToken() external;
+}

package/contracts/interfaces/Sophon/ISophonFarming.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface ISophonFarming {
+    function pendingPoints(uint256 _pid, address _user) external view returns (uint256);
+
+    function transferPoints(uint256 _pid, address _sender, address _receiver, uint256 _transferAmount) external;
+
+    function poolInfo(
+        uint256 _pid
+    )
+        external
+        view
+        returns (address, address, uint256, uint256, uint256, uint256, uint256, uint256, uint256, string memory);
+
+    function deposit(uint256 _pid, uint256 _amount, uint256 _boostAmount) external;
+
+    function withdraw(uint256 _pid, uint256 _withdrawAmount) external;
+}