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

package/contracts/core/YieldContracts/PendleYieldToken.sol

@@ -3,14 +3,14 @@ pragma solidity 0.8.17;
 
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
-import "../../interfaces/ISuperComposableYield.sol";
+import "../../interfaces/IStandardizedYield.sol";
 import "../../interfaces/IPYieldToken.sol";
 import "../../interfaces/IPPrincipalToken.sol";
 
 import "../libraries/math/Math.sol";
 import "../libraries/ArrayLib.sol";
 import "../../interfaces/IPYieldContractFactory.sol";
-import "../SuperComposableYield/SCYUtils.sol";
+import "../StandardizedYield/SYUtils.sol";
 import "../libraries/Errors.sol";
 import "../libraries/MiniHelpers.sol";
 
@@ -35,17 +35,17 @@ contract PendleYieldToken is
 
     struct PostExpiryData {
         uint128 firstPYIndex;
-        uint128 totalScyInterestForTreasury;
+        uint128 totalSyInterestForTreasury;
         mapping(address => uint256) firstRewardIndex;
         mapping(address => uint256) userRewardOwed;
     }
 
-    address public immutable SCY;
+    address public immutable SY;
     address public immutable PT;
     address public immutable factory;
     uint256 public immutable expiry;
 
-    uint128 public scyReserve;
+    uint128 public syReserve;
     uint128 internal _pyIndexStored;
 
     PostExpiryData public postExpiry;
@@ -53,7 +53,7 @@ contract PendleYieldToken is
     modifier updateData() {
         if (isExpired()) _setPostExpiryData();
         _;
-        _updateScyReserve();
+        _updateSyReserve();
     }
 
     modifier notExpired() {
@@ -62,20 +62,20 @@ contract PendleYieldToken is
     }
 
     constructor(
-        address _SCY,
+        address _SY,
         address _PT,
         string memory _name,
         string memory _symbol,
         uint8 __decimals,
         uint256 _expiry
     ) PendleERC20Permit(_name, _symbol, __decimals) {
-        SCY = _SCY;
+        SY = _SY;
         PT = _PT;
         expiry = _expiry;
         factory = msg.sender;
     }
 
-    /// @notice Tokenize SCY into PT + YT of equal qty. Every unit of underlying of SCY will create 1 PT + 1 YT
+    /// @notice Tokenize SY into PT + YT of equal qty. Every unit of underlying of SY will create 1 PT + 1 YT
     function mintPY(address receiverPT, address receiverYT)
         external
         nonReentrant
