@pendle/core-v2 5.0.7 → 5.1.0

package/contracts/core/StandardizedYield/implementations/Sky/PendleSUSDSSY.sol

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "../PendleERC4626SY.sol";
+import "../../../../interfaces/Sky/ISkyConverter.sol";
+
+contract PendleSUSDSSY is PendleERC4626SY {
+    address public constant SUSDS = 0xa3931d71877C0E7a3148CB7Eb4463524FEc27fbD;
+    address public constant CONVERTER = 0x3225737a9Bbb6473CB4a45b7244ACa2BeFdB276A;
+    address public constant DAI = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
+    address public constant USDS = 0xdC035D45d973E3EC169d2276DDab16f1e407384F;
+
+    constructor() PendleERC4626SY("SY Savings USDS", "SY-sUSDS", SUSDS) {
+        _safeApproveInf(DAI, CONVERTER);
+        _safeApproveInf(USDS, CONVERTER);
+    }
+
+    function _deposit(address tokenIn, uint256 amountDeposited) internal virtual override returns (uint256) {
+        if (tokenIn == DAI) {
+            ISkyConverter(CONVERTER).daiToUsds(address(this), amountDeposited);
+            return super._deposit(USDS, amountDeposited);
+        }
+        return super._deposit(tokenIn, amountDeposited);
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal override returns (uint256 amountTokenOut) {
+        if (tokenOut == SUSDS) {
+            amountTokenOut = amountSharesToRedeem;
+            _transferOut(SUSDS, receiver, amountTokenOut);
+        } else {
+            if (tokenOut == USDS) {
+                amountTokenOut = IERC4626(SUSDS).redeem(amountSharesToRedeem, receiver, address(this));
+            } else {
+                amountTokenOut = IERC4626(SUSDS).redeem(amountSharesToRedeem, address(this), address(this));
+                ISkyConverter(CONVERTER).usdsToDai(receiver, amountTokenOut);
+            }
+        }
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        res = new address[](3);
+        res[0] = DAI;
+        res[1] = USDS;
+        res[2] = SUSDS;
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](3);
+        res[0] = DAI;
+        res[1] = USDS;
+        res[2] = SUSDS;
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == DAI || token == USDS || token == SUSDS;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == DAI || token == USDS || token == SUSDS;
+    }
+}

package/contracts/core/StandardizedYield/implementations/Sky/PendleStakingUSDSSY.sol

@@ -0,0 +1,103 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "../../SYBaseWithRewards.sol";
+import "../../../../interfaces/Sky/ISkyStaking.sol";
+import "../../../../interfaces/Sky/ISkyConverter.sol";
+
+contract PendleStakingUSDSSY is SYBaseWithRewards {
+    address public constant CONVERTER = 0x3225737a9Bbb6473CB4a45b7244ACa2BeFdB276A;
+    address public constant DAI = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
+    address public constant USDS = 0xdC035D45d973E3EC169d2276DDab16f1e407384F;
+    address public constant SKY = 0x56072C95FAA701256059aa122697B133aDEd9279;
+    address public immutable STAKING_CONTRACT = 0x0650CAF159C5A49f711e8169D4336ECB9b950275;
+
+    constructor() SYBaseWithRewards("SY Staking USDS", "SY-staking-USDS", USDS) {
+        _safeApproveInf(DAI, CONVERTER);
+        _safeApproveInf(USDS, CONVERTER);
+        _safeApproveInf(USDS, STAKING_CONTRACT);
+    }
+
+    function _deposit(address tokenIn, uint256 amountDeposited) internal virtual override returns (uint256) {
+        if (tokenIn == DAI) {
+            ISkyConverter(CONVERTER).daiToUsds(address(this), amountDeposited);
+        }
+        ISkyStaking(STAKING_CONTRACT).stake(amountDeposited);
+        return amountDeposited;
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256) {
+        ISkyStaking(STAKING_CONTRACT).withdraw(amountSharesToRedeem);
+        if (tokenOut == DAI) {
+            ISkyConverter(CONVERTER).usdsToDai(receiver, amountSharesToRedeem);
+        } else {
+            _transferOut(USDS, receiver, amountSharesToRedeem);
+        }
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return PMath.ONE;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {IStandardizedYield-getRewardTokens}
+     */
+    function _getRewardTokens() internal pure override returns (address[] memory) {
+        return ArrayLib.create(SKY);
+    }
+
+    function _redeemExternalReward() internal override {
+        ISkyStaking(STAKING_CONTRACT).getReward();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address /*tokenIn*/,
+        uint256 amountTokenToDeposit
+    ) internal pure override returns (uint256 amountSharesOut) {
+        return amountTokenToDeposit;
+    }
+
+    function _previewRedeem(
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal pure override returns (uint256 amountTokenOut) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(DAI, USDS);
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(DAI, USDS);
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == DAI || token == USDS;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == DAI || token == USDS;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, USDS, IERC20Metadata(USDS).decimals());
+    }
+}

