@pendle/core-v2 0.13.0-testnet → 0.14.0-testnet

package/contracts/LiquidityMining/CrossChainMsg/PendleMsgReceiveEndpointUpg.sol

@@ -1,40 +1,72 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.17;
 
-import "../../interfaces/ICelerMessageReceiverApp.sol";
+import "../../interfaces/ILayerZeroEndpoint.sol";
 import "../../interfaces/IPMsgReceiverApp.sol";
-import "../../interfaces/ICelerMessageBus.sol";
+import "../../interfaces/ILayerZeroReceiver.sol";
 import "../../core/libraries/BoringOwnableUpgradeable.sol";
 import "../../core/libraries/Errors.sol";
+import "./libraries/LayerZeroHelper.sol";
+import "./libraries/ExcessivelySafeCall.sol";
 import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 
+/**
+ * @dev Initially, currently we will use layer zero's default send and receive version (which is most updated)
+ * So we can leave the configuration unset.
+ */
+
 contract PendleMsgReceiveEndpointUpg is
-    ICelerMessageReceiverApp,
+    ILayerZeroReceiver,
     Initializable,
     UUPSUpgradeable,
     BoringOwnableUpgradeable
 {
-    ICelerMessageBus public immutable celerMessageBus;
+    using ExcessivelySafeCall for address;
+
+    address public immutable lzEndpoint;
     address public immutable sendEndpointAddr;
     uint64 public immutable sendEndpointChainId;
 
-    modifier onlyCelerMessageBus() {
-        if (msg.sender != address(celerMessageBus)) revert Errors.OnlyCelerBus();
+    mapping(uint16 => mapping(bytes => mapping(uint64 => bytes32))) public failedMessages;
+
+    event MessageFailed(
+        uint16 _srcChainId,
+        bytes _path,
+        uint64 _nonce,
+        bytes _payload,
+        bytes _reason
+    );
+    event RetryMessageSuccess(
+        uint16 _srcChainId,
+        bytes _path,
+        uint64 _nonce,
+        bytes32 _payloadHash
+    );
+
+    modifier onlyLzEndpoint() {
+        if (msg.sender != address(lzEndpoint)) revert Errors.OnlyLayerZeroEndpoint();
         _;
     }
 
-    modifier mustOriginateFromSendEndpoint(address srcAddress, uint64 srcChainId) {
-        if (srcAddress != sendEndpointAddr || srcChainId != sendEndpointChainId)
-            revert Errors.MsgNotFromSendEndpoint(msg.sender);
+    /**
+     * @dev Lz has a built-in feature for trusted receive and send endpoint
+     * But in order to aim for flexibility in switching to other crosschain messaging protocol, there
+     * is no harm to keep our current whitelisting mechanism.
+     */
+    modifier mustOriginateFromSendEndpoint(uint16 srcChainId, bytes memory path) {
+        if (
+            sendEndpointAddr != LayerZeroHelper._getSrcAdrressFromPath(path) ||
+            sendEndpointChainId != LayerZeroHelper._getOriginalChainIds(srcChainId)
+        ) revert Errors.MsgNotFromSendEndpoint(msg.sender);
         _;
     }
 
     constructor(
-        ICelerMessageBus _celerMessageBus,
+        address _lzEndpoint,
         address _sendEndpointAddr,
         uint64 _sendEndpointChainId
     ) initializer {
-        celerMessageBus = _celerMessageBus;
+        lzEndpoint = _lzEndpoint;
         sendEndpointAddr = _sendEndpointAddr;
         sendEndpointChainId = _sendEndpointChainId;
     }
@@ -43,22 +75,55 @@ contract PendleMsgReceiveEndpointUpg is
         __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 lzReceive(
+        uint16 _srcChainId,
+        bytes calldata _path,
+        uint64 _nonce,
+        bytes calldata _payload
+    ) external onlyLzEndpoint mustOriginateFromSendEndpoint(_srcChainId, _path) {
+        (bool success, bytes memory reason) = address(this).excessivelySafeCall(
+            gasleft(),
+            150,
+            abi.encodeWithSelector(this.nonBlockingReceive.selector, _payload)
+        );
+
+        if (!success) {
+            failedMessages[_srcChainId][_path][_nonce] = keccak256(_payload);
+            emit MessageFailed(_srcChainId, _path, _nonce, _payload, reason);
+        }
+    }
+
+    function retryMessage(
+        uint16 _srcChainId,
+        bytes calldata _path,
+        uint64 _nonce,
+        bytes calldata _payload
+    ) public payable virtual {
+        bytes32 payloadHash = failedMessages[_srcChainId][_path][_nonce];
+
+        if (payloadHash == bytes32(0) || keccak256(_payload) != payloadHash)
+            revert Errors.InvalidRetryData();
+
+        failedMessages[_srcChainId][_path][_nonce] = bytes32(0);
+        nonBlockingReceive(_payload);
+        emit RetryMessageSuccess(_srcChainId, _path, _nonce, payloadHash);
+    }
+
+    /**
+     * @dev LayerZero by default will stop all the incoming messages once some message failed to execute
+     * In the very extreme case that it fails to deliver some message to Pendle, we still want the crosschain
+     * messaging feature to keep functioning. 
+     * 
+     * @dev As the nature of all type of messages we have:
+     * - Update vePendle totalSupply
+     * - Update vePendle user balance
+     * - Send voting result to GaugeController
+     * 
+     * There is not a need to ensure the index order of messages
+     */
+    function nonBlockingReceive(bytes memory payload) public {
+        (address receiver, bytes memory message) = abi.decode(payload, (address, bytes));
+        IPMsgReceiverApp(receiver).executeMessage(message);
     }
 
     function govExecuteMessage(address receiver, bytes calldata message)
@@ -69,6 +134,10 @@ contract PendleMsgReceiveEndpointUpg is
         IPMsgReceiverApp(receiver).executeMessage(message);
     }
 
+    function setReceiveVersion(uint16 _newVersion) external {
+        ILayerZeroEndpoint(lzEndpoint).setReceiveVersion(_newVersion);
+    }
+
     //solhint-disable-next-line
     function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
 }

package/contracts/LiquidityMining/CrossChainMsg/PendleMsgSendEndpointUpg.sol

@@ -2,12 +2,18 @@
 pragma solidity 0.8.17;
 
 import "../../interfaces/IPMsgSendEndpoint.sol";
-import "../../interfaces/ICelerMessageBus.sol";
+import "../../interfaces/ILayerZeroEndpoint.sol";
 import "../../core/libraries/BoringOwnableUpgradeable.sol";
 import "../../core/libraries/Errors.sol";
+import "./libraries/LayerZeroHelper.sol";
 import "@openzeppelin/contracts/utils/structs/EnumerableMap.sol";
 import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 
+/**
+ * @dev Initially, currently we will use layer zero's default send and receive version (which is most updated)
+ * So we can leave the configuration unset.
+ */
+
 contract PendleMsgSendEndpointUpg is
     IPMsgSendEndpoint,
     Initializable,
@@ -16,7 +22,9 @@ contract PendleMsgSendEndpointUpg is
 {
     using EnumerableMap for EnumerableMap.UintToAddressMap;
 
-    ICelerMessageBus public immutable celerMessageBus;
+    address payable public immutable refundAddress;
+    ILayerZeroEndpoint public immutable lzEndpoint;
+
     EnumerableMap.UintToAddressMap internal receiveEndpoints;
     mapping(address => bool) public isWhitelisted;
 
@@ -25,8 +33,9 @@ contract PendleMsgSendEndpointUpg is
         _;
     }
 
-    constructor(ICelerMessageBus _celerMessageBus) initializer {
-        celerMessageBus = _celerMessageBus;
+    constructor(address _refundAddress, ILayerZeroEndpoint _lzEndpoint) initializer {
+        refundAddress = payable(_refundAddress);
+        lzEndpoint = _lzEndpoint;
     }
 
     function initialize() external initializer {
@@ -35,21 +44,36 @@ contract PendleMsgSendEndpointUpg is
 
     function calcFee(
         address dstAddress,
-        uint256, /*dstChainId*/
-        bytes memory message
-    ) external view returns (uint256) {
-        return celerMessageBus.calcFee(abi.encode(dstAddress, message));
+        uint256 dstChainId,
+        bytes memory payload,
+        bytes memory adapterParams
+    ) external view returns (uint256 fee) {
+        (fee, ) = lzEndpoint.estimateFees(
+            LayerZeroHelper._getLayerZeroChainIds(dstChainId),
+            receiveEndpoints.get(dstChainId),
+            abi.encode(dstAddress, payload),
+            false,
+            adapterParams
+        );
     }
 
     function sendMessage(
         address dstAddress,
         uint256 dstChainId,
-        bytes calldata message
+        bytes calldata payload,
+        bytes calldata adapterParams
     ) external payable onlyWhitelisted {
-        celerMessageBus.sendMessage{ value: msg.value }(
+        bytes memory path = abi.encodePacked(
             receiveEndpoints.get(dstChainId),
-            dstChainId,
-            abi.encode(dstAddress, message)
+            address(this)
+        );
+        lzEndpoint.send{ value: msg.value }(
+            LayerZeroHelper._getLayerZeroChainIds(dstChainId),
+            path,
+            abi.encode(dstAddress, payload),
+            refundAddress,
+            address(0),
+            adapterParams
         );
     }
 
@@ -65,6 +89,10 @@ contract PendleMsgSendEndpointUpg is
         isWhitelisted[addr] = status;
     }
 
+    function setLzSendVersion(uint16 _newVersion) external onlyOwner {
+        ILayerZeroEndpoint(lzEndpoint).setSendVersion(_newVersion);
+    }
+
     function getAllReceiveEndpoints()
         external
         view

package/contracts/LiquidityMining/CrossChainMsg/PendleMsgSenderAppUpg.sol

@@ -8,12 +8,14 @@ import "@openzeppelin/contracts/utils/structs/EnumerableMap.sol";
 
 // solhint-disable no-empty-blocks
 /// This contract is upgradable because
-/// - its constructor only sets immutable variables
+/// - its constructor only sets immutable varia\bles
 /// - it has storage gaps for safe addition of future variables
 /// - it inherits only upgradable contract
 abstract contract PendleMsgSenderAppUpg is BoringOwnableUpgradeable {
     using EnumerableMap for EnumerableMap.UintToAddressMap;
 
+    uint256 public approxDstExecutionGas;
+
     IPMsgSendEndpoint public immutable pendleMsgSendEndpoint;
 
     // destinationContracts mapping contains one address for each chainId only
@@ -35,11 +37,12 @@ abstract contract PendleMsgSenderAppUpg is BoringOwnableUpgradeable {
     function _sendMessage(uint256 chainId, bytes memory message) internal {
         assert(destinationContracts.contains(chainId));
         address toAddr = destinationContracts.get(chainId);
-        uint256 fee = pendleMsgSendEndpoint.calcFee(toAddr, chainId, message);
+        bytes memory adapterParams = _getAdapterParams();
+        uint256 fee = pendleMsgSendEndpoint.calcFee(toAddr, chainId, message, adapterParams);
         // LM contracts won't hold ETH on its own so this is fine
         if (address(this).balance < fee)
             revert Errors.InsufficientFeeToSendMsg(address(this).balance, fee);
-        pendleMsgSendEndpoint.sendMessage{ value: fee }(toAddr, chainId, message);
+        pendleMsgSendEndpoint.sendMessage{ value: fee }(toAddr, chainId, message, adapterParams);
     }
 
     function addDestinationContract(address _address, uint256 _chainId)
@@ -48,7 +51,10 @@ abstract contract PendleMsgSenderAppUpg is BoringOwnableUpgradeable {
         onlyOwner
     {
         destinationContracts.set(_chainId, _address);
-        _afterAddDestinationContract(_address, _chainId);
+    }
+
+    function setApproxDstExecutionGas(uint256 gas) external onlyOwner {
+        approxDstExecutionGas = gas;
     }
 
     function getAllDestinationContracts()
@@ -65,5 +71,18 @@ abstract contract PendleMsgSenderAppUpg is BoringOwnableUpgradeable {
         }
     }
 
-    function _afterAddDestinationContract(address addr, uint256 chainId) internal virtual {}
+    function _getAdapterParams() internal view returns (bytes memory) {
+        uint256 gas = approxDstExecutionGas;
+        if (gas == 0) revert Errors.ApproxDstExecutionGasNotSet();
+        // (version, gas consumption)
+        return abi.encodePacked(uint16(1), gas);
+    }
+
+    function _getSendMessageFee(
+        address dstContract,
+        uint256 chainId,
+        bytes memory message
+    ) internal view returns (uint256) {
+        return pendleMsgSendEndpoint.calcFee(dstContract, chainId, message, _getAdapterParams());
+    }
 }

package/contracts/LiquidityMining/CrossChainMsg/libraries/ExcessivelySafeCall.sol

@@ -0,0 +1,133 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.7.6;
+
+library ExcessivelySafeCall {
+    uint256 constant LOW_28_MASK =
+        0x00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
+
+    /// @notice Use when you _really_ really _really_ don't trust the called
+    /// contract. This prevents the called contract from causing reversion of
+    /// the caller in as many ways as we can.
+    /// @dev The main difference between this and a solidity low-level call is
+    /// that we limit the number of bytes that the callee can cause to be
+    /// copied to caller memory. This prevents stupid things like malicious
+    /// contracts returning 10,000,000 bytes causing a local OOG when copying
+    /// to memory.
+    /// @param _target The address to call
+    /// @param _gas The amount of gas to forward to the remote contract
+    /// @param _maxCopy The maximum number of bytes of returndata to copy
+    /// to memory.
+    /// @param _calldata The data to send to the remote contract
+    /// @return success and returndata, as `.call()`. Returndata is capped to
+    /// `_maxCopy` bytes.
+    function excessivelySafeCall(
+        address _target,
+        uint256 _gas,
+        uint16 _maxCopy,
+        bytes memory _calldata
+    ) internal returns (bool, bytes memory) {
+        // set up for assembly call
+        uint256 _toCopy;
+        bool _success;
+        bytes memory _returnData = new bytes(_maxCopy);
+        // dispatch message to recipient
+        // by assembly calling "handle" function
+        // we call via assembly to avoid memcopying a very large returndata
+        // returned by a malicious contract
+        assembly {
+            _success := call(
+                _gas, // gas
+                _target, // recipient
+                0, // ether value
+                add(_calldata, 0x20), // inloc
+                mload(_calldata), // inlen
+                0, // outloc
+                0 // outlen
+            )
+            // limit our copy to 256 bytes
+            _toCopy := returndatasize()
+            if gt(_toCopy, _maxCopy) {
+                _toCopy := _maxCopy
+            }
+            // Store the length of the copied bytes
+            mstore(_returnData, _toCopy)
+            // copy the bytes from returndata[0:_toCopy]
+            returndatacopy(add(_returnData, 0x20), 0, _toCopy)
+        }
+        return (_success, _returnData);
+    }
+
+    /// @notice Use when you _really_ really _really_ don't trust the called
+    /// contract. This prevents the called contract from causing reversion of
+    /// the caller in as many ways as we can.
+    /// @dev The main difference between this and a solidity low-level call is
+    /// that we limit the number of bytes that the callee can cause to be
+    /// copied to caller memory. This prevents stupid things like malicious
+    /// contracts returning 10,000,000 bytes causing a local OOG when copying
+    /// to memory.
+    /// @param _target The address to call
+    /// @param _gas The amount of gas to forward to the remote contract
+    /// @param _maxCopy The maximum number of bytes of returndata to copy
+    /// to memory.
+    /// @param _calldata The data to send to the remote contract
+    /// @return success and returndata, as `.call()`. Returndata is capped to
+    /// `_maxCopy` bytes.
+    function excessivelySafeStaticCall(
+        address _target,
+        uint256 _gas,
+        uint16 _maxCopy,
+        bytes memory _calldata
+    ) internal view returns (bool, bytes memory) {
+        // set up for assembly call
+        uint256 _toCopy;
+        bool _success;
+        bytes memory _returnData = new bytes(_maxCopy);
+        // dispatch message to recipient
+        // by assembly calling "handle" function
+        // we call via assembly to avoid memcopying a very large returndata
+        // returned by a malicious contract
+        assembly {
+            _success := staticcall(
+                _gas, // gas
+                _target, // recipient
+                add(_calldata, 0x20), // inloc
+                mload(_calldata), // inlen
+                0, // outloc
+                0 // outlen
+            )
+            // limit our copy to 256 bytes
+            _toCopy := returndatasize()
+            if gt(_toCopy, _maxCopy) {
+                _toCopy := _maxCopy
+            }
+            // Store the length of the copied bytes
+            mstore(_returnData, _toCopy)
+            // copy the bytes from returndata[0:_toCopy]
+            returndatacopy(add(_returnData, 0x20), 0, _toCopy)
+        }
+        return (_success, _returnData);
+    }
+
+    /**
+     * @notice Swaps function selectors in encoded contract calls
+     * @dev Allows reuse of encoded calldata for functions with identical
+     * argument types but different names. It simply swaps out the first 4 bytes
+     * for the new selector. This function modifies memory in place, and should
+     * only be used with caution.
+     * @param _newSelector The new 4-byte selector
+     * @param _buf The encoded contract args
+     */
+    function swapSelector(bytes4 _newSelector, bytes memory _buf) internal pure {
+        require(_buf.length >= 4);
+        uint256 _mask = LOW_28_MASK;
+        assembly {
+            // load the first word of
+            let _word := mload(add(_buf, 0x20))
+            // mask out the top 4 bytes
+            // /x
+            _word := and(_word, _mask)
+            _word := or(_newSelector, _word)
+            mstore(add(_buf, 0x20), _word)
+        }
+    }
+}

package/contracts/LiquidityMining/CrossChainMsg/libraries/LayerZeroHelper.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+
+library LayerZeroHelper {
+    uint256 constant EVM_ADDRESS_SIZE = 20;
+
+    function _getLayerZeroChainIds(uint256 chainId) internal pure returns (uint16) {
+        if (chainId == 43113) return 10106; // fuji testnet
+        else if (chainId == 80001) return 10109; // mumbai testnet
+        else if (chainId == 43114) return 106; // avax mainnet
+        revert("");
+    }
+
+    function _getOriginalChainIds(uint16 chainId) internal pure returns (uint256) {
+        if (chainId == 10106) return 43113; // fuji testnet
+        else if (chainId == 10109) return 80001; // mumbai testnet
+        else if (chainId == 106) return 43114; // avax mainnet
+        revert("");
+    }
+
+    function _getSrcAdrressFromPath(bytes memory path) internal pure returns (address src) {
+        assembly {
+            src := mload(add(add(path, EVM_ADDRESS_SIZE), EVM_ADDRESS_SIZE)) 
+        }
+    }
+
+    function _getDstAddressFromPath(bytes memory path) internal pure returns (address dst) {
+        assembly {
+            dst := mload(add(add(path, EVM_ADDRESS_SIZE), 0)) 
+        }
+    }
+}

package/contracts/LiquidityMining/GaugeController/PendleGaugeControllerBaseUpg.sol

@@ -14,6 +14,7 @@ import "../../interfaces/IPMarket.sol";
 
 import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 
 /**
  * @dev Gauge controller provides no write function to any party other than voting controller
@@ -28,7 +29,11 @@ import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 /// - its constructor only sets immutable variables
 /// - it has storage gaps for safe addition of future variables
 /// - it inherits only upgradable contract
-abstract contract PendleGaugeControllerBaseUpg is IPGaugeController, BoringOwnableUpgradeable {
+abstract contract PendleGaugeControllerBaseUpg is
+    IPGaugeController,
+    BoringOwnableUpgradeable,
+    UUPSUpgradeable
+{
     using SafeERC20 for IERC20;
     using Math for uint256;
 
@@ -148,4 +153,6 @@ abstract contract PendleGaugeControllerBaseUpg is IPGaugeController, BoringOwnab
         rwd.lastUpdated = newLastUpdated;
         return rwd;
     }
+
+    function _authorizeUpgrade(address) internal virtual override onlyOwner {}
 }

package/contracts/LiquidityMining/VotingController/PendleVotingControllerUpg.sol

@@ -21,7 +21,7 @@ Voting accounting:
     will receive both of the reward pack
     - Each pack of money will has it own id as timestamp, a gauge controller does not
     receive a pack of money with the same id twice, this allow governance to rebroadcast
-    in case the last message was corrupted by Celer
+    in case the last message was corrupted by LayerZero
 
 Pros:
     - If governance does not forget broadcasting the reward on the early of the week,
@@ -196,7 +196,7 @@ contract PendleVotingControllerUpg is
     }
 
     /**
-     * @notice use the gov-privilege to force broadcast a message in case there are issues with Celer
+     * @notice use the gov-privilege to force broadcast a message in case there are issues with LayerZero
      * @dev it's intentional for this function to have minimal checks since we assume gov has done the
         due diligence
      * @dev gov should always call finalizeEpoch beforehand
@@ -233,7 +233,7 @@ contract PendleVotingControllerUpg is
         uint256[] memory totalPendleAmounts = new uint256[](length);
 
         return
-            pendleMsgSendEndpoint.calcFee(
+            _getSendMessageFee(
                 destinationContracts.get(chainId),
                 chainId,
                 abi.encode(uint128(0), pools, totalPendleAmounts)

package/contracts/LiquidityMining/VotingEscrow/VotingEscrowPendleMainchain.sol

@@ -181,7 +181,7 @@ contract VotingEscrowPendleMainchain is
     {
         fees = new uint256[](chainIds.length);
         for (uint256 i = 0; i < chainIds.length; i++) {
-            fees[i] = pendleMsgSendEndpoint.calcFee(
+            fees[i] = _getSendMessageFee(
                 destinationContracts.get(chainIds[i]),
                 chainIds[i],
                 SAMPLE_SUPPLY_UPDATE_MESSAGE
@@ -196,7 +196,7 @@ contract VotingEscrowPendleMainchain is
     {
         fees = new uint256[](chainIds.length);
         for (uint256 i = 0; i < chainIds.length; i++) {
-            fees[i] = pendleMsgSendEndpoint.calcFee(
+            fees[i] = _getSendMessageFee(
                 destinationContracts.get(chainIds[i]),
                 chainIds[i],
                 SAMPLE_POSITION_UPDATE_MESSAGE
@@ -295,11 +295,6 @@ contract VotingEscrowPendleMainchain is
         emit BroadcastTotalSupply(supply, chainIds);
     }
 
-    function _afterAddDestinationContract(address, uint256 chainId) internal virtual override {
-        (VeBalance memory supply, uint128 wTime) = _applySlopeChange();
-        _broadcast(chainId, wTime, supply, EMPTY_BYTES);
-    }
-
     function _broadcast(
         uint256 chainId,
         uint128 wTime,