@@ -85,52 +85,52 @@ contract PendleYieldToken is
     {
         address[] memory receiverPTs = new address[](1);
         address[] memory receiverYTs = new address[](1);
-        uint256[] memory amountScyToMints = new uint256[](1);
+        uint256[] memory amountSyToMints = new uint256[](1);
 
-        (receiverPTs[0], receiverYTs[0], amountScyToMints[0]) = (
+        (receiverPTs[0], receiverYTs[0], amountSyToMints[0]) = (
             receiverPT,
             receiverYT,
-            _getFloatingScyAmount()
+            _getFloatingSyAmount()
         );
 
-        uint256[] memory amountPYOuts = _mintPY(receiverPTs, receiverYTs, amountScyToMints);
+        uint256[] memory amountPYOuts = _mintPY(receiverPTs, receiverYTs, amountSyToMints);
         amountPYOut = amountPYOuts[0];
     }
 
-    /// @notice Tokenize SCY into PT + YT of equal qty. Every unit of underlying of SCY will create 1 PT + 1 YT
+    /// @notice Tokenize SY into PT + YT of equal qty. Every unit of underlying of SY will create 1 PT + 1 YT
     function mintPYMulti(
         address[] calldata receiverPTs,
         address[] calldata receiverYTs,
-        uint256[] calldata amountScyToMints
+        uint256[] calldata amountSyToMints
     ) external nonReentrant notExpired updateData returns (uint256[] memory amountPYOuts) {
         uint256 length = receiverPTs.length;
 
-        if (receiverYTs.length != length && amountScyToMints.length == length)
+        if (receiverYTs.length != length && amountSyToMints.length == length)
             revert Errors.ArrayLengthMismatch();
         if (length == 0) revert Errors.ArrayEmpty();
 
-        uint256 totalScyToMint = amountScyToMints.sum();
-        if (totalScyToMint > _getFloatingScyAmount())
-            revert Errors.YieldContractInsufficientScy(totalScyToMint, _getFloatingScyAmount());
+        uint256 totalSyToMint = amountSyToMints.sum();
+        if (totalSyToMint > _getFloatingSyAmount())
+            revert Errors.YieldContractInsufficientSy(totalSyToMint, _getFloatingSyAmount());
 
-        amountPYOuts = _mintPY(receiverPTs, receiverYTs, amountScyToMints);
+        amountPYOuts = _mintPY(receiverPTs, receiverYTs, amountSyToMints);
     }
 
-    /// @dev this function converts PY tokens into scy, but interests & rewards are not redeemed at the same time
+    /// @dev this function converts PY tokens into sy, but interests & rewards are not redeemed at the same time
     function redeemPY(address receiver)
         external
         nonReentrant
         updateData
-        returns (uint256 amountScyOut)
+        returns (uint256 amountSyOut)
     {
         address[] memory receivers = new address[](1);
         uint256[] memory amounts = new uint256[](1);
         (receivers[0], amounts[0]) = (receiver, _getAmountPYToRedeem());
 
-        uint256[] memory amountScyOuts;
-        amountScyOuts = _redeemPY(receivers, amounts);
+        uint256[] memory amountSyOuts;
+        amountSyOuts = _redeemPY(receivers, amounts);
 
-        amountScyOut = amountScyOuts[0];
+        amountSyOut = amountSyOuts[0];
     }
 
     /// @dev this function limit how much each receiver will receive. For example, if the totalOut is 100,
@@ -140,16 +140,16 @@ contract PendleYieldToken is
         external
         nonReentrant
         updateData
-        returns (uint256[] memory amountScyOuts)
+        returns (uint256[] memory amountSyOuts)
     {
         if (receivers.length != amountPYToRedeems.length) revert Errors.ArrayLengthMismatch();
         if (receivers.length == 0) revert Errors.ArrayEmpty();
-        amountScyOuts = _redeemPY(receivers, amountPYToRedeems);
+        amountSyOuts = _redeemPY(receivers, amountPYToRedeems);
     }
 
     /**
-    * @dev With YT yielding interest in the form of SCY, which is redeemable by users, the reward
-    distribution should be based on the amount of SCYs that their YT currently represent, plus their
+    * @dev With YT yielding interest in the form of SY, which is redeemable by users, the reward
+    distribution should be based on the amount of SYs that their YT currently represent, plus their
     dueInterest. It has been proven and tested that _rewardSharesUser will not change over time,
     unless users redeem their dueInterest or redeemPY. Due to this, it is required to update users'
     accruedReward STRICTLY BEFORE transferring out their interest.
@@ -175,7 +175,7 @@ contract PendleYieldToken is
 
         if (redeemInterest) {
             _distributeInterest(user);
-            interestOut = _doTransferOutInterest(user, SCY, factory);
+            interestOut = _doTransferOutInterest(user, SY, factory);
             emit RedeemInterest(user, interestOut);
         } else {
             interestOut = 0;
@@ -203,13 +203,13 @@ contract PendleYieldToken is
 
         _transferOut(tokens, treasury, rewardsOut);
 
-        interestOut = postExpiry.totalScyInterestForTreasury;
-        postExpiry.totalScyInterestForTreasury = 0;
-        _transferOut(SCY, treasury, interestOut);
+        interestOut = postExpiry.totalSyInterestForTreasury;
+        postExpiry.totalSyInterestForTreasury = 0;
+        _transferOut(SY, treasury, interestOut);
     }
 
     function rewardIndexesCurrent() external override nonReentrant returns (uint256[] memory) {
-        return ISuperComposableYield(SCY).rewardIndexesCurrent();
+        return IStandardizedYield(SY).rewardIndexesCurrent();
     }
 
     /// @dev maximize the current rate with the previous rate to guarantee non-decreasing rate
@@ -228,7 +228,7 @@ contract PendleYieldToken is
         view
         returns (
             uint256 firstPYIndex,
-            uint256 totalScyInterestForTreasury,
+            uint256 totalSyInterestForTreasury,
             uint256[] memory firstRewardIndexes,
             uint256[] memory userRewardOwed
         )
@@ -236,7 +236,7 @@ contract PendleYieldToken is
         if (postExpiry.firstPYIndex == 0) revert Errors.YCPostExpiryDataNotSet();
 
         firstPYIndex = postExpiry.firstPYIndex;
-        totalScyInterestForTreasury = postExpiry.totalScyInterestForTreasury;
+        totalSyInterestForTreasury = postExpiry.totalSyInterestForTreasury;
 
         address[] memory tokens = getRewardTokens();
         firstRewardIndexes = new uint256[](tokens.length);
@@ -251,14 +251,14 @@ contract PendleYieldToken is
     function _mintPY(
         address[] memory receiverPTs,
         address[] memory receiverYTs,
-        uint256[] memory amountScyToMints
+        uint256[] memory amountSyToMints
     ) internal returns (uint256[] memory amountPYOuts) {
-        amountPYOuts = new uint256[](amountScyToMints.length);
+        amountPYOuts = new uint256[](amountSyToMints.length);
 
         uint256 index = _pyIndexCurrent();
 
-        for (uint256 i = 0; i < amountScyToMints.length; i++) {
-            amountPYOuts[i] = _calcPYToMint(amountScyToMints[i], index);
+        for (uint256 i = 0; i < amountSyToMints.length; i++) {
+            amountPYOuts[i] = _calcPYToMint(amountSyToMints[i], index);
 
             _mint(receiverYTs[i], amountPYOuts[i]);
             IPPrincipalToken(PT).mintByYT(receiverPTs[i], amountPYOuts[i]);
@@ -267,7 +267,7 @@ contract PendleYieldToken is
                 msg.sender,
                 receiverPTs[i],
                 receiverYTs[i],
-                amountScyToMints[i],
+                amountSyToMints[i],
                 amountPYOuts[i]
             );
         }
@@ -283,50 +283,50 @@ contract PendleYieldToken is
 
     function _redeemPY(address[] memory receivers, uint256[] memory amountPYToRedeems)
         internal
-        returns (uint256[] memory amountScyOuts)
+        returns (uint256[] memory amountSyOuts)
     {
         uint256 totalAmountPYToRedeem = amountPYToRedeems.sum();
         IPPrincipalToken(PT).burnByYT(address(this), totalAmountPYToRedeem);
         if (!isExpired()) _burn(address(this), totalAmountPYToRedeem);
 
         uint256 index = _pyIndexCurrent();
-        uint256 totalScyInterestPostExpiry;
-        amountScyOuts = new uint256[](receivers.length);
+        uint256 totalSyInterestPostExpiry;
+        amountSyOuts = new uint256[](receivers.length);
 
         for (uint256 i = 0; i < receivers.length; i++) {
-            uint256 scyInterestPostExpiry;
-            (amountScyOuts[i], scyInterestPostExpiry) = _calcScyRedeemableFromPY(
+            uint256 syInterestPostExpiry;
+            (amountSyOuts[i], syInterestPostExpiry) = _calcSyRedeemableFromPY(
                 amountPYToRedeems[i],
                 index
             );
-            _transferOut(SCY, receivers[i], amountScyOuts[i]);
-            totalScyInterestPostExpiry += scyInterestPostExpiry;
+            _transferOut(SY, receivers[i], amountSyOuts[i]);
+            totalSyInterestPostExpiry += syInterestPostExpiry;
 
-            emit Burn(msg.sender, receivers[i], amountPYToRedeems[i], amountScyOuts[i]);
+            emit Burn(msg.sender, receivers[i], amountPYToRedeems[i], amountSyOuts[i]);
         }
-        if (totalScyInterestPostExpiry != 0) {
-            postExpiry.totalScyInterestForTreasury += totalScyInterestPostExpiry.Uint128();
+        if (totalSyInterestPostExpiry != 0) {
+            postExpiry.totalSyInterestForTreasury += totalSyInterestPostExpiry.Uint128();
         }
     }
 
-    function _calcPYToMint(uint256 amountScy, uint256 indexCurrent)
+    function _calcPYToMint(uint256 amountSy, uint256 indexCurrent)
         internal
         pure
         returns (uint256 amountPY)
     {
         // doesn't matter before or after expiry, since mintPY is only allowed before expiry
-        return SCYUtils.scyToAsset(indexCurrent, amountScy);
+        return SYUtils.syToAsset(indexCurrent, amountSy);
     }
 
-    function _calcScyRedeemableFromPY(uint256 amountPY, uint256 indexCurrent)
+    function _calcSyRedeemableFromPY(uint256 amountPY, uint256 indexCurrent)
         internal
         view
-        returns (uint256 scyToUser, uint256 scyInterestPostExpiry)
+        returns (uint256 syToUser, uint256 syInterestPostExpiry)
     {
-        scyToUser = SCYUtils.assetToScy(indexCurrent, amountPY);
+        syToUser = SYUtils.assetToSy(indexCurrent, amountPY);
         if (isExpired()) {
-            uint256 totalScyRedeemable = SCYUtils.assetToScy(postExpiry.firstPYIndex, amountPY);
-            scyInterestPostExpiry = totalScyRedeemable - scyToUser;
+            uint256 totalSyRedeemable = SYUtils.assetToSy(postExpiry.firstPYIndex, amountPY);
+            syInterestPostExpiry = totalSyRedeemable - syToUser;
         }
     }
 
@@ -335,13 +335,13 @@ contract PendleYieldToken is
         else return _selfBalance(PT);
     }
 
-    function _updateScyReserve() internal virtual {
-        scyReserve = _selfBalance(SCY).Uint128();
+    function _updateSyReserve() internal virtual {
+        syReserve = _selfBalance(SY).Uint128();
     }
 
-    function _getFloatingScyAmount() internal view returns (uint256 amount) {
-        amount = _selfBalance(SCY) - scyReserve;
-        if (amount == 0) revert Errors.YCNoFloatingScy();
+    function _getFloatingSyAmount() internal view returns (uint256 amount) {
+        amount = _selfBalance(SY) - syReserve;
+        if (amount == 0) revert Errors.YCNoFloatingSy();
     }
 
     function _setPostExpiryData() internal {
@@ -351,8 +351,8 @@ contract PendleYieldToken is
         _redeemExternalReward(); // do a final redeem. All the future reward income will belong to the treasury
 
         local.firstPYIndex = _pyIndexCurrent().Uint128();
-        address[] memory rewardTokens = ISuperComposableYield(SCY).getRewardTokens();
-        uint256[] memory rewardIndexes = ISuperComposableYield(SCY).rewardIndexesCurrent();
+        address[] memory rewardTokens = IStandardizedYield(SY).getRewardTokens();
+        uint256[] memory rewardIndexes = IStandardizedYield(SY).rewardIndexesCurrent();
         for (uint256 i = 0; i < rewardTokens.length; i++) {
             local.firstRewardIndex[rewardTokens[i]] = rewardIndexes[i];
             local.userRewardOwed[rewardTokens[i]] = _selfBalance(rewardTokens[i]);
@@ -369,7 +369,7 @@ contract PendleYieldToken is
     }
 
     function _pyIndexCurrent() internal returns (uint256 currentIndex) {
-        currentIndex = Math.max(ISuperComposableYield(SCY).exchangeRate(), _pyIndexStored);
+        currentIndex = Math.max(IStandardizedYield(SY).exchangeRate(), _pyIndexStored);
         _pyIndexStored = currentIndex.Uint128();
         emit NewInterestIndex(currentIndex);
     }
@@ -383,7 +383,7 @@ contract PendleYieldToken is
     //////////////////////////////////////////////////////////////*/
 
     function getRewardTokens() public view returns (address[] memory) {
-        return ISuperComposableYield(SCY).getRewardTokens();
+        return IStandardizedYield(SY).getRewardTokens();
     }
 
     function _doTransferOutRewards(address user, address receiver)
@@ -436,14 +436,14 @@ contract PendleYieldToken is
     }
 
     function _redeemExternalReward() internal virtual override {
-        ISuperComposableYield(SCY).claimRewards(address(this));
+        IStandardizedYield(SY).claimRewards(address(this));
     }
 
