@pendle/core-v2 5.0.1 → 5.0.4

package/contracts/LiquidityMining/GaugeController/PendleGaugeControllerMainchainUpg.sol

@@ -17,8 +17,9 @@ contract PendleGaugeControllerMainchainUpg is PendleGaugeControllerBaseUpg, IPGa
         address _pendle,
         address _marketFactory,
         address _marketFactory2,
-        address _marketFactory3
-    ) PendleGaugeControllerBaseUpg(_pendle, _marketFactory, _marketFactory2, _marketFactory3) {
+        address _marketFactory3,
+        address _marketFactory4
+    ) PendleGaugeControllerBaseUpg(_pendle, _marketFactory, _marketFactory2, _marketFactory3, _marketFactory4) {
         votingController = _votingController;
         _disableInitializers();
     }

package/contracts/LiquidityMining/GaugeController/PendleGaugeControllerSidechainUpg.sol

@@ -12,9 +12,10 @@ contract PendleGaugeControllerSidechainUpg is PendleGaugeControllerBaseUpg, Pend
         address _marketFactory,
         address _marketFactory2,
         address _marketFactory3,
+        address _marketFactory4,
         address _PendleMsgReceiveEndpointUpg
     )
-        PendleGaugeControllerBaseUpg(_pendle, _marketFactory, _marketFactory2, _marketFactory3)
+        PendleGaugeControllerBaseUpg(_pendle, _marketFactory, _marketFactory2, _marketFactory3, _marketFactory4)
         PendleMsgReceiverAppUpg(_PendleMsgReceiveEndpointUpg)
     {
         _disableInitializers();

package/contracts/core/RewardManager/RewardManager.sol

@@ -39,12 +39,15 @@ abstract contract RewardManager is RewardManagerAbstract {
 
                 RewardState memory _state = rewardState[token];
                 (uint256 lastBalance, uint256 index) = (_state.lastBalance, _state.index);
+
+                uint256 accrued = _selfBalance(tokens[i]) - lastBalance;
+
                 if (index == 0) index = INITIAL_REWARD_INDEX;
+                if (totalShares != 0) index += accrued.divDown(totalShares);
 
-                (uint256 consumedIndex, uint256 consumedReward) = _getConsumedReward(token, lastBalance, totalShares);
                 rewardState[token] = RewardState({
-                    index: (index + consumedIndex).Uint128(),
-                    lastBalance: (lastBalance + consumedReward).Uint128()
+                    index: index.Uint128(),
+                    lastBalance: (lastBalance + accrued).Uint128()
                 });
                 indexes[i] = index;
             }
@@ -55,20 +58,6 @@ abstract contract RewardManager is RewardManagerAbstract {
         }
     }
 
-    function _getConsumedReward(
-        address token,
-        uint256 lastBalance,
-        uint256 totalShares
-    ) private view returns (uint256 consumedIndex, uint256 consumedReward) {
-        if (totalShares == 0) {
-            return (0, 0);
-        }
-
-        uint256 accrued = _selfBalance(token) - lastBalance;
-        consumedIndex = accrued.divDown(totalShares);
-        consumedReward = (consumedIndex * totalShares + PMath.ONE - 1) / PMath.ONE;
-    }
-
     /// @dev this function doesn't need redeemExternal since redeemExternal is bundled in updateRewardIndex
     /// @dev this function also has to update rewardState.lastBalance
     function _doTransferOutRewards(

package/contracts/core/StandardizedYield/implementations/Gains/PendleGTokenSY.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../PendleERC4626SY.sol";
+import "../../../../interfaces/IERC4626.sol";
+
+contract PendleGTokenSY is PendleERC4626SY {
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _erc4626
+    ) PendleERC4626SY(_name, _symbol, _erc4626) {}
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](1);
+        res[0] = yieldToken;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == yieldToken;
+    }
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return IERC4626(yieldToken).convertToAssets(1e18);
+    }
+}

