Merge branch 'master' into issue-68

Author: YouStillAlive

contracts/BNBPartyFactory.sol

@@ -37,7 +37,7 @@ contract BNBPartyFactory is BNBPartyLiquidity, ReentrancyGuard, BNBPartyManageab
         payable
         override
         nonReentrant
-        insufficientBNB
+        insufficientBNB(party.createTokenFee)
         whenNotPaused
         notZeroAddress(address(BNBPositionManager))
         returns (IERC20 newToken)
@@ -49,7 +49,6 @@ contract BNBPartyFactory is BNBPartyLiquidity, ReentrancyGuard, BNBPartyManageab
         lpToCreator[liquidityPool] = msg.sender; // Set the creator of the liquidity pool
         lpToTokenId[liquidityPool] = tokenId; // Set the token ID of the liquidity pool
         isParty[liquidityPool] = true; // Mark the liquidity pool as a party pool
-        isTokenOnPartyLP[address(newToken)] = true; // Mark the token as part of the party LP
         if (msg.value > party.createTokenFee) {
             _executeSwap(address(newToken));
         }
@@ -58,7 +57,8 @@ contract BNBPartyFactory is BNBPartyLiquidity, ReentrancyGuard, BNBPartyManageab
 
     /// @notice Handles token swaps for the liquidity pool
     /// @param recipient The address of the entity making the exchange
