@pendle/core-v2 5.2.2 → 5.2.3-beta

package/contracts/core/StandardizedYield/implementations/Zircuit/PendleZtakeUSDESY.sol

@@ -1,133 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.17;
-
-import "../../SYBaseUpg.sol";
-import "../../../../interfaces/Zircuit/IZircuitZtaking.sol";
-
-contract PendleZtakeUSDESY is SYBaseUpg {
-    // solhint-disable immutable-vars-naming
-    address public immutable zircuitStaking;
-    address public immutable usde;
-
-    // Supply cap might be updated more often than on special occasion. Leave it as normal storage for better conveinence.
-    uint256 public supplyCap;
-
-    event SupplyCapUpdated(uint256 newSupplyCap);
-
-    error SupplyCapExceeded(uint256 totalSupply, uint256 supplyCap);
-
-    constructor(address _zircuitStaking, address _usde) SYBaseUpg(_usde) {
-        _disableInitializers();
-        zircuitStaking = _zircuitStaking;
-        usde = _usde;
-    }
-
-    function initialize(uint256 _initialSupplyCap) external initializer {
-        __SYBaseUpg_init("SY Zircuit Staking USDe", "SY-zs-USDe");
-        _safeApproveInf(usde, zircuitStaking);
-        _updateSupplyCap(_initialSupplyCap);
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                    DEPOSIT/REDEEM USING BASE TOKENS
-    //////////////////////////////////////////////////////////////*/
-
-    function _deposit(address /*tokenIn*/, uint256 amountDeposited) internal virtual override returns (uint256) {
-        IZircuitZtaking(zircuitStaking).depositFor(usde, address(this), amountDeposited);
-        return amountDeposited;
-    }
-
-    function _redeem(
-        address receiver,
-        address /*tokenOut*/,
-        uint256 amountSharesToRedeem
-    ) internal override returns (uint256 /*amountTokenOut*/) {
-        IZircuitZtaking(zircuitStaking).withdraw(usde, amountSharesToRedeem);
-        _transferOut(usde, receiver, amountSharesToRedeem);
-        return amountSharesToRedeem;
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                               EXCHANGE-RATE
-    //////////////////////////////////////////////////////////////*/
-
-    function exchangeRate() public view virtual override returns (uint256) {
-        return PMath.ONE;
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                MISC FUNCTIONS FOR METADATA
-    //////////////////////////////////////////////////////////////*/
-
-    function _previewDeposit(
-        address /*tokenIn*/,
-        uint256 amountTokenToDeposit
-    ) internal view override returns (uint256 /*amountSharesOut*/) {
-        uint256 _newSupply = totalSupply() + amountTokenToDeposit;
-        uint256 _supplyCap = supplyCap;
-
-        if (_newSupply > _supplyCap) {
-            revert SupplyCapExceeded(_newSupply, _supplyCap);
-        }
-
-        return amountTokenToDeposit;
-    }
-
-    function _previewRedeem(
-        address /*tokenOut*/,
-        uint256 amountSharesToRedeem
-    ) internal pure override returns (uint256 /*amountTokenOut*/) {
-        return amountSharesToRedeem;
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                SUPPLY CAP RELATED FUNCTIONS
-    //////////////////////////////////////////////////////////////*/
-
-    function updateSupplyCap(uint256 newSupplyCap) external onlyOwner {
-        _updateSupplyCap(newSupplyCap);
-    }
-
-    function _updateSupplyCap(uint256 newSupplyCap) internal {
-        supplyCap = newSupplyCap;
-        emit SupplyCapUpdated(newSupplyCap);
-    }
-
-    // @dev: whenNotPaused not needed as it has already been added to beforeTransfer
-    function _afterTokenTransfer(address from, address, uint256) internal virtual override {
-        // only check for minting case
-        // saving gas on user->user transfers
-        // skip supply cap checking on burn to allow lowering supply cap
-        if (from != address(0)) {
-            return;
-        }
-
-        uint256 _supply = totalSupply();
-        uint256 _supplyCap = supplyCap;
-        if (_supply > _supplyCap) {
-            revert SupplyCapExceeded(_supply, _supplyCap);
-        }
-    }
-
-    function getTokensIn() public view override returns (address[] memory res) {
-        return ArrayLib.create(usde);
-    }
-
-    function getTokensOut() public view override returns (address[] memory res) {
-        return ArrayLib.create(usde);
-    }
-
-    function isValidTokenIn(address token) public view override returns (bool) {
-        return token == usde;
-    }
-
-    function isValidTokenOut(address token) public view override returns (bool) {
-        return token == usde;
-    }
-
-    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
-        assetType = AssetType.TOKEN;
-        assetAddress = usde;
-        assetDecimals = IERC20Metadata(usde).decimals();
-    }
-}

package/contracts/core/StandardizedYield/implementations/Zircuit/PendleZtakeWeETHSY.sol

@@ -1,111 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.17;
-
-import "../../SYBaseUpg.sol";
-import "../../../../interfaces/EtherFi/IEtherFiWEEth.sol";
-import "../../../../interfaces/Zircuit/IZircuitZtaking.sol";
-import "../../../../interfaces/EtherFi/IEtherFiLiquidityPool.sol";
-
-contract PendleZtakeWeETHSY is SYBaseUpg {
-    using PMath for int256;
-
-    address public immutable zircuitStaking;
-    address public immutable weETH;
-    address public immutable liquidityPool;
-    address public immutable eETH;
-    address public immutable referee;
-
-    constructor(address _zircuitStaking, address _weETH, address _referee) SYBaseUpg(_weETH) {
-        _disableInitializers();
-
-        zircuitStaking = _zircuitStaking;
-        weETH = _weETH;
-        liquidityPool = IEtherFiWEEth(_weETH).liquidityPool();
-        eETH = IEtherFiWEEth(_weETH).eETH();
-        referee = _referee;
-    }
-
-    function initialize() external initializer {
-        __SYBaseUpg_init("SY Zircuit Ether.fi weETH", "SY-zs-weETH");
-        _safeApproveInf(eETH, weETH);
-        _safeApproveInf(weETH, zircuitStaking);
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                    DEPOSIT/REDEEM USING BASE TOKENS
-    //////////////////////////////////////////////////////////////*/
-
-    function _deposit(address tokenIn, uint256 amountDeposited) internal override returns (uint256 amountSharesOut) {
-        if (tokenIn == NATIVE) {
-            IEtherFiLiquidityPool(liquidityPool).deposit{value: amountDeposited}(referee);
-        }
-        if (tokenIn != weETH) {
-            amountSharesOut = IEtherFiWEEth(weETH).wrap(_selfBalance(eETH));
-        } else {
-            amountSharesOut = amountDeposited;
-        }
-        IZircuitZtaking(zircuitStaking).depositFor(weETH, address(this), amountSharesOut);
-    }
-
-    function _redeem(
-        address receiver,
-        address tokenOut,
-        uint256 amountSharesToRedeem
-    ) internal override returns (uint256 amountTokenOut) {
-        IZircuitZtaking(zircuitStaking).withdraw(weETH, amountSharesToRedeem);
-        if (tokenOut == weETH) {
-            amountTokenOut = amountSharesToRedeem;
-        } else {
-            amountTokenOut = IEtherFiWEEth(weETH).unwrap(amountSharesToRedeem);
-        }
-        _transferOut(tokenOut, receiver, amountTokenOut);
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                               EXCHANGE-RATE
-    //////////////////////////////////////////////////////////////*/
-
-    function exchangeRate() public view override returns (uint256) {
-        return IEtherFiLiquidityPool(liquidityPool).amountForShare(1 ether);
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                MISC FUNCTIONS FOR METADATA
-    //////////////////////////////////////////////////////////////*/
-
-    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit) internal view override returns (uint256) {
-        if (tokenIn == weETH) {
-            return amountTokenToDeposit;
-        } else {
-            return IEtherFiLiquidityPool(liquidityPool).sharesForAmount(amountTokenToDeposit);
-        }
-    }
-
-    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem) internal view override returns (uint256) {
-        if (tokenOut == weETH) {
-            return amountSharesToRedeem;
-        } else {
-            return IEtherFiLiquidityPool(liquidityPool).amountForShare(amountSharesToRedeem);
-        }
-    }
-
-    function getTokensIn() public view override returns (address[] memory res) {
-        return ArrayLib.create(weETH, eETH, NATIVE);
-    }
-
-    function getTokensOut() public view override returns (address[] memory res) {
-        return ArrayLib.create(weETH, eETH);
-    }
-
-    function isValidTokenIn(address token) public view override returns (bool) {
-        return token == NATIVE || token == eETH || token == weETH;
-    }
-
-    function isValidTokenOut(address token) public view override returns (bool) {
-        return token == eETH || token == weETH;
-    }
-
-    function assetInfo() external view override returns (AssetType, address, uint8) {
-        return (AssetType.TOKEN, eETH, 18);
-    }
-}

package/contracts/interfaces/AaveV3/IAaveStkGHO.sol

@@ -1,17 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-pragma solidity ^0.8.0;
-
-interface IAaveStkGHO {
-    function stake(address to, uint256 amount) external;
-
-    function redeem(address to, uint256 amount) external;
-
-    function claimRewards(address to, uint256 amount) external;
-
-    function getExchangeRate() external view returns (uint216);
-
-    function previewStake(uint256 assets) external view returns (uint256);
-
-    function previewRedeem(uint256 shares) external view returns (uint256);
-}

package/contracts/interfaces/AaveV3/IAaveV3AToken.sol

@@ -1,17 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-pragma solidity ^0.8.0;
-
-interface IAaveV3AToken {
-    function UNDERLYING_ASSET_ADDRESS() external view returns (address);
-
-    function scaledBalanceOf(address user) external view returns (uint256);
-
-    function getScaledUserBalanceAndSupply(address user) external view returns (uint256, uint256);
-
-    function scaledTotalSupply() external view returns (uint256);
-
-    function getPreviousIndex(address user) external view returns (uint256);
-
-    function getIncentivesController() external view returns (address);
-}

package/contracts/interfaces/AaveV3/IAaveV3IncentiveController.sol

@@ -1,11 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-pragma solidity ^0.8.0;
-
-interface IAaveV3IncentiveController {
-    function getRewardsList() external view returns (address[] memory);
-
-    function claimAllRewardsToSelf(
-        address[] calldata assets
-    ) external returns (address[] memory rewardsList, uint256[] memory claimedAmounts);
-}

package/contracts/interfaces/AaveV3/IAaveV3Pool.sol

@@ -1,11 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-pragma solidity ^0.8.0;
-
-interface IAaveV3Pool {
-    function supply(address asset, uint256 amount, address onBehalfOf, uint16 referralCode) external;
-
-    function withdraw(address asset, uint256 amount, address to) external returns (uint256);
-
-    function getReserveNormalizedIncome(address asset) external view returns (uint256);
-}

package/contracts/interfaces/Angle/IAngleDistributor.sol

@@ -1,12 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-pragma solidity ^0.8.0;
-
-interface IAngleDistributor {
-    function claim(
-        address[] calldata users,
-        address[] calldata tokens,
-        uint256[] calldata amounts,
-        bytes32[][] calldata proofs
-    ) external;
-}

package/contracts/interfaces/Ankr/IAnkrBNB.sol

@@ -1,11 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-pragma solidity ^0.8.0;
-
-interface IAnkrBNB {
-    function ratio() external view returns (uint256);
-
-    function bondsToShares(uint256 amount) external view returns (uint256);
-
-    function sharesToBonds(uint256 amount) external view returns (uint256);
-}

package/contracts/interfaces/Ankr/IAnkrLiquidStaking.sol

@@ -1,21 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-pragma solidity ^0.8.0;
-
-interface IAnkrLiquidStaking {
-    function swap(uint256 shares, address receiverAddress) external;
-
-    function stakeBonds() external payable;
-
-    function stakeCerts() external payable;
-
-    function getFreeBalance() external view returns (uint256);
-
-    function getMinStake() external view returns (uint256);
-
-    function getMinUnstake() external view returns (uint256);
-
-    function flashPoolCapacity() external view returns (uint256);
-
-    function getFlashUnstakeFee() external view returns (uint256);
-}

package/contracts/interfaces/Balancer/IAsset.sol

@@ -1,4 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.0;
-
-interface IAsset {}

package/contracts/interfaces/Balancer/IBalancerFees.sol

@@ -1,6 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.0;
-
-interface IBalancerFees {
-    function getSwapFeePercentage() external view returns (uint256);
-}

package/contracts/interfaces/Balancer/IBalancerStablePreview.sol

@@ -1,22 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.0;
-
-import "./IVault.sol";
-
-interface IBalancerStablePreview {
-    function joinPoolPreview(
-        bytes32 poolId,
-        address sender,
-        address recipient,
-        IVault.JoinPoolRequest memory request,
-        bytes memory data
-    ) external view returns (uint256 amountBptOut);
-
-    function exitPoolPreview(
-        bytes32 poolId,
-        address sender,
-        address recipient,
-        IVault.ExitPoolRequest memory request,
-        bytes memory data
-    ) external view returns (uint256 amountTokenOut);
-}

package/contracts/interfaces/Balancer/IBasePool.sol

@@ -1,30 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.0;
-
-import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-
-interface IBasePool is IERC20 {
-    function onJoinPool(
-        bytes32 poolId,
-        address sender,
-        address recipient,
-        uint256[] memory balances,
-        uint256 lastChangeBlock,
-        uint256 protocolSwapFeePercentage,
-        bytes memory userData
-    ) external returns (uint256[] memory amountsIn, uint256[] memory dueProtocolFeeAmounts);
-
-    function onExitPool(
-        bytes32 poolId,
-        address sender,
-        address recipient,
-        uint256[] memory balances,
-        uint256 lastChangeBlock,
-        uint256 protocolSwapFeePercentage,
-        bytes memory userData
-    ) external returns (uint256[] memory amountsOut, uint256[] memory dueProtocolFeeAmounts);
-
-    function getPoolId() external view returns (bytes32);
-
-    function getSwapFeePercentage() external view returns (uint256);
-}

package/contracts/interfaces/Balancer/IComposableStable.sol

@@ -1,28 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.0;
-
-import "./IBasePool.sol";
-import "./IRateProvider.sol";
-
-interface IComposableStable is IBasePool {
-    function getLastJoinExitData()
-        external
-        view
-        returns (uint256 lastJoinExitAmplification, uint256 lastPostJoinExitInvariant);
-
-    function getAmplificationParameter() external view returns (uint256 value, bool isUpdating, uint256 precision);
-
-    function getProtocolFeePercentageCache(uint256 feeType) external view returns (uint256);
-
-    function isTokenExemptFromYieldProtocolFee(IERC20 token) external view returns (bool);
-
-    function getTokenRateCache(
-        IERC20 token
-    ) external view returns (uint256 rate, uint256 oldRate, uint256 duration, uint256 expires);
-
-    function getRateProviders() external view returns (IRateProvider[] memory);
-
-    function getBptIndex() external view returns (uint256);
-
-    function getTokenRate(IERC20 token) external view returns (uint256);
-}

package/contracts/interfaces/Balancer/IERC4626LinearPool.sol

@@ -1,173 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.0;
-
-interface IERC4626LinearPool {
-    event Approval(address indexed owner, address indexed spender, uint256 value);
-    event PausedStateChanged(bool paused);
-    event RecoveryModeStateChanged(bool enabled);
-    event SwapFeePercentageChanged(uint256 swapFeePercentage);
-    event TargetsSet(address indexed token, uint256 lowerTarget, uint256 upperTarget);
-    event Transfer(address indexed from, address indexed to, uint256 value);
-
-    struct SwapRequest {
-        uint8 kind;
-        address tokenIn;
-        address tokenOut;
-        uint256 amount;
-        bytes32 poolId;
-        uint256 lastChangeBlock;
-        address from;
-        address to;
-        bytes userData;
-    }
-
-    function DOMAIN_SEPARATOR() external view returns (bytes32);
-
-    function allowance(address owner, address spender) external view returns (uint256);
-
-    function approve(address spender, uint256 amount) external returns (bool);
-
-    function balanceOf(address account) external view returns (uint256);
-
-    function decimals() external view returns (uint8);
-
-    function decreaseAllowance(address spender, uint256 amount) external returns (bool);
-
-    function disableRecoveryMode() external;
-
-    function enableRecoveryMode() external;
-
-    function getActionId(bytes4 selector) external view returns (bytes32);
-
-    function getAuthorizer() external view returns (address);
-
-    function getBptIndex() external pure returns (uint256);
-
-    function getDomainSeparator() external view returns (bytes32);
-
-    function getMainIndex() external view returns (uint256);
-
-    function getMainToken() external view returns (address);
-
-    function getNextNonce(address account) external view returns (uint256);
-
-    function getOwner() external view returns (address);
-
-    function getPausedState()
-        external
-        view
-        returns (bool paused, uint256 pauseWindowEndTime, uint256 bufferPeriodEndTime);
-
-    function getPoolId() external view returns (bytes32);
-
-    function getProtocolFeesCollector() external view returns (address);
-
-    function getRate() external view returns (uint256);
-
-    function getScalingFactors() external view returns (uint256[] memory);
-
-    function getSwapFeePercentage() external view returns (uint256);
-
-    function getTargets() external view returns (uint256 lowerTarget, uint256 upperTarget);
-
-    function getVault() external view returns (address);
-
-    function getVirtualSupply() external view returns (uint256);
-
-    function getWrappedIndex() external view returns (uint256);
-
-    function getWrappedToken() external view returns (address);
-
-    function getWrappedTokenRate() external view returns (uint256);
-
-    function inRecoveryMode() external view returns (bool);
-
-    function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
-
-    function initialize() external;
-
-    function name() external view returns (string memory);
-
-    function nonces(address owner) external view returns (uint256);
-
-    function onExitPool(
-        bytes32 poolId,
-        address sender,
-        address,
-        uint256[] memory balances,
-        uint256,
-        uint256,
-        bytes memory userData
-    ) external returns (uint256[] memory amountsOut, uint256[] memory dueProtocolFees);
-
-    function onJoinPool(
-        bytes32 poolId,
-        address sender,
-        address recipient,
-        uint256[] memory balances,
-        uint256,
-        uint256,
-        bytes memory userData
-    ) external returns (uint256[] memory amountsIn, uint256[] memory dueProtocolFees);
-
-    function onSwap(
-        SwapRequest memory request,
-        uint256[] memory balances,
-        uint256 indexIn,
-        uint256 indexOut
-    ) external returns (uint256);
-
-    function onSwap(
-        SwapRequest memory request,
-        uint256 balanceTokenIn,
-        uint256 balanceTokenOut
-    ) external returns (uint256);
-
-    function pause() external;
-
-    function permit(
-        address owner,
-        address spender,
-        uint256 value,
-        uint256 deadline,
-        uint8 v,
-        bytes32 r,
-        bytes32 s
-    ) external;
-
-    function queryExit(
-        bytes32,
-        address sender,
-        address,
-        uint256[] memory balances,
-        uint256,
-        uint256,
-        bytes memory userData
-    ) external returns (uint256 bptIn, uint256[] memory amountsOut);
-
-    function queryJoin(
-        bytes32,
-        address sender,
-        address,
-        uint256[] memory balances,
-        uint256,
-        uint256,
-        bytes memory userData
-    ) external returns (uint256 bptOut, uint256[] memory amountsIn);
-
-    function setSwapFeePercentage(uint256 swapFeePercentage) external;
-
-    function setTargets(uint256 newLowerTarget, uint256 newUpperTarget) external;
-
-    function symbol() external view returns (string memory);
-
-    function totalSupply() external view returns (uint256);
-
-    function transfer(address recipient, uint256 amount) external returns (bool);
-
-    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
-
-    function unpause() external;
-
-    function version() external view returns (string memory);
-}

package/contracts/interfaces/Balancer/IGauge.sol

@@ -1,10 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.0;
-
-interface IGauge {
-    function claim_rewards(address _addr, address _receiver) external;
-
-    function reward_count() external view returns (uint256);
-
-    function reward_tokens(uint256 arg0) external view returns (address);
-}

package/contracts/interfaces/Balancer/ILiquidityGaugeFactory.sol

@@ -1,6 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.0;
-
-interface ILiquidityGaugeFactory {
-    function getPoolGauge(address poolAddress) external view returns (address);
-}

package/contracts/interfaces/Balancer/IMetaStablePool.sol

@@ -1,14 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.0;
-
-import "./IBasePool.sol";
-
-interface IMetaStablePool is IBasePool {
-    function getLastInvariant() external view returns (uint256 lastInvariant, uint256 lastInvariantAmp);
-
-    function getAmplificationParameter() external view returns (uint256 value, bool isUpdating, uint256 precision);
-
-    function getSwapFeePercentage() external view returns (uint256);
-
-    function getPriceRateCache(IERC20 token) external view returns (uint256 rate, uint256 duration, uint256 expires);
-}