@pendle/core-v2 2.29.1 → 3.0.0-beta-2

package/build/artifacts/contracts/router/base/ActionBaseMintRedeem.sol/ActionBaseMintRedeem.dbg.json

@@ -1,4 +0,0 @@
-{
-  "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/91c09e97d1f707209fe2e0a48e97be24.json"
-}

package/contracts/core/BulkSeller/BulkSeller.sol

@@ -1,233 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
-
-import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
-
-import "../../interfaces/IStandardizedYield.sol";
-import "../../interfaces/IPBulkSellerFactory.sol";
-import "../../interfaces/IPBulkSeller.sol";
-
-import "../libraries/TokenHelper.sol";
-import "../libraries/math/PMath.sol";
-import "../libraries/Errors.sol";
-
-import "./BulkSellerMathCore.sol";
-
-contract BulkSeller is IPBulkSeller, Initializable, TokenHelper, ReentrancyGuardUpgradeable {
-    using PMath for uint256;
-    using SafeERC20 for IERC20;
-    using BulkSellerMathCore for BulkSellerState;
-
-    struct BulkSellerStorage {
-        uint128 rateTokenToSy;
-        uint128 rateSyToToken;
-        uint128 totalSy;
-        uint128 totalToken;
-    }
-
-    address public token;
-    address public SY;
-    uint64 public feeRate;
-
-    address public factory;
-    BulkSellerStorage public _storage;
-
-    modifier onlyMaintainer() {
-        if (!IPBulkSellerFactory(factory).isMaintainer(msg.sender))
-            revert Errors.BulkNotMaintainer();
-        _;
-    }
-
-    // Since this contract is a beacon contract, no constructor should be defined.
-    function initialize(address _token, address _SY, address _factory) external initializer {
-        __ReentrancyGuard_init();
-        token = _token;
-        SY = _SY;
-        factory = _factory;
-        _safeApproveInf(token, SY);
-    }
-
-    function swapExactTokenForSy(
-        address receiver,
-        uint256 netTokenIn,
-        uint256 minSyOut
-    ) external payable nonReentrant returns (uint256 netSyOut) {
-        BulkSellerState memory state = readState();
-
-        _transferIn(token, msg.sender, netTokenIn);
-
-        netSyOut = state.swapExactTokenForSy(netTokenIn);
-
-        if (netSyOut < minSyOut) revert Errors.BulkInSufficientSyOut(netSyOut, minSyOut);
-
-        _transferOut(SY, receiver, netSyOut);
-
-        _writeState(state);
-
-        emit SwapExactTokenForSy(receiver, netTokenIn, netSyOut);
-    }
-
-    function swapExactSyForToken(
-        address receiver,
-        uint256 exactSyIn,
-        uint256 minTokenOut,
-        bool swapFromInternalBalance
-    ) external nonReentrant returns (uint256 netTokenOut) {
-        BulkSellerState memory state = readState();
-
-        if (!swapFromInternalBalance) _transferIn(SY, msg.sender, exactSyIn);
-        else {
-            uint256 netSyReceived = _selfBalance(SY) - state.totalSy;
-            if (netSyReceived < exactSyIn)
-                revert Errors.BulkInsufficientSyReceived(netSyReceived, exactSyIn);
-        }
-
-        netTokenOut = state.swapExactSyForToken(exactSyIn);
-
-        if (netTokenOut < minTokenOut)
-            revert Errors.BulkInSufficientTokenOut(netTokenOut, minTokenOut);
-
-        _transferOut(token, receiver, netTokenOut);
-
-        _writeState(state);
-
-        emit SwapExactSyForToken(receiver, exactSyIn, netTokenOut);
-    }
-
-    function readState() public view returns (BulkSellerState memory state) {
-        BulkSellerStorage storage s = _storage;
-
-        state = BulkSellerState({
-            rateTokenToSy: s.rateTokenToSy,
-            rateSyToToken: s.rateSyToToken,
-            totalToken: s.totalToken,
-            totalSy: s.totalSy,
-            feeRate: feeRate
-        });
-    }
-
-    function _writeState(BulkSellerState memory state) internal {
-        BulkSellerStorage memory tmp = BulkSellerStorage({
-            rateTokenToSy: state.rateTokenToSy.Uint128(),
-            rateSyToToken: state.rateSyToToken.Uint128(),
-            totalSy: state.totalSy.Uint128(),
-            totalToken: state.totalToken.Uint128()
-        });
-
-        _storage = tmp;
-    }
-
-    // ----------------- BulkSeller management -----------------
-
-    function increaseReserve(uint256 netTokenIn, uint256 netSyIn) external payable onlyMaintainer {
-        BulkSellerState memory state = readState();
-
-        state.totalToken += netTokenIn;
-        state.totalSy += netSyIn;
-
-        _transferIn(token, msg.sender, netTokenIn);
-        _transferIn(SY, msg.sender, netSyIn);
-
-        emit ReserveUpdated(state.totalToken, state.totalSy);
-
-        _writeState(state);
-    }
-
-    function decreaseReserve(uint256 netTokenOut, uint256 netSyOut) external onlyMaintainer {
-        BulkSellerState memory state = readState();
-
-        if (netTokenOut == type(uint256).max) netTokenOut = state.totalToken;
-        if (netSyOut == type(uint256).max) netSyOut = state.totalSy;
-
-        state.totalToken -= netTokenOut;
-        state.totalSy -= netSyOut;
-
-        _transferOut(token, msg.sender, netTokenOut);
-        _transferOut(SY, msg.sender, netSyOut);
-
-        emit ReserveUpdated(state.totalToken, state.totalSy);
-
-        _writeState(state);
-    }
-
-    function redeemRewards() external onlyMaintainer {
-        IStandardizedYield(SY).claimRewards(address(this));
-        address[] memory rewardTokens = IStandardizedYield(SY).getRewardTokens();
-
-        for (uint256 i = 0; i < rewardTokens.length; i++) {
-            if (rewardTokens[i] == token) continue;
-            _transferOut(rewardTokens[i], msg.sender, _selfBalance(rewardTokens[i]));
-        }
-    }
-
-    function skim() external onlyMaintainer {
-        BulkSellerState memory state = readState();
-        uint256 excessToken = _selfBalance(token) - state.totalToken;
-        uint256 excessSy = _selfBalance(SY) - state.totalSy;
-        if (excessToken != 0) IERC20(token).safeTransfer(msg.sender, excessToken);
-        if (excessSy != 0) IERC20(SY).safeTransfer(msg.sender, excessSy);
-    }
-
-    function reBalance(uint256 targetProp, uint256 maxDiff) external onlyMaintainer {
-        BulkSellerState memory state = readState();
-        uint256 oldTokenProp = state.getTokenProp();
-
-        (uint256 netTokenDeposit, uint256 netSyRedeem) = state.getReBalanceParams(targetProp);
-
-        if (netTokenDeposit > 0) {
-            uint256 netSyFromToken = _depositToken(netTokenDeposit);
-            state.reBalanceTokenToSy(netTokenDeposit, netSyFromToken, maxDiff);
-
-            uint256 newTokenProp = state.getTokenProp();
-            emit ReBalanceTokenToSy(netTokenDeposit, netSyFromToken, newTokenProp, oldTokenProp);
-        } else {
-            uint256 netTokenFromSy = _redeemSy(netSyRedeem);
-            state.reBalanceSyToToken(netSyRedeem, netTokenFromSy, maxDiff);
-
-            uint256 newTokenProp = state.getTokenProp();
-            emit ReBalanceSyToToken(netSyRedeem, netTokenFromSy, newTokenProp, oldTokenProp);
-        }
-
-        _writeState(state);
-    }
-
-    function setRate(
-        uint256 newRateSyToToken,
-        uint256 newRateTokenToSy,
-        uint256 maxDiff
-    ) external onlyMaintainer {
-        BulkSellerState memory state = readState();
-
-        emit RateUpdated(
-            newRateTokenToSy,
-            newRateSyToToken,
-            state.rateTokenToSy,
-            state.rateSyToToken
-        );
-
-        state.setRate(newRateSyToToken, newRateTokenToSy, maxDiff);
-
-        _writeState(state);
-    }
-
-    function setFeeRate(uint64 newFeeRate) external onlyMaintainer {
-        emit FeeRateUpdated(newFeeRate, feeRate);
-        feeRate = newFeeRate;
-    }
-
-    function _depositToken(uint256 netTokenDeposit) internal returns (uint256 netSyFromToken) {
-        uint256 nativeToDeposit = token == NATIVE ? netTokenDeposit : 0;
-        return
-            IStandardizedYield(SY).deposit{ value: nativeToDeposit }(
-                address(this),
-                token,
-                netTokenDeposit,
-                0
-            );
-    }
-
-    function _redeemSy(uint256 netSyRedeem) internal returns (uint256 netTokenFromSy) {
-        _transferOut(SY, SY, netSyRedeem);
-        return IStandardizedYield(SY).redeem(address(this), netSyRedeem, token, 0, true);
-    }
-}