-    /// @dev effectively returning the amount of SCY generating rewards for this user
+    /// @dev effectively returning the amount of SY generating rewards for this user
     function _rewardSharesUser(address user) internal view virtual override returns (uint256) {
         uint256 index = userInterest[user].index;
         if (index == 0) return 0;
-        return SCYUtils.assetToScy(index, balanceOf(user)) + userInterest[user].accrued;
+        return SYUtils.assetToSy(index, balanceOf(user)) + userInterest[user].accrued;
     }
 
     function _updateRewardIndex()
@@ -457,7 +457,7 @@ contract PendleYieldToken is
             for (uint256 i = 0; i < tokens.length; i++)
                 indexes[i] = postExpiry.firstRewardIndex[tokens[i]];
         } else {
-            indexes = ISuperComposableYield(SCY).rewardIndexesCurrent();
+            indexes = IStandardizedYield(SY).rewardIndexesCurrent();
         }
     }
 

package/contracts/core/libraries/Errors.sol

@@ -15,7 +15,7 @@ library Errors {
     error MarketZeroLnImpliedRate();
     error MarketInsufficientPtForTrade(int256 currentAmount, int256 requiredAmount);
     error MarketInsufficientPtReceived(uint256 actualBalance, uint256 requiredBalance);
-    error MarketInsufficientScyReceived(uint256 actualBalance, uint256 requiredBalance);
+    error MarketInsufficientSyReceived(uint256 actualBalance, uint256 requiredBalance);
     error MarketZeroTotalPtOrTotalAsset(int256 totalPt, int256 totalAsset);
     error MarketExchangeRateBelowOne(int256 exchangeRate);
     error MarketProportionMustNotEqualOne();
@@ -36,15 +36,15 @@ library Errors {
 
     // ROUTER
     error RouterInsufficientLpOut(uint256 actualLpOut, uint256 requiredLpOut);
-    error RouterInsufficientScyOut(uint256 actualScyOut, uint256 requiredScyOut);
+    error RouterInsufficientSyOut(uint256 actualSyOut, uint256 requiredSyOut);
     error RouterInsufficientPtOut(uint256 actualPtOut, uint256 requiredPtOut);
     error RouterInsufficientYtOut(uint256 actualYtOut, uint256 requiredYtOut);
     error RouterInsufficientPYOut(uint256 actualPYOut, uint256 requiredPYOut);
     error RouterInsufficientTokenOut(uint256 actualTokenOut, uint256 requiredTokenOut);
-    error RouterExceededLimitScyIn(uint256 actualScyIn, uint256 limitScyIn);
+    error RouterExceededLimitSyIn(uint256 actualSyIn, uint256 limitSyIn);
     error RouterExceededLimitPtIn(uint256 actualPtIn, uint256 limitPtIn);
     error RouterExceededLimitYtIn(uint256 actualYtIn, uint256 limitYtIn);
-    error RouterInsufficientScyRepay(uint256 actualScyRepay, uint256 requiredScyRepay);
+    error RouterInsufficientSyRepay(uint256 actualSyRepay, uint256 requiredSyRepay);
     error RouterInsufficientPtRepay(uint256 actualPtRepay, uint256 requiredPtRepay);
 
     error RouterTimeRangeZero();
@@ -54,31 +54,31 @@ library Errors {
     // YIELD CONTRACT
     error YCExpired();
     error YCNotExpired();
-    error YieldContractInsufficientScy(uint256 actualScy, uint256 requiredScy);
+    error YieldContractInsufficientSy(uint256 actualSy, uint256 requiredSy);
     error YCNothingToRedeem();
     error YCPostExpiryDataNotSet();
-    error YCNoFloatingScy();
+    error YCNoFloatingSy();
 
     // YieldFactory
     error YCFactoryInvalidExpiry();
     error YCFactoryYieldContractExisted();
 
-    // SCY
-    error SCYInvalidTokenIn(address token);
-    error SCYInvalidTokenOut(address token);
-    error SCYZeroDeposit();
-    error SCYZeroRedeem();
-    error SCYInsufficientSharesOut(uint256 actualSharesOut, uint256 requiredSharesOut);
-    error SCYInsufficientTokenOut(uint256 actualTokenOut, uint256 requiredTokenOut);
+    // SY
+    error SYInvalidTokenIn(address token);
+    error SYInvalidTokenOut(address token);
+    error SYZeroDeposit();
+    error SYZeroRedeem();
+    error SYInsufficientSharesOut(uint256 actualSharesOut, uint256 requiredSharesOut);
+    error SYInsufficientTokenOut(uint256 actualTokenOut, uint256 requiredTokenOut);
 
-    // SCY-specific
-    error SCYQiTokenMintFailed(uint256 errCode);
-    error SCYQiTokenRedeemFailed(uint256 errCode);
-    error SCYQiTokenRedeemRewardsFailed(uint256 rewardAccruedType0, uint256 rewardAccruedType1);
-    error SCYQiTokenBorrowRateTooHigh(uint256 borrowRate, uint256 borrowRateMax);
+    // SY-specific
+    error SYQiTokenMintFailed(uint256 errCode);
+    error SYQiTokenRedeemFailed(uint256 errCode);
+    error SYQiTokenRedeemRewardsFailed(uint256 rewardAccruedType0, uint256 rewardAccruedType1);
+    error SYQiTokenBorrowRateTooHigh(uint256 borrowRate, uint256 borrowRateMax);
 
-    error SCYCurveInvalidPid();
-    error SCYCurve3crvPoolNotFound();
+    error SYCurveInvalidPid();
+    error SYCurve3crvPoolNotFound();
 
     // Liquidity Mining
     error VCInactivePool(address pool);
@@ -111,6 +111,8 @@ library Errors {
     error MsgNotFromSendEndpoint(address sender);
     error MsgNotFromReceiveEndpoint(address sender);
     error InsufficientFeeToSendMsg(uint256 currentFee, uint256 requiredFee);
+    error ApproxDstExecutionGasNotSet();
+    error InvalidRetryData();
 
     // GENERIC MSG
     error ArrayLengthMismatch();
@@ -118,7 +120,7 @@ library Errors {
     error ArrayOutOfBounds();
     error ZeroAddress();
 
-    error OnlyCelerBus();
+    error OnlyLayerZeroEndpoint();
     error OnlyYT();
     error OnlyYCFactory();
     error OnlyWhitelisted();

package/contracts/core/libraries/TokenHelper.sol

@@ -8,39 +8,6 @@ abstract contract TokenHelper {
     address internal constant NATIVE = address(0);
     uint256 internal constant LOWER_BOUND_APPROVAL = type(uint96).max / 2; // some tokens use 96 bits for approval
 
-    function _transferFrom(
-        address token,
-        address from,
-        address to,
-        uint256 amount
-    ) internal {
-        if (token == NATIVE) require(msg.value == amount, "eth mismatch");
-        else if (amount != 0) IERC20(token).safeTransferFrom(from, to, amount);
-    }
-
-    function _transferFrom(
-        address[] memory tokens,
-        address from,
-        address to,
-        uint256[] memory amounts
-    ) internal {
-        uint256 length = tokens.length;
-        require(length == amounts.length, "length mismatch");
-
-        for (uint256 i = 0; i < length; ) {
-            if (amounts[i] > 0) {
-                if (tokens[i] == NATIVE) {
-                    require(msg.value == amounts[i], "native mismatch");
-                } else {
-                    IERC20(tokens[i]).safeTransferFrom(from, to, amounts[i]);
-                }
-            }
-            unchecked {
-                i++;
-            }
-        }
-    }
-
     function _transferIn(
         address token,
         address from,

package/contracts/interfaces/Curve/ICrvPool.sol

@@ -2,6 +2,8 @@
 pragma solidity 0.8.17;
 
 interface ICrvPool {
+    function coins(uint256 i) external view returns (address);
+
     function get_virtual_price() external view returns (uint256);
 
     function get_dy(

package/contracts/interfaces/ILayerZeroEndpoint.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.5.0;
+
+interface ILayerZeroEndpoint {
+    // @notice send a LayerZero message to the specified address at a LayerZero endpoint.
+    // @param _dstChainId - the destination chain identifier
+    // @param _destination - the address on destination chain (in bytes). address length/format may vary by chains
+    // @param _payload - a custom bytes payload to send to the destination contract
+    // @param _refundAddress - if the source transaction is cheaper than the amount of value passed, refund the additional amount to this address
+    // @param _zroPaymentAddress - the address of the ZRO token holder who would pay for the transaction
+    // @param _adapterParams - parameters for custom functionality. e.g. receive airdropped native gas from the relayer on destination
+    function send(
+        uint16 _dstChainId,
+        bytes calldata _destination,
+        bytes calldata _payload,
+        address payable _refundAddress,
+        address _zroPaymentAddress,
+        bytes calldata _adapterParams
+    ) external payable;
+
+    // @notice gets a quote in source native gas, for the amount that send() requires to pay for message delivery
+    // @param _dstChainId - the destination chain identifier
+    // @param _userApplication - the user app address on this EVM chain
+    // @param _payload - the custom message to send over LayerZero
+    // @param _payInZRO - if false, user app pays the protocol fee in native token
+    // @param _adapterParam - parameters for the adapter service, e.g. send some dust native token to dstChain
+    function estimateFees(
+        uint16 _dstChainId,
+        address _userApplication,
+        bytes calldata _payload,
+        bool _payInZRO,
+        bytes calldata _adapterParam
+    ) external view returns (uint256 nativeFee, uint256 zroFee);
+
+    function setSendVersion(uint16 _newVersion) external;
+
+    function setReceiveVersion(uint16 _newVersion) external;
+}

package/contracts/interfaces/ILayerZeroReceiver.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity >=0.5.0;
+
+interface ILayerZeroReceiver {
+    // @notice LayerZero endpoint will invoke this function to deliver the message on the destination
+    // @param _srcChainId - the source endpoint identifier
+    // @param _srcAddress - the source sending contract address from the source chain
+    // @param _nonce - the ordered message nonce
+    // @param _payload - the signed payload is the UA bytes has encoded to be sent
+    function lzReceive(uint16 _srcChainId, bytes calldata _srcAddress, uint64 _nonce, bytes calldata _payload) external;
+}