@pendle/core-v2 2.3.2-mainnet → 2.5.0-mainnet

package/build/artifacts/contracts/router/swap-aggregator/kyberswap/ethereum/KyberHelperEthereum.sol/KyberHelperEthereum.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../../../build-info/92d54f9b76a0207ec4375fc6c12319a9.json"
+  "buildInfo": "../../../../../../build-info/c3489c617a6ecbf681f91df4f40237bf.json"
 }

package/build/artifacts/contracts/router/swap-aggregator/kyberswap/ethereum/ScaleDataHelperEthereum.sol/ScaleDataHelperEthereum.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../../../build-info/92d54f9b76a0207ec4375fc6c12319a9.json"
+  "buildInfo": "../../../../../../build-info/c3489c617a6ecbf681f91df4f40237bf.json"
 }

package/contracts/core/StandardizedYield/implementations/PendleStargateLPSY.sol

@@ -0,0 +1,222 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../SYBaseWithRewards.sol";
+import "../../../interfaces/IStargateRouter.sol";
+import "../../../interfaces/IStargateLP.sol";
+import "../../../interfaces/IStargateStaking.sol";
+
+contract PendleStargateLPSY is SYBaseWithRewards {
+    uint256 public constant STARGATE_BP_DENOMINATOR = 10000;
+
+    using Math for uint256;
+
+    uint16 public immutable pid; // pool id
+    uint256 public immutable sid; // staking id
+    address public immutable lp;
+    address public immutable underlying;
+    address public immutable stargateRouter;
+    address public immutable stargateStaking;
+    address public immutable stgToken;
+
+    // preview variables
+    uint256 public immutable convertRate;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _stargateLP,
+        address _stargateStaking,
+        uint256 _sid
+    ) SYBaseWithRewards(_name, _symbol, _stargateLP) {
+        lp = _stargateLP;
+        underlying = IStargateLP(lp).token();
+
+        stargateRouter = IStargateLP(lp).router();
+        pid = uint16(IStargateLP(lp).poolId());
+
+        stargateStaking = _stargateStaking;
+        sid = _sid;
+
+        stgToken = IStargateStaking(stargateStaking).stargate();
+
+        // preview variables
+        convertRate = IStargateLP(lp).convertRate();
+
+        _safeApproveInf(underlying, stargateRouter);
+        _safeApproveInf(lp, stargateStaking);
+
+        _validateStargateStakingId(stargateStaking, sid, lp);
+    }
+
+    function _validateStargateStakingId(
+        address staking,
+        uint256 id,
+        address lpToken
+    ) internal view {
+        (address _lpToken, , , ) = IStargateStaking(staking).poolInfo(id);
+        // Custom error not needed here since this only happens on deployment
+        require(_lpToken == lpToken, "invalid sid & lpToken");
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * The underlying yield token is startgateLP. If the base token deposited is underlying, the function
+     * deposits received underlying into the startgateLP contract.
+     */
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 amountSharesOut) {
+        if (tokenIn == underlying) {
+            IStargateRouter(stargateRouter).addLiquidity(pid, amountDeposited, address(this));
+            amountSharesOut = _selfBalance(lp);
+            // all outstanding LP will be staked
+        } else {
+            amountSharesOut = amountDeposited;
+        }
+        IStargateStaking(stargateStaking).deposit(sid, amountSharesOut);
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 amountTokenOut) {
+        IStargateStaking(stargateStaking).withdraw(sid, amountSharesToRedeem);
+        if (tokenOut == lp) {
+            amountTokenOut = amountSharesToRedeem;
+            _transferOut(lp, receiver, amountTokenOut);
+        } else {
+            /**
+             * @dev There is an lp cap variable in stargate to define the maximum amount of lp
+             * which can be burned.
+             * In case there is not enough liquidity in the pool to proceed the withdrawal,
+             * stargatePool will not revert and try to withdraw as much lp as it can instead.
+             *
+             * When this rare case happens, Pendle's SY should guarantee to revert.
+             */
+
+            uint256 preBalanceLp = _selfBalance(lp);
+
+            uint256 amountSD = IStargateRouter(stargateRouter).instantRedeemLocal(
+                pid,
+                amountSharesToRedeem,
+                receiver
+            );
+            uint256 lpUsed = preBalanceLp - _selfBalance(lp);
+            if (lpUsed < amountSharesToRedeem) {
+                revert Errors.SYStargateRedeemCapExceeded(amountSharesToRedeem, lpUsed);
+            }
+
+            amountTokenOut = amountSD * convertRate;
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @notice Calculates and updates the exchange rate of shares to underlying asset token
+     * @dev It is the exchange rate of lp to underlying
+     */
+    function exchangeRate() public view virtual override returns (uint256) {
+        return
+            IStargateLP(lp).totalLiquidity().divDown(IStargateLP(lp).totalSupply()) * convertRate;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {IStandardizedYield-getRewardTokens}
+     */
+    function _getRewardTokens() internal view override returns (address[] memory res) {
+        res = new address[](1);
+        res[0] = stgToken;
+    }
+
+    function _redeemExternalReward() internal override {
+        IStargateStaking(stargateStaking).withdraw(sid, 0);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 amountSharesOut) {
+        if (tokenIn == lp) {
+            amountSharesOut = amountTokenToDeposit;
+        } else {
+            uint256 totalLiquidity = IStargateLP(lp).totalLiquidity();
+            uint256 totalSupply = IStargateLP(lp).totalSupply();
+            uint256 mintFeeBP = IStargateLP(lp).mintFeeBP();
+
+            uint256 amountSD = amountTokenToDeposit / convertRate;
+
+            // Tho fee is always enabled, it is currently set to zero
+            uint256 mintFeeSD = (amountSD * mintFeeBP) / STARGATE_BP_DENOMINATOR;
+            amountSD = amountSD - mintFeeSD;
+
+            // skip check for lp.totalSupply() == 0
+            amountSharesOut = (amountSD * totalSupply) / totalLiquidity;
+        }
+    }
+
+    function _previewRedeem(
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal view override returns (uint256 amountTokenOut) {
+        if (tokenOut == lp) {
+            amountTokenOut = amountSharesToRedeem;
+        } else {
+            uint256 totalLiquidity = IStargateLP(lp).totalLiquidity();
+            uint256 totalSupply = IStargateLP(lp).totalSupply();
+            uint256 deltaCredit = IStargateLP(lp).deltaCredit();
+
+            uint256 capAmountLp = (deltaCredit * totalSupply) / totalLiquidity;
+            if (amountSharesToRedeem > capAmountLp) {
+                revert Errors.SYStargateRedeemCapExceeded(amountSharesToRedeem, capAmountLp);
+            }
+
+            uint256 amountSD = (amountSharesToRedeem * totalLiquidity) / totalSupply;
+            amountTokenOut = amountSD * convertRate;
+        }
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = underlying;
+        res[1] = lp;
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = underlying;
+        res[1] = lp;
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == underlying || token == lp;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == underlying || token == lp;
+    }
+
+    function assetInfo()
+        external
+        view
+        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
+    {
+        return (AssetType.TOKEN, underlying, IERC20Metadata(underlying).decimals());
+    }
+}

package/contracts/core/libraries/Errors.sol

@@ -114,6 +114,8 @@ library Errors {
     error SYBalancerInvalidPid();
     error SYInvalidRewardToken(address token);
 
+    error SYStargateRedeemCapExceeded(uint256 amountLpDesired, uint256 amountLpRedeemable);
+
     // Liquidity Mining
     error VCInactivePool(address pool);
     error VCPoolAlreadyActive(address pool);

package/contracts/interfaces/{IStargatePool.sol → IStargateLP.sol}

@@ -22,7 +22,9 @@
  */
 pragma solidity 0.8.17;
 
-interface IStargatePool {
+interface IStargateLP {
+
+
     struct SwapObj {
         uint256 amount;
         uint256 eqFee;
@@ -45,5 +47,16 @@ interface IStargatePool {
 
     function token() external view returns (address);
 
+    function router() external view returns (address);
+
+    function totalSupply() external view returns (uint256);
+
     function totalLiquidity() external view returns (uint256);
+
+    function mintFeeBP() external view returns (uint256);
+
+    function convertRate() external view returns (uint256);
+
+    function deltaCredit() external view returns (uint256);
+
 }

package/contracts/interfaces/{IStargateLPStaking.sol → IStargateStaking.sol}

@@ -22,7 +22,7 @@
  */
 pragma solidity 0.8.17;
 
-interface IStargateLPStaking {
+interface IStargateStaking {
     struct PoolInfo {
         address lpToken; // Address of LP token contract.
         uint256 allocPoint; // How many allocation points assigned to this pool. STGs to distribute per block.
@@ -41,7 +41,7 @@ interface IStargateLPStaking {
 
     function withdraw(uint256 _pid, uint256 _amount) external;
 
-    function poolInfo(uint256 _pid) external view returns (PoolInfo memory);
+    function poolInfo(uint256 _pid) external view returns (address, uint256, uint256, uint256);
 
     function userInfo(uint256 _pid, address _user) external view returns (UserInfo memory);
 }

package/deployments/1-core.json

@@ -22,10 +22,11 @@
     "bulkSellerOffchain": "0x9ACc60F915dFcd190D270fc92567aE71776bd320",
     "router": "0x0000000001e4ef00d069e71d6ba041b0a16f7ea0",
     "routerStatic": "0x263833d47eA3fA4a30f269323aba6a107f9eB14C",
-    "pendleSwap": "0x2065e12735D678B23eC926603180c96623d5af41",
+    "pendleSwap": "0x38812C3AC3563Bf200482ac9D096952D7cB55f9b",
     "vePendle": "0x4f30A9D41B80ecC5B94306AB4364951AE3170210",
     "senderEndpoint": "0x07b1014c88f14C9E910092526db57A20052E989F",
     "votingController": "0x44087E105137a5095c008AaB6a6530182821F2F0",
     "gaugeController": "0x47D74516B33eD5D70ddE7119A40839f6Fcc24e57",
-    "feeDistributor": "0xd7b34a6fDCb2A7ceD2115FF7f5fdD72aa6aA4dE2"
+    "feeDistributor": "0xd7b34a6fDCb2A7ceD2115FF7f5fdD72aa6aA4dE2",
+    "routerHelper": "0xeb984195D54Df02BaF757e21B0705032FaEFde2E"
 }

package/deployments/1-markets/STARGATE-USDT-27JUNE2024-ETHEREUM.json

@@ -0,0 +1,10 @@
+{
+    "name": "SY Stargate USDT",
+    "SY": "0x3025680925349c9C01c0F01cf300EC963832ec64",
+    "YT": "0x9Ba9D392bE8b4CA159b1934E531D13Ad66dA023C",
+    "PT": "0x9014F29610E904c8269726c74ebc79f5d512DAfD",
+    "market": "0x30e0dC9a1D33EAc83211a1113de238b3Ce826950",
+    "expiry": 1719446400,
+    "scalarRoot": "57668010000000000000",
+    "initAnchor": "1079801000000000000"
+}

package/deployments/1-markets/STETH-26DEC2024.json

@@ -0,0 +1,10 @@
+{
+    "name": "SY stETH",
+    "SY": "0xcbC72d92b2dc8187414F6734718563898740C0BC",
+    "YT": "0xc3863CCcd012f8E45D72Ec87c5A9C4F77e1C7549",
+    "PT": "0x7758896b6AC966BbABcf143eFA963030f17D3EdF",
+    "market": "0xD0354D4e7bCf345fB117cabe41aCaDb724eccCa2",
+    "expiry": 1735171200,
+    "scalarRoot": "76568950000000000000",
+    "initAnchor": "1104003000000000000"
+}

package/deployments/42161-core.json

@@ -19,8 +19,9 @@
     "marketFactory": "0xf5a7De2D276dbda3EEf1b62A9E718EFf4d29dDC8",
     "router": "0x0000000001e4ef00d069e71d6ba041b0a16f7ea0",
     "routerStatic": "0xAdB09F65bd90d19e3148D9ccb693F3161C6DB3E8",
-    "pendleSwap": "0x4546FF0fbc6fb29916Ca56b4F95744B0b356112C",
+    "pendleSwap": "0xDa78D46C4133EA548386e64eaca26FC456F71D2d",
     "receiverEndpoint": "0xC9215ae9EC67385F38C755D862C8eE3702B5793A",
     "vePendle": "0x3209E9412cca80B18338f2a56ADA59c484c39644",
-    "gaugeController": "0x1e56299ebc8a1010cec26005d12e3e5c5cc2db00"
+    "gaugeController": "0x1e56299ebc8a1010cec26005d12e3e5c5cc2db00",
+    "routerHelper": "0xeb984195D54Df02BaF757e21B0705032FaEFde2E"
 }

package/deployments/42161-markets/STARGATE-USDT-27JUNE2024-ARBITRUM.json

@@ -0,0 +1,10 @@
+{
+    "name": "SY Stargate USDT",
+    "SY": "0x068DEf65B9dbAFf02b4ee54572a9Fa7dFb188EA3",
+    "YT": "0x0AdEd315d2e51F676a2Aa8d2bc6A79C88e0F1c1a",
+    "PT": "0x7D180a4f451FC15B543B5d1Ba7dDa6b3014A4c49",
+    "market": "0x0A21291A184cf36aD3B0a0def4A17C12Cbd66A14",
+    "expiry": 1719446400,
+    "scalarRoot": "55429700000000000000",
+    "initAnchor": "1081744000000000000"
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "2.3.2-mainnet",
+  "version": "2.5.0-mainnet",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",

package/typechain-types/IChainlinkAggregator.ts

@@ -0,0 +1,246 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
+import { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+} from "./common";
+
+export interface IChainlinkAggregatorInterface extends utils.Interface {
+  contractName: "IChainlinkAggregator";
+  functions: {
+    "decimals()": FunctionFragment;
+    "getAnswer(uint256)": FunctionFragment;
+    "getTimestamp(uint256)": FunctionFragment;
+    "latestAnswer()": FunctionFragment;
+    "latestRound()": FunctionFragment;
+    "latestTimestamp()": FunctionFragment;
+  };
+
+  encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "getAnswer",
+    values: [BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getTimestamp",
+    values: [BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "latestAnswer",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "latestRound",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "latestTimestamp",
+    values?: undefined
+  ): string;
+
+  decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "getAnswer", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getTimestamp",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "latestAnswer",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "latestRound",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "latestTimestamp",
+    data: BytesLike
+  ): Result;
+
+  events: {
+    "AnswerUpdated(int256,uint256,uint256)": EventFragment;
+    "NewRound(uint256,address,uint256)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "AnswerUpdated"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "NewRound"): EventFragment;
+}
+
+export type AnswerUpdatedEvent = TypedEvent<
+  [BigNumber, BigNumber, BigNumber],
+  { current: BigNumber; roundId: BigNumber; updatedAt: BigNumber }
+>;
+
+export type AnswerUpdatedEventFilter = TypedEventFilter<AnswerUpdatedEvent>;
+
+export type NewRoundEvent = TypedEvent<
+  [BigNumber, string, BigNumber],
+  { roundId: BigNumber; startedBy: string; startedAt: BigNumber }
+>;
+
+export type NewRoundEventFilter = TypedEventFilter<NewRoundEvent>;
+
+export interface IChainlinkAggregator extends BaseContract {
+  contractName: "IChainlinkAggregator";
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IChainlinkAggregatorInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    decimals(overrides?: CallOverrides): Promise<[number]>;
+
+    getAnswer(
+      roundId: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    getTimestamp(
+      roundId: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    latestAnswer(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    latestRound(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    latestTimestamp(overrides?: CallOverrides): Promise<[BigNumber]>;
+  };
+
+  decimals(overrides?: CallOverrides): Promise<number>;
+
+  getAnswer(
+    roundId: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  getTimestamp(
+    roundId: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  latestAnswer(overrides?: CallOverrides): Promise<BigNumber>;
+
+  latestRound(overrides?: CallOverrides): Promise<BigNumber>;
+
+  latestTimestamp(overrides?: CallOverrides): Promise<BigNumber>;
+
+  callStatic: {
+    decimals(overrides?: CallOverrides): Promise<number>;
+
+    getAnswer(
+      roundId: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getTimestamp(
+      roundId: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    latestAnswer(overrides?: CallOverrides): Promise<BigNumber>;
+
+    latestRound(overrides?: CallOverrides): Promise<BigNumber>;
+
+    latestTimestamp(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  filters: {
+    "AnswerUpdated(int256,uint256,uint256)"(
+      current?: BigNumberish | null,
+      roundId?: BigNumberish | null,
+      updatedAt?: null
+    ): AnswerUpdatedEventFilter;
+    AnswerUpdated(
+      current?: BigNumberish | null,
+      roundId?: BigNumberish | null,
+      updatedAt?: null
+    ): AnswerUpdatedEventFilter;
+
+    "NewRound(uint256,address,uint256)"(
+      roundId?: BigNumberish | null,
+      startedBy?: string | null,
+      startedAt?: null
+    ): NewRoundEventFilter;
+    NewRound(
+      roundId?: BigNumberish | null,
+      startedBy?: string | null,
+      startedAt?: null
+    ): NewRoundEventFilter;
+  };
+
+  estimateGas: {
+    decimals(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getAnswer(
+      roundId: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getTimestamp(
+      roundId: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    latestAnswer(overrides?: CallOverrides): Promise<BigNumber>;
+
+    latestRound(overrides?: CallOverrides): Promise<BigNumber>;
+
+    latestTimestamp(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    decimals(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    getAnswer(
+      roundId: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getTimestamp(
+      roundId: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    latestAnswer(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    latestRound(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    latestTimestamp(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+  };
+}