-    function handleSwap(address recipient) external override onlyParty notZeroAddress(recipient) whenNotPaused {
+    function handleSwap(address recipient) external override notZeroAddress(recipient) whenNotPaused {
+        if (!isParty[msg.sender]) revert LPNotAtParty(); // Reverts if the LP is not part of a party
         IUniswapV3Pool pool = IUniswapV3Pool(msg.sender);
 
         uint256 WBNBBalance = WBNB.balanceOf(msg.sender);

contracts/BNBPartyFee.sol

@@ -1,12 +1,12 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
-import "./BNBPartyModifiers.sol";
+import "./BNBPartyState.sol";
 import "./interfaces/IUniswapV3Pool.sol";
 
 /// @title BNBPartyFee
 /// @notice This abstract contract provides internal functions for calculating fees in the BNB Party system.
-abstract contract BNBPartyFee is BNBPartyModifiers {
+abstract contract BNBPartyFee is BNBPartyState {
     /// @notice Internal function to retrieve the fee growth inside the position from the last observation
     /// @param pool Address of the Uniswap V3 pool
     /// @return feeGrowthInside0LastX128 Fee growth inside for token0 from the last observation
@@ -126,4 +126,38 @@ abstract contract BNBPartyFee is BNBPartyModifiers {
             adjustedTicks = ticks;
         }
     }
+    
+    /// @notice Internal function to withdraw LP fees from specified liquidity pools
+    /// @param liquidityPools Array of liquidity pool addresses from which fees will be withdrawn
+    /// @param manager The non-fungible position manager used to collect fees
+    /// @dev Reverts if the liquidity pools array is empty
+    function _withdrawLPFees(
+        address[] calldata liquidityPools,
+        INonfungiblePositionManager manager
+    ) internal {
+        if (liquidityPools.length == 0) {
+            revert ZeroLength();
+        }
+        for (uint256 i = 0; i < liquidityPools.length; ++i) {
+            _collectFee(liquidityPools[i], manager); // Collects fees from each specified liquidity pool
+        }
+    }
+
+    /// @notice Internal function to collect LP fees from a specific liquidity pool
+    /// @param liquidityPool Address of the liquidity pool from which fees will be collected
+    /// @param manager The non-fungible position manager used to collect fees
+    /// @dev Reverts if the provided liquidity pool address is zero
+    function _collectFee(
+        address liquidityPool,
+        INonfungiblePositionManager manager
+    ) internal notZeroAddress(liquidityPool) {
+        manager.collect(
+            INonfungiblePositionManager.CollectParams({
+                tokenId: lpToTokenId[liquidityPool],
+                recipient: msg.sender,
+                amount0Max: type(uint128).max,
+                amount1Max: type(uint128).max
+            })
+        ); // Collects fees from the specified liquidity pool
+    }
 }

contracts/BNBPartyLiquidity.sol

@@ -25,7 +25,7 @@ abstract contract BNBPartyLiquidity is BNBPartyLiquidityHelper {
 
         if (token0 == address(WBNB)) {
             amount0 -= unwrapAmount; // Deduct unwrap amount from token0 if it is WBNB
-            isTokenOnPartyLP[token1] = false;
+            isTokenTargetReached[token1] = true;
             newSqrtPriceX96 = sqrtPriceCalculator.getNextSqrtPriceFromAmount0RoundingUp(
                 sqrtPriceX96,
                 liquidity,
@@ -34,7 +34,7 @@ abstract contract BNBPartyLiquidity is BNBPartyLiquidityHelper {
             );
         } else {
             amount1 -= unwrapAmount; // Deduct unwrap amount from token1 if it is WBNB
-            isTokenOnPartyLP[token0] = false;
+            isTokenTargetReached[token0] = true;
             newSqrtPriceX96 = sqrtPriceCalculator.getNextSqrtPriceFromAmount1RoundingDown(
                 sqrtPriceX96,
                 liquidity,

contracts/BNBPartyManageable.sol

@@ -1,12 +1,12 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
-import "./BNBPartyModifiers.sol";
+import "./BNBPartyFee.sol";
 import "@openzeppelin/contracts/utils/Pausable.sol";
 
 /// @title BNBPartyManageable
 /// @notice This abstract contract provides management functions for setting position managers, swap routers, and withdrawing fees in the BNBParty system.
-abstract contract BNBPartyManageable is BNBPartyModifiers, Pausable {
+abstract contract BNBPartyManageable is BNBPartyFee, Pausable {
     /// @notice Sets the non-fungible position managers for BNB Party and Pancakeswap V3
     /// @param _BNBPositionManager Address of the new BNB Party non-fungible position manager
     /// @param _positionManager Address of the new Pancakeswap V3 non-fungible position manager
@@ -69,38 +69,4 @@ abstract contract BNBPartyManageable is BNBPartyModifiers, Pausable {
     function unpause() external onlyOwner {
         _unpause();
     }
-
-    /// @notice Internal function to withdraw LP fees from specified liquidity pools
-    /// @param liquidityPools Array of liquidity pool addresses from which fees will be withdrawn
-    /// @param manager The non-fungible position manager used to collect fees
-    /// @dev Reverts if the liquidity pools array is empty
-    function _withdrawLPFees(
-        address[] calldata liquidityPools,
-        INonfungiblePositionManager manager
-    ) internal {
-        if (liquidityPools.length == 0) {
-            revert ZeroLength();
-        }
-        for (uint256 i = 0; i < liquidityPools.length; ++i) {
-            _collectFee(liquidityPools[i], manager); // Collects fees from each specified liquidity pool
-        }
-    }
-
-    /// @notice Internal function to collect LP fees from a specific liquidity pool
-    /// @param liquidityPool Address of the liquidity pool from which fees will be collected
-    /// @param manager The non-fungible position manager used to collect fees
-    /// @dev Reverts if the provided liquidity pool address is zero
-    function _collectFee(
-        address liquidityPool,
-        INonfungiblePositionManager manager
-    ) internal notZeroAddress(liquidityPool) {
-        manager.collect(
-            INonfungiblePositionManager.CollectParams({
-                tokenId: lpToTokenId[liquidityPool],
-                recipient: msg.sender,
-                amount0Max: type(uint128).max,
-                amount1Max: type(uint128).max
-            })
-        ); // Collects fees from the specified liquidity pool
-    }
 }

contracts/BNBPartyModifiers.sol

@@ -1,18 +1,12 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
-import "./BNBPartyState.sol";
+import "./interfaces/IBNBPartyFactory.sol";
+import "@bnb-party/v3-periphery/contracts/interfaces/ISwapRouter.sol";
 
 /// @title BNBPartyModifiers
 /// @notice This abstract contract provides various modifiers used in the BNBParty system to enforce conditions on function calls.
-abstract contract BNBPartyModifiers is BNBPartyState {
-    /// @notice Restricts function access to liquidity pools that are part of a party
-    /// @dev Reverts if the caller is not a registered party liquidity pool
-    modifier onlyParty() {
-        if (!isParty[msg.sender]) revert LPNotAtParty();
-        _;
-    }
-
+abstract contract BNBPartyModifiers is IBNBPartyFactory{
     /// @notice Ensures the provided address is not a zero address
     /// @param _address Address to be checked
     /// @dev Reverts if the address is zero
@@ -23,8 +17,8 @@ abstract contract BNBPartyModifiers is BNBPartyState {
 
     /// @notice Ensures the amount of BNB sent is sufficient to cover the token creation fee
     /// @dev Reverts if the sent BNB is less than the required fee
-    modifier insufficientBNB() {
-        if (msg.value < party.createTokenFee) revert InsufficientBNB();
+    modifier insufficientBNB(uint256 fee) {
+        if (msg.value < fee) revert InsufficientBNB();
         _;
     }
 

contracts/BNBPartyState.sol

@@ -2,24 +2,23 @@
 pragma solidity ^0.8.0;
 
 import "@openzeppelin/contracts/access/Ownable.sol";
-import "@bnb-party/v3-periphery/contracts/interfaces/ISwapRouter.sol";
 import "./interfaces/ISqrtPriceCalculator.sol";
 import "./interfaces/INonfungiblePositionManager.sol";
-import "./interfaces/IBNBPartyFactory.sol";
 import "./interfaces/IWBNB.sol";
+import "./BNBPartyModifiers.sol";
 
 /// @title BNBPartyState
 /// @notice This abstract contract handles the state variables and initial setup for the BNBParty system.
-abstract contract BNBPartyState is IBNBPartyFactory, Ownable {
+abstract contract BNBPartyState is BNBPartyModifiers, Ownable {
     INonfungiblePositionManager public BNBPositionManager; // BNB Party position manager
     INonfungiblePositionManager public positionManager; // Default Pancakeswap V3 position manager
     ISwapRouter public BNBSwapRouter; // V3 swap router
     ISwapRouter public swapRouter; // Pancakeswap V3 router
     mapping(address => bool) public isParty; // Mapping to track if a LiquidityPool is a party
     mapping(address => uint256) public lpToTokenId; // Mapping from LiquidityPool to its NFT tokenId
     mapping(address => address) public lpToCreator; // Mapping from LiquidityPool to its creator
-    mapping(address => bool) public isTokenOnPartyLP; // Mapping to track if a token is part of a party
-    uint256 constant FEE_GROWTH_GLOBAL_SCALE = 2**128;
+    mapping(address => bool) public isTokenTargetReached; // Mapping to track if a token has reached its target
+    uint256 constant public FEE_GROWTH_GLOBAL_SCALE = 2**128;
 
     Party public party; // store party parameters
 
@@ -29,27 +28,32 @@ abstract contract BNBPartyState is IBNBPartyFactory, Ownable {
     /// @notice Constructor to initialize the BNBPartyState contract
     /// @param _party Struct containing party parameters
     /// @param _WBNB Address of the Wrapped BNB token contract
-    constructor(Party memory _party, IWBNB _WBNB, ISqrtPriceCalculator _sqrtPriceCalculator) Ownable(_msgSender()) {
-        if (address(_WBNB) == address(0)) {
-            revert ZeroAddress(); // Reverts if the WBNB address is zero
-        }
-        if(address(_sqrtPriceCalculator) == address(0)) {
-            revert ZeroAddress(); // Reverts if the sqrt price calculator address is zero
-        }
-        if (_party.partyTarget == 0) {
-            revert ZeroAmount(); // Reverts if the party target is zero
-        }
-        if (_party.initialTokenAmount == 0) {
-            revert ZeroAmount(); // Reverts if the initial token amount is zero
-        }
-        if (_party.partyTarget <= (_party.bonusPartyCreator + _party.bonusTargetReach + _party.targetReachFee)) {
-            revert BonusGreaterThanTarget(); // Reverts if the party target is less than or equal to the sum of bonuses and fees
-        }
-        if (_party.sqrtPriceX96 == 0) {
-            revert ZeroAmount(); // Reverts if the sqrt price is zero
-        }
+    constructor(
+        Party memory _party,
+        IWBNB _WBNB,
+        ISqrtPriceCalculator _sqrtPriceCalculator
+    ) Ownable(_msgSender()) {
+        _constructorValidation(_party, _WBNB, _sqrtPriceCalculator);
         party = _party;
         WBNB = _WBNB;
         sqrtPriceCalculator = _sqrtPriceCalculator;
     }
+
+    function _constructorValidation(
+        Party memory _party,
+        IWBNB _WBNB,
+        ISqrtPriceCalculator _sqrtPriceCalculator
+    )
+        private
+        pure
+        notZeroAddress(address(_WBNB))
+        notZeroAddress(address(_sqrtPriceCalculator))
+        notZeroAmount(_party.partyTarget)
+        notZeroAmount(_party.initialTokenAmount)
+        notZeroAmount(_party.sqrtPriceX96)
+    {
+        if (_party.partyTarget <= (_party.bonusPartyCreator + _party.bonusTargetReach + _party.targetReachFee)) {
+            revert BonusGreaterThanTarget(); // Reverts if the party target is less than or equal to the sum of bonuses and fees
+        }
+    }
 }

contracts/BNBPartySwaps.sol

@@ -81,12 +81,12 @@ abstract contract BNBPartySwaps is BNBPartyView {
     /// @return router The address of the swap router
     /// @return fee The fee amount for the swap
     function _getRouterAndFee(address token) internal view returns (ISwapRouter router, uint24 fee) {
-        if (isTokenOnPartyLP[token]) {
-            router = BNBSwapRouter;
-            fee = party.partyLpFee;
-        } else {
+        if (isTokenTargetReached[token]) {
             router = swapRouter;
             fee = party.lpFee;
+        } else {
+            router = BNBSwapRouter;
+            fee = party.partyLpFee;
         }
     }
 }