@pendle/core-v2 5.1.1 → 5.2.0-beta-1

package/contracts/oracles/factory/PendleChainlinkOracleBase.sol

@@ -0,0 +1,138 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../interfaces/IPChainlinkOracle.sol";
+import "../PendleLpOracleLib.sol";
+
+/**
+ * @dev The round data returned from this contract will follow:
+ * - There will be only one round (roundId=0)
+ * - startedAt=0, updatedAt=block.timestamp
+ */
+abstract contract PendleChainlinkOracleBase is IPChainlinkOracle {
+    using PendlePYOracleLib for IPMarket;
+    using PendleLpOracleLib for IPMarket;
+
+    error InvalidRoundId();
+
+    uint8 internal constant LP_DECIMALS = 18;
+
+    // solhint-disable immutable-vars-naming
+    address public immutable factory;
+    address public immutable market;
+    uint16 public immutable twapDuration;
+
+    uint8 public immutable fromTokenDecimals;
+    uint8 public immutable toTokenDecimals;
+
+    PendleOracleType public immutable baseOracleType;
+
+    function(IPMarket, uint32) internal view returns (uint256) internal immutable getRate;
+
+    modifier validateRoundId(uint80 roundId) {
+        if (roundId != 0) {
+            revert InvalidRoundId();
+        }
+        _;
+    }
+
+    constructor(address _market, uint16 _twapDuration, PendleOracleType _baseOracleType) {
+        factory = msg.sender;
+        market = _market;
+        twapDuration = _twapDuration;
+        baseOracleType = _baseOracleType;
+        (fromTokenDecimals, toTokenDecimals) = _readDecimals(_market, _baseOracleType);
+        getRate = getMethod();
+    }
+
+    // =================================================================
+    //                          CHAINLINK INTERFACE
+    // =================================================================
+
+    function latestRoundData()
+        public
+        view
+        virtual
+        returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound)
+    {
+        roundId = 0;
+        answer = _getFinalPrice();
+        startedAt = 0;
+        updatedAt = block.timestamp;
+        answeredInRound = 0;
+    }
+
+    function getRoundData(
+        uint80 roundId
+    ) external view validateRoundId(roundId) returns (uint80, int256, uint256, uint256, uint80) {
+        return latestRoundData();
+    }
+
+    function decimals() external pure returns (uint8) {
+        return 18;
+    }
+
+    function description() external pure returns (string memory) {
+        return "Pendle Chainlink-compatible Oracle";
+    }
+
+    function version() external pure returns (uint256) {
+        return 1;
+    }
+
+    // =================================================================
+    //                          PRICING FUNCTIONS
+    // =================================================================
+
+    function _getFinalPrice() internal view virtual returns (int256);
+
+    function _getPendleTokenPrice() internal view returns (int256) {
+        return _descalePrice(getRate(IPMarket(market), twapDuration));
+    }
+
+    function _descalePrice(uint256 price) internal view returns (int256 unwrappedPrice) {
+        unwrappedPrice = PMath.Int((price * (10 ** fromTokenDecimals)) / (10 ** toTokenDecimals));
+    }
+
+    // =================================================================
+    //                          USE ONLY AT INITIALIZATION
+    // =================================================================
+
+    function getMethod() internal view returns (function(IPMarket, uint32) internal view returns (uint256)) {
+        if (baseOracleType == PendleOracleType.PT_TO_SY) {
+            return PendlePYOracleLib.getPtToSyRate;
+        } else if (baseOracleType == PendleOracleType.PT_TO_ASSET) {
+            return PendlePYOracleLib.getPtToAssetRate;
+        } else if (baseOracleType == PendleOracleType.YT_TO_SY) {
+            return PendlePYOracleLib.getYtToSyRate;
+        } else if (baseOracleType == PendleOracleType.YT_TO_ASSET) {
+            return PendlePYOracleLib.getYtToAssetRate;
+        } else if (baseOracleType == PendleOracleType.LP_TO_SY) {
+            return PendleLpOracleLib.getLpToSyRate;
+        } else if (baseOracleType == PendleOracleType.LP_TO_ASSET) {
+            return PendleLpOracleLib.getLpToAssetRate;
+        } else {
+            revert("not supported");
+        }
+    }
+
+    function _readDecimals(
+        address _market,
+        PendleOracleType _oracleType
+    ) internal view returns (uint8 _fromDecimals, uint8 _toDecimals) {
+        (IStandardizedYield SY, , ) = IPMarket(_market).readTokens();
+
+        uint8 syDecimals = SY.decimals();
+        (, , uint8 assetDecimals) = SY.assetInfo();
+
+        if (_oracleType == PendleOracleType.LP_TO_ASSET) {
+            return (LP_DECIMALS, assetDecimals);
+        } else if (_oracleType == PendleOracleType.LP_TO_SY) {
+            return (LP_DECIMALS, syDecimals);
+        } else if (_oracleType == PendleOracleType.PT_TO_ASSET || _oracleType == PendleOracleType.YT_TO_ASSET) {
+            return (assetDecimals, assetDecimals);
+        } else if (_oracleType == PendleOracleType.PT_TO_SY || _oracleType == PendleOracleType.YT_TO_SY) {
+            return (assetDecimals, syDecimals);
+        }
+    }
+}

