@pendle/core-v2 0.15.1-mainnet → 0.15.3-mainnet

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,
+        uint256 estimatedGasAmount
+    ) external view returns (uint256 fee) {
+        (fee, ) = lzEndpoint.estimateFees(
+            LayerZeroHelper._getLayerZeroChainIds(dstChainId),
+            receiveEndpoints.get(dstChainId),
+            abi.encode(dstAddress, payload),
+            false,
+            _getAdapterParams(estimatedGasAmount)
+        );
     }
 
     function sendMessage(
         address dstAddress,
         uint256 dstChainId,
-        bytes calldata message
+        bytes calldata payload,
+        uint256 estimatedGasAmount
     ) 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),
+            _getAdapterParams(estimatedGasAmount)
         );
     }
 
@@ -65,6 +89,10 @@ contract PendleMsgSendEndpointUpg is
         isWhitelisted[addr] = status;
     }
 
+    function setLzSendVersion(uint16 _newVersion) external onlyOwner {
+        ILayerZeroEndpoint(lzEndpoint).setSendVersion(_newVersion);
+    }
+
     function getAllReceiveEndpoints()
         external
         view
@@ -80,4 +108,10 @@ contract PendleMsgSendEndpointUpg is
     }
 
     function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
+
+    function _getAdapterParams(uint256 estimatedGasAmount) internal pure returns (bytes memory adapterParams) {
+        // this is more like "type" rather than version
+        // It is the type of adapter params you want to pass to relayer
+        adapterParams = abi.encodePacked(uint16(1), estimatedGasAmount);
+    }
 }

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
@@ -24,22 +26,29 @@ abstract contract PendleMsgSenderAppUpg is BoringOwnableUpgradeable {
     modifier refundUnusedEth() {
         _;
         if (address(this).balance > 0) {
-            Address.sendValue(payable(msg.sender), address(this).balance);
+            AddressUpgradeable.sendValue(payable(msg.sender), address(this).balance);
         }
     }
 
-    constructor(address _pendleMsgSendEndpoint) {
+    constructor(address _pendleMsgSendEndpoint, uint256 _approxDstExecutionGas) {
         pendleMsgSendEndpoint = IPMsgSendEndpoint(_pendleMsgSendEndpoint);
+        approxDstExecutionGas = _approxDstExecutionGas;
     }
 
     function _sendMessage(uint256 chainId, bytes memory message) internal {
         assert(destinationContracts.contains(chainId));
         address toAddr = destinationContracts.get(chainId);
-        uint256 fee = pendleMsgSendEndpoint.calcFee(toAddr, chainId, message);
+        uint256 estimatedGasAmount = approxDstExecutionGas;
+        uint256 fee = pendleMsgSendEndpoint.calcFee(toAddr, chainId, message, estimatedGasAmount);
         // 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,
+            estimatedGasAmount
+        );
     }
 
     function addDestinationContract(address _address, uint256 _chainId)
@@ -48,7 +57,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 +77,17 @@ abstract contract PendleMsgSenderAppUpg is BoringOwnableUpgradeable {
         }
     }
 
-    function _afterAddDestinationContract(address addr, uint256 chainId) internal virtual {}
+    function _getSendMessageFee(uint256 chainId, bytes memory message)
+        internal
+        view
+        returns (uint256)
+    {
+        return
+            pendleMsgSendEndpoint.calcFee(
+                destinationContracts.get(chainId),
+                chainId,
+                message,
+                approxDstExecutionGas
+            );
+    }
 }

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,27 @@
+// 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
+        assert(false);
+    }
+
+    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
+        assert(false);
+    }
+
+    function _getFirstAddressFromPath(bytes memory path) internal pure returns (address dst) {
+        assembly {
+            dst := mload(add(add(path, EVM_ADDRESS_SIZE), 0)) 
+        }
+    }
+}

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,
@@ -47,9 +47,13 @@ contract PendleVotingControllerUpg is
     using EnumerableMap for EnumerableMap.UintToAddressMap;
     using EnumerableSet for EnumerableSet.AddressSet;
 
-    constructor(address _vePendle, address _pendleMsgSendEndpoint)
+    constructor(
+        address _vePendle,
+        address _pendleMsgSendEndpoint,
+        uint256 initialApproxDestinationGas
+    )
         VotingControllerStorageUpg(_vePendle)
-        PendleMsgSenderAppUpg(_pendleMsgSendEndpoint) // constructor only set immutable variables
+        PendleMsgSenderAppUpg(_pendleMsgSendEndpoint, initialApproxDestinationGas) // constructor only set immutable variables
         initializer
     //solhint-disable-next-line
     {
@@ -196,7 +200,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
@@ -232,12 +236,7 @@ contract PendleVotingControllerUpg is
         address[] memory pools = new address[](length);
         uint256[] memory totalPendleAmounts = new uint256[](length);
 
-        return
-            pendleMsgSendEndpoint.calcFee(
-                destinationContracts.get(chainId),
-                chainId,
-                abi.encode(uint128(0), pools, totalPendleAmounts)
-            );
+        return _getSendMessageFee(chainId, abi.encode(uint128(0), pools, totalPendleAmounts));
     }
 
     /*///////////////////////////////////////////////////////////////

package/contracts/LiquidityMining/VotingEscrow/VotingEscrowPendleMainchain.sol

@@ -43,10 +43,11 @@ contract VotingEscrowPendleMainchain is
     // to ask for their vePendle balance at any wTime
     mapping(address => Checkpoints.History) internal userHistory;
 
-    constructor(IERC20 _pendle, address _pendleMsgSendEndpoint)
-        initializer
-        PendleMsgSenderAppUpg(_pendleMsgSendEndpoint)
-    {
+    constructor(
+        IERC20 _pendle,
+        address _pendleMsgSendEndpoint,
+        uint256 initialApproxDestinationGas
+    ) initializer PendleMsgSenderAppUpg(_pendleMsgSendEndpoint, initialApproxDestinationGas) {
         pendle = _pendle;
         __BoringOwnable_init();
     }
@@ -177,30 +178,20 @@ contract VotingEscrowPendleMainchain is
     function getBroadcastSupplyFee(uint256[] calldata chainIds)
         external
         view
-        returns (uint256[] memory fees)
+        returns (uint256 fee)
     {
-        fees = new uint256[](chainIds.length);
         for (uint256 i = 0; i < chainIds.length; i++) {
-            fees[i] = pendleMsgSendEndpoint.calcFee(
-                destinationContracts.get(chainIds[i]),
-                chainIds[i],
-                SAMPLE_SUPPLY_UPDATE_MESSAGE
-            );
+            fee += _getSendMessageFee(chainIds[i], SAMPLE_SUPPLY_UPDATE_MESSAGE);
         }
     }
 
     function getBroadcastPositionFee(uint256[] calldata chainIds)
         external
         view
-        returns (uint256[] memory fees)
+        returns (uint256 fee)
     {
-        fees = new uint256[](chainIds.length);
         for (uint256 i = 0; i < chainIds.length; i++) {
-            fees[i] = pendleMsgSendEndpoint.calcFee(
-                destinationContracts.get(chainIds[i]),
-                chainIds[i],
-                SAMPLE_POSITION_UPDATE_MESSAGE
-            );
+            fee += _getSendMessageFee(chainIds[i], SAMPLE_POSITION_UPDATE_MESSAGE);
         }
     }
 
@@ -295,11 +286,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,