@pendle/core-v2 4.5.1-beta-1 → 4.5.1-beta-3

package/contracts/core/StandardizedYield/implementations/Swell/PendleSwellStakingERC20SY.sol

@@ -0,0 +1,111 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../SYBase.sol";
+import "../../../../interfaces/Swell/ISwellSimpleStakingERC20.sol";
+
+contract PendleSwellStakingERC20SY is SYBase {
+    using ArrayLib for address[];
+
+    address public constant SWELL_STAKING = 0x38D43a6Cb8DA0E855A42fB6b0733A0498531d774;
+
+    // solhint-disable immutable-vars-naming
+    address public immutable stakeToken;
+
+    constructor(string memory _name, string memory _symbol, address _stakeToken) SYBase(_name, _symbol, _stakeToken) {
+        stakeToken = _stakeToken;
+        _safeApproveInf(_stakeToken, SWELL_STAKING);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn != stakeToken) {
+            amountDeposited = _wrapToStakeToken(tokenIn, amountDeposited);
+        }
+        ISwellSimpleStakingERC20(SWELL_STAKING).deposit(stakeToken, amountDeposited, address(this));
+        return amountDeposited;
+    }
+
+    function _redeem(
+        address receiver,
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 /*amountTokenOut*/) {
+        ISwellSimpleStakingERC20(SWELL_STAKING).withdraw(stakeToken, amountSharesToRedeem, receiver);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+    function exchangeRate() public view virtual override returns (uint256) {
+        return PMath.ONE;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit) internal view override returns (uint256) {
+        if (tokenIn == stakeToken) {
+            return amountTokenToDeposit;
+        }
+        return _previewToStakeToken(tokenIn, amountTokenToDeposit);
+    }
+
+    function _previewRedeem(
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal pure override returns (uint256 /*amountTokenOut*/) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(stakeToken).merge(_getAdditionalTokens());
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(stakeToken);
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == stakeToken || _canWrapToStakeToken(token);
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == stakeToken;
+    }
+
+    function assetInfo()
+        external
+        view
+        virtual
+        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
+    {
+        return (AssetType.TOKEN, stakeToken, IERC20Metadata(stakeToken).decimals());
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    ADDITIONAL TOKEN IN FUNCTIONS
+    //////////////////////////////////////////////////////////////*/
+
+    function _getAdditionalTokens() internal view virtual returns (address[] memory) {}
+
+    function _previewToStakeToken(address, uint256) internal view virtual returns (uint256) {
+        assert(false);
+    }
+
+    function _wrapToStakeToken(address, uint256) internal virtual returns (uint256) {
+        assert(false);
+    }
+
+    function _canWrapToStakeToken(address) internal view virtual returns (bool) {
+        return false;
+    }
+}

package/contracts/interfaces/IPActionMiscV3.sol

@@ -26,6 +26,26 @@ interface IPActionMiscV3 {
         bytes returnData;
     }
 
+    struct ExitPreExpReturnParams {
+        uint256 netPtFromRemove;
+        uint256 netSyFromRemove;
+        uint256 netPyRedeem;
+        uint256 netSyFromRedeem;
+        uint256 netPtSwap;
+        uint256 netYtSwap;
+        uint256 netSyFromSwap;
+        uint256 netSyFee;
+        uint256 totalSyOut;
+    }
+
+    struct ExitPostExpReturnParams {
+        uint256 netPtFromRemove;
+        uint256 netSyFromRemove;
+        uint256 netPtRedeem;
+        uint256 netSyFromRedeem;
+        uint256 totalSyOut;
+    }
+
     event MintSyFromToken(
         address indexed caller,
         address indexed tokenIn,
@@ -80,6 +100,42 @@ interface IPActionMiscV3 {
         uint256 netSyInterm
     );
 
+    event ExitPreExpToToken(
+        address indexed caller,
+        address indexed market,
+        address indexed token,
+        address receiver,
+        uint256 netLpIn,
+        uint256 totalTokenOut,
+        ExitPreExpReturnParams params
+    );
+
+    event ExitPreExpToSy(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        uint256 netLpIn,
+        ExitPreExpReturnParams params
+    );
+
+    event ExitPostExpToToken(
+        address indexed caller,
+        address indexed market,
+        address indexed token,
+        address receiver,
+        uint256 netLpIn,
+        uint256 totalTokenOut,
+        ExitPostExpReturnParams params
+    );
+
+    event ExitPostExpToSy(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        uint256 netLpIn,
+        ExitPostExpReturnParams params
+    );
+
     function mintSyFromToken(
         address receiver,
         address SY,
@@ -143,7 +199,7 @@ interface IPActionMiscV3 {
         uint256 minTokenOut
     ) external payable returns (uint256 netTokenOut, uint256 netSyInterm);
 
-    function exitMultiplePreExpiry(
+    function exitPreExpToToken(
         address receiver,
         address market,
         uint256 netPtIn,
@@ -151,35 +207,39 @@ interface IPActionMiscV3 {
         uint256 netLpIn,
         TokenOutput calldata output,
         LimitOrderData calldata limit
-    )
-        external
-        returns (
-            uint256 netTokenOut,
-            uint256 netPtFromRemove,
-            uint256 netSyFromRemove,
-            uint256 netPyRedeem,
-            uint256 netSyFromRedeem,
-            uint256 netPtSwap,
-            uint256 netYtSwap,
-            uint256 netSyFromSwap,
-            uint256 netSyFee
-        );
-
-    function exitMultiplePostExpiry(
+    ) external returns (uint256 netTokenOut, ExitPreExpReturnParams memory params);
+
+    function exitPreExpToSy(
+        address receiver,
+        address market,
+        uint256 netPtIn,
+        uint256 netYtIn,
+        uint256 netLpIn,
+        uint256 minSyOut,
+        LimitOrderData calldata limit
+    ) external returns (ExitPreExpReturnParams memory params);
+
+    function exitPostExpToToken(
         address receiver,
         address market,
         uint256 netPtIn,
         uint256 netLpIn,
         TokenOutput calldata output
-    )
-        external
-        returns (
-            uint256 netTokenOut,
-            uint256 netPtFromRemove,
-            uint256 netSyFromRemove,
-            uint256 netPtRedeem,
-            uint256 netSyFromRedeem
-        );
+    ) external returns (uint256 netTokenOut, ExitPostExpReturnParams memory params);
+
+    function exitPostExpToSy(
+        address receiver,
+        address market,
+        uint256 netPtIn,
+        uint256 netLpIn,
+        uint256 minSyOut
+    ) external returns (ExitPostExpReturnParams memory params);
+
+    function multicallAlpha(
+        address payable reflector,
+        bytes calldata selfCall,
+        bytes calldata reflectCall
+    ) external payable returns (bytes memory selfRes, bytes memory reflectRes);
 
     function boostMarkets(address[] memory markets) external;
 

package/contracts/interfaces/IPGovernanceProxy.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IPGovernanceProxy {
+    struct Call {
+        address target;
+        uint256 value;
+        bytes callData;
+    }
+
+    function pause(address[] calldata addrs) external;
+
+    function aggregate(Call[] calldata calls) external payable returns (bytes[] memory rtnData);
+}

package/contracts/interfaces/IPPausingInterface.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IPPausingInterface {
+    function pause() external;
+
+    function unpause() external;
+}

package/contracts/interfaces/Swell/ISwellSimpleStakingERC20.sol

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.0;
+
+interface ISwellSimpleStakingERC20 {
+    /// @notice Struct to hold the supported booleans
+    /// @param deposit true if deposit is supported
+    /// @param withdraw true if withdraw is supported
+    struct Supported {
+        bool deposit;
+        bool withdraw;
+    }
+
+    /// @notice Error emitted when the amount is null
+    error AMOUNT_NULL();
+
+    /// @notice Error emitted when the address is null
+    error ADDRESS_NULL();
+
+    /// @notice Error emitted when the balance is insufficient
+    error INSUFFICIENT_BALANCE();
+
+    /// @notice Error emitted when the token is not allowed
+    error TOKEN_NOT_ALLOWED(address token);
+
+    /// @notice Event emitted when a token is added or removed
+    /// @param token address of the token
+    /// @param supported struct with deposit and withdraw booleans
+    event SupportedToken(address indexed token, Supported supported);
+
+    /// @notice Event emitted when a deposit is made
+    /// @param token address of the token
+    /// @param staker address of the staker
+    /// @param amount amount of the deposit
+    event Deposit(address indexed token, address indexed staker, uint256 amount);
+
+    /// @notice Event emitted when a withdrawal is made
+    /// @param token address of the token
+    /// @param staker address of the staker
+    /// @param amount amount of the withdrawal
+    event Withdraw(address indexed token, address indexed staker, uint256 amount);
+
+    /// @notice Method to deposit tokens
+    /// @dev token are transferred from the sender, and the receiver is credited
+    /// @param _token address of the token
+    /// @param _amount amount to deposit
+    /// @param _receiver address of the receiver
+    function deposit(address _token, uint256 _amount, address _receiver) external;
+
+    /// @notice Method to rescue tokens, only callable by the owner
+    /// @dev difference between balance and internal balance is transferred to the owner
+    /// @param _token address of the token
+    function rescueERC20(address _token) external;
+
+    /// @notice Method to add or remove a token
+    /// @dev only callable by the owner
+    /// @param _token address of the token
+    /// @param _supported struct with deposit and withdraw booleans
+    function supportToken(address _token, Supported calldata _supported) external;
+
+    /// @notice Method to rescue tokens, only callable by the owner
+    /// @dev token are transferred to the receiver and sender is credited
+    /// @param _token address of the token
+    /// @param _amount amount to withdraw
+    /// @param _receiver address of the receiver
+    function withdraw(address _token, uint256 _amount, address _receiver) external;
+}

package/contracts/offchain-helpers/PendleGovernanceProxy.sol

@@ -0,0 +1,84 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import "../interfaces/IPPausingInterface.sol";
+import "../interfaces/IPGovernanceProxy.sol";
+import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+
+// solhint-disable custom-errors
+// solhint-disable no-inline-assembly
+// solhint-disable no-empty-blocks
+
+contract PendleGovernanceProxy is AccessControlUpgradeable, UUPSUpgradeable, IPGovernanceProxy {
+    bytes32 public constant GUARDIAN = keccak256("GUARDIAN");
+
+    modifier onlyGuardian() {
+        require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender) || hasRole(GUARDIAN, msg.sender), "not authorized");
+        _;
+    }
+
+    modifier onlyAdmin() {
+        require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "not authorized");
+        _;
+    }
+
+    constructor() {
+        _disableInitializers();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                                PAUSING
+    //////////////////////////////////////////////////////////////*/
+
+    function pause(address[] calldata addrs) external onlyGuardian {
+        uint256 length = addrs.length;
+        for (uint256 i = 0; i < length; ) {
+            IPPausingInterface(addrs[i]).pause();
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                            ADMIN CALL
+    //////////////////////////////////////////////////////////////*/
+
+    function aggregate(
+        IPGovernanceProxy.Call[] calldata calls
+    ) external payable onlyAdmin returns (bytes[] memory rtnData) {
+        uint256 length = calls.length;
+        rtnData = new bytes[](length);
+
+        Call calldata call;
+        for (uint256 i = 0; i < length; ) {
+            call = calls[i];
+
+            (bool success, bytes memory resp) = call.target.call{value: call.value}(call.callData);
+            if (!success) {
+                assembly {
+                    revert(add(32, resp), mload(resp))
+                }
+            }
+
+            rtnData[i] = resp;
+
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    receive() external payable {}
+
+    /*///////////////////////////////////////////////////////////////
+                            UPGRADABLE RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    function initialize(address governance) external initializer {
+        _grantRole(DEFAULT_ADMIN_ROLE, governance);
+    }
+
+    function _authorizeUpgrade(address) internal view override onlyAdmin {}
+}

package/contracts/offchain-helpers/router-static/base/ActionMarketAuxStatic.sol

@@ -114,12 +114,20 @@ contract ActionMarketAuxStatic is IPActionMarketAuxStatic {
     function getLpToAssetRate(address market) public view returns (uint256) {
         MarketState memory state = _readState(market);
         PYIndex pyIndexCurrent = _pyIndex(market);
-        MarketPreCompute memory comp = state.getMarketPreCompute(pyIndexCurrent, block.timestamp);
 
-        int256 totalHypotheticalAsset = comp.totalAsset +
-            state.totalPt.mulDown(int256(_getPtToAssetRate(market, state, pyIndexCurrent)));
+        int256 totalHypotheticalAsset;
+        if (state.expiry <= block.timestamp) {
+            // 1 PT = 1 Asset post-expiry
+            totalHypotheticalAsset = state.totalPt + pyIndexCurrent.syToAsset(state.totalSy);
+        } else {
+            MarketPreCompute memory comp = state.getMarketPreCompute(pyIndexCurrent, block.timestamp);
+
+            totalHypotheticalAsset =
+                comp.totalAsset +
+                state.totalPt.mulDown(int256(_getPtToAssetRate(market, state, pyIndexCurrent)));
+        }
 
-        return uint256(totalHypotheticalAsset.divDown(state.totalLp));
+        return totalHypotheticalAsset.divDown(state.totalLp).Uint();
     }
 
     function getPtToAssetRate(address market) public view returns (uint256) {