package/contracts/oracles/factory/PendleChainlinkOracleFactory.sol

@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "./PendleChainlinkOracle.sol";
+import "./PendleChainlinkOracleWithQuote.sol";
+import "../../interfaces/IPChainlinkOracleFactory.sol";
+import "../../interfaces/IPPYLpOracle.sol";
+
+contract PendleChainlinkOracleFactory is IPChainlinkOracleFactory {
+    error OracleAlreadyExists();
+    error OracleNotReady();
+
+    // [keccak256(market, duration, baseOracleType)]
+    mapping(bytes32 oracleId => address oracleAddr) public oracles;
+
+    // [keccak256(market, duration, baseOracleType, quoteOracle)]
+    mapping(bytes32 oracleId => address oracleAddr) public oraclesWithQuote;
+
+    address public immutable pyLpOracle;
+
+    constructor(address _pyLpOracle) {
+        pyLpOracle = _pyLpOracle;
+    }
+
+    function createOracle(
+        address market,
+        uint16 twapDuration,
+        PendleOracleType baseOracleType
+    ) external returns (address oracle) {
+        bytes32 oracleId = _getOracleId(market, twapDuration, baseOracleType);
+        if (oracles[oracleId] != address(0)) revert OracleAlreadyExists();
+
+        _checkOracleState(market, twapDuration);
+
+        oracle = address(new PendleChainlinkOracle(market, twapDuration, baseOracleType));
+        oracles[oracleId] = oracle;
+        emit OracleCreated(market, twapDuration, baseOracleType, oracle, oracleId);
+    }
+
+    function createOracleWithQuote(
+        address market,
+        uint16 twapDuration,
+        PendleOracleType baseOracleType,
+        address quoteOracle
+    ) external returns (address oracle) {
+        bytes32 oracleId = _getOracleWithQuoteId(market, twapDuration, baseOracleType, quoteOracle);
+        if (oraclesWithQuote[oracleId] != address(0)) revert OracleAlreadyExists();
+
+        _checkOracleState(market, twapDuration);
+
+        oracle = address(new PendleChainlinkOracleWithQuote(market, twapDuration, baseOracleType, quoteOracle));
+        oraclesWithQuote[oracleId] = oracle;
+        emit OracleWithQuoteCreated(market, twapDuration, baseOracleType, quoteOracle, oracle, oracleId);
+    }
+
+    function getOracle(
+        address market,
+        uint16 twapDuration,
+        PendleOracleType baseOracleType
+    ) public view returns (address) {
+        return oracles[_getOracleId(market, twapDuration, baseOracleType)];
+    }
+
+    function getOracleWithQuote(
+        address market,
+        uint16 twapDuration,
+        PendleOracleType baseOracleType,
+        address quoteOracle
+    ) public view returns (address) {
+        return oraclesWithQuote[_getOracleWithQuoteId(market, twapDuration, baseOracleType, quoteOracle)];
+    }
+
+    function _getOracleId(
+        address market,
+        uint16 twapDuration,
+        PendleOracleType baseOracleType
+    ) internal pure returns (bytes32) {
+        return keccak256(abi.encode(market, twapDuration, baseOracleType));
+    }
+
+    function _getOracleWithQuoteId(
+        address market,
+        uint16 twapDuration,
+        PendleOracleType baseOracleType,
+        address quoteOracle
+    ) internal pure returns (bytes32) {
+        return keccak256(abi.encode(market, twapDuration, baseOracleType, quoteOracle));
+    }
+
+    function _checkOracleState(address market, uint16 twapDuration) internal view {
+        (bool increaseCardinalityRequired, , bool oldestObservationSatisfied) = IPPYLpOracle(pyLpOracle).getOracleState(
+            market,
+            twapDuration
+        );
+        if (increaseCardinalityRequired || !oldestObservationSatisfied) {
+            revert OracleNotReady();
+        }
+    }
+}