package/contracts/core/BulkSeller/BulkSellerFactory.sol

@@ -1,85 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
-
-import "@openzeppelin/contracts/proxy/beacon/IBeacon.sol";
-import "@openzeppelin/contracts/proxy/beacon/BeaconProxy.sol";
-import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
-
-import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
-import "../libraries/BoringOwnableUpgradeable.sol";
-
-import "../../interfaces/IStandardizedYield.sol";
-import "../../interfaces/IPBulkSellerFactory.sol";
-import "../libraries/Errors.sol";
-
-contract BulkSellerFactory is
-    IBeacon,
-    IPBulkSellerFactory,
-    Initializable,
-    AccessControlUpgradeable,
-    UUPSUpgradeable
-{
-    bytes32 public constant MAINTAINER = keccak256("MAINTAINER");
-
-    address public implementation;
-
-    mapping(address => mapping(address => address)) internal syToBulkSeller;
-
-    modifier onlyMaintainer() {
-        if (!isMaintainer(msg.sender)) revert Errors.BulkNotMaintainer();
-        _;
-    }
-
-    constructor() initializer {}
-
-    function initialize(address implementation_) external initializer {
-        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
-        upgradeBeacon(implementation_);
-    }
-
-    function createBulkSeller(
-        address token,
-        address SY
-    ) external onlyMaintainer returns (address bulk) {
-        IStandardizedYield _SY = IStandardizedYield(SY);
-        if (syToBulkSeller[token][SY] != address(0))
-            revert Errors.BulkSellerAlreadyExisted(token, SY, syToBulkSeller[token][SY]);
-        if (_SY.isValidTokenIn(token) == false || _SY.isValidTokenOut(token) == false)
-            revert Errors.BulkSellerInvalidToken(token, SY);
-
-        bytes memory data = abi.encodeWithSignature(
-            "initialize(address,address,address)",
-            token,
-            SY,
-            address(this)
-        );
-
-        bulk = address(new BeaconProxy(address(this), data));
-
-        syToBulkSeller[token][SY] = bulk;
-
-        emit BulkSellerCreated(token, SY, bulk);
-
-        return bulk;
-    }
-
-    function get(address token, address SY) external view override returns (address) {
-        return syToBulkSeller[token][SY];
-    }
-
-    function isMaintainer(address addr) public view override returns (bool) {
-        return (hasRole(DEFAULT_ADMIN_ROLE, addr) || hasRole(MAINTAINER, addr));
-    }
-
-    // ----------------- upgrade-related -----------------
-    function upgradeBeacon(address newImplementation) public onlyMaintainer {
-        require(
-            AddressUpgradeable.isContract(newImplementation),
-            "UpgradeableBeacon: implementation is not a contract"
-        );
-        implementation = newImplementation;
-        emit UpgradedBeacon(newImplementation);
-    }
-
-    function _authorizeUpgrade(address) internal override onlyMaintainer {}
-}