package/contracts/core/StandardizedYield/implementations/Gains/PendleGUSDCSY.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "./PendleGTokenSY.sol";
+
+contract PendleGUSDCSY is PendleGTokenSY {
+    address public constant gUSDC = 0xd3443ee1e91aF28e5FB858Fbd0D72A63bA8046E0;
+
+    constructor() PendleGTokenSY("SY gUSDC", "SY-gUSDC", gUSDC) {}
+}

package/contracts/core/StandardizedYield/implementations/{PendleGdaiSY.sol → Gains/PendleGdaiSY.sol}

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "../SYBase.sol";
-import "../../../interfaces/IERC4626.sol";
+import "../../SYBase.sol";
+import "../../../../interfaces/IERC4626.sol";
 
 contract PendleGDaiSY is SYBase {
     address public immutable DAI;

package/contracts/core/StandardizedYield/implementations/Mantle/PendleMETHSY.sol

@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../SYBase.sol";
+import "../../../../interfaces/IPExchangeRateOracle.sol";
+
+contract PendleMETHSY is SYBase {
+    using PMath for int256;
+
+    address public exchangeRateOracle = 0x1E2Ad9764cfAc60876486A7c714bc71f5b55f5C2;
+    address public constant METH = 0xcDA86A272531e8640cD7F1a92c01839911B90bb0;
+    address public constant WETH = 0xdEAddEaDdeadDEadDEADDEAddEADDEAddead1111;
+
+    constructor() SYBase("SY mETH", "SY-mETH", METH) {}
+
+    function setExchangeRateOracle(address newOracle) external onlyOwner {
+        exchangeRateOracle = newOracle;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(address, uint256 amountDeposited) internal pure override returns (uint256 /*amountSharesOut*/) {
+        return amountDeposited;
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal override returns (uint256 /*amountTokenOut*/) {
+        _transferOut(tokenOut, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view override returns (uint256) {
+        return IPExchangeRateOracle(exchangeRateOracle).getExchangeRate();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address,
+        uint256 amountTokenToDeposit
+    ) internal pure override returns (uint256 /*amountSharesOut*/) {
+        return amountTokenToDeposit;
+    }
+
+    function _previewRedeem(
+        address,
+        uint256 amountSharesToRedeem
+    ) internal pure override returns (uint256 /*amountTokenOut*/) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view override returns (address[] memory res) {
+        return ArrayLib.create(yieldToken);
+    }
+
+    function getTokensOut() public view override returns (address[] memory res) {
+        return ArrayLib.create(yieldToken);
+    }
+
+    function isValidTokenIn(address token) public view override returns (bool) {
+        return token == yieldToken;
+    }
+
+    function isValidTokenOut(address token) public view override returns (bool) {
+        return token == yieldToken;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, WETH, 18);
+    }
+}

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

@@ -79,7 +79,12 @@ contract PendleERC4626SY is SYBase {
         return token == yieldToken || token == asset;
     }
 
-    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+    function assetInfo()
+        external
+        view
+        virtual
+        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
+    {
         return (AssetType.TOKEN, asset, IERC20Metadata(asset).decimals());
     }
 }

package/contracts/core/StandardizedYield/implementations/Sophon/PendleSophonFarmingSY.sol

@@ -0,0 +1,116 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../SYBaseWithRewards.sol";
+import "../../../../interfaces/Sophon/ISophonFarming.sol";
+import "../../../../interfaces/Sophon/IPSophonPointManager.sol";
+
+contract PendleSophonFarmingSY is SYBaseWithRewards {
+    using Address for address;
+
+    address public immutable sophonFarming;
+    uint256 public immutable pid;
+    address public immutable pointManager;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _sophonFarming,
+        uint256 _pid,
+        address _pointManager
+    ) SYBaseWithRewards(_name, _symbol, __getPoolDepositToken(_sophonFarming, _pid)) {
+        sophonFarming = _sophonFarming;
+        pid = _pid;
+        pointManager = _pointManager;
+        _safeApproveInf(yieldToken, _sophonFarming);
+    }
+
+    function __getPoolDepositToken(address _sophonFarming, uint256 _pid) internal view returns (address) {
+        (address lp, , , , , , , , , ) = ISophonFarming(_sophonFarming).poolInfo(_pid);
+        return lp;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(address /*tokenIn*/, uint256 amountDeposited) internal virtual override returns (uint256) {
+        ISophonFarming(sophonFarming).deposit(pid, amountDeposited, 0);
+        return amountDeposited;
+    }
+
+    function _redeem(
+        address receiver,
+        address,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256) {
+        ISophonFarming(sophonFarming).withdraw(pid, amountSharesToRedeem);
+        _transferOut(yieldToken, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return PMath.ONE;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    function _getRewardTokens() internal view override returns (address[] memory) {
+        return ArrayLib.create(pointManager);
+    }
+
+    function _redeemExternalReward() internal override {
+        uint256 owningPoints = _getOwningPoints();
+        if (owningPoints == 0) return;
+        ISophonFarming(sophonFarming).transferPoints(pid, address(this), pointManager, owningPoints);
+        IPSophonPointManager(pointManager).claimPointReceiptToken();
+    }
+
+    function _getOwningPoints() internal view returns (uint256) {
+        return ISophonFarming(sophonFarming).pendingPoints(pid, address(this));
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address /*tokenIn*/,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256) {
+        return amountTokenToDeposit;
+    }
+
+    function _previewRedeem(
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal view override returns (uint256) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        return ArrayLib.create(yieldToken);
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        return ArrayLib.create(yieldToken);
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == yieldToken;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == yieldToken;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, yieldToken, IERC20Metadata(yieldToken).decimals());
+    }
+}

package/contracts/core/StandardizedYield/implementations/Sophon/PendleSophonPointManager.sol

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import "../../../erc20/PendleERC20.sol";
+import "../../../libraries/BoringOwnableUpgradeable.sol";
+import "../../../../interfaces/Sophon/ISophonFarming.sol";
+import "../../../../interfaces/Sophon/IPSophonPointManager.sol";
+import "@openzeppelin/contracts/utils/Strings.sol";
+
+contract PendleSophonPointManager is PendleERC20, BoringOwnableUpgradeable, IPSophonPointManager {
+    // solhint-disable immutable-vars-naming
+    address public immutable sophonFarming;
+    uint256 public immutable pid;
+    address public immutable sy;
+
+    mapping(address => bool) public isAddressWhitelisted;
+
+    constructor(
+        address _sophonFarming,
+        uint256 _pid,
+        address _sy
+    ) PendleERC20("Pendle Sophon Point Receipt Token", __getSpointSymbol(_pid), 18) initializer {
+        sophonFarming = _sophonFarming;
+        pid = _pid;
+        sy = _sy;
+        __BoringOwnable_init();
+    }
+
+    function __getSpointSymbol(uint256 _pid) internal pure returns (string memory) {
+        string memory id = Strings.toString(_pid);
+        return string(abi.encodePacked("SPOINT-", id));
+    }
+
+    function claimPointReceiptToken() external {
+        uint256 floatingPoints = _getOwningPoints() - totalSupply();
+        _mint(sy, floatingPoints);
+    }
+
+    function addWhitelistedAddress(address addr) external onlyOwner {
+        isAddressWhitelisted[addr] = true;
+    }
+
+    function _getOwningPoints() internal view returns (uint256) {
+        return ISophonFarming(sophonFarming).pendingPoints(pid, address(this));
+    }
+
+    function _afterTokenTransfer(address, address to, uint256 amount) internal virtual override {
+        if (amount != 0 && to != address(0) && _shouldBurnReceiptToken(to)) {
+            _burn(to, amount);
+            ISophonFarming(sophonFarming).transferPoints(pid, address(this), to, amount);
+        }
+    }
+
+    function _shouldBurnReceiptToken(address addr) internal view returns (bool) {
+        return addr != sy && !isAddressWhitelisted[addr];
+    }
+}

package/contracts/core/libraries/math/PMath.sol

@@ -67,6 +67,14 @@ library PMath {
         return (a + b - 1) / b;
     }
 
+    function slipUp(uint256 a, uint256 factor) internal pure returns (uint256) {
+        return mulDown(a, ONE + factor);
+    }
+
+    function slipDown(uint256 a, uint256 factor) internal pure returns (uint256) {
+        return mulDown(a, ONE - factor);
+    }
+
     // @author Uniswap
     function sqrt(uint256 y) internal pure returns (uint256 z) {
         if (y > 3) {

package/contracts/interfaces/IPActionMarketAuxStatic.sol

@@ -1,6 +1,7 @@
 pragma solidity ^0.8.0;
 
 import "./IPMarket.sol";
+import {ApproxParams} from "../router/base/MarketApproxLib.sol";
 
 interface IPActionMarketAuxStatic {
     function calcPriceImpactPY(address market, int256 netPtOut) external view returns (uint256);
@@ -27,11 +28,57 @@ interface IPActionMarketAuxStatic {
 
     function getTradeExchangeRateIncludeFee(address market, int256 netPtOut) external view returns (uint256);
 
+    function getYieldTokenAndPtRate(
+        address market
+    ) external view returns (address yieldToken, uint256 netPtOut, uint256 netYieldTokenOut);
+
+    function getYieldTokenAndYtRate(
+        address market
+    ) external view returns (address yieldToken, uint256 netYtOut, uint256 netYieldTokenOut);
+
     function getLpToSyRate(address market) external view returns (uint256);
 
     function getPtToSyRate(address market) external view returns (uint256);
 
+    function getYtToSyRate(address market) external view returns (uint256);
+
     function getLpToAssetRate(address market) external view returns (uint256);
 
     function getPtToAssetRate(address market) external view returns (uint256);
+
+    function getYtToAssetRate(address market) external view returns (uint256);
+
+    /// @param slippage A fixed-point number with 18 decimal places
+    function swapExactSyForPtStaticAndGenerateApproxParams(
+        address market,
+        uint256 exactSyIn,
+        uint256 slippage
+    )
+        external
+        view
+        returns (
+            uint256 netPtOut,
+            uint256 netSyFee,
+            uint256 priceImpact,
+            uint256 exchangeRateAfter,
+            ApproxParams memory approxParams
+        );
+
+    /// @param slippage A fixed-point number with 18 decimal places
+    function swapExactTokenForPtStaticAndGenerateApproxParams(
+        address market,
+        address tokenIn,
+        uint256 amountTokenIn,
+        uint256 slippage
+    )
+        external
+        view
+        returns (
+            uint256 netPtOut,
+            uint256 netSyMinted,
+            uint256 netSyFee,
+            uint256 priceImpact,
+            uint256 exchangeRateAfter,
+            ApproxParams memory approxParams
+        );
 }

package/contracts/interfaces/Sophon/IPSophonPointManager.sol

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

package/contracts/interfaces/Sophon/ISophonFarming.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface ISophonFarming {
+    function pendingPoints(uint256 _pid, address _user) external view returns (uint256);
+
+    function transferPoints(uint256 _pid, address _sender, address _receiver, uint256 _transferAmount) external;
+
+    function poolInfo(
+        uint256 _pid
+    )
+        external
+        view
+        returns (address, address, uint256, uint256, uint256, uint256, uint256, uint256, uint256, string memory);
+
+    function deposit(uint256 _pid, uint256 _amount, uint256 _boostAmount) external;
+
+    function withdraw(uint256 _pid, uint256 _withdrawAmount) external;
+}

package/contracts/offchain-helpers/router-static/base/ActionMarketAuxStatic.sol

@@ -4,6 +4,7 @@ pragma solidity ^0.8.17;
 import "../../../interfaces/IPMarket.sol";
 import "../../../interfaces/IPRouterStatic.sol";
 import "./StorageLayout.sol";
+import "hardhat/console.sol";
 
 contract ActionMarketAuxStatic is IPActionMarketAuxStatic {
     using MarketMathCore for MarketState;
@@ -101,6 +102,60 @@ contract ActionMarketAuxStatic is IPActionMarketAuxStatic {
         priceImpact = _calculateImpact(pyPreTradeRate, pyTradeRate);
     }
 
+    /**
+     * @notice get the rate of yieldToken & PT
+     * @return yieldToken the address of yieldToken
+     * @return netPtOut the amount of PT that can be swapped from 1 yieldToken (10**yieldToken.decimals())
+     * @return netYieldTokenOut the amount of yieldToken that can be swapped from 1 PT (10**PT.decimals())
+     */
+    function getYieldTokenAndPtRate(
+        address market
+    ) public view returns (address yieldToken, uint256 netPtOut, uint256 netYieldTokenOut) {
+        (IStandardizedYield SY, IPPrincipalToken PT, ) = _readTokens(market);
+        yieldToken = SY.yieldToken();
+        uint256 yieldDecimals = IERC20Metadata(yieldToken).decimals();
+        uint256 ptDecimals = PT.decimals();
+
+        (netPtOut, , , , ) = IPRouterStatic(address(this)).swapExactTokenForPtStatic(
+            market,
+            yieldToken,
+            10 ** yieldDecimals
+        );
+
+        (netYieldTokenOut, , , , ) = IPRouterStatic(address(this)).swapExactPtForTokenStatic(
+            market,
+            10 ** ptDecimals,
+            yieldToken
+        );
+    }
+
+    /**
+     * @notice get the rate of yieldToken & YT
+     * @return yieldToken the address of yieldToken
+     * @return netYtOut the amount of YT that can be swapped from 1 yieldToken (10**yieldToken.decimals())
+     * @return netYieldTokenOut the amount of yieldToken that can be swapped from 1 YT (10**YT.decimals())
+     */
+    function getYieldTokenAndYtRate(
+        address market
+    ) public view returns (address yieldToken, uint256 netYtOut, uint256 netYieldTokenOut) {
+        (IStandardizedYield SY, IPPrincipalToken PT, ) = _readTokens(market);
+        yieldToken = SY.yieldToken();
+        uint256 yieldDecimals = IERC20Metadata(yieldToken).decimals();
+        uint256 ptDecimals = PT.decimals();
+
+        (netYtOut, , , , ) = IPRouterStatic(address(this)).swapExactTokenForYtStatic(
+            market,
+            yieldToken,
+            10 ** yieldDecimals
+        );
+
+        (netYieldTokenOut, , , , , , , ) = IPRouterStatic(address(this)).swapExactYtForTokenStatic(
+            market,
+            10 ** ptDecimals,
+            yieldToken
+        );
+    }
+
     function getLpToSyRate(address market) public view returns (uint256) {
         (IStandardizedYield SY, , ) = _readTokens(market);
         return getLpToAssetRate(market).divDown(SY.exchangeRate());
@@ -111,6 +166,11 @@ contract ActionMarketAuxStatic is IPActionMarketAuxStatic {
         return getPtToAssetRate(market).divDown(SY.exchangeRate());
     }
 
+    function getYtToSyRate(address market) external view returns (uint256) {
+        (IStandardizedYield SY, , ) = _readTokens(market);
+        return getYtToAssetRate(market).divDown(SY.exchangeRate());
+    }
+
     function getLpToAssetRate(address market) public view returns (uint256) {
         MarketState memory state = _readState(market);
         PYIndex pyIndexCurrent = _pyIndex(market);
@@ -135,6 +195,94 @@ contract ActionMarketAuxStatic is IPActionMarketAuxStatic {
         return _getPtToAssetRate(market, state, _pyIndex(market));
     }
 
+    function getYtToAssetRate(address market) public view returns (uint256) {
+        return PMath.ONE - getPtToAssetRate(market);
+    }
+
+    /// @param slippage A fixed-point number with 18 decimal places
+    function swapExactSyForPtStaticAndGenerateApproxParams(
+        address market,
+        uint256 exactSyIn,
+        uint256 slippage
+    )
+        external
+        view
+        returns (
+            uint256 netPtOut,
+            uint256 netSyFee,
+            uint256 priceImpact,
+            uint256 exchangeRateAfter,
+            ApproxParams memory approxParams
+        )
+    {
+        (netPtOut, netSyFee, priceImpact, exchangeRateAfter) = IPActionMarketCoreStatic(address(this))
+            .swapExactSyForPtStatic(market, exactSyIn);
+        approxParams = genApproxParamsToSwapExactSyForPt(market, netPtOut, slippage);
+    }
+
+    /// @param slippage A fixed-point number with 18 decimal places
+    function swapExactTokenForPtStaticAndGenerateApproxParams(
+        address market,
+        address tokenIn,
+        uint256 amountTokenIn,
+        uint256 slippage
+    )
+        external
+        view
+        returns (
+            uint256 netPtOut,
+            uint256 netSyMinted,
+            uint256 netSyFee,
+            uint256 priceImpact,
+            uint256 exchangeRateAfter,
+            ApproxParams memory approxParams
+        )
+    {
+        (netPtOut, netSyMinted, netSyFee, priceImpact, exchangeRateAfter) = IPActionMarketCoreStatic(address(this))
+            .swapExactTokenForPtStatic(market, tokenIn, amountTokenIn);
+        approxParams = genApproxParamsToSwapExactSyForPt(market, netPtOut, slippage);
+    }
+
+    /// @param slippage A fixed-point number with 18 decimal places
+    function genApproxParamsToSwapExactSyForPt(
+        address market,
+        uint256 netPtOut,
+        uint256 slippage
+    ) public view returns (ApproxParams memory) {
+        MarketState memory state = _readState(market);
+        MarketPreCompute memory comp = state.getMarketPreCompute(_pyIndex(market), block.timestamp);
+
+        uint256 guessLowerBound = 0;
+        uint256 guessUpperBound = MarketApproxPtOutLib.calcMaxPtOut(comp, state.totalPt);
+        return genApproxParamsPtOut(netPtOut, guessLowerBound, guessUpperBound, slippage);
+    }
+
+    /// @param slippage A fixed-point number with 18 decimal places
+    function genApproxParamsPtOut(
+        uint256 netPtOut,
+        uint256 guessLowerBound,
+        uint256 guessUpperBound,
+        uint256 slippage
+    ) internal pure returns (ApproxParams memory) {
+        uint256 guessOffchain = netPtOut;
+        uint256 MAX_ITERATION = 30;
+
+        uint256 MIN_EPS_CAP = PMath.ONE / 10 ** 5;
+        uint256 eps = PMath.min(slippage / 2, MIN_EPS_CAP);
+
+        uint256 guessMin = PMath.max(guessLowerBound, netPtOut.slipDown(slippage));
+        uint256 guessMax = PMath.min(guessUpperBound, netPtOut.slipUp(5 * slippage));
+
+        return
+            ApproxParams({
+                guessOffchain: guessOffchain,
+                maxIteration: MAX_ITERATION,
+                eps: eps,
+                guessMin: guessMin,
+                guessMax: guessMax
+            });
+    }
+
     function _getPtToAssetRate(
         address market,
         MarketState memory state,