package/contracts/oracles/factory/PendleChainlinkOracleWithQuote.sol

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "./PendleChainlinkOracleBase.sol";
+
+/**
+ * @dev The round data returned from this contract will follow:
+ * - There will be only one round (roundId=0)
+ * - startedAt=0, updatedAt=quoteOracle.updatedAt()
+ */
+contract PendleChainlinkOracleWithQuote is PendleChainlinkOracleBase {
+    // solhint-disable immutable-vars-naming
+    address public immutable quoteOracle;
+    int256 public immutable quoteScale;
+
+    constructor(
+        address _market,
+        uint16 _twapDuration,
+        PendleOracleType _baseOracleType,
+        address _quoteOracle
+    ) PendleChainlinkOracleBase(_market, _twapDuration, _baseOracleType) {
+        quoteOracle = _quoteOracle;
+        quoteScale = PMath.Int(10 ** AggregatorV3Interface(quoteOracle).decimals());
+    }
+
+    function _getFinalPrice() internal view virtual override returns (int256) {
+        (, int256 quoteAnswer, , , ) = AggregatorV3Interface(quoteOracle).latestRoundData();
+        return (_getPendleTokenPrice() * quoteAnswer) / quoteScale;
+    }
+
+    function latestRoundData()
+        public
+        view
+        virtual
+        override
+        returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound)
+    {
+        (, int256 quoteAnswer, , uint256 quoteUpdatedAt, ) = AggregatorV3Interface(quoteOracle).latestRoundData();
+
+        roundId = 0;
+        answer = (_getPendleTokenPrice() * quoteAnswer) / quoteScale;
+        startedAt = 0;
+        updatedAt = quoteUpdatedAt;
+        answeredInRound = 0;
+    }
+}

package/package.json

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

package/typechain-types/IPChainlinkOracle.ts