package/contracts/core/BulkSeller/BulkSellerMathCore.sol

@@ -1,139 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.0;
-
-import "../libraries/TokenHelper.sol";
-import "../libraries/math/PMath.sol";
-import "../libraries/Errors.sol";
-
-struct BulkSellerState {
-    uint256 rateTokenToSy;
-    uint256 rateSyToToken;
-    uint256 totalToken;
-    uint256 totalSy;
-    uint256 feeRate;
-}
-
-library BulkSellerMathCore {
-    using PMath for uint256;
-
-    function swapExactTokenForSy(
-        BulkSellerState memory state,
-        uint256 netTokenIn
-    ) internal pure returns (uint256 netSyOut) {
-        netSyOut = calcSwapExactTokenForSy(state, netTokenIn);
-        state.totalToken += netTokenIn;
-        state.totalSy -= netSyOut;
-    }
-
-    function swapExactSyForToken(
-        BulkSellerState memory state,
-        uint256 netSyIn
-    ) internal pure returns (uint256 netTokenOut) {
-        netTokenOut = calcSwapExactSyForToken(state, netSyIn);
-        state.totalSy += netSyIn;
-        state.totalToken -= netTokenOut;
-    }
-
-    function calcSwapExactTokenForSy(
-        BulkSellerState memory state,
-        uint256 netTokenIn
-    ) internal pure returns (uint256 netSyOut) {
-        uint256 postFeeRate = state.rateTokenToSy.mulDown(PMath.ONE - state.feeRate);
-        assert(postFeeRate != 0);
-
-        netSyOut = netTokenIn.mulDown(postFeeRate);
-        if (netSyOut > state.totalSy)
-            revert Errors.BulkInsufficientSyForTrade(state.totalSy, netSyOut);
-    }
-
-    function calcSwapExactSyForToken(
-        BulkSellerState memory state,
-        uint256 netSyIn
-    ) internal pure returns (uint256 netTokenOut) {
-        uint256 postFeeRate = state.rateSyToToken.mulDown(PMath.ONE - state.feeRate);
-        assert(postFeeRate != 0);
-
-        netTokenOut = netSyIn.mulDown(postFeeRate);
-        if (netTokenOut > state.totalToken)
-            revert Errors.BulkInsufficientTokenForTrade(state.totalToken, netTokenOut);
-    }
-
-    function getTokenProp(BulkSellerState memory state) internal pure returns (uint256) {
-        uint256 totalToken = state.totalToken;
-        uint256 totalTokenFromSy = state.totalSy.mulDown(state.rateSyToToken);
-        return totalToken.divDown(totalToken + totalTokenFromSy);
-    }
-
-    function getReBalanceParams(
-        BulkSellerState memory state,
-        uint256 targetTokenProp
-    ) internal pure returns (uint256 netTokenToDeposit, uint256 netSyToRedeem) {
-        uint256 currentTokenProp = getTokenProp(state);
-
-        if (currentTokenProp > targetTokenProp) {
-            netTokenToDeposit = state
-                .totalToken
-                .mulDown(currentTokenProp - targetTokenProp)
-                .divDown(currentTokenProp);
-        } else {
-            uint256 currentSyProp = PMath.ONE - currentTokenProp;
-            netSyToRedeem = state.totalSy.mulDown(targetTokenProp - currentTokenProp).divDown(
-                currentSyProp
-            );
-        }
-    }
-
-    function reBalanceTokenToSy(
-        BulkSellerState memory state,
-        uint256 netTokenToDeposit,
-        uint256 netSyFromToken,
-        uint256 maxDiff
-    ) internal pure {
-        uint256 rate = netSyFromToken.divDown(netTokenToDeposit);
-
-        if (!PMath.isAApproxB(rate, state.rateTokenToSy, maxDiff))
-            revert Errors.BulkBadRateTokenToSy(rate, state.rateTokenToSy, maxDiff);
-
-        state.totalToken -= netTokenToDeposit;
-        state.totalSy += netSyFromToken;
-    }
-
-    function reBalanceSyToToken(
-        BulkSellerState memory state,
-        uint256 netSyToRedeem,
-        uint256 netTokenFromSy,
-        uint256 maxDiff
-    ) internal pure {
-        uint256 rate = netTokenFromSy.divDown(netSyToRedeem);
-
-        if (!PMath.isAApproxB(rate, state.rateSyToToken, maxDiff))
-            revert Errors.BulkBadRateSyToToken(rate, state.rateSyToToken, maxDiff);
-
-        state.totalToken += netTokenFromSy;
-        state.totalSy -= netSyToRedeem;
-    }
-
-    function setRate(
-        BulkSellerState memory state,
-        uint256 rateSyToToken,
-        uint256 rateTokenToSy,
-        uint256 maxDiff
-    ) internal pure {
-        if (
-            state.rateTokenToSy != 0 &&
-            !PMath.isAApproxB(rateTokenToSy, state.rateTokenToSy, maxDiff)
-        ) {
-            revert Errors.BulkBadRateTokenToSy(rateTokenToSy, state.rateTokenToSy, maxDiff);
-        }
-
-        if (
-            state.rateSyToToken != 0 &&
-            !PMath.isAApproxB(rateSyToToken, state.rateSyToToken, maxDiff)
-        ) {
-            revert Errors.BulkBadRateSyToToken(rateSyToToken, state.rateSyToToken, maxDiff);
-        }
-
-        state.rateTokenToSy = rateTokenToSy;
-        state.rateSyToToken = rateSyToToken;
-    }
-}

