@pendle/core-v2 2.23.4-mantle → 2.24.0

package/contracts/core/StandardizedYield/implementations/BalancerStable/AuraSwEthBbAWethSYV2.sol

@@ -0,0 +1,160 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "./base/PendleAuraBalancerStableLPSYV2.sol";
+import "./base/ComposableStable/ComposableStablePreview.sol";
+import "./base/Linear/BbAPoolHelper.sol";
+
+contract AuraSwEthBbAWethSYV2 is PendleAuraBalancerStableLPSYV2, BbAWethHelper {
+    uint256 internal constant AURA_PID = 143;
+    address internal constant LP = 0xaE8535c23afeDdA9304B03c68a3563B75fc8f92b;
+    address internal constant SWETH = 0xf951E335afb289353dc249e82926178EaC7DEd78;
+
+    address internal constant LINEAR_PREVIEW = 0x73187e5b27F2aadD5fFee023d6a9E179365F2ad6;
+    address internal constant COMPOSABLE_PREVIEW = 0x4239Ddd3c50463383670E86c119220849BFaF64a;
+
+    address internal constant _BB_A_WETH = 0xbB6881874825E60e1160416D6C426eae65f2459E;
+    address internal constant _WA_WETH = 0x03928473f25bb2da6Bc880b07eCBaDC636822264;
+    bytes32 internal constant _BB_A_WETH_POOL_ID =
+        0xbb6881874825e60e1160416d6c426eae65f2459e000000000000000000000592;
+
+    bool internal constant NO_TOKENS_EXEMPT = true;
+    bool internal constant ALL_TOKENS_EXEMPT = false;
+
+    constructor(
+        string memory _name,
+        string memory _symbol
+    )
+        BbAWethHelper(LinearPreview(LINEAR_PREVIEW), _BB_A_WETH, _BB_A_WETH_POOL_ID, _WA_WETH)
+        PendleAuraBalancerStableLPSYV2(
+            _name,
+            _symbol,
+            LP,
+            AURA_PID,
+            ComposableStablePreview(COMPOSABLE_PREVIEW)
+        )
+    //solhint-disable-next-line
+    {
+
+    }
+
+    function _deposit(
+        address tokenIn,
+        uint256 amount
+    ) internal override returns (uint256 amountSharesOut) {
+        if (tokenIn == NATIVE || tokenIn == WETH || tokenIn == WA_WETH) {
+            uint256 amountBbAWeth = _depositBbAWeth(tokenIn, amount);
+            amountSharesOut = super._deposit(BB_A_WETH, amountBbAWeth);
+        } else {
+            amountSharesOut = super._deposit(tokenIn, amount);
+        }
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal override returns (uint256 amountTokenOut) {
+        if (tokenOut == NATIVE || tokenOut == WETH || tokenOut == WA_WETH) {
+            uint256 amountBbAWeth = super._redeem(address(this), BB_A_WETH, amountSharesToRedeem);
+            amountTokenOut = _redeemBbAWeth(receiver, tokenOut, amountBbAWeth);
+        } else {
+            return super._redeem(receiver, tokenOut, amountSharesToRedeem);
+        }
+    }
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 amountSharesOut) {
+        if (tokenIn == NATIVE || tokenIn == WETH || tokenIn == WA_WETH) {
+            uint256 amountBbAWeth = _previewDepositBbAWeth(tokenIn, amountTokenToDeposit);
+            amountSharesOut = super._previewDeposit(BB_A_WETH, amountBbAWeth);
+        } else {
+            amountSharesOut = super._previewDeposit(tokenIn, amountTokenToDeposit);
+        }
+    }
+
+    function _previewRedeem(
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal view override returns (uint256 amountTokenOut) {
+        if (tokenOut == NATIVE || tokenOut == WETH || tokenOut == WA_WETH) {
+            uint256 amountBbAWeth = super._previewRedeem(BB_A_WETH, amountSharesToRedeem);
+            amountTokenOut = _previewRedeemBbAWeth(tokenOut, amountBbAWeth);
+        } else {
+            return super._previewRedeem(tokenOut, amountSharesToRedeem);
+        }
+    }
+
+    function _getImmutablePoolData() internal pure override returns (bytes memory ret) {
+        ComposableStablePreview.ImmutableData memory res;
+        res.poolTokens = _getPoolTokenAddresses();
+        res.rateProviders = _getRateProviders();
+        res.rawScalingFactors = _getRawScalingFactors();
+        res.isExemptFromYieldProtocolFee = _getExemption();
+        res.LP = LP;
+        res.noTokensExempt = NO_TOKENS_EXEMPT;
+        res.allTokensExempt = ALL_TOKENS_EXEMPT;
+        res.bptIndex = _getBPTIndex();
+        res.totalTokens = res.poolTokens.length;
+
+        return abi.encode(res);
+    }
+
+    //  --------------------------------- POOL CONSTANTS ---------------------------------
+    function _getPoolTokenAddresses() internal pure override returns (address[] memory res) {
+        res = new address[](3);
+        res[0] = LP;
+        res[1] = _BB_A_WETH;
+        res[2] = SWETH;
+    }
+
+    function _getBPTIndex() internal pure override returns (uint256) {
+        return 0;
+    }
+
+    function _getRateProviders() internal pure returns (address[] memory res) {
+        res = new address[](3);
+        res[0] = 0x0000000000000000000000000000000000000000;
+        res[1] = 0xbB6881874825E60e1160416D6C426eae65f2459E;
+        res[2] = 0xf951E335afb289353dc249e82926178EaC7DEd78;
+    }
+
+    function _getRawScalingFactors() internal pure returns (uint256[] memory res) {
+        res = new uint256[](3);
+        res[0] = res[1] = res[2] = 1e18;
+    }
+
+    function _getExemption() internal pure returns (bool[] memory res) {
+        res = new bool[](3);
+        res[0] = res[1] = res[2] = false;
+    }
+
+    function getTokensIn() public view override returns (address[] memory res) {
+        res = new address[](6);
+        res[0] = NATIVE;
+        res[1] = WETH;
+        res[2] = WA_WETH;
+        res[3] = BB_A_WETH;
+        res[4] = SWETH;
+        res[5] = LP;
+    }
+
+    function getTokensOut() public view override returns (address[] memory res) {
+        return getTokensIn();
+    }
+
+    function isValidTokenIn(address token) public view override returns (bool) {
+        return (token == NATIVE ||
+            token == WETH ||
+            token == WA_WETH ||
+            token == BB_A_WETH ||
+            token == SWETH ||
+            token == LP);
+    }
+
+    function isValidTokenOut(address token) public view override returns (bool) {
+        return isValidTokenIn(token);
+    }
+}

package/deployments/core.ts

@@ -0,0 +1,29 @@
+import ethCoreJSON from './1-core.json';
+
+export interface PendleCore {
+    PENDLE: string;
+    yieldContractFactory: string;
+    marketFactory: string;
+    bulkSellerFactory: string;
+    bulkSellerOffchain: string;
+    router: string;
+    routerStatic: string;
+    vePendle: string;
+    gaugeController: string;
+}
+
+export interface PendleCoreMainchain extends PendleCore {
+    senderEndpoint: string;
+    votingController: string;
+    feeDistributor: string;
+}
+
+export interface PendleCoreSidechain extends PendleCore {
+    receiverEndpoint: string;
+}
+
+const ethCore: PendleCoreMainchain = ethCoreJSON;
+
+export const pendleCore = {
+    ethereum: ethCore,
+};

package/deployments/index.ts

@@ -0,0 +1,4 @@
+export * from './core';
+export * from './markets';
+export * from './misc';
+export * from '../typechain-types';

package/deployments/markets/ape-june-29-2023.ts

@@ -0,0 +1,3 @@
+import { MarketDeployment } from './types';
+import marketApeJune292022JSON from '../1-markets/APE-JUNE-29.json';
+export const apeJune292022: MarketDeployment = marketApeJune292022JSON;

package/deployments/markets/balancer-reth-dec-28-2023.ts

@@ -0,0 +1,3 @@
+import { MarketDeployment } from './types';
+import marketBalancerRethDec282023JSON from '../1-markets/BALANCER-LP-AURA-RETH-WETH-28DEC.json';
+export const balancerRethDec282023: MarketDeployment = marketBalancerRethDec282023JSON;

package/deployments/markets/balancer-wsteth-jun-27-2024.ts

@@ -0,0 +1,3 @@
+import { MarketDeployment } from './types';
+import marketBalancerWstEthJun272024JSON from '../1-markets/BALANCER-LP-AURA-WSTETH-WETH-JUN272024.json';
+export const balancerWstEthJun272024: MarketDeployment = marketBalancerWstEthJun272024JSON;

package/deployments/markets/curve-fraxusdc-march-30-2023.ts

@@ -0,0 +1,3 @@
+import { MarketDeployment } from './types';
+import marketCurveFraxUsdcMarch302023JSON from '../1-markets/FRAXUSDC-CURVELP-MARCH30.json';
+export const curveFraxUsdcMarch302023: MarketDeployment = marketCurveFraxUsdcMarch302023JSON;

package/deployments/markets/index.ts

@@ -0,0 +1,17 @@
+import { apeJune292022 } from './ape-june-29-2023';
+import { balancerRethDec282023 } from './balancer-reth-dec-28-2023';
+import { balancerWstEthJun272024 } from './balancer-wsteth-jun-27-2024';
+import { curveFraxUsdcMarch302023 } from './curve-fraxusdc-march-30-2023';
+import { looksMarch302023 } from './looks-march-30-2023';
+import { stEthJune292023 } from './steth-june-29-2023';
+import { stEthMarch302023 } from './steth-march-30-2023';
+
+export const markets = {
+    apeJune292022,
+    balancerRethDec282023,
+    balancerWstEthJun272024,
+    curveFraxUsdcMarch302023,
+    looksMarch302023,
+    stEthJune292023,
+    stEthMarch302023,
+};

package/deployments/markets/looks-march-30-2023.ts

@@ -0,0 +1,3 @@
+import { MarketDeployment } from './types';
+import marketLooksMarch302023JSON from '../1-markets/LOOKS-STAKING-MARCH30.json';
+export const looksMarch302023: MarketDeployment = marketLooksMarch302023JSON;

package/deployments/markets/steth-june-29-2023.ts

@@ -0,0 +1,3 @@
+import { MarketDeployment } from './types';
+import marketStEthJune292023JSON from '../1-markets/STETH-JUNE29.json';
+export const stEthJune292023: MarketDeployment = marketStEthJune292023JSON;

package/deployments/markets/steth-march-30-2023.ts

@@ -0,0 +1,3 @@
+import { MarketDeployment } from './types';
+import marketStEthMarch302023JSON from '../1-markets/STETH-MARCH30.json';
+export const stEthMarch302023: MarketDeployment = marketStEthMarch302023JSON;

package/deployments/markets/types.ts

@@ -0,0 +1,9 @@
+export interface MarketDeployment {
+    name: string;
+    SY: string;
+    YT: string;
+    PT: string;
+    market: string;
+    expiry: number;
+    bulkSeller?: string;
+}

package/deployments/misc.ts

@@ -0,0 +1,23 @@
+import { BigNumber as BN, utils } from 'ethers';
+
+export const MISC_CONSTS = {
+    RONE: BN.from(2).pow(40),
+    ONE_E_12: BN.from(10).pow(12),
+    ONE_E_18: BN.from(10).pow(18),
+    INF: BN.from(2).pow(256).sub(1),
+    ZERO_BYTES: utils.formatBytes32String(''),
+    ZERO_ADDRESS: '0x0000000000000000000000000000000000000000',
+    DUMMY_ADDRESS: '0xDEADbeEfEEeEEEeEEEeEEeeeeeEeEEeeeeEEEEeE',
+    ONE_HOUR: BN.from(3600),
+    ONE_DAY: BN.from(86400),
+    ONE_WEEK: BN.from(86400 * 7),
+    FIFTEEN_DAY: BN.from(86400 * 15),
+    ONE_MONTH: BN.from(2592000),
+    THREE_MONTH: BN.from(2592000 * 3),
+    FIVE_MONTH: BN.from(2592000 * 5),
+    SIX_MONTH: BN.from(2592000 * 6),
+    ONE_QUARTER: BN.from(7884000),
+    ONE_YEAR: BN.from(31536000),
+    END_OF_2023: BN.from(1703721600),
+    JUNE_OF_2022: BN.from(1656547200),
+};

package/package.json

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

package/typechain-types/AutomateReady.ts

@@ -0,0 +1,102 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import {
+  BaseContract,
+  BigNumber,
+  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 AutomateReadyInterface extends utils.Interface {
+  contractName: "AutomateReady";
+  functions: {
+    "automate()": FunctionFragment;
+    "dedicatedMsgSender()": FunctionFragment;
+  };
+
+  encodeFunctionData(functionFragment: "automate", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "dedicatedMsgSender",
+    values?: undefined
+  ): string;
+
+  decodeFunctionResult(functionFragment: "automate", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "dedicatedMsgSender",
+    data: BytesLike
+  ): Result;
+
+  events: {};
+}
+
+export interface AutomateReady extends BaseContract {
+  contractName: "AutomateReady";
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: AutomateReadyInterface;
+
+  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: {
+    automate(overrides?: CallOverrides): Promise<[string]>;
+
+    dedicatedMsgSender(overrides?: CallOverrides): Promise<[string]>;
+  };
+
+  automate(overrides?: CallOverrides): Promise<string>;
+
+  dedicatedMsgSender(overrides?: CallOverrides): Promise<string>;
+
+  callStatic: {
+    automate(overrides?: CallOverrides): Promise<string>;
+
+    dedicatedMsgSender(overrides?: CallOverrides): Promise<string>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    automate(overrides?: CallOverrides): Promise<BigNumber>;
+
+    dedicatedMsgSender(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    automate(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    dedicatedMsgSender(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+  };
+}

package/typechain-types/AutomationBase.ts

@@ -0,0 +1,57 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import { BaseContract, Signer, utils } from "ethers";
+
+import { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+} from "./common";
+
+export interface AutomationBaseInterface extends utils.Interface {
+  contractName: "AutomationBase";
+  functions: {};
+
+  events: {};
+}
+
+export interface AutomationBase extends BaseContract {
+  contractName: "AutomationBase";
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: AutomationBaseInterface;
+
+  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: {};
+
+  estimateGas: {};
+
+  populateTransaction: {};
+}

package/typechain-types/AutomationCompatible.ts

@@ -0,0 +1,140 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import {
+  BaseContract,
+  BigNumber,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  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 AutomationCompatibleInterface extends utils.Interface {
+  contractName: "AutomationCompatible";
+  functions: {
+    "checkUpkeep(bytes)": FunctionFragment;
+    "performUpkeep(bytes)": FunctionFragment;
+  };
+
+  encodeFunctionData(
+    functionFragment: "checkUpkeep",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "performUpkeep",
+    values: [BytesLike]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "checkUpkeep",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "performUpkeep",
+    data: BytesLike
+  ): Result;
+
+  events: {};
+}
+
+export interface AutomationCompatible extends BaseContract {
+  contractName: "AutomationCompatible";
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: AutomationCompatibleInterface;
+
+  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: {
+    checkUpkeep(
+      checkData: BytesLike,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    performUpkeep(
+      performData: BytesLike,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  checkUpkeep(
+    checkData: BytesLike,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  performUpkeep(
+    performData: BytesLike,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    checkUpkeep(
+      checkData: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<
+      [boolean, string] & { upkeepNeeded: boolean; performData: string }
+    >;
+
+    performUpkeep(
+      performData: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<void>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    checkUpkeep(
+      checkData: BytesLike,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    performUpkeep(
+      performData: BytesLike,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    checkUpkeep(
+      checkData: BytesLike,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    performUpkeep(
+      performData: BytesLike,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+  };
+}