@pendle/core-v2 2.22.3 → 2.23.1-mantle

package/contracts/core/StandardizedYield/implementations/ChainlinkRelayer/PendleChainlinkRelayer.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "@openzeppelin/contracts/utils/Address.sol";
+import { AggregatorV2V3Interface as IChainlinkAggregator } from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";
+
+import "../../../../LiquidityMining/CrossChainMsg/libraries/LayerZeroHelper.sol";
+import "../../../../interfaces/ILayerZeroEndpoint.sol";
+import "../../../../interfaces/IWstETH.sol";
+import "../../../libraries/BoringOwnableUpgradeable.sol";
+
+contract PendleChainlinkRelayer {
+    uint256 private constant DST_EXECUTION_GAS = 50000;
+
+    address public immutable lzEndpoint;
+    address public immutable dstAddress;
+    uint256 public immutable dstChainId;
+    address public immutable chainlinkFeed;
+
+    constructor(
+        address _lzEndpoint,
+        address _dstAddress,
+        uint256 _dstChainId,
+        address _chainlinkFeed
+    ) {
+        lzEndpoint = _lzEndpoint;
+        dstAddress = _dstAddress;
+        dstChainId = _dstChainId;
+        chainlinkFeed = _chainlinkFeed;
+    }
+
+    function run() external payable {
+        bytes memory path = abi.encodePacked(dstAddress, address(this));
+        ILayerZeroEndpoint(lzEndpoint).send{ value: msg.value }(
+            LayerZeroHelper._getLayerZeroChainIds(dstChainId),
+            path,
+            abi.encode(IChainlinkAggregator(chainlinkFeed).latestAnswer()),
+            payable(msg.sender),
+            address(0),
+            abi.encodePacked(uint16(1), DST_EXECUTION_GAS)
+        );
+    }
+}

package/contracts/core/StandardizedYield/implementations/MantleStakedEth/PendleMantleStakedEthSY.sol

@@ -0,0 +1,120 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../SYBase.sol";
+import "../../../../interfaces/IPOracleForSy.sol";
+
+contract PendleMantleStakedEthSY is SYBase {
+    using Math for int256;
+
+    address internal immutable underlyingAssetOnEthAddr;
+    uint8 internal immutable underlyingAssetOnEthDecimals;
+    address public immutable oracleAddress;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _token,
+        address _underlyingAssetOnEthAddr,
+        uint8 _underlyingAssetOnEthDecimals,
+        address _oracleAddress
+    ) SYBase(_name, _symbol, _token) {
+        underlyingAssetOnEthAddr = _underlyingAssetOnEthAddr;
+        underlyingAssetOnEthDecimals = _underlyingAssetOnEthDecimals;
+        oracleAddress = _oracleAddress;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    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 IPOracleForSy(oracleAddress).latestAnswer().Uint();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                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) {
+        res = new address[](1);
+        res[0] = yieldToken;
+    }
+
+    function getTokensOut() public view override returns (address[] memory res) {
+        res = new address[](1);
+        res[0] = 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, underlyingAssetOnEthAddr, underlyingAssetOnEthDecimals);
+    }
+}

package/contracts/core/StandardizedYield/implementations/MantleStakedEth/PendleOracleForSyProxy.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../SYBase.sol";
+import "../../../../interfaces/IPOracleForSy.sol";
+
+// the Owner of this will be a timelock
+contract PendleOracleForSyProxy is BoringOwnableUpgradeable, IPOracleForSy {
+    address public oracleAddress;
+
+    constructor(address _oracleAddress) initializer {
+        __BoringOwnable_init();
+        oracleAddress = _oracleAddress;
+    }
+
+    function latestAnswer() external view override returns (int256) {
+        return IPOracleForSy(oracleAddress).latestAnswer();
+    }
+
+    function setOracleAddress(address _oracleAddress) external onlyOwner {
+        oracleAddress = _oracleAddress;
+    }
+}

package/contracts/core/libraries/ArrayLib.sol

@@ -39,6 +39,36 @@ library ArrayLib {
         }
         out[length] = element;
     }