package/contracts/core/StandardizedYield/implementations/Solv/PendleSolvBTCBBNBSCSYUpg.sol

@@ -0,0 +1,103 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "../../SYBaseUpg.sol";
+import "./PendleSolvHelperBSC.sol";
+import "../../../../interfaces/IPExchangeRateOracle.sol";
+
+contract PendleSolvBTCBBNBSCSYUpg is SYBaseUpg {
+    event SetNewExchangeRateOracle(address oracle);
+
+    address public constant WBTC = PendleSolvHelperBSC.WBTC;
+    address public constant SOLV_BTC = PendleSolvHelperBSC.SOLV_BTC_TOKEN;
+    address public constant SOLV_BTCBBN = PendleSolvHelperBSC.SOLV_BTCBBN_TOKEN;
+
+    address public exchangeRateOracle;
+
+    constructor() SYBaseUpg(SOLV_BTCBBN) {}
+
+    function initialize(address _initialExchangeRateOracle) external initializer {
+        __SYBaseUpg_init("SY SolvBTC Babylon", "SY-SolvBTC.BBN");
+        _setExchangeRateOracle(_initialExchangeRateOracle);
+        _safeApproveInf(WBTC, PendleSolvHelperBSC.SOLV_BTC_ROUTER);
+        _safeApproveInf(SOLV_BTC, PendleSolvHelperBSC.SOLV_BTCBBN_ROUTER);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(address tokenIn, uint256 amountDeposited) internal virtual override returns (uint256) {
+        if (tokenIn == SOLV_BTCBBN) {
+            return amountDeposited;
+        }
+        return PendleSolvHelperBSC._mintBTCBBN(tokenIn, amountDeposited);
+    }
+
+    function _redeem(
+        address receiver,
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256) {
+        _transferOut(SOLV_BTCBBN, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return IPExchangeRateOracle(exchangeRateOracle).getExchangeRate();
+    }
+
+    function setExchangeRateOracle(address newOracle) external virtual onlyOwner {
+        _setExchangeRateOracle(newOracle);
+    }
+
+    function _setExchangeRateOracle(address newOracle) internal virtual {
+        exchangeRateOracle = newOracle;
+        emit SetNewExchangeRateOracle(newOracle);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view virtual override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == SOLV_BTCBBN) {
+            return amountTokenToDeposit;
+        }
+        return PendleSolvHelperBSC._previewMintBTCBBN(tokenIn, amountTokenToDeposit);
+    }
+
+    function _previewRedeem(
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal view virtual override returns (uint256 amountTokenOut) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(WBTC, SOLV_BTC, SOLV_BTCBBN);
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(SOLV_BTCBBN);
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == WBTC || token == SOLV_BTC || token == SOLV_BTCBBN;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == SOLV_BTCBBN;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, WBTC, IERC20Metadata(WBTC).decimals());
+    }
+}

