@gooddollar/goodcollective-contracts 1.2.0 → 1.3.0

package/contracts/DirectPayments/DirectPaymentsFactory.sol

@@ -11,7 +11,7 @@ import "@openzeppelin/contracts/proxy/beacon/UpgradeableBeacon.sol";
 import { AccessControlUpgradeable } from "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
 import { UUPSUpgradeable } from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
 
-import "hardhat/console.sol";
+// import "hardhat/console.sol";
 
 contract DirectPaymentsFactory is AccessControlUpgradeable, UUPSUpgradeable {
     error NOT_PROJECT_OWNER();
@@ -98,18 +98,20 @@ contract DirectPaymentsFactory is AccessControlUpgradeable, UUPSUpgradeable {
         string memory _projectId,
         string memory _ipfs,
         DirectPaymentsPool.PoolSettings memory _settings,
-        DirectPaymentsPool.SafetyLimits memory _limits
+        DirectPaymentsPool.SafetyLimits memory _limits,
+        uint32 _managerFeeBps
     ) external onlyProjectOwnerOrNon(_projectId) returns (DirectPaymentsPool pool) {
-        return _createPool(_projectId, _ipfs, _settings, _limits, true);
+        return _createPool(_projectId, _ipfs, _settings, _limits, _managerFeeBps, true);
     }
 
     function createPool(
         string memory _projectId,
         string memory _ipfs,
         DirectPaymentsPool.PoolSettings memory _settings,
-        DirectPaymentsPool.SafetyLimits memory _limits
+        DirectPaymentsPool.SafetyLimits memory _limits,
+        uint32 _managerFeeBps
     ) external onlyProjectOwnerOrNon(_projectId) returns (DirectPaymentsPool pool) {
-        return _createPool(_projectId, _ipfs, _settings, _limits, false);
+        return _createPool(_projectId, _ipfs, _settings, _limits, _managerFeeBps, false);
     }
 
     function _createPool(
@@ -117,12 +119,16 @@ contract DirectPaymentsFactory is AccessControlUpgradeable, UUPSUpgradeable {
         string memory _ipfs,
         DirectPaymentsPool.PoolSettings memory _settings,
         DirectPaymentsPool.SafetyLimits memory _limits,
+        uint32 _managerFeeBps,
         bool useBeacon
     ) internal returns (DirectPaymentsPool pool) {
         //TODO: add check if msg.sender is whitelisted
 
         _settings.nftType = nextNftType;
-        bytes memory initCall = abi.encodeCall(DirectPaymentsPool.initialize, (nft, _settings, _limits, this));
+        bytes memory initCall = abi.encodeCall(
+            DirectPaymentsPool.initialize,
+            (nft, _settings, _limits, _managerFeeBps, this)
+        );
 
         if (useBeacon) {
             pool = DirectPaymentsPool(address(new BeaconProxy(address(impl), initCall)));
@@ -130,7 +136,6 @@ contract DirectPaymentsFactory is AccessControlUpgradeable, UUPSUpgradeable {
             pool = DirectPaymentsPool(address(new ERC1967Proxy(impl.implementation(), initCall)));
         }
 
-        nft.grantRole(nft.getManagerRole(nextNftType), _settings.manager);
         nft.grantRole(nft.getManagerRole(nextNftType), address(pool));
 
         //access control to project is determinted by the first pool access control rules

package/contracts/DirectPayments/DirectPaymentsLibrary.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+import "./DirectPaymentsPool.sol";
+
+library DirectPayemntsLibrary {
+    function _updateMemberLimits(
+        DirectPaymentsPool.LimitsData storage memberStats,
+        uint128 reward,
+        uint64 curMonth
+    ) internal {
+        if (memberStats.lastReward + 60 * 60 * 24 < block.timestamp) //more than a day passed since last reward
+        {
+            memberStats.daily = reward;
+        } else {
+            memberStats.daily += reward;
+        }
+
+        if (memberStats.lastMonth < curMonth) //month switched
+        {
+            memberStats.monthly = reward;
+        } else {
+            memberStats.monthly += reward;
+        }
+
+        memberStats.total += reward;
+        memberStats.lastReward = uint64(block.timestamp);
+        memberStats.lastMonth = curMonth;
+    }
+
+    function _updateGlobalLimits(
+        DirectPaymentsPool.LimitsData storage globalLimits,
+        uint128 reward,
+        uint64 curMonth
+    ) internal {
+        if (globalLimits.lastReward + 60 * 60 * 24 < block.timestamp) //more than a day passed since last reward
+        {
+            globalLimits.daily = reward;
+        } else {
+            globalLimits.daily += reward;
+        }
+
+        if (globalLimits.lastMonth < curMonth) //month switched
+        {
+            globalLimits.monthly = reward;
+        } else {
+            globalLimits.monthly += reward;
+        }
+
+        globalLimits.total += reward;
+        globalLimits.lastReward = uint64(block.timestamp);
+        globalLimits.lastMonth = curMonth;
+    }
+}

package/contracts/DirectPayments/DirectPaymentsPool.sol

@@ -9,6 +9,7 @@ import { IERC721ReceiverUpgradeable } from "@openzeppelin/contracts-upgradeable/
 
 import { ProvableNFT } from "./ProvableNFT.sol";
 import { DirectPaymentsFactory } from "./DirectPaymentsFactory.sol";
+import { DirectPayemntsLibrary } from "./DirectPaymentsLibrary.sol";
 import "../GoodCollective/GoodCollectiveSuperApp.sol";
 
 interface IMembersValidator {
@@ -111,6 +112,8 @@ contract DirectPaymentsPool is
     LimitsData public globalLimits;
     DirectPaymentsFactory public registry;
 
+    uint32 public managerFeeBps;
+
     /// @custom:oz-upgrades-unsafe-allow constructor
     constructor(ISuperfluid _host, IV3SwapRouter _swapRouter) GoodCollectiveSuperApp(_host, _swapRouter) {}
 
@@ -124,6 +127,10 @@ contract DirectPaymentsPool is
         return IRegistry(address(registry));
     }
 
+    function getManagerFee() public view override returns (address feeRecipient, uint32 feeBps) {
+        return (settings.manager, managerFeeBps);
+    }
+
     /**
      * @dev Initializes the contract with the given settings and limits.
      * @param _nft The ProvableNFT contract address.
@@ -134,12 +141,14 @@ contract DirectPaymentsPool is
         ProvableNFT _nft,
         PoolSettings memory _settings,
         SafetyLimits memory _limits,
+        uint32 _managerFeeBps,
         DirectPaymentsFactory _registry
     ) external initializer {
         registry = _registry;
         settings = _settings;
         limits = _limits;
         nft = _nft;
+        managerFeeBps = _managerFeeBps;
         _setupRole(DEFAULT_ADMIN_ROLE, msg.sender); // when using factory this gives factory role which then set role to the real msg.sender
         _setupRole(MANAGER_ROLE, _settings.manager);
         _setupRole(MINTER_ROLE, _settings.manager);
@@ -259,24 +268,7 @@ contract DirectPaymentsPool is
             return false;
         }
 
-        uint64 curMonth = _month();
-        if (memberLimits[member].lastReward + 60 * 60 * 24 < block.timestamp) //more than a day passed since last reward
-        {
-            memberLimits[member].daily = reward;
-        } else {
-            memberLimits[member].daily += reward;
-        }
-
-        if (memberLimits[member].lastMonth < curMonth) //month switched
-        {
-            memberLimits[member].monthly = reward;
-        } else {
-            memberLimits[member].monthly += reward;
-        }
-
-        memberLimits[member].total += reward;
-        memberLimits[member].lastReward = uint64(block.timestamp);
-        memberLimits[member].lastMonth = curMonth;
+        DirectPayemntsLibrary._updateMemberLimits(memberLimits[member], reward, _month());
 
         if (
             memberLimits[member].daily > limits.maxMemberPerDay ||
@@ -291,25 +283,7 @@ contract DirectPaymentsPool is
      * @param reward The amount of rewards to enforce and update limits for.
      */
     function _enforceAndUpdateGlobalLimits(uint128 reward) internal {
-        uint64 curMonth = _month();
-
-        if (globalLimits.lastReward + 60 * 60 * 24 < block.timestamp) //more than a day passed since last reward
-        {
-            globalLimits.daily = reward;
-        } else {
-            globalLimits.daily += reward;
-        }
-
-        if (globalLimits.lastMonth < curMonth) //month switched
-        {
-            globalLimits.monthly = reward;
-        } else {
-            globalLimits.monthly += reward;
-        }
-
-        globalLimits.total += reward;
-        globalLimits.lastReward = uint64(block.timestamp);
-        globalLimits.lastMonth = curMonth;
+        DirectPayemntsLibrary._updateGlobalLimits(globalLimits, reward, _month());
 
         if (globalLimits.monthly > limits.maxTotalPerMonth) revert OVER_GLOBAL_LIMITS();
     }
@@ -409,7 +383,8 @@ contract DirectPaymentsPool is
      * @dev Sets the settings for the pool.
      * @param _settings The new pool settings.
      */
-    function setPoolSettings(PoolSettings memory _settings) public onlyRole(MANAGER_ROLE) {
+    function setPoolSettings(PoolSettings memory _settings, uint32 _managerFeeBps) public onlyRole(MANAGER_ROLE) {
+        managerFeeBps = _managerFeeBps;
         if (_settings.nftType != settings.nftType) revert NFTTYPE_CHANGED();
         if (_settings.manager == address(0)) revert EMPTY_MANAGER();
 

package/contracts/GoodCollective/GoodCollectiveSuperApp.sol

@@ -14,6 +14,8 @@ import "@uniswap/swap-router-contracts/contracts/interfaces/IV3SwapRouter.sol";
 import "../DirectPayments/DirectPaymentsFactory.sol";
 import "../utils/HelperLibrary.sol";
 
+// import "hardhat/console.sol";
+
 abstract contract GoodCollectiveSuperApp is SuperAppBaseFlow {
     int96 public constant MIN_FLOW_RATE = 386e9;
 
@@ -66,7 +68,7 @@ abstract contract GoodCollectiveSuperApp is SuperAppBaseFlow {
 
     IGoodCollectiveSuperApp.Stats public stats;
 
-    uint256[48] private _reserved;
+    uint256[45] private _reserved;
 
     /// @custom:oz-upgrades-unsafe-allow constructor
     constructor(ISuperfluid _host, IV3SwapRouter _swapRouter) SuperAppBaseFlow(_host) {
@@ -76,6 +78,8 @@ abstract contract GoodCollectiveSuperApp is SuperAppBaseFlow {
 
     function getRegistry() public view virtual returns (IRegistry);
 
+    function getManagerFee() public view virtual returns (address admin, uint32 feeBps);
+
     /**
      * @dev Sets the address of the super token and registers the app with the host
      * @param _superToken The address of the super token contract
@@ -114,7 +118,15 @@ abstract contract GoodCollectiveSuperApp is SuperAppBaseFlow {
     function getRealtimeStats()
         public
         view
-        returns (uint256 netIncome, uint256 totalFees, int96 incomeFlowRate, int96 feeRate)
+        returns (
+            uint256 netIncome,
+            uint256 totalFees,
+            uint256 protocolFees,
+            uint256 managerFees,
+            int96 incomeFlowRate,
+            int96 feeRate,
+            int96 managerFeeRate
+        )
     {
         return HelperLibrary.getRealtimeStats(stats, superToken);
     }
@@ -249,6 +261,7 @@ abstract contract GoodCollectiveSuperApp is SuperAppBaseFlow {
         bytes calldata _ctx
     ) internal virtual override returns (bytes memory /*newCtx*/) {
         // Update the supporter's information
+
         return _updateSupporter(_sender, _previousFlowRate, _lastUpdated, _ctx);
     }
 
@@ -267,10 +280,18 @@ abstract contract GoodCollectiveSuperApp is SuperAppBaseFlow {
     ) internal returns (bytes memory newCtx) {
         newCtx = _ctx;
         bool _isFlow = _ctx.length > 0;
-        HelperLibrary.updateStats(stats, superToken, getRegistry(), _isFlow ? 0 : uint256(_previousFlowRateOrAmount));
+        (address feeRecipient, uint32 feeBps) = getManagerFee();
+        HelperLibrary.updateStats(
+            stats,
+            superToken,
+            getRegistry(),
+            feeBps,
+            _isFlow ? 0 : uint256(_previousFlowRateOrAmount)
+        );
         // Get the current flow rate for the supporter
         int96 flowRate = superToken.getFlowRate(_supporter, address(this));
         uint256 prevContribution = supporters[_supporter].contribution;
+
         if (_isFlow) {
             //enforce minimal flow rate
             if (flowRate > 0 && flowRate < MIN_FLOW_RATE) revert MIN_FLOWRATE(flowRate);
@@ -278,21 +299,54 @@ abstract contract GoodCollectiveSuperApp is SuperAppBaseFlow {
             supporters[_supporter].lastUpdated = uint128(block.timestamp);
             supporters[_supporter].flowRate = flowRate;
             supporters[_supporter].contribution +=
-                uint96(int96(_previousFlowRateOrAmount)) *
+                uint256(_previousFlowRateOrAmount) *
                 (block.timestamp - _lastUpdated);
+
+            // address feeRecipient;
+            // uint32 feeBps;
+            if (address(getRegistry()) != address(0)) {
+                feeRecipient = getRegistry().feeRecipient();
+                feeBps = getRegistry().feeBps();
+                // console.log("taking fees %s %s", feeRecipient, feeBps);
+
+                newCtx = HelperLibrary.takeFeeFlow(
+                    cfaV1,
+                    superToken,
+                    stats.lastFeeRecipient,
+                    feeRecipient,
+                    feeBps,
+                    flowRate - int96(_previousFlowRateOrAmount), // we use diff, because manager takes fee from many streams not just this one
+                    newCtx
+                );
+                stats.lastFeeRecipient = feeRecipient;
+            }
+            // console.log("protocol fee stream ok");
+            (feeRecipient, feeBps) = getManagerFee();
+
             newCtx = HelperLibrary.takeFeeFlow(
                 cfaV1,
-                stats,
                 superToken,
-                getRegistry(),
-                flowRate - int96(_previousFlowRateOrAmount),
-                _ctx
+                stats.lastManagerFeeRecipient,
+                feeRecipient,
+                feeBps,
+                flowRate - int96(_previousFlowRateOrAmount), // we use diff, because manager takes fee from many streams not just this one
+                newCtx
             );
+
+            stats.lastManagerFeeRecipient = feeRecipient;
+            // console.log("admin fee stream ok");
             // we update the last rate after we do all changes to our own flows
             stats.lastIncomeRate = superToken.getNetFlowRate(address(this));
         } else {
+            if (address(getRegistry()) != address(0)) {
+                feeRecipient = getRegistry().feeRecipient();
+                feeBps = getRegistry().feeBps();
+                _takeFeeSingle(feeRecipient, feeBps, uint256(_previousFlowRateOrAmount));
+            }
+            (feeRecipient, feeBps) = getManagerFee();
+            _takeFeeSingle(feeRecipient, feeBps, uint256(_previousFlowRateOrAmount));
+
             supporters[_supporter].contribution += uint256(_previousFlowRateOrAmount);
-            _takeFeeSingle(uint256(_previousFlowRateOrAmount));
         }
 
         emit SupporterUpdated(
@@ -305,12 +359,10 @@ abstract contract GoodCollectiveSuperApp is SuperAppBaseFlow {
         );
     }
 
-    function _takeFeeSingle(uint256 _amount) internal {
-        if (address(getRegistry()) == address(0)) return;
-        address recipient = getRegistry().feeRecipient();
+    function _takeFeeSingle(address recipient, uint32 feeBps, uint256 _amount) internal {
         if (recipient == address(0)) return;
 
-        uint256 fee = (_amount * getRegistry().feeBps()) / 10000;
+        uint256 fee = (_amount * feeBps) / 10000;
         TransferHelper.safeTransfer(address(superToken), recipient, fee);
     }
 

package/contracts/GoodCollective/IGoodCollectiveSuperApp.sol

@@ -14,5 +14,11 @@ interface IGoodCollectiveSuperApp {
         uint256 lastUpdate;
         address lastFeeRecipient;
         int96 lastIncomeRate;
+        address lastManagerFeeRecipient;
+        uint256 protocolFees;
+        uint256 managerFees;
+        // adding fields MUST update GoodCollectiveSuperApp storage layout
     }
+
+    function getAdminFee() external view returns (address admin, uint32 feeBps);
 }

package/contracts/Interfaces.sol

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+import { IERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
+
+interface IMembersValidator {
+    function isMemberValid(
+        address pool,
+        address operator,
+        address member,
+        bytes memory extraData
+    ) external returns (bool);
+}
+
+interface IIdentityV2 {
+    function getWhitelistedRoot(address member) external view returns (address);
+}
+
+struct PoolSettings {
+    address manager;
+    IMembersValidator membersValidator;
+    IIdentityV2 uniquenessValidator;
+    IERC20Upgradeable rewardToken;
+}

package/contracts/UBI/UBIPool.sol

@@ -9,19 +9,7 @@ import { IERC721ReceiverUpgradeable } from "@openzeppelin/contracts-upgradeable/
 
 import "../GoodCollective/GoodCollectiveSuperApp.sol";
 import "./UBIPoolFactory.sol";
-
-interface IMembersValidator {
-    function isMemberValid(
-        address pool,
-        address operator,
-        address member,
-        bytes memory extraData
-    ) external returns (bool);
-}
-
-interface IIdentityV2 {
-    function getWhitelistedRoot(address member) external view returns (address);
-}
+import "../Interfaces.sol";
 
 contract UBIPool is AccessControlUpgradeable, GoodCollectiveSuperApp, UUPSUpgradeable {
     using SafeERC20Upgradeable for IERC20Upgradeable;
@@ -33,7 +21,8 @@ contract UBIPool is AccessControlUpgradeable, GoodCollectiveSuperApp, UUPSUpgrad
     error ALREADY_CLAIMED(address whitelistedRoot);
     error INVALID_0_VALUE();
     error EMPTY_MANAGER();
-    error MAX_CLAIMERS_REACHED();
+    error MAX_MEMBERS_REACHED();
+    error MAX_PERIOD_CLAIMERS_REACHED(uint256 claimers);
 
     bytes32 public constant MANAGER_ROLE = keccak256("MANAGER_ROLE");
     bytes32 public constant MEMBER_ROLE = keccak256("MEMBER_ROLE");
@@ -53,13 +42,6 @@ contract UBIPool is AccessControlUpgradeable, GoodCollectiveSuperApp, UUPSUpgrad
     event UBICycleCalculated(uint256 day, uint256 pool, uint256 cycleLength, uint256 dailyUBIPool);
 
     event UBIClaimed(address indexed whitelistedRoot, address indexed claimer, uint256 amount);
-    // Define functions
-    struct PoolSettings {
-        address manager;
-        IMembersValidator membersValidator;
-        IIdentityV2 uniquenessValidator;
-        IERC20Upgradeable rewardToken;
-    }
 
     struct UBISettings {
         //number of days of each UBI pool cycle
@@ -70,8 +52,10 @@ contract UBIPool is AccessControlUpgradeable, GoodCollectiveSuperApp, UUPSUpgrad
         uint32 minActiveUsers;
         // can you trigger claim for someone else
         bool claimForEnabled;
+        // max daily claim amount
         uint maxClaimAmount;
-        uint32 maxClaimers;
+        // max number of members in a pool
+        uint32 maxMembers;
         bool onlyMembers;
     }
 
@@ -90,7 +74,16 @@ contract UBIPool is AccessControlUpgradeable, GoodCollectiveSuperApp, UUPSUpgrad
         uint256 periodClaimers;
         uint256 periodDistributed;
         mapping(address => uint256) lastClaimed;
-        uint32 claimersCount;
+        uint32 membersCount;
+    }
+
+    struct ExtendedSettings {
+        // max number of members that can claim in a day maxPeriodClaimers <= maxMembers
+        uint32 maxPeriodClaimers;
+        // min daily claim amount, daily amount will be 0 if <minClaimAmount
+        uint minClaimAmount;
+        // fees taken from income to the pool manager
+        uint32 managerFeeBps;
     }
 
     PoolSettings public settings;
@@ -98,6 +91,7 @@ contract UBIPool is AccessControlUpgradeable, GoodCollectiveSuperApp, UUPSUpgrad
     PoolStatus public status;
 
     UBIPoolFactory public registry;
+    ExtendedSettings public extendedSettings;
 
     /// @custom:oz-upgrades-unsafe-allow constructor
     constructor(ISuperfluid _host, IV3SwapRouter _swapRouter) GoodCollectiveSuperApp(_host, _swapRouter) {}
@@ -112,6 +106,10 @@ contract UBIPool is AccessControlUpgradeable, GoodCollectiveSuperApp, UUPSUpgrad
         return IRegistry(address(registry));
     }
 
+    function getManagerFee() public view override returns (address feeRecipient, uint32 feeBps) {
+        return (settings.manager, extendedSettings.managerFeeBps);
+    }
+
     /**
      * @dev Initializes the contract with the given settings and limits.
      * @param _settings The PoolSettings struct containing pool settings.
@@ -120,11 +118,13 @@ contract UBIPool is AccessControlUpgradeable, GoodCollectiveSuperApp, UUPSUpgrad
     function initialize(
         PoolSettings memory _settings,
         UBISettings memory _ubiSettings,
+        ExtendedSettings memory _extendedSettings,
         UBIPoolFactory _registry
     ) external initializer {
         registry = _registry;
         settings = _settings;
         ubiSettings = _ubiSettings;
+        extendedSettings = _extendedSettings;
         _verifyPoolSettings(_settings);
         _verifyUBISettings(_ubiSettings);
         _setupRole(DEFAULT_ADMIN_ROLE, msg.sender); // when using factory this gives factory role which then set role to the real msg.sender
@@ -148,36 +148,22 @@ contract UBIPool is AccessControlUpgradeable, GoodCollectiveSuperApp, UUPSUpgrad
      * the daily balance is determined by dividing current pool by the cycle length
      * @return The amount of GoodDollar the user can claim
      */
-    function distributionFormula() internal returns (uint256) {
+    function distributionFormula() public returns (uint256) {
         // once every claim cycle
         uint256 currentDay = getCurrentDay();
         if (currentDay >= status.currentDay + ubiSettings.claimPeriodDays) {
-            status.currentDay = currentDay;
-            uint32 cycleLength = ubiSettings.cycleLengthDays;
-            uint256 currentBalance = settings.rewardToken.balanceOf(address(this));
-            //start early cycle if daily pool size is +%5 previous pool or not enough until end of cycle
-            uint256 nextDailyPool = currentBalance / cycleLength;
-            bool shouldStartEarlyCycle = nextDailyPool > (status.dailyCyclePool * 105) / 100 ||
-                (currentDayInCycle() <= cycleLength &&
-                    currentBalance < (status.dailyCyclePool * (cycleLength - currentDayInCycle())));
-
-            if (
-                currentDayInCycle() >= status.currentCycleLength || shouldStartEarlyCycle
-            ) //start of cycle or first time
-            {
+            (uint256 nextDailyPool, uint256 nextDailyUbi, bool newCycle) = _calcNextDailyUBI();
+            if (newCycle) {
+                uint256 currentBalance = settings.rewardToken.balanceOf(address(this));
                 status.dailyCyclePool = nextDailyPool;
-                status.currentCycleLength = cycleLength;
+                status.currentCycleLength = ubiSettings.cycleLengthDays;
                 status.startOfCycle = currentDay;
-                emit UBICycleCalculated(currentDay, currentBalance, cycleLength, nextDailyPool);
+                emit UBICycleCalculated(currentDay, currentBalance, ubiSettings.cycleLengthDays, nextDailyPool);
             }
 
-            uint256 prevPeriodClaimers = status.periodClaimers;
-            status.dailyUbi = min(
-                ubiSettings.maxClaimAmount,
-                status.dailyCyclePool / max((prevPeriodClaimers * 10500) / 10000, ubiSettings.minActiveUsers)
-            );
-            //update minActiveUsers as claimers grow
-            ubiSettings.minActiveUsers = uint32(max(prevPeriodClaimers / 2, ubiSettings.minActiveUsers));
+            status.currentDay = currentDay;
+            status.dailyUbi = nextDailyUbi;
+            if (status.dailyUbi <= extendedSettings.minClaimAmount) status.dailyUbi = 0;
 
             emit UBICalculated(
                 currentDay,
@@ -193,6 +179,32 @@ contract UBIPool is AccessControlUpgradeable, GoodCollectiveSuperApp, UUPSUpgrad
         return status.dailyUbi;
     }
 
+    function _calcNextDailyUBI() internal view returns (uint256 nextPeriodPool, uint256 nextDailyUbi, bool newCycle) {
+        uint256 currentBalance = settings.rewardToken.balanceOf(address(this));
+        //start early cycle if we can increase the daily UBI pool
+        uint256 nextDailyPool = currentBalance / ubiSettings.cycleLengthDays;
+        bool shouldStartEarlyCycle = nextDailyPool > (status.dailyCyclePool * 105) / 100 ||
+            (currentDayInCycle() <= status.currentCycleLength &&
+                currentBalance < (status.dailyCyclePool * (status.currentCycleLength - currentDayInCycle())));
+
+        nextPeriodPool = status.dailyCyclePool;
+        nextDailyUbi;
+        if (
+            (currentDayInCycle() + 1) >= status.currentCycleLength || shouldStartEarlyCycle
+        ) //start of cycle or first time
+        {
+            nextPeriodPool = currentBalance / ubiSettings.cycleLengthDays;
+            newCycle = true;
+        }
+
+        nextDailyUbi = min(
+            ubiSettings.maxClaimAmount,
+            nextPeriodPool / max((status.periodClaimers * 10500) / 10000, ubiSettings.minActiveUsers)
+        );
+
+        if (nextDailyUbi < extendedSettings.minClaimAmount) nextDailyUbi = 0;
+    }
+
     /**
      * @dev returns the day count since start of current cycle
      */
@@ -231,12 +243,15 @@ contract UBIPool is AccessControlUpgradeable, GoodCollectiveSuperApp, UUPSUpgrad
         if (whitelistedRoot == address(0)) revert NOT_WHITELISTED(claimer);
 
         // if open for anyone but has limits, we add the first claimers as members to handle the max claimers
-        if ((ubiSettings.maxClaimers > 0 && ubiSettings.onlyMembers == false)) _grantRole(MEMBER_ROLE, claimer);
+        if ((ubiSettings.maxMembers > 0 && ubiSettings.onlyMembers == false)) _grantRole(MEMBER_ROLE, claimer);
 
         // check membership if has claimers limits or limited to members only
-        if ((ubiSettings.maxClaimers > 0 || ubiSettings.onlyMembers) && hasRole(MEMBER_ROLE, claimer) == false)
+        if ((ubiSettings.maxMembers > 0 || ubiSettings.onlyMembers) && hasRole(MEMBER_ROLE, claimer) == false)
             revert NOT_MEMBER(claimer);
 
+        if (extendedSettings.maxPeriodClaimers > 0 && status.periodClaimers >= extendedSettings.maxPeriodClaimers)
+            revert MAX_PERIOD_CLAIMERS_REACHED(status.periodClaimers);
+
         // calculats the formula up today ie on day 0 there are no active users, on day 1 any user
         // (new or active) will trigger the calculation with the active users count of the day before
         // and so on. the new or inactive users that will become active today, will not take into account
@@ -287,17 +302,17 @@ contract UBIPool is AccessControlUpgradeable, GoodCollectiveSuperApp, UUPSUpgrad
 
     function _grantRole(bytes32 role, address account) internal virtual override {
         if (role == MEMBER_ROLE && hasRole(MEMBER_ROLE, account) == false) {
-            if (ubiSettings.maxClaimers > 0 && status.claimersCount > ubiSettings.maxClaimers)
-                revert MAX_CLAIMERS_REACHED();
+            if (ubiSettings.maxMembers > 0 && status.membersCount > ubiSettings.maxMembers)
+                revert MAX_MEMBERS_REACHED();
             registry.addMember(account);
-            status.claimersCount += 1;
+            status.membersCount += 1;
         }
         super._grantRole(role, account);
     }
 
     function _revokeRole(bytes32 role, address account) internal virtual override {
         if (role == MEMBER_ROLE && hasRole(MEMBER_ROLE, account)) {
-            status.claimersCount -= 1;
+            status.membersCount -= 1;
             registry.removeMember(account);
         }
         super._revokeRole(role, account);
@@ -307,9 +322,13 @@ contract UBIPool is AccessControlUpgradeable, GoodCollectiveSuperApp, UUPSUpgrad
      * @dev Sets the safety limits for the pool.
      * @param _ubiSettings The new safety limits.
      */
-    function setUBISettings(UBISettings memory _ubiSettings) public onlyRole(MANAGER_ROLE) {
+    function setUBISettings(
+        UBISettings memory _ubiSettings,
+        ExtendedSettings memory _extendedSettings
+    ) public onlyRole(MANAGER_ROLE) {
         _verifyUBISettings(_ubiSettings);
         ubiSettings = _ubiSettings;
+        extendedSettings = _extendedSettings;
         emit UBISettingsChanged(_ubiSettings);
     }
 
@@ -345,28 +364,8 @@ contract UBIPool is AccessControlUpgradeable, GoodCollectiveSuperApp, UUPSUpgrad
         ) revert INVALID_0_VALUE();
     }
 
-    function estimateNextDailyUBI() public view returns (uint256) {
-        uint256 currentBalance = settings.rewardToken.balanceOf(address(this));
-        //start early cycle if we can increase the daily UBI pool
-        uint256 nextDailyPool = currentBalance / ubiSettings.cycleLengthDays;
-        bool shouldStartEarlyCycle = nextDailyPool > (status.dailyCyclePool * 105) / 100 ||
-            (currentDayInCycle() <= status.currentCycleLength &&
-                currentBalance < (status.dailyCyclePool * (status.currentCycleLength - currentDayInCycle())));
-
-        uint256 _dailyCyclePool = status.dailyCyclePool;
-        uint256 _dailyUbi;
-        if (
-            (currentDayInCycle() + 1) >= status.currentCycleLength || shouldStartEarlyCycle
-        ) //start of cycle or first time
-        {
-            _dailyCyclePool = currentBalance / ubiSettings.cycleLengthDays;
-        }
-
-        _dailyUbi = min(
-            ubiSettings.maxClaimAmount,
-            _dailyCyclePool / max((status.periodClaimers * 10500) / 10000, ubiSettings.minActiveUsers)
-        );
-        return _dailyUbi;
+    function estimateNextDailyUBI() public view returns (uint256 nextDailyUbi) {
+        (, nextDailyUbi, ) = _calcNextDailyUBI();
     }
 
     function checkEntitlement() public view returns (uint256) {
@@ -384,6 +383,8 @@ contract UBIPool is AccessControlUpgradeable, GoodCollectiveSuperApp, UUPSUpgrad
         // current day has already been updated which means
         // that the dailyUbi has been updated
         if (status.currentDay == getCurrentDay() && status.dailyUbi > 0) {
+            if (extendedSettings.maxPeriodClaimers > 0 && status.periodClaimers >= extendedSettings.maxPeriodClaimers)
+                return 0;
             return hasClaimed(_member) ? 0 : status.dailyUbi;
         }
         return estimateNextDailyUBI();