+    /**
+     * @dev This function assumes a and b each contains unidentical elements 
+     * @param a array of addresses a
+     * @param b array of addresses b
+     * @return out Concatenation of a and b containing unidentical elements
+     */
+    function concat(
+        address[] memory a,
+        address[] memory b
+    ) internal pure returns (address[] memory out) {
+        uint256 countUnidenticalB = 0;
+        bool[] memory isUnidentical = new bool[](b.length);
+        for(uint256 i = 0; i < b.length; ++i) {
+            if (!contains(a, b[i])) {
+                countUnidenticalB++;
+                isUnidentical[i] = true;
+            }
+        }
+
+        out = new address[](a.length + countUnidenticalB);
+        for(uint256 i = 0; i < a.length; ++i) {
+            out[i] = a[i];
+        }
+        uint256 id = a.length;
+        for(uint256 i = 0; i < b.length; ++i) {
+            if (isUnidentical[i]) {
+                out[id++] = b[i];
+            }
+        }
+    }
 
     // various version of contains
     function contains(address[] memory array, address element) internal pure returns (bool) {

package/contracts/core/libraries/Errors.sol

@@ -118,6 +118,8 @@ library Errors {
 
     error SYBalancerReentrancy();
 
+    error NotFromTrustedRemote(uint16 srcChainId, bytes path);
+
     // Liquidity Mining
     error VCInactivePool(address pool);
     error VCPoolAlreadyActive(address pool);

package/contracts/interfaces/Balancer/IPComposableStablePreview.sol

@@ -0,0 +1,23 @@
+pragma solidity 0.8.17;
+
+import "./IBalancerStablePreview.sol";
+
+interface IPComposableStablePreview is IBalancerStablePreview {
+    struct ImmutableData {
+        address[] poolTokens;
+        address[] rateProviders;
+        uint256[] rawScalingFactors;
+        bool[] isExemptFromYieldProtocolFee;
+        //
+        address LP;
+        bool noTokensExempt;
+        bool allTokensExempt;
+        uint256 bptIndex;
+        uint256 totalTokens;
+    }
+
+    struct TokenRateCache {
+        uint256 currentRate;
+        uint256 oldRate;
+    }
+}

package/contracts/interfaces/Balancer/IVersion.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity 0.8.17;
+
+/**
+ * @notice Simple interface to retrieve the version of a deployed contract.
+ */
+interface IVersion {
+    /**
+     * @dev Returns a JSON representation of the contract version containing name, version number and task ID.
+     */
+    function version() external view returns (string memory);
+}

package/contracts/interfaces/IPExternalRewardDistributor.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+interface IPExternalRewardDistributor {
+    struct MarketRewardData {
+        uint128 rewardPerSec;
+        uint128 accumulatedReward;
+        uint128 lastUpdated;
+        uint128 incentiveEndsAt;
+    }
+
+    event DistributeReward(address indexed market, address indexed rewardToken, uint256 amount);
+
+    event AddRewardToMarket(address indexed market, address indexed token, MarketRewardData data);
+
+    function getRewardTokens(address market) external view returns (address[] memory);
+
+    function redeemRewards() external;
+}

package/contracts/interfaces/IPMarketFactoryV2.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "./IPMarketFactory.sol";
+
+interface IPMarketFactoryV2 is IPMarketFactory {
+    function rewardDistributor() external view returns (address);
+}

package/contracts/interfaces/IPOracleForSy.sol

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity 0.8.17;
+
+interface IPOracleForSy {
+    function latestAnswer() external view returns (int256);
+}

package/contracts/offchain-helpers/LegacyNFTHelper.sol

@@ -0,0 +1,100 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+contract LegacyNFTHelper {
+    address private constant ADDR = 0x9B1Bfa5D13375e8E21FDCb0A5F965974f9DcfDd1;
+
+    function getNumOwned(address user) public view returns (uint256) {
+        uint256 starCount = StarNFTV1(ADDR).starCount();
+        uint256 numOwned = 0;
+        for (uint256 i = 0; i < starCount; i++) {
+            if (StarNFTV1(ADDR).isOwnerOf(user, i)) {
+                numOwned++;
+            }
+        }
+        return numOwned;
+    }
+}
+
+interface StarNFTV1 {
+    event ApprovalForAll(address indexed account, address indexed operator, bool approved);
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+    event TransferBatch(
+        address indexed operator,
+        address indexed from,
+        address indexed to,
+        uint256[] ids,
+        uint256[] values
+    );
+    event TransferSingle(
+        address indexed operator,
+        address indexed from,
+        address indexed to,
+        uint256 id,
+        uint256 value
+    );
+    event URI(string value, uint256 indexed id);
+
+    function addMinter(address minter) external;
+
+    function balanceOf(address account, uint256 id) external view returns (uint256);
+
+    function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
+        external
+        view
+        returns (uint256[] memory);
+
+    function baseURI() external view returns (string memory);
+
+    function burn(address account, uint256 id) external;
+
+    function burnBatch(address account, uint256[] memory ids) external;
+
+    function isApprovedForAll(address account, address operator) external view returns (bool);
+
+    function isOwnerOf(address account, uint256 id) external view returns (bool);
+
+    function mint(address account, uint256 powah) external returns (uint256);
+
+    function mintBatch(
+        address account,
+        uint256 amount,
+        uint256[] memory powahArr
+    ) external returns (uint256[] memory);
+
+    function minters(address) external view returns (bool);
+
+    function owner() external view returns (address);
+
+    function removeMinter(address minter) external;
+
+    function renounceOwnership() external;
+
+    function safeBatchTransferFrom(
+        address from,
+        address to,
+        uint256[] memory ids,
+        uint256[] memory amounts,
+        bytes memory data
+    ) external;
+
+    function safeTransferFrom(
+        address from,
+        address to,
+        uint256 id,
+        uint256 amount,
+        bytes memory data
+    ) external;
+
+    function setApprovalForAll(address operator, bool approved) external;
+
+    function setURI(string memory newURI) external;
+
+    function starCount() external view returns (uint256);
+
+    function supportsInterface(bytes4 interfaceId) external view returns (bool);
+
+    function transferOwnership(address newOwner) external;
+
+    function uri(uint256 id) external view returns (string memory);
+}

package/contracts/router/swap-aggregator/PendleSwap.sol

@@ -4,7 +4,7 @@ pragma solidity 0.8.17;
 import "../../core/libraries/TokenHelper.sol";
 import "./IPSwapAggregator.sol";
 import "./kyberswap/KyberInputScalingHelper.sol";
-import "./1inch/OneInchAggregationRouterHelper.sol";
+import "./oneinch/OneInchAggregationRouterHelper.sol";
 
 contract PendleSwap is IPSwapAggregator, TokenHelper, KyberInputScalingHelper, OneInchAggregationRouterHelper {
     using Address for address;

package/deployments/1-markets/BALANCER-LP-AURA-ETHX-BBAWETH-SEP-26-2024.json

@@ -0,0 +1,12 @@
+{
+    "name": "SY ETHx-BbAWeth_BalancerLP Aura",
+    "symbol": "SY-ETHx-BbAWeth_BalancerLP Aura",
+    "doCacheIndex": true,
+    "expiry": 1727308800,
+    "scalarRoot": "43572533013000000000",
+    "initialRateAnchor": "1059268791000000000",
+    "SY": "0xbA72de8B5B56552e537994DddFe82e7ce43409f5",
+    "PT": "0x880cC97A7222C6b7Ed77232143a220fd2dcB3004",
+    "YT": "0x2C4413364623d6AC247E0AF629cEC8ACc596f646",
+    "market": "0xC112B12aDDc11f988AbC1AAfb47e4C2F62fb6070"
+}

package/deployments/5000-core.json

@@ -0,0 +1,30 @@
+{
+    "deployer": "0x1FcCC097db89A86Bfc474A1028F93958295b1Fb7",
+    "network": {
+        "chainId": 5000,
+        "treasury": "0x5C30d3578A4D07a340650a76B9Ae5dF20D5bdF55",
+        "governance": "0x9F72a06084EdD040E973C32Bf026b1ACf65db9aB",
+        "pendle": "0xd27B18915e7acc8FD6Ac75DB6766a80f8D2f5729",
+        "lzEndpoint": "0xb6319cC6c8c27A8F5dAF0dD3DF91EA35C4720dd7",
+        "wrappedNative": "0x78c1b0c915c4faa5fffa6cabf0219da63d7f4cb8",
+        "initialRewardFee": "30000000000000000",
+        "initialInterestFee": "30000000000000000",
+        "initialFeeRateRoot": "999500333083533",
+        "initialReserveFeePercent": "80",
+        "safeWaitTime": 15000,
+        "sySwapper": ""
+    },
+    "baseCodeSplitter": "0x872c9d71a5B64A9611b08F0956A3cc3deB77A317",
+    "PENDLE": "0xd27B18915e7acc8FD6Ac75DB6766a80f8D2f5729",
+    "yieldContractFactory": "0x1e9FF49352E7155D0AF658fd88a1B3d44ed60B20",
+    "marketFactory": "0x5E9a7E1A15ab0eAaBD2D78fa36A87158752A1346",
+    "router": "0xFc7A495389cD3454f5cC0Ecaa55D30E343A1Fc16",
+    "routerStatic": "0x3B5ae552310638a69863f6E348B41912deFA0e3f",
+    "pendleSwap": "0x9d9874e867b877dD0a3F1EafB8bb1Bc54eeCc682",
+    "routerHelper": "0x09D65812dCD0f276e052583d41885cA5C7Dd0086",
+    "ptOracle": "0x9D6d509C0354ACA187aAC6beA7d063D3Ef68e2A0",
+    "externalRewardDistributor": "0xB4205a645c7e920BD8504181B1D7f2c5C955C3e7",
+    "receiverEndpoint": "0x96F77F24b3d17166FcaF3a9E3B8330fF38B966F9",
+    "vePendle": "0xaA7495dcbe99A8dbd0cfA8b27b95f77565a077c8",
+    "gaugeController": "0x921b10Eb4F4a2afDD1fCD0514022D18faf32fDbF"
+}

package/deployments/5000-markets/WSTETH-MANTLE-MARCH2024.json

@@ -0,0 +1,10 @@
+{
+    "name": "SY wstETH",
+    "SY": "0xeC030Ca1A8bc0084271d5CC3E0bd3184B1DDFC27",
+    "YT": "0x6B212804b510c1140d8a968888F0B3b8b2FB71E0",
+    "PT": "0xbFDc43Fd918586673f308D898f10e9B87dc8dB5B",
+    "market": "0xf6936e20859fc2085544852c65787f8870AE8dFa",
+    "expiry": 1711584000,
+    "scalarRoot": "197848855033000000000",
+    "initAnchor": "1025391787000000000"
+}