@pendle/core-v2 0.17.5-testnet → 0.17.6-testnet

package/contracts/LiquidityMining/VotingController/VotingControllerStorageUpg.sol

@@ -13,10 +13,6 @@ import "../../core/libraries/Errors.sol";
 
 import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
 
-/// This contract is upgradable because
-/// - its constructor only sets immutable variables
-/// - it has storage gaps for safe addition of future variables
-/// - it inherits only upgradable contract
 abstract contract VotingControllerStorageUpg is IPVotingController {
     using VeBalanceLib for VeBalance;
     using VeBalanceLib for LockedPosition;
@@ -50,7 +46,7 @@ abstract contract VotingControllerStorageUpg is IPVotingController {
 
     uint128 public constant MAX_LOCK_TIME = 104 weeks;
     uint128 public constant WEEK = 1 weeks;
-    uint128 public constant GOVERNANCE_PENDLE_VOTE = 10**24;
+    uint128 public constant GOVERNANCE_PENDLE_VOTE = 10 * (10**6) * (10**18); // 10 mils of PENDLE
 
     IPVeToken public immutable vePendle;
 
@@ -147,12 +143,10 @@ abstract contract VotingControllerStorageUpg is IPVotingController {
         for (uint256 i = 0; i < pools.length; ++i) poolVotes[i] = data.poolVotes[pools[i]];
     }
 
-    /// @dev trivial view function
     function getAllActivePools() external view returns (address[] memory) {
         return allActivePools.values();
     }
 
-    /// @dev trivial view function
     function getAllRemovedPools(uint256 start, uint256 end)
         external
         view
@@ -166,12 +160,10 @@ abstract contract VotingControllerStorageUpg is IPVotingController {
         for (uint256 i = start; i <= end; ++i) arr[i - start] = allRemovedPools.at(i);
     }
 
-    /// @dev trivial view function
     function getActiveChainPools(uint64 chainId) external view returns (address[] memory) {
         return activeChainPools[chainId].values();
     }
 
-    /// @dev trivial view function
     function getUserPoolVote(address user, address pool)
         external
         view
@@ -193,14 +185,9 @@ abstract contract VotingControllerStorageUpg is IPVotingController {
     }
 
     /*///////////////////////////////////////////////////////////////
-                            INTERNAL DATA MANIPULATION FUNCTIONS
+                INTERNAL DATA MANIPULATION FUNCTIONS
     //////////////////////////////////////////////////////////////*/
 
-    /**
-    * @dev expected behavior:
-        - add to allActivePools, activeChainPools
-        - set params in poolData
-     */
     function _addPool(uint64 chainId, address pool) internal {
         if (!activeChainPools[chainId].add(pool)) assert(false);
         if (!allActivePools.add(pool)) assert(false);
@@ -209,12 +196,6 @@ abstract contract VotingControllerStorageUpg is IPVotingController {
         poolData[pool].lastSlopeChangeAppliedAt = WeekMath.getCurrentWeekStart();
     }
 
-    /**
-    * @dev expected behavior:
-        - remove from allActivePool, activeChainPools
-        - add to allRemovedPools
-        - clear all params in poolData
-     */
     function _removePool(address pool) internal {
         uint64 chainId = poolData[pool].chainId;
         if (!activeChainPools[chainId].remove(pool)) assert(false);
@@ -224,10 +205,6 @@ abstract contract VotingControllerStorageUpg is IPVotingController {
         delete poolData[pool];
     }
 
-    /**
-     * @notice set the final pool vote for weekData
-     * @dev assumption: weekData[wTime].poolVotes[pool] == 0
-     */
     function _setFinalPoolVoteForWeek(
         address pool,
         uint128 wTime,
@@ -247,6 +224,10 @@ abstract contract VotingControllerStorageUpg is IPVotingController {
         emit PoolVoteChange(pool, vote);
     }
 
+    /**
+     * @notice modifies `user`'s vote weight on `pool`
+     * @dev works by simply removing the old vote position, then adds in a fresh vote
+     */
     function _modifyVoteWeight(
         address user,
         address pool,

package/contracts/LiquidityMining/VotingEscrow/VotingEscrowPendleMainchain.sol

@@ -66,14 +66,14 @@ contract VotingEscrowPendleMainchain is
     }
 
     /**
-     * @notice increase the lock position of an user. Applicable even when user has no position or the
-        current position has expired
-     * @dev expected state changes:
-        - a new lock with amount = amountToPull + amountExpired, expiry = expiry is created for msg.sender in positionData
-        - pendle is taken in if necessary
-        - _totalSupply, lastSlopeChangeAppliedAt, slopeChanges, totalSupplyAt is updated
-        - a checkpoint is added
-     * @dev broadcast is not bundled since it can be done anytime after
+     * @notice increases the lock position of a user (amount and/or expiry). Applicable even when
+     * user has no position or the current position has expired.
+     * @param additionalAmountToLock pendle amount to be pulled in from user to lock.
+     * @param newExpiry new lock expiry. Must be a valid week beginning, and resulting lock
+     * duration (since `block.timestamp`) must be within the allowed range.
+     * @dev Will revert if resulting position has zero lock amount.
+     * @dev See `_increasePosition()` for details on inner workings.
+     * @dev Sidechain broadcasting is not bundled since it can be done anytime after.
      */
     function increaseLockPosition(uint128 additionalAmountToLock, uint128 newExpiry)
         public
@@ -104,13 +104,8 @@ contract VotingEscrowPendleMainchain is
     }
 
     /**
-     * @notice withdraw an expired lock position, get back all locked PENDLE
-     * @dev expected state changes:
-        - positionData is cleared
-        - pendle is transferred out
-        - _totalSupply, lastSlopeChangeAppliedAt, slopeChanges, totalSupplyAt all doesn't need to be updated
-            since these data will automatically hold true when _applySlopeChange() is called
-        - no checkpoint is added
+     * @notice Withdraws an expired lock position, returns locked PENDLE back to user
+     * @dev reverts if position is not expired, or if no locked PENDLE to withdraw
      * @dev broadcast is not bundled since it can be done anytime after
      */
     function withdraw() external returns (uint128 amount) {
@@ -129,9 +124,8 @@ contract VotingEscrowPendleMainchain is
     }
 
     /**
-     * @notice update & return the current totalSupply
-     * @dev state changes expected:
-        - _totalSupply & lastSlopeChangeAppliedAt is updated
+     * @notice update & return the current totalSupply, but does not broadcast info to other chains
+     * @dev See `broadcastTotalSupply()` and `broadcastUserPosition()` for broadcasting
      */
     function totalSupplyCurrent()
         public
@@ -143,19 +137,14 @@ contract VotingEscrowPendleMainchain is
         return supply.getCurrentValue();
     }
 
-    /**
-     * @notice broadcast the totalSupply to different chains
-     * @dev state changes expected:
-        - all chains in chainIds receive the new totalSupply
-     */
+    /// @notice updates and broadcast the current totalSupply to different chains
     function broadcastTotalSupply(uint256[] calldata chainIds) public payable refundUnusedEth {
         _broadcastPosition(address(0), chainIds);
     }
 
     /**
-     * @notice broadcast the position of users to different chains
-     * @dev state changes expected:
-        - all chains in chainIds receive the new totalSupply & user's new position
+     * @notice updates and broadcast the position of `user` to different chains, also updates and
+     * broadcasts totalSupply
      */
     function broadcastUserPosition(address user, uint256[] calldata chainIds)
         public
@@ -200,13 +189,8 @@ contract VotingEscrowPendleMainchain is
 
     /**
      * @notice increase the locking position of the user
-     * @dev it works by simply removing the old position from all relevant data (as if the user has never locked) and
-        then add in the new position
-      * @dev expected state changes:
-        - a new lock with the amount & expiry increase accordingly
-        - pendle is taken in if necessary
-        - _totalSupply, lastSlopeChangeAppliedAt, slopeChanges, totalSupplyAt is updated
-        - a checkpoint is added
+     * @dev works by simply removing the old position from all relevant data (as if the user has
+     * never locked) and then add in the new position
      */
     function _increasePosition(
         address user,
@@ -241,10 +225,8 @@ contract VotingEscrowPendleMainchain is
     }
 
     /**
-     * @notice update the totalSupply, processing all slope changes of past weeks. At the same time, set the finalized
-        totalSupplyAt
-     * @dev state changes expected:
-        - _totalSupply, lastSlopeChangeAppliedAt, totalSupplyAt is updated
+     * @notice updates the totalSupply, processing all slope changes of past weeks. At the same time,
+     * set the finalized totalSupplyAt
      */
     function _applySlopeChange() internal returns (VeBalance memory, uint128) {
         VeBalance memory supply = _totalSupply;
@@ -271,7 +253,7 @@ contract VotingEscrowPendleMainchain is
     function _broadcastPosition(address user, uint256[] calldata chainIds) internal {
         if (chainIds.length == 0) revert Errors.ArrayEmpty();
 
-        (VeBalance memory supply,) = _applySlopeChange();
+        (VeBalance memory supply, ) = _applySlopeChange();
 
         bytes memory userData = (
             user == address(0) ? EMPTY_BYTES : abi.encode(user, positionData[user])

package/contracts/LiquidityMining/libraries/VeHistoryLib.sol

@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: MIT
+// SPDX-License-Identifier: GPL-3.0-or-later
 // Forked from OpenZeppelin (v4.5.0) (utils/Checkpoints.sol)
 pragma solidity ^0.8.0;
 

package/contracts/core/BulkSeller/BulkSeller.sol

@@ -18,29 +18,6 @@ contract BulkSeller is IPBulkSeller, Initializable, TokenHelper, ReentrancyGuard
     using SafeERC20 for IERC20;
     using BulkSellerMathCore for BulkSellerState;
 
-    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);
-
     struct BulkSellerStorage {
         uint128 rateTokenToSy;
         uint128 rateSyToToken;
@@ -61,11 +38,6 @@ contract BulkSeller is IPBulkSeller, Initializable, TokenHelper, ReentrancyGuard
         _;
     }
 
-    modifier onlyAdmin() {
-        if (!IPBulkSellerFactory(factory).isAdmin(msg.sender)) revert Errors.BulkNotAdmin();
-        _;
-    }
-
     // Since this contract is a beacon contract, no constructor should be defined.
     function initialize(
         address _token,
@@ -76,46 +48,52 @@ contract BulkSeller is IPBulkSeller, Initializable, TokenHelper, ReentrancyGuard
         token = _token;
         SY = _SY;
         factory = _factory;
+        _safeApproveInf(token, SY);
     }
 
     function swapExactTokenForSy(
         address receiver,
         uint256 netTokenIn,
         uint256 minSyOut
-    ) external nonReentrant returns (uint256 netSyOut) {
+    ) 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);
 
-        if (receiver != address(this)) _transferOut(SY, receiver, netSyOut);
+        _transferOut(SY, receiver, netSyOut);
 
         _writeState(state);
 
-        if (_selfBalance(token) < state.totalToken)
-            revert Errors.BulkInsufficientTokenReceived(_selfBalance(token), state.totalToken);
-
         emit SwapExactTokenForSy(receiver, netTokenIn, netSyOut);
     }
 
     function swapExactSyForToken(
         address receiver,
         uint256 exactSyIn,
-        uint256 minTokenOut
+        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(exactSyIn, netSyReceived);
+        }
+
         netTokenOut = state.swapExactSyForToken(exactSyIn);
 
         if (netTokenOut < minTokenOut)
             revert Errors.BulkInSufficientTokenOut(netTokenOut, minTokenOut);
-        if (receiver != address(this)) _transferOut(token, receiver, netTokenOut);
 
-        _writeState(state);
+        _transferOut(token, receiver, netTokenOut);
 
-        if (_selfBalance(SY) < state.totalSy)
-            revert Errors.BulkInsufficientSyReceived(_selfBalance(SY), state.totalSy);
+        _writeState(state);
 
         emit SwapExactSyForToken(receiver, exactSyIn, netTokenOut);
     }
@@ -159,7 +137,7 @@ contract BulkSeller is IPBulkSeller, Initializable, TokenHelper, ReentrancyGuard
         _writeState(state);
     }
 
-    function decreaseReserve(uint256 netTokenOut, uint256 netSyOut) external onlyAdmin {
+    function decreaseReserve(uint256 netTokenOut, uint256 netSyOut) external onlyMaintainer {
         BulkSellerState memory state = readState();
 
         if (netTokenOut == type(uint256).max) netTokenOut = state.totalToken;
@@ -176,6 +154,24 @@ contract BulkSeller is IPBulkSeller, Initializable, TokenHelper, ReentrancyGuard
         _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();
@@ -224,7 +220,6 @@ contract BulkSeller is IPBulkSeller, Initializable, TokenHelper, ReentrancyGuard
     }
 
     function _depositToken(uint256 netTokenDeposit) internal returns (uint256 netSyFromToken) {
-        _safeApprove(token, SY, netTokenDeposit);
         uint256 nativeToDeposit = token == NATIVE ? netTokenDeposit : 0;
         return
             IStandardizedYield(SY).deposit{ value: nativeToDeposit }(
@@ -239,6 +234,4 @@ contract BulkSeller is IPBulkSeller, Initializable, TokenHelper, ReentrancyGuard
         _transferOut(SY, SY, netSyRedeem);
         return IStandardizedYield(SY).redeem(address(this), netSyRedeem, token, 0, true);
     }
-
-    receive() external payable {}
 }

package/contracts/core/BulkSeller/BulkSellerFactory.sol

@@ -25,8 +25,8 @@ contract BulkSellerFactory is
 
     mapping(address => mapping(address => address)) internal syToBulkSeller;
 
-    modifier onlyAdmin() {
-        if (!isAdmin(msg.sender)) revert Errors.BulkNotAdmin();
+    modifier onlyMaintainer() {
+        if (!isMaintainer(msg.sender)) revert Errors.BulkNotMaintainer();
         _;
     }
 
@@ -39,7 +39,7 @@ contract BulkSellerFactory is
 
     function createBulkSeller(address token, address SY)
         external
-        onlyAdmin
+        onlyMaintainer
         returns (address bulk)
     {
         IStandardizedYield _SY = IStandardizedYield(SY);
@@ -72,12 +72,8 @@ contract BulkSellerFactory is
         return (hasRole(DEFAULT_ADMIN_ROLE, addr) || hasRole(MAINTAINER, addr));
     }
 
-    function isAdmin(address addr) public view override returns (bool) {
-        return hasRole(DEFAULT_ADMIN_ROLE, addr);
-    }
-
     // ----------------- upgrade-related -----------------
-    function upgradeBeacon(address newImplementation) public onlyAdmin {
+    function upgradeBeacon(address newImplementation) public onlyMaintainer {
         require(
             AddressUpgradeable.isContract(newImplementation),
             "UpgradeableBeacon: implementation is not a contract"
@@ -86,5 +82,5 @@ contract BulkSellerFactory is
         emit UpgradedBeacon(newImplementation);
     }
 
-    function _authorizeUpgrade(address) internal override onlyAdmin {}
+    function _authorizeUpgrade(address) internal override onlyMaintainer {}
 }

package/contracts/core/BulkSeller/BulkSellerMathCore.sol

@@ -76,13 +76,14 @@ library BulkSellerMathCore {
         uint256 currentTokenProp = getTokenProp(state);
 
         if (currentTokenProp > targetTokenProp) {
-            netTokenToDeposit = state.totalToken.mulDown(
-                (currentTokenProp - targetTokenProp).divDown(currentTokenProp)
-            );
+            netTokenToDeposit = state
+                .totalToken
+                .mulDown(currentTokenProp - targetTokenProp)
+                .divDown(currentTokenProp);
         } else {
             uint256 currentSyProp = Math.ONE - currentTokenProp;
-            netSyToRedeem = state.totalSy.mulDown(
-                (targetTokenProp - currentTokenProp).divDown(currentSyProp)
+            netSyToRedeem = state.totalSy.mulDown(targetTokenProp - currentTokenProp).divDown(
+                currentSyProp
             );
         }
     }

package/contracts/core/StandardizedYield/implementations/BenQi/PendleQiTokenSY.sol

@@ -35,9 +35,7 @@ contract PendleQiTokenSY is SYBaseWithRewards, PendleQiTokenHelper {
         QI = IBenQiComptroller(comptroller).qiAddress();
         WAVAX = _WAVAX;
 
-        if (underlying != NATIVE) {
-            _safeApprove(underlying, qiToken, type(uint256).max);
-        }
+        _safeApproveInf(underlying, qiToken);
     }
 
     /*///////////////////////////////////////////////////////////////

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

@@ -102,7 +102,7 @@ library CurveUsdd3CrvPoolHelper {
     {
         uint256[N_COINS] memory result;
         for (uint256 i = 0; i < N_COINS; ++i) {
-            result[i] = balances[i] * _rates[i] / PRECISION;
+            result[i] = (balances[i] * _rates[i]) / PRECISION;
         }
         return result;
     }

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

@@ -32,7 +32,7 @@ abstract contract PendleConvexLPSY is SYBaseWithRewards {
         (crvLp, cvxRewardManager) = _getPoolInfo(cvxPid);
         if (crvLp != _crvLp) revert Errors.SYCurveInvalidPid();
 
-        _safeApprove(crvLp, BOOSTER, type(uint256).max);
+        _safeApproveInf(crvLp, BOOSTER);
     }
 
     function _getPoolInfo(uint256 _cvxPid)

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

@@ -20,7 +20,7 @@ contract PendleWstEthSY is SYBase {
         wETH = _wETH;
         wstETH = _wstETH;
         stETH = IWstETH(wstETH).stETH();
-        _safeApprove(stETH, wstETH, type(uint256).max);
+        _safeApproveInf(stETH, wstETH);
     }
 
     /*///////////////////////////////////////////////////////////////

package/contracts/core/YieldContracts/PendleYieldToken.sol

@@ -66,8 +66,8 @@ contract PendleYieldToken is
     }
 
     /**
-     * @param _doCacheIndexSameBlock if true, the PY index is cached for each block, and thus is 
-     * constant for all txs within the same block. Otherwise, the PY index is recalculated for 
+     * @param _doCacheIndexSameBlock if true, the PY index is cached for each block, and thus is
+     * constant for all txs within the same block. Otherwise, the PY index is recalculated for
      * every tx.
      */
     constructor(
@@ -131,7 +131,7 @@ contract PendleYieldToken is
     }
 
     /**
-     * @notice converts PT(+YT) tokens into SY, but interests & rewards are not redeemed at the 
+     * @notice converts PT(+YT) tokens into SY, but interests & rewards are not redeemed at the
      * same time
      * @dev PT/YT must be transferred to this contract prior to calling
      */
@@ -172,9 +172,9 @@ contract PendleYieldToken is
      * @param redeemInterest will only transfer out interest for user if true
      * @param redeemRewards will only transfer out rewards for user if true
      * @dev With YT yielding interest in the form of SY, which is redeemable by users, the reward
-     * distribution should be based on the amount of SYs that their YT currently represent, plus 
-     * their dueInterest. It has been proven and tested that _rewardSharesUser will not change over 
-     * time, unless users redeem their dueInterest or redeemPY. Due to this, it is required to 
+     * distribution should be based on the amount of SYs that their YT currently represent, plus
+     * their dueInterest. It has been proven and tested that _rewardSharesUser will not change over
+     * time, unless users redeem their dueInterest or redeemPY. Due to this, it is required to
      * update users' accruedReward STRICTLY BEFORE transferring out their interest.
      */
     function redeemDueInterestAndRewards(

package/contracts/core/erc20/PendleERC20.sol

@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: MIT
+// SPDX-License-Identifier: GPL-3.0-or-later
 // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/ERC20.sol)
 
 pragma solidity ^0.8.0;
@@ -26,7 +26,7 @@ contract PendleERC20 is Context, IERC20, IERC20Metadata {
     mapping(address => mapping(address => uint256)) private _allowances;
 
     uint248 private _totalSupply;
-    uint8 private _status; 
+    uint8 private _status;
 
     string private _name;
     string private _symbol;

package/contracts/core/erc20/PendleERC20Permit.sol

@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: MIT
+// SPDX-License-Identifier: GPL-3.0-or-later
 // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/ERC20.sol)
 
 pragma solidity ^0.8.0;

package/contracts/core/libraries/ArrayLib.sol

@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: AGPL-3.0-only
+// SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity >=0.8.0;
 
 library ArrayLib {

package/contracts/core/libraries/BoringOwnableUpgradeable.sol

@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: MIT
+// SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.17;
 
 import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";

package/contracts/core/libraries/Errors.sol

@@ -9,7 +9,6 @@ library Errors {
     error BulkInsufficientTokenForTrade(uint256 currentAmount, uint256 requiredAmount);
     error BulkInSufficientSyOut(uint256 actualSyOut, uint256 requiredSyOut);
     error BulkInSufficientTokenOut(uint256 actualTokenOut, uint256 requiredTokenOut);
-    error BulkInsufficientTokenReceived(uint256 actualBalance, uint256 requiredBalance);
     error BulkInsufficientSyReceived(uint256 actualBalance, uint256 requiredBalance);
     error BulkNotMaintainer();
     error BulkNotAdmin();

package/contracts/core/libraries/MiniHelpers.sol

@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.17;
 
 library MiniHelpers {

package/contracts/core/libraries/TokenHelper.sol

@@ -64,10 +64,7 @@ abstract contract TokenHelper {
     }
 
     /// @notice Approves the stipulated contract to spend the given allowance in the given token
-    /// @dev Errors with 'SA' if transfer fails
-    /// @param token The contract address of the token to be approved
-    /// @param to The target of the approval
-    /// @param value The amount of the given token the target will be allowed to spend
+    /// @dev PLS PAY ATTENTION to tokens that requires the approval to be set to 0 before changing it
     function _safeApprove(
         address token,
         address to,
@@ -81,7 +78,9 @@ abstract contract TokenHelper {
 
     function _safeApproveInf(address token, address to) internal {
         if (token == NATIVE) return;
-        if (IERC20(token).allowance(address(this), to) < LOWER_BOUND_APPROVAL)
+        if (IERC20(token).allowance(address(this), to) < LOWER_BOUND_APPROVAL) {
+            _safeApprove(token, to, 0);
             _safeApprove(token, to, type(uint256).max);
+        }
     }
 }

package/contracts/interfaces/Curve/ICrvPool.sol

@@ -25,10 +25,9 @@ interface ICrvPool {
         uint256 min_dy // The amount of i being exchanged.
     ) external returns (uint256);
 
-    function add_liquidity(
-        uint256[2] memory _deposit_amount,
-        uint256 _min_amount
-    ) external returns (uint256 lpOut);
+    function add_liquidity(uint256[2] memory _deposit_amount, uint256 _min_amount)
+        external
+        returns (uint256 lpOut);
 
     function remove_liquidity_one_coin(
         uint256 _burn_amount,

package/contracts/interfaces/Curve/ITriCrvPool.sol

@@ -19,10 +19,7 @@ interface ITriCrvPool {
         uint256 min_dy // The amount of i being exchanged.
     ) external returns (uint256);
 
-    function add_liquidity(
-        uint256[3] memory _deposit_amount,
-        uint256 _min_amount
-    ) external;
+    function add_liquidity(uint256[3] memory _deposit_amount, uint256 _min_amount) external;
 
     function remove_liquidity_one_coin(
         uint256 _burn_amount,

package/contracts/interfaces/IBoringOwnableUpgradeable.sol

@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: MIT
+// SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.17;
 
 interface IBoringOwnableUpgradeable {
@@ -7,4 +7,4 @@ interface IBoringOwnableUpgradeable {
         bool direct,
         bool renounce
     ) external;
-}
+}

package/contracts/interfaces/ILayerZeroEndpoint.sol

@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: MIT
+// SPDX-License-Identifier: GPL-3.0-or-later
 
 pragma solidity >=0.5.0;
 

package/contracts/interfaces/ILayerZeroReceiver.sol

@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: BUSL-1.1
+// SPDX-License-Identifier: GPL-3.0-or-later
 
 pragma solidity >=0.5.0;
 
@@ -8,5 +8,10 @@ interface ILayerZeroReceiver {
     // @param _srcAddress - the source sending contract address from the source chain
     // @param _nonce - the ordered message nonce
     // @param _payload - the signed payload is the UA bytes has encoded to be sent
-    function lzReceive(uint16 _srcChainId, bytes calldata _srcAddress, uint64 _nonce, bytes calldata _payload) external;
-}
+    function lzReceive(
+        uint16 _srcChainId,
+        bytes calldata _srcAddress,
+        uint64 _nonce,
+        bytes calldata _payload
+    ) external;
+}