package/contracts/interfaces/IPActionMintRedeem.sol

@@ -1,108 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.0;
-
-import "../router/base/MarketApproxLib.sol";
-import "../router/base/ActionBaseMintRedeem.sol";
-
-interface IPActionMintRedeem {
-    event MintSyFromToken(
-        address indexed caller,
-        address indexed tokenIn,
-        address indexed SY,
-        address receiver,
-        uint256 netTokenIn,
-        uint256 netSyOut
-    );
-
-    event RedeemSyToToken(
-        address indexed caller,
-        address indexed tokenOut,
-        address indexed SY,
-        address receiver,
-        uint256 netSyIn,
-        uint256 netTokenOut
-    );
-
-    event MintPyFromSy(
-        address indexed caller,
-        address indexed receiver,
-        address indexed YT,
-        uint256 netSyIn,
-        uint256 netPyOut
-    );
-
-    event RedeemPyToSy(
-        address indexed caller,
-        address indexed receiver,
-        address indexed YT,
-        uint256 netPyIn,
-        uint256 netSyOut
-    );
-
-    event MintPyFromToken(
-        address indexed caller,
-        address indexed tokenIn,
-        address indexed YT,
-        address receiver,
-        uint256 netTokenIn,
-        uint256 netPyOut
-    );
-
-    event RedeemPyToToken(
-        address indexed caller,
-        address indexed tokenOut,
-        address indexed YT,
-        address receiver,
-        uint256 netPyIn,
-        uint256 netTokenOut
-    );
-
-    function mintSyFromToken(
-        address receiver,
-        address SY,
-        uint256 minSyOut,
-        TokenInput calldata input
-    ) external payable returns (uint256 netSyOut);
-
-    function redeemSyToToken(
-        address receiver,
-        address SY,
-        uint256 netSyIn,
-        TokenOutput calldata output
-    ) external returns (uint256 netTokenOut);
-
-    function mintPyFromToken(
-        address receiver,
-        address YT,
-        uint256 minPyOut,
-        TokenInput calldata input
-    ) external payable returns (uint256 netPyOut);
-
-    function redeemPyToToken(
-        address receiver,
-        address YT,
-        uint256 netPyIn,
-        TokenOutput calldata output
-    ) external returns (uint256 netTokenOut);
-
-    function mintPyFromSy(
-        address receiver,
-        address YT,
-        uint256 netSyIn,
-        uint256 minPyOut
-    ) external returns (uint256 netPyOut);
-
-    function redeemPyToSy(
-        address receiver,
-        address YT,
-        uint256 netPyIn,
-        uint256 minSyOut
-    ) external returns (uint256 netSyOut);
-
-    function redeemDueInterestAndRewards(
-        address user,
-        address[] calldata sys,
-        address[] calldata yts,
-        address[] calldata markets
-    ) external;
-}