@@ -0,0 +1,221 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import { FunctionFragment, Result } from "@ethersproject/abi";
+import { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+} from "./common";
+
+export interface IPChainlinkOracleInterface extends utils.Interface {
+  contractName: "IPChainlinkOracle";
+  functions: {
+    "decimals()": FunctionFragment;
+    "description()": FunctionFragment;
+    "getRoundData(uint80)": FunctionFragment;
+    "latestRoundData()": FunctionFragment;
+    "version()": FunctionFragment;
+  };
+
+  encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "description",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRoundData",
+    values: [BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "latestRoundData",
+    values?: undefined
+  ): string;
+  encodeFunctionData(functionFragment: "version", values?: undefined): string;
+
+  decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "description",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoundData",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "latestRoundData",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "version", data: BytesLike): Result;
+
+  events: {};
+}
+
+export interface IPChainlinkOracle extends BaseContract {
+  contractName: "IPChainlinkOracle";
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IPChainlinkOracleInterface;
+
+  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]>;
+
+    description(overrides?: CallOverrides): Promise<[string]>;
+
+    getRoundData(
+      _roundId: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
+        roundId: BigNumber;
+        answer: BigNumber;
+        startedAt: BigNumber;
+        updatedAt: BigNumber;
+        answeredInRound: BigNumber;
+      }
+    >;
+
+    latestRoundData(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
+        roundId: BigNumber;
+        answer: BigNumber;
+        startedAt: BigNumber;
+        updatedAt: BigNumber;
+        answeredInRound: BigNumber;
+      }
+    >;
+
+    version(overrides?: CallOverrides): Promise<[BigNumber]>;
+  };
+
+  decimals(overrides?: CallOverrides): Promise<number>;
+
+  description(overrides?: CallOverrides): Promise<string>;
+
+  getRoundData(
+    _roundId: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
+      roundId: BigNumber;
+      answer: BigNumber;
+      startedAt: BigNumber;
+      updatedAt: BigNumber;
+      answeredInRound: BigNumber;
+    }
+  >;
+
+  latestRoundData(
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
+      roundId: BigNumber;
+      answer: BigNumber;
+      startedAt: BigNumber;
+      updatedAt: BigNumber;
+      answeredInRound: BigNumber;
+    }
+  >;
+
+  version(overrides?: CallOverrides): Promise<BigNumber>;
+
+  callStatic: {
+    decimals(overrides?: CallOverrides): Promise<number>;
+
+    description(overrides?: CallOverrides): Promise<string>;
+
+    getRoundData(
+      _roundId: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
+        roundId: BigNumber;
+        answer: BigNumber;
+        startedAt: BigNumber;
+        updatedAt: BigNumber;
+        answeredInRound: BigNumber;
+      }
+    >;
+
+    latestRoundData(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
+        roundId: BigNumber;
+        answer: BigNumber;
+        startedAt: BigNumber;
+        updatedAt: BigNumber;
+        answeredInRound: BigNumber;
+      }
+    >;
+
+    version(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    decimals(overrides?: CallOverrides): Promise<BigNumber>;
+
+    description(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getRoundData(
+      _roundId: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    latestRoundData(overrides?: CallOverrides): Promise<BigNumber>;
+
+    version(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    decimals(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    description(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    getRoundData(
+      _roundId: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    latestRoundData(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    version(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+  };
+}

package/typechain-types/IPChainlinkOracleFactory.ts

@@ -0,0 +1,123 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import { BaseContract, Signer, utils } from "ethers";
+import { EventFragment } from "@ethersproject/abi";
+import { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+} from "./common";
+
+export interface IPChainlinkOracleFactoryInterface extends utils.Interface {
+  contractName: "IPChainlinkOracleFactory";
+  functions: {};
+
+  events: {
+    "OracleCreated(address,uint16,uint8,address,bytes32)": EventFragment;
+    "OracleWithQuoteCreated(address,uint16,uint8,address,address,bytes32)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "OracleCreated"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "OracleWithQuoteCreated"): EventFragment;
+}
+
+export type OracleCreatedEvent = TypedEvent<
+  [string, number, number, string, string],
+  {
+    market: string;
+    twapDuration: number;
+    baseOracleType: number;
+    oracle: string;
+    oracleId: string;
+  }
+>;
+
+export type OracleCreatedEventFilter = TypedEventFilter<OracleCreatedEvent>;
+
+export type OracleWithQuoteCreatedEvent = TypedEvent<
+  [string, number, number, string, string, string],
+  {
+    market: string;
+    twapDuration: number;
+    baseOracleType: number;
+    quoteOracle: string;
+    oracle: string;
+    oracleId: string;
+  }
+>;
+
+export type OracleWithQuoteCreatedEventFilter =
+  TypedEventFilter<OracleWithQuoteCreatedEvent>;
+
+export interface IPChainlinkOracleFactory extends BaseContract {
+  contractName: "IPChainlinkOracleFactory";
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IPChainlinkOracleFactoryInterface;
+
+  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: {};
+
+  callStatic: {};
+
+  filters: {
+    "OracleCreated(address,uint16,uint8,address,bytes32)"(
+      market?: string | null,
+      twapDuration?: null,
+      baseOracleType?: null,
+      oracle?: string | null,
+      oracleId?: null
+    ): OracleCreatedEventFilter;
+    OracleCreated(
+      market?: string | null,
+      twapDuration?: null,
+      baseOracleType?: null,
+      oracle?: string | null,
+      oracleId?: null
+    ): OracleCreatedEventFilter;
+
+    "OracleWithQuoteCreated(address,uint16,uint8,address,address,bytes32)"(
+      market?: string | null,
+      twapDuration?: null,
+      baseOracleType?: null,
+      quoteOracle?: string | null,
+      oracle?: string | null,
+      oracleId?: null
+    ): OracleWithQuoteCreatedEventFilter;
+    OracleWithQuoteCreated(
+      market?: string | null,
+      twapDuration?: null,
+      baseOracleType?: null,
+      quoteOracle?: string | null,
+      oracle?: string | null,
+      oracleId?: null
+    ): OracleWithQuoteCreatedEventFilter;
+  };
+
+  estimateGas: {};
+
+  populateTransaction: {};
+}