package/contracts/core/StandardizedYield/implementations/Solv/PendleSolvHelperBSC.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "../../../../interfaces/Solv/ISolvRouter.sol";
+import "../../../../interfaces/Solv/ISolvOpenFundMarket.sol";
+import "../../../../interfaces/Solv/ISolvOracle.sol";
+import "../../../../interfaces/Solv/ISolvERC3525.sol";
+
+library PendleSolvHelperBSC {
+    address public constant SOLV_BTCBBN_ROUTER = 0x8EC6Ef69a423045cEa97d2Bd0D768D042A130aA7;
+    address public constant SOLV_BTCBBN_TOKEN = 0x1346b618dC92810EC74163e4c27004c921D446a5;
+    bytes32 public constant SOLV_BTCBBN_POOLID = 0x6fe7f2753798616f555389f971dae58b32e181fab8b1d60d35e5ddafbb6bb5b7;
+
+    address public constant SOLV_BTC_ROUTER = 0x5c1215712F174dF2Cbc653eDce8B53FA4CAF2201;
+    address public constant SOLV_BTC_TOKEN = 0x4aae823a6a0b376De6A78e74eCC5b079d38cBCf7;
+    bytes32 public constant SOLV_BTC_POOLID = 0xafb1107b43875eb79f72e3e896933d4f96707451c3d5c32741e8e05410b321d8;
+
+    address public constant WBTC = 0x7130d2A12B9BCbFAe4f2634d864A1Ee1Ce3Ead9c;
+
+    address public constant SOLV_OPEN_FUND_MARKET = 0xaE050694c137aD777611286C316E5FDda58242F3;
+
+    function _mintBTCBBN(address tokenIn, uint256 amountIn) internal returns (uint256) {
+        assert(tokenIn == WBTC || tokenIn == SOLV_BTC_TOKEN);
+
+        if (tokenIn == WBTC) {
+            amountIn = ISolvRouter(SOLV_BTC_ROUTER).createSubscription(SOLV_BTC_POOLID, amountIn);
+        }
+        return ISolvRouter(SOLV_BTCBBN_ROUTER).createSubscription(SOLV_BTCBBN_POOLID, amountIn);
+    }
+
+    function _previewMintBTCBBN(address tokenIn, uint256 amountIn) internal view returns (uint256) {
+        assert(tokenIn == WBTC || tokenIn == SOLV_BTC_TOKEN);
+
+        if (tokenIn == WBTC) {
+            amountIn = _convertToShare(WBTC, amountIn);
+        }
+        return _convertToShare(SOLV_BTC_TOKEN, amountIn);
+    }
+
+    function _convertToShare(address tokenIn, uint256 amountIn) internal view returns (uint256) {
+        bytes32 poolId = tokenIn == WBTC ? SOLV_BTC_POOLID : SOLV_BTCBBN_POOLID;
+        ISolvOpenFundMarket.PoolInfo memory info = ISolvOpenFundMarket(SOLV_OPEN_FUND_MARKET).poolInfos(poolId);
+        uint256 numerator = 10 ** ISolvERC3525(info.poolSFTInfo.openFundShare).valueDecimals();
+        (uint256 price, ) = ISolvOracle(info.navOracle).getSubscribeNav(poolId, block.timestamp);
+        return (amountIn * numerator) / price;
+    }
+}

package/contracts/core/StandardizedYield/implementations/Syrup/PendleSyrupSY.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+import "../PendleERC4626NotRedeemableToAssetSY.sol";
+import "../../../../interfaces/Syrup/ISyrupRouter.sol";
+
+contract PendleSyrupSY is PendleERC4626NotRedeemableToAssetSY {
+    // solhint-disable immutable-vars-naming
+    address public immutable syrupRouter;
+    bytes32 public constant PENDLE_DEPOSIT_DATA = 0x303a70656e646c65000000000000000000000000000000000000000000000000;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _syrupRouter
+    ) PendleERC4626NotRedeemableToAssetSY(_name, _symbol, ISyrupRouter(_syrupRouter).pool()) {
+        syrupRouter = _syrupRouter;
+        _safeApproveInf(asset, syrupRouter);
+    }
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == yieldToken) {
+            return amountDeposited;
+        } else {
+            return ISyrupRouter(syrupRouter).deposit(amountDeposited, PENDLE_DEPOSIT_DATA);
+        }
+    }
+}

package/contracts/core/StandardizedYield/implementations/Usual/PendleUsualUSD0PPSY.sol

@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+import "../../SYBase.sol";
+import "../../../../interfaces/Usual/IUsualUSD0PP.sol";
+
+contract PendleUsualUSD0PPSY is SYBase {
+    address public constant USD0PP = 0x35D8949372D46B7a3D5A56006AE77B215fc69bC0;
+    address public constant USD0 = 0x73A15FeD60Bf67631dC6cd7Bc5B6e8da8190aCF5;
+
+    constructor() SYBase("SY USD0++", "SY-USD0++", USD0PP) {
+        _safeApproveInf(USD0, USD0PP);
+    }
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == USD0) {
+            IUsualUSD0PP(USD0PP).mint(amountDeposited);
+        }
+        return amountDeposited;
+    }
+
+    function _redeem(
+        address receiver,
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal override returns (uint256) {
+        _transferOut(yieldToken, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    function exchangeRate() public view virtual override returns (uint256 res) {
+        return PMath.ONE;
+    }
+
+    function _previewDeposit(
+        address /*tokenIn*/,
+        uint256 amountTokenToDeposit
+    ) internal view virtual override returns (uint256 /*amountSharesOut*/) {
+        return amountTokenToDeposit;
+    }
+
+    function _previewRedeem(
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal view virtual override returns (uint256 /*amountTokenOut*/) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public pure override returns (address[] memory res) {
+        return ArrayLib.create(USD0PP, USD0);
+    }
+
+    function getTokensOut() public pure override returns (address[] memory res) {
+        return ArrayLib.create(USD0PP);
+    }
+
+    function isValidTokenIn(address token) public pure override returns (bool) {
+        return token == USD0PP || token == USD0;
+    }
+
+    function isValidTokenOut(address token) public pure override returns (bool) {
+        return token == USD0PP;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, USD0PP, IERC20Metadata(USD0PP).decimals());
+    }
+}

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

@@ -67,14 +67,38 @@ library PMath {
         return (a + b - 1) / b;
     }
 
-    function slipUp(uint256 a, uint256 factor) internal pure returns (uint256) {
+    function tweakUp(uint256 a, uint256 factor) internal pure returns (uint256) {
         return mulDown(a, ONE + factor);
     }
 
-    function slipDown(uint256 a, uint256 factor) internal pure returns (uint256) {
+    function tweakDown(uint256 a, uint256 factor) internal pure returns (uint256) {
         return mulDown(a, ONE - factor);
     }
 
+    /// @return res = min(a + b, bound)
+    /// @dev This function should handle arithmetic operation and bound check without overflow/underflow
+    function addWithUpperBound(uint256 a, uint256 b, uint256 bound) internal pure returns (uint256 res) {
+        unchecked {
+            if (type(uint256).max - b < a) res = bound;
+            else res = min(bound, a + b);
+        }
+    }
+
+    /// @return res = max(a - b, bound)
+    /// @dev This function should handle arithmetic operation and bound check without overflow/underflow
+    function subWithLowerBound(uint256 a, uint256 b, uint256 bound) internal pure returns (uint256 res) {
+        unchecked {
+            if (b > a) res = bound;
+            else res = max(a - b, bound);
+        }
+    }
+
+    function clamp(uint256 x, uint256 lower, uint256 upper) internal pure returns (uint256 res) {
+        res = x;
+        if (x < lower) res = lower;
+        else if (x > upper) res = upper;
+    }
+
     // @author Uniswap
     function sqrt(uint256 y) internal pure returns (uint256 z) {
         if (y > 3) {

package/contracts/interfaces/Equilibria/IEquilibriaConverter.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity ^0.8.0;
+
+interface IEquilibriaConverter {
+    function deposit(uint256 _amount) external returns (uint256);
+
+    function estimateTotalConversion(uint256 _amount) external view returns (uint256);
+}

package/contracts/interfaces/Equilibria/IEquilibriaVault.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity ^0.8.0;
+
+interface IEquilibriaVault {
+    function deposit(uint256 _amount) external returns (uint256);
+
+    function withdraw(uint256 _shares) external returns (uint256);
+
+    function getReward(address _account) external;
+
+    function balance() external view returns (uint256);
+}

package/contracts/interfaces/EtherFi/IVedaTeller.sol

@@ -2,6 +2,12 @@
 pragma solidity ^0.8.23;
 
 interface IVedaTeller {
+    struct Asset {
+        bool allowDeposits;
+        bool allowWithdraws;
+        uint16 sharePremium;
+    }
+
     function deposit(
         address depositAsset,
         uint256 depositAmount,
@@ -16,4 +22,6 @@ interface IVedaTeller {
         uint256 minimumMint,
         address to
     ) external returns (uint256 shares);
+
+    function assetData(address) external view returns (Asset memory);
 }

package/contracts/interfaces/IPActionAddRemoveLiqV3.sol

@@ -1,135 +1,12 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
-import "../router/base/MarketApproxLib.sol";
+import "../router/math/MarketApproxLib.sol";
 import "./IPAllActionTypeV3.sol";
+import {IPAllEventsV3} from "./IPAllEventsV3.sol";
 
-/*
- *******************************************************************************************************************
- *******************************************************************************************************************
- * NOTICE *
- * Refer to https://docs.pendle.finance/Developers/Contracts/PendleRouter for more information on
- * TokenInput, TokenOutput, ApproxParams, LimitOrderData
- * It's recommended to use Pendle's Hosted SDK to generate the params
- *******************************************************************************************************************
- *******************************************************************************************************************
- */
-
-interface IPActionAddRemoveLiqV3 {
-    event AddLiquidityDualSyAndPt(
-        address indexed caller,
-        address indexed market,
-        address indexed receiver,
-        uint256 netSyUsed,
-        uint256 netPtUsed,
-        uint256 netLpOut
-    );
-
-    event AddLiquidityDualTokenAndPt(
-        address indexed caller,
-        address indexed market,
-        address indexed tokenIn,
-        address receiver,
-        uint256 netTokenUsed,
-        uint256 netPtUsed,
-        uint256 netLpOut,
-        uint256 netSyInterm
-    );
-
-    event AddLiquiditySinglePt(
-        address indexed caller,
-        address indexed market,
-        address indexed receiver,
-        uint256 netPtIn,
-        uint256 netLpOut
-    );
-
-    event AddLiquiditySingleSy(
-        address indexed caller,
-        address indexed market,
-        address indexed receiver,
-        uint256 netSyIn,
-        uint256 netLpOut
-    );
-
-    event AddLiquiditySingleToken(
-        address indexed caller,
-        address indexed market,
-        address indexed token,
-        address receiver,
-        uint256 netTokenIn,
-        uint256 netLpOut,
-        uint256 netSyInterm
-    );
-
-    event AddLiquiditySingleSyKeepYt(
-        address indexed caller,
-        address indexed market,
-        address indexed receiver,
-        uint256 netSyIn,
-        uint256 netSyMintPy,
-        uint256 netLpOut,
-        uint256 netYtOut
-    );
-
-    event AddLiquiditySingleTokenKeepYt(
-        address indexed caller,
-        address indexed market,
-        address indexed token,
-        address receiver,
-        uint256 netTokenIn,
-        uint256 netLpOut,
-        uint256 netYtOut,
-        uint256 netSyMintPy,
-        uint256 netSyInterm
-    );
-
-    event RemoveLiquidityDualSyAndPt(
-        address indexed caller,
-        address indexed market,
-        address indexed receiver,
-        uint256 netLpToRemove,
-        uint256 netPtOut,
-        uint256 netSyOut
-    );
-
-    event RemoveLiquidityDualTokenAndPt(
-        address indexed caller,
-        address indexed market,
-        address indexed tokenOut,
-        address receiver,
-        uint256 netLpToRemove,
-        uint256 netPtOut,
-        uint256 netTokenOut,
-        uint256 netSyInterm
-    );
-
-    event RemoveLiquiditySinglePt(
-        address indexed caller,
-        address indexed market,
-        address indexed receiver,
-        uint256 netLpToRemove,
-        uint256 netPtOut
-    );
-
-    event RemoveLiquiditySingleSy(
-        address indexed caller,
-        address indexed market,
-        address indexed receiver,
-        uint256 netLpToRemove,
-        uint256 netSyOut
-    );
-
-    event RemoveLiquiditySingleToken(
-        address indexed caller,
-        address indexed market,
-        address indexed token,
-        address receiver,
-        uint256 netLpToRemove,
-        uint256 netTokenOut,
-        uint256 netSyInterm
-    );
-
+/// Refer to IPAllActionTypeV3.sol for details on the parameters
+interface IPActionAddRemoveLiqV3 is IPAllEventsV3 {
     function addLiquidityDualTokenAndPt(
         address receiver,
         address market,

package/contracts/interfaces/IPActionMarketAuxStatic.sol

@@ -1,7 +1,7 @@
 pragma solidity ^0.8.0;
 
 import "./IPMarket.sol";
-import {ApproxParams} from "../router/base/MarketApproxLib.sol";
+import {ApproxParams} from "../router/math/MarketApproxLib.sol";
 
 interface IPActionMarketAuxStatic {
     function calcPriceImpactPY(address market, int256 netPtOut) external view returns (uint256);