@pendle/core-v2 2.27.0 → 2.28.0

package/contracts/core/StandardizedYield/implementations/BalancerStable/base/StablePreviewBase.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.0;
 
 import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import "../../../../../interfaces/Balancer/IVault.sol";

package/contracts/core/StandardizedYield/implementations/CamelotV1Volatile/CamelotRewardHelper.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-pragma solidity 0.8.17;
+pragma solidity ^0.8.0;
 
 import "../../../libraries/TokenHelper.sol";
 import "../../../../interfaces/Camelot/ICamelotNFTFactory.sol";

package/contracts/core/StandardizedYield/implementations/CamelotV1Volatile/CamelotV1VolatileCommon.sol

@@ -1,12 +1,12 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-pragma solidity 0.8.17;
+pragma solidity ^0.8.0;
 
 import "../../../../interfaces/Camelot/ICamelotPair.sol";
 import "../../../../interfaces/Camelot/ICamelotRouter.sol";
 import "../../../../interfaces/Camelot/ICamelotFactory.sol";
 import "../../../libraries/TokenHelper.sol";
-import "../../../libraries/math/Math.sol";
+import "../../../libraries/math/PMath.sol";
 
 contract CamelotV1VolatileCommon {
     struct CamelotPairData {
@@ -31,7 +31,7 @@ contract CamelotV1VolatileCommon {
         uint256 fee
     ) internal pure returns (uint256) {
         return
-            (Math.sqrt(Math.square((TWO - fee) * reserve) + FOUR * (ONE - fee) * amountIn * reserve) -
+            (PMath.sqrt(PMath.square((TWO - fee) * reserve) + FOUR * (ONE - fee) * amountIn * reserve) -
                 (TWO - fee) *
                 reserve) / (2 * (ONE - fee));
     }

package/contracts/core/StandardizedYield/implementations/CamelotV1Volatile/CamelotV1VolatileLpHelper.sol

@@ -1,12 +1,12 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-pragma solidity >=0.8.0;
+pragma solidity ^0.8.0;
 
 import "../../../../interfaces/Camelot/ICamelotPair.sol";
 import "../../../../interfaces/Camelot/ICamelotRouter.sol";
 import "../../../../interfaces/Camelot/ICamelotFactory.sol";
 import "../../../libraries/TokenHelper.sol";
-import "../../../libraries/math/Math.sol";
+import "../../../libraries/math/PMath.sol";
 import "./CamelotV1VolatileCommon.sol";
 
 /**

package/contracts/core/StandardizedYield/implementations/CamelotV1Volatile/CamelotV1VolatilePreview.sol

@@ -132,7 +132,7 @@ contract CamelotV1VolatilePreview is
 
         uint256 supply = _getTotalSupplyAfterMintFee(data);
         return
-            Math.min(
+            PMath.min(
                 (amount0ToAddLiq * supply) / data.reserve0,
                 (amount1ToAddLiq * supply) / data.reserve1
             );
@@ -159,8 +159,8 @@ contract CamelotV1VolatilePreview is
         // gas savings
         if (feeOn) {
             if (_kLast != 0) {
-                uint256 rootK = Math.sqrt(data.reserve0 * data.reserve1);
-                uint256 rootKLast = Math.sqrt(_kLast);
+                uint256 rootK = PMath.sqrt(data.reserve0 * data.reserve1);
+                uint256 rootKLast = PMath.sqrt(_kLast);
                 if (rootK > rootKLast) {
                     uint256 d = (FEE_DENOMINATOR * 100) / ownerFeeShare - 100;
                     uint256 numerator = totalSupply * (rootK - rootKLast) * 100;

package/contracts/core/StandardizedYield/implementations/CamelotV1Volatile/PendleCamelotV1VolatileSY.sol

@@ -12,7 +12,7 @@ contract PendleCamelotV1VolatileSY is
     CamelotRewardHelper,
     CamelotV1VolatileLpHelper
 {
-    using Math for uint256;
+    using PMath for uint256;
     using ArrayLib for address[];
 
     address[] public rewardTokens;
@@ -85,7 +85,7 @@ contract PendleCamelotV1VolatileSY is
     function exchangeRate() public view virtual override returns (uint256) {
         (uint256 reserve0, uint256 reserve1, , ) = ICamelotPair(pair).getReserves();
         uint256 supply = ICamelotPair(pair).totalSupply();
-        return Math.sqrt(reserve0 * reserve1).divDown(supply);
+        return PMath.sqrt(reserve0 * reserve1).divDown(supply);
     }
 
     /*///////////////////////////////////////////////////////////////

package/contracts/core/StandardizedYield/implementations/Convex/PendleCurveFraxUsdcSY.sol

@@ -44,7 +44,7 @@ contract PendleCurveFraxUsdcSY is PendleConvexLPSY {
     ) internal virtual override returns (uint256 amountTokenOut) {
         amountTokenOut = ICrvPool(crvPool).remove_liquidity_one_coin(
             amountLpToRedeem,
-            Math.Int128(_getIndex(tokenOut)),
+            PMath.Int128(_getIndex(tokenOut)),
             0
         );
     }
@@ -63,7 +63,7 @@ contract PendleCurveFraxUsdcSY is PendleConvexLPSY {
         return
             ICrvPool(crvPool).calc_withdraw_one_coin(
                 amountLpToRedeem,
-                Math.Int128(_getIndex(tokenOut))
+                PMath.Int128(_getIndex(tokenOut))
             );
     }
 

package/contracts/core/StandardizedYield/implementations/Convex/PendleCurveUsdd3CrvSY.sol

@@ -67,7 +67,7 @@ contract PendleCurveUsdd3CrvSY is PendleConvexLPSY {
 
         ICrvPool(crvPool).remove_liquidity_one_coin(
             amountLpToRedeem,
-            Math.Int128(_getIndex(tokenToRemove)),
+            PMath.Int128(_getIndex(tokenToRemove)),
             0
         );
 
@@ -95,7 +95,7 @@ contract PendleCurveUsdd3CrvSY is PendleConvexLPSY {
         address tokenToRemove = tokenOut == USDD ? USDD : LP_3CRV;
         uint256 amountTokenRemoved = ICrvPool(crvPool).calc_withdraw_one_coin(
             amountLpToRedeem,
-            Math.Int128(_getIndex(tokenToRemove))
+            PMath.Int128(_getIndex(tokenToRemove))
         );
 
         if (Curve3CrvPoolHelper.is3CrvToken(tokenOut)) {

package/contracts/core/StandardizedYield/implementations/Convex/base/Curve3CrvPoolHelper.sol

@@ -1,12 +1,12 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.0;
 
-import "../../../../libraries/math/Math.sol";
+import "../../../../libraries/math/PMath.sol";
 import "../../../../../interfaces/Curve/ITriCrvPool.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
 library Curve3CrvPoolHelper {
-    using Math for uint256;
+    using PMath for uint256;
 
     uint256 internal constant N_COINS = 3;
     uint256 internal constant PRECISION = 10 ** 18;

package/contracts/core/StandardizedYield/implementations/Convex/base/CurveFraxUsdcPoolHelper.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.0;
 
-import "../../../../libraries/math/Math.sol";
+import "../../../../libraries/math/PMath.sol";
 import "../../../../../interfaces/Curve/ICrvPool.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
@@ -18,7 +18,7 @@ library CurveFraxUsdcPoolHelper {
     address internal constant FRAX = 0x853d955aCEf822Db058eb8505911ED77F175b99e;
     address internal constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
 
-    using Math for uint256;
+    using PMath for uint256;
 
     function previewAddLiquidity(address token, uint256 amount) internal view returns (uint256) {
         uint256 amp = ICrvPool(POOL).A_precise();

package/contracts/core/StandardizedYield/implementations/Convex/base/CurveUsdd3CrvPoolHelper.sol

@@ -1,13 +1,13 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.0;
 
-import "../../../../libraries/math/Math.sol";
+import "../../../../libraries/math/PMath.sol";
 import "../../../../../interfaces/Curve/ICrvPool.sol";
 import "./Curve3CrvPoolHelper.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
 library CurveUsdd3CrvPoolHelper {
-    using Math for uint256;
+    using PMath for uint256;
 
     uint256 internal constant N_COINS = 2;
     uint256 internal constant A_PRECISION = 100;

package/contracts/core/StandardizedYield/implementations/Convex/base/PendleConvexLPSY.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.0;
 
 import "../../../SYBaseWithRewards.sol";
 import "../../../../../interfaces/ConvexCurve/IBooster.sol";

package/contracts/core/StandardizedYield/implementations/Flux/FluxTokenLib.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.0;
 
 import "../../../../interfaces/Flux/IFluxErc20.sol";
 import "../../../../interfaces/Flux/IFluxInterestRateModel.sol";

package/contracts/core/StandardizedYield/implementations/Flux/PendleFluxLendingSY.sol

@@ -6,7 +6,7 @@ import "../../SYBase.sol";
 import "../../../../interfaces/Flux/IFluxErc20.sol";
 
 contract PendleFluxLendingSY is SYBase {
-    using Math for uint256;
+    using PMath for uint256;
 
     error FluxLendingError(uint256 errCode);
 

package/contracts/core/StandardizedYield/implementations/GLP/GLPPreviewHelper.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.0;
 
 import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import "../../../../interfaces/GMX/IGMXVault.sol";

package/contracts/core/StandardizedYield/implementations/GLP/PendleGlpSY.sol

@@ -113,7 +113,7 @@ contract PendleGlpSY is SYBaseWithRewards, GLPPreviewHelper {
      * @dev 1 SY = 1 GLP
      */
     function exchangeRate() public view virtual override returns (uint256) {
-        return Math.ONE;
+        return PMath.ONE;
     }
 
     /*///////////////////////////////////////////////////////////////

package/contracts/core/StandardizedYield/implementations/HMX/HLPPricingHelper.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import "../../../libraries/BoringOwnableUpgradeable.sol";
+import "../../../../interfaces/HMX/IHMXCalculator.sol";
+
+contract HLPPricingHelper is BoringOwnableUpgradeable, UUPSUpgradeable {
+    address public immutable hmxCalculator;
+    address public immutable hlp;
+
+    constructor(address _hmxCalculator, address _hlp) {
+        hmxCalculator = _hmxCalculator;
+        hlp = _hlp;
+    }
+
+
+    function initialize() external initializer {
+        __BoringOwnable_init();
+    }
+
+    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
+
+    function getPrice() external view returns (uint256) {
+        uint256 aum = IHMXCalculator(hmxCalculator).getAUME30(true);
+        uint256 supply = IERC20(hlp).totalSupply();
+        return aum * 1e6 / supply;
+    }
+}

package/contracts/core/StandardizedYield/implementations/HMX/PendleHlpSY.sol

@@ -0,0 +1,189 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../SYBaseWithRewards.sol";
+import "../../../libraries/ArrayLib.sol";
+import "../../../../interfaces/HMX/IHMXCompounder.sol";
+import "../../../../interfaces/HMX/IHLPStaking.sol";
+import "../../../../interfaces/HMX/IHMXStaking.sol";
+import "../../../../interfaces/HMX/IHMXVester.sol";
+import "./HLPPricingHelper.sol";
+
+contract PendleHlpSY is SYBaseWithRewards {
+    using ArrayLib for address[];
+
+    address public immutable hlp;
+    address public immutable usdc;
+    address public immutable compounder;
+
+    address public immutable vester;
+    address public immutable hlpStakingPool;
+    address public immutable hmxStakingPool;
+
+    address[] public allRewardTokens;
+
+    // off-chain usage only, no security related, no auditing required
+    address public immutable hlpPriceHelper;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _hlp,
+        address _usdc,
+        address _compounder,
+        address _vester,
+        address _hlpStakingPool,
+        address _hmxStakingPool,
+        address _hlpPriceHelper
+    ) SYBaseWithRewards(_name, _symbol, _hlp) {
+        hlp = _hlp;
+        usdc = _usdc;
+
+        compounder = _compounder;
+        vester = _vester;
+
+        hlpStakingPool = _hlpStakingPool;
+        hmxStakingPool = _hmxStakingPool;
+
+        hlpPriceHelper = _hlpPriceHelper;
+
+        allRewardTokens.push(_usdc);
+        _safeApproveInf(hlp, hlpStakingPool);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {SYBase-_deposit}
+     */
+    function _deposit(address, /*tokenIn*/ uint256 amountDeposited)
+        internal
+        virtual
+        override
+        returns (uint256 /*amountSharesOut*/ )
+    {
+        IHLPStaking(hlpStakingPool).deposit(address(this), amountDeposited);
+        return amountDeposited;
+    }
+
+    /**
+     * @dev See {SYBase-_redeem}
+     */
+    function _redeem(address receiver, address, /*tokenOut*/ uint256 amountSharesToRedeem)
+        internal
+        virtual
+        override
+        returns (uint256 /*amountTokenOut*/ )
+    {
+        IHLPStaking(hlpStakingPool).withdraw(amountSharesToRedeem);
+        _transferOut(hlp, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return PMath.ONE;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {IStandardizedYield-getRewardTokens}
+     */
+
+    function addRewardToken(address token) external onlyOwner {
+        require(!allRewardTokens.contains(token), "invalid additional reward token");
+        allRewardTokens.push(token);
+    }
+
+    function _getRewardTokens() internal view override returns (address[] memory res) {
+        return allRewardTokens;
+    }
+
+    function _redeemExternalReward() internal override {
+        address[] memory pools = new address[](2);
+        pools[0] = hmxStakingPool;
+        pools[1] = hlpStakingPool;
+
+        address[][] memory rewarders = new address[][](2);
+
+        rewarders[0] = IHMXStaking(hmxStakingPool).getAllRewarders();
+        rewarders[1] = IHLPStaking(hlpStakingPool).getRewarders(); // Surge HLP programme is redundent but it's not very gas-sensitive
+
+        IHMXCompounder(compounder).compound(pools, rewarders, 0, 0, new uint256[](0));
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    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 res) {
+        res = new address[](1);
+        res[0] = hlp;
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](1);
+        res[0] = hlp;
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == hlp;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == hlp;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.LIQUIDITY, hlp, IERC20Metadata(hlp).decimals());
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                        esHMX vest & claim
+    //////////////////////////////////////////////////////////////*/
+
+    function vestAllEsHMX(address to) external onlyOwner {
+        _updateAndDistributeRewards(to); // to correctly trigger _redeemExternalReward
+        address esHMX = IHMXVester(vester).esHMX();
+        uint256 amountToVest = IHMXStaking(hmxStakingPool).userTokenAmount(esHMX, address(this));
+        IHMXStaking(hmxStakingPool).withdraw(esHMX, amountToVest);
+
+        _safeApproveInf(esHMX, vester);
+        IHMXVester(vester).vestFor(to, amountToVest, 365 days);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                        OFF-CHAIN USAGE ONLY
+            (NO SECURITY RELATED && CAN BE LEFT UNAUDITED)
+    //////////////////////////////////////////////////////////////*/
+
+    function getPrice() external view returns (uint256) {
+        return HLPPricingHelper(hlpPriceHelper).getPrice();
+    }
+}

package/contracts/core/StandardizedYield/implementations/MantleStakedEth/PendleMantleStakedEthSY.sol

@@ -5,7 +5,7 @@ import "../../SYBase.sol";
 import "../../../../interfaces/IPOracleForSy.sol";
 
 contract PendleMantleStakedEthSY is SYBase {
-    using Math for int256;
+    using PMath for int256;
 
     address internal immutable underlyingAssetOnEthAddr;
     uint8 internal immutable underlyingAssetOnEthDecimals;

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

@@ -5,7 +5,7 @@ import "../SYBase.sol";
 import { AggregatorV2V3Interface as IChainlinkAggregator } from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";
 
 contract PendleArbitrumStakedEthSY is SYBase {
-    using Math for int256;
+    using PMath for int256;
 
     address public immutable chainlinkFeed;
     address internal immutable underlyingAssetOnEthAddr;

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

@@ -5,7 +5,7 @@ import "../SYBase.sol";
 import { AggregatorV2V3Interface as IChainlinkAggregator } from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";
 
 contract PendleBridgedLSDSY is SYBase {
-    using Math for int256;
+    using PMath for int256;
 
     address public immutable chainlinkFeed;
     address internal immutable underlyingAssetOnEthAddr;

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

@@ -5,7 +5,7 @@ import "../SYBase.sol";
 import "../../../interfaces/IERC4626.sol";
 
 contract PendleERC4626SY is SYBase {
-    using Math for uint256;
+    using PMath for uint256;
     address public immutable asset;
 
     constructor(

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

@@ -6,7 +6,7 @@ import "../../../interfaces/ILooksFeeSharing.sol";
 import "../../../interfaces/ILooksStaking.sol";
 
 contract PendleLooksStakingSY is SYBase {
-    using Math for uint256;
+    using PMath for uint256;
 
     address public immutable looks;
     address public immutable stakingContract;

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

@@ -9,7 +9,7 @@ import "../../../interfaces/IStargateStaking.sol";
 contract PendleStargateLPSY is SYBaseWithRewards {
     uint256 public constant STARGATE_BP_DENOMINATOR = 10000;
 
-    using Math for uint256;
+    using PMath for uint256;
 
     uint16 public immutable pid; // pool id
     uint256 public immutable sid; // staking id

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

@@ -5,7 +5,7 @@ import "../SYBase.sol";
 import "../../../interfaces/BinanceEth/IWBETH.sol";
 
 contract PendleWbEthSY is SYBase {
-    using Math for uint256;
+    using PMath for uint256;
 
     address public immutable eth;
     address public immutable wbETH;

package/contracts/core/StandardizedYield/implementations/Swell/PendleSwETH.sol

@@ -4,7 +4,7 @@ import "../../SYBase.sol";
 import "../../../../interfaces/ISwETH.sol";
 
 contract SwETHSY is SYBase {
-    using Math for uint256;
+    using PMath for uint256;
 
     address public immutable swETH;
 

package/contracts/core/StandardizedYield/implementations/Thena/PendleThenaSY.sol

@@ -12,7 +12,7 @@ contract PendleThenaSY is ThenaLpHelper, SYBaseWithRewards {
     event SetNewBinarySearchEps(uint256 newEps);
     event AddExternalRewardToken(address indexed token);
 
-    using Math for uint256;
+    using PMath for uint256;
     using ArrayLib for address[];
 
     address[] public externalRewardTokens;
@@ -73,7 +73,7 @@ contract PendleThenaSY is ThenaLpHelper, SYBaseWithRewards {
     }
 
     function exchangeRate() public view virtual override returns (uint256) {
-        return Math.ONE;
+        return PMath.ONE;
     }
 
     /*///////////////////////////////////////////////////////////////

package/contracts/core/StandardizedYield/implementations/Thena/ThenaLpHelper.sol

@@ -1,12 +1,12 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-pragma solidity >=0.8.0;
+pragma solidity ^0.8.0;
 
 import "../../../../interfaces/Thena/IThenaPair.sol";
 import "../../../../interfaces/Thena/IThenaRouter.sol";
 import "../../../../interfaces/Thena/IThenaFactory.sol";
 import "../../../libraries/TokenHelper.sol";
-import "../../../libraries/math/Math.sol";
+import "../../../libraries/math/PMath.sol";
 import "./ThenaMath.sol";
 
 abstract contract ThenaLpHelper is TokenHelper, ThenaMath {

package/contracts/core/StandardizedYield/implementations/Thena/ThenaMath.sol

@@ -1,12 +1,12 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-pragma solidity 0.8.17;
+pragma solidity ^0.8.0;
 
-import "../../../libraries/math/Math.sol";
+import "../../../libraries/math/PMath.sol";
 import "../../../../interfaces/Thena/IThenaPair.sol";
 
 abstract contract ThenaMath {
-    using Math for uint256;
+    using PMath for uint256;
 
     struct ThenaData {
         address pair;
@@ -53,11 +53,11 @@ abstract contract ThenaMath {
     ) private pure returns (uint256) {
 
         uint256 numer0 = (TWO - FEE_DENOMINATOR) * data.reserve0 / FEE_DENOMINATOR;
-        uint256 numer1 = Math.square(numer0);
-        uint256 numer2 = 4 * Math.square(ONE - data.fee) * amountIn * data.reserve0;
+        uint256 numer1 = PMath.square(numer0);
+        uint256 numer2 = 4 * PMath.square(ONE - data.fee) * amountIn * data.reserve0;
 
-        uint256 numer = Math.sqrt(numer1 + numer2) - numer0;
-        uint256 denom = 2 * Math.square(ONE - data.fee);
+        uint256 numer = PMath.sqrt(numer1 + numer2) - numer0;
+        uint256 denom = 2 * PMath.square(ONE - data.fee);
 
         return numer * FEE_DENOMINATOR / denom;
     }
@@ -69,7 +69,7 @@ abstract contract ThenaMath {
     ) private view returns (uint256) {
         StableBinarySearchParams memory params = _prepareStableBinarySearchParams(amountIn, data);
 
-        while (!Math.isAApproxB(params.guessMin, params.guessMax, binarySearchEps)) {
+        while (!PMath.isAApproxB(params.guessMin, params.guessMax, binarySearchEps)) {
             params.amountSwapIn = (params.guessMax + params.guessMin) / 2;
             params.amount1ToAddLiq = IThenaPair(data.pair).getAmountOut(
                 params.amountSwapIn,
@@ -122,7 +122,7 @@ abstract contract ThenaMath {
 
     // this returns the fourthRoot of y in base 18
     function _fourthRoot(uint256 y) private pure returns (uint256) {
-        uint256 root = Math.sqrt(y) * (10 ** 9);
-        return Math.sqrt(root) * (10 ** 9);
+        uint256 root = PMath.sqrt(y) * (10 ** 9);
+        return PMath.sqrt(root) * (10 ** 9);
     }
 }

package/contracts/core/StandardizedYield/implementations/Thena/ThenaPreview.sol

@@ -20,7 +20,7 @@ contract ThenaPreview is
     BoringOwnableUpgradeable,
     UUPSUpgradeable
 {
-    using Math for uint256;
+    using PMath for uint256;
 
     address internal immutable factory;
 
@@ -118,7 +118,7 @@ contract ThenaPreview is
 
         uint256 supply = IThenaPair(data.pair).totalSupply();
         return
-            Math.min(
+            PMath.min(
                 (amount0ToAddLiq * supply) / data.reserve0,
                 (amount1ToAddLiq * supply) / data.reserve1
             );