package/contracts/interfaces/IPBulkSeller.sol

@@ -1,48 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.0;
-
-import "../core/BulkSeller/BulkSellerMathCore.sol";
-
-interface IPBulkSeller {
-    event SwapExactTokenForSy(address receiver, uint256 netTokenIn, uint256 netSyOut);
-    event SwapExactSyForToken(address receiver, uint256 netSyIn, uint256 netTokenOut);
-    event RateUpdated(
-        uint256 newRateTokenToSy,
-        uint256 newRateSyToToken,
-        uint256 oldRateTokenToSy,
-        uint256 oldRateSyToToken
-    );
-    event ReBalanceTokenToSy(
-        uint256 netTokenDeposit,
-        uint256 netSyFromToken,
-        uint256 newTokenProp,
-        uint256 oldTokenProp
-    );
-    event ReBalanceSyToToken(
-        uint256 netSyRedeem,
-        uint256 netTokenFromSy,
-        uint256 newTokenProp,
-        uint256 oldTokenProp
-    );
-    event ReserveUpdated(uint256 totalToken, uint256 totalSy);
-    event FeeRateUpdated(uint256 newFeeRate, uint256 oldFeeRate);
-
-    function swapExactTokenForSy(
-        address receiver,
-        uint256 netTokenIn,
-        uint256 minSyOut
-    ) external payable returns (uint256 netSyOut);
-
-    function swapExactSyForToken(
-        address receiver,
-        uint256 exactSyIn,
-        uint256 minTokenOut,
-        bool swapFromInternalBalance
-    ) external returns (uint256 netTokenOut);
-
-    function SY() external view returns (address);
-
-    function token() external view returns (address);
-
-    function readState() external view returns (BulkSellerState memory);
-}

package/contracts/interfaces/IPBulkSellerFactory.sol

@@ -1,12 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.0;
-
-interface IPBulkSellerFactory {
-    event BulkSellerCreated(address indexed token, address indexed sy, address indexed bulk);
-
-    event UpgradedBeacon(address indexed implementation);
-
-    function get(address token, address SY) external view returns (address);
-
-    function isMaintainer(address addr) external view returns (bool);
-}

package/contracts/interfaces/IPBulkSellerSYCallback.sol

@@ -1,6 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.0;
-
-interface IPBulkSellerCallback {
-    function swapCallback(int256 ptToAccount, int256 syToAccount, bytes calldata data) external;
-}