@gooddollar/goodcollective-contracts 1.3.0 → 1.4.0

package/contracts/DirectPayments/DirectPaymentsLibrary.sol

@@ -1,14 +1,30 @@
 // SPDX-License-Identifier: MIT
 pragma solidity >=0.8.0;
 
+import { SafeERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol";
+import { IERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
+
 import "./DirectPaymentsPool.sol";
+import "./ProvableNFT.sol";
 
-library DirectPayemntsLibrary {
-    function _updateMemberLimits(
-        DirectPaymentsPool.LimitsData storage memberStats,
-        uint128 reward,
-        uint64 curMonth
-    ) internal {
+library DirectPaymentsLibrary {
+    using SafeERC20Upgradeable for IERC20Upgradeable;
+    event NOT_MEMBER_OR_WHITELISTED_OR_LIMITS(address contributer);
+    event EventRewardClaimed(
+        uint256 indexed tokenId,
+        uint16 eventType,
+        uint32 eventTimestamp,
+        uint256 eventQuantity,
+        string eventUri,
+        address[] contributers,
+        uint256 rewardPerContributer
+    );
+    event NFTClaimed(uint256 indexed tokenId, uint256 totalRewards);
+    error OVER_MEMBER_LIMITS(address);
+    error OVER_GLOBAL_LIMITS();
+    error NO_BALANCE();
+
+    function _updateMemberLimits(DirectPaymentsPool.LimitsData storage memberStats, uint128 reward) public {
         if (memberStats.lastReward + 60 * 60 * 24 < block.timestamp) //more than a day passed since last reward
         {
             memberStats.daily = reward;
@@ -16,7 +32,7 @@ library DirectPayemntsLibrary {
             memberStats.daily += reward;
         }
 
-        if (memberStats.lastMonth < curMonth) //month switched
+        if (memberStats.lastMonth < _month()) //month switched
         {
             memberStats.monthly = reward;
         } else {
@@ -25,14 +41,20 @@ library DirectPayemntsLibrary {
 
         memberStats.total += reward;
         memberStats.lastReward = uint64(block.timestamp);
-        memberStats.lastMonth = curMonth;
+        memberStats.lastMonth = _month();
     }
 
-    function _updateGlobalLimits(
+    /**
+     * @dev Updates the global limits with the new reward.
+     * @param globalLimits The global limits data to update.
+     * @param limits The safety limits to check against.
+     * @param reward The amount of rewards to update.
+     */
+    function _enforceAndUpdateGlobalLimits(
         DirectPaymentsPool.LimitsData storage globalLimits,
-        uint128 reward,
-        uint64 curMonth
-    ) internal {
+        DirectPaymentsPool.SafetyLimits memory limits,
+        uint128 reward
+    ) public {
         if (globalLimits.lastReward + 60 * 60 * 24 < block.timestamp) //more than a day passed since last reward
         {
             globalLimits.daily = reward;
@@ -40,7 +62,7 @@ library DirectPayemntsLibrary {
             globalLimits.daily += reward;
         }
 
-        if (globalLimits.lastMonth < curMonth) //month switched
+        if (globalLimits.lastMonth < _month()) //month switched
         {
             globalLimits.monthly = reward;
         } else {
@@ -49,6 +71,138 @@ library DirectPayemntsLibrary {
 
         globalLimits.total += reward;
         globalLimits.lastReward = uint64(block.timestamp);
-        globalLimits.lastMonth = curMonth;
+        globalLimits.lastMonth = _month();
+
+        if (globalLimits.monthly > limits.maxTotalPerMonth) revert OVER_GLOBAL_LIMITS();
+    }
+
+    /**
+     * @dev Enforces and updates the reward limits for the specified member. if the member is not a valid member, or past limit it returns false and member will not get rewards.
+     * @param memberStats The member's limits data to update.
+     * @param limits The safety limits to check against.
+     * @param member The address of the member to enforce and update limits for.
+     * @param reward The amount of rewards to enforce and update limits for.
+     */
+    function _enforceAndUpdateMemberLimits(
+        DirectPaymentsPool.LimitsData storage memberStats,
+        DirectPaymentsPool.SafetyLimits memory limits,
+        address member,
+        uint128 reward
+    ) public returns (bool) {
+        if (
+            DirectPaymentsPool(address(this)).hasRole(DirectPaymentsPool(address(this)).MEMBER_ROLE(), member) == false
+        ) {
+            return false;
+        }
+        _updateMemberLimits(memberStats, reward);
+
+        if (memberStats.daily > limits.maxMemberPerDay || memberStats.monthly > limits.maxMemberPerMonth) return false;
+
+        return true;
+    }
+
+    /**
+     * @dev Sends rewards to the specified recipients.
+     * @param recipients The addresses of the recipients to send rewards to.
+     * @param reward The total amount of rewards to send.
+     */
+    function _sendReward(
+        DirectPaymentsPool.LimitsData storage globalLimits,
+        DirectPaymentsPool.SafetyLimits memory limits,
+        mapping(address => DirectPaymentsPool.LimitsData) storage memberLimits,
+        DirectPaymentsPool.PoolSettings memory settings,
+        address[] memory recipients,
+        uint128 reward
+    ) public {
+        uint128 perReward = uint128(reward / recipients.length);
+        uint128 totalSent;
+        for (uint i = 0; i < recipients.length; i++) {
+            bool valid = _enforceAndUpdateMemberLimits(memberLimits[recipients[i]], limits, recipients[i], perReward);
+            if (valid) {
+                settings.rewardToken.safeTransfer(recipients[i], perReward);
+                totalSent += perReward;
+            } else {
+                emit NOT_MEMBER_OR_WHITELISTED_OR_LIMITS(recipients[i]);
+            }
+        }
+        _enforceAndUpdateGlobalLimits(globalLimits, limits, totalSent);
+    }
+
+    /**
+     * @dev Claims rewards for the specified NFT ID.
+     * @param globalLimits The global limits data to check against.
+     * @param limits The safety limits to check against.
+     * @param memberLimits The mapping of member limits to check against.
+     * @param settings The pool settings containing the reward token and other configurations.
+     * @param _nftId The ID of the NFT to claim rewards for.
+     * @param _data The NFTData struct containing data about the NFT.
+     */
+    function _claim(
+        DirectPaymentsPool.LimitsData storage globalLimits,
+        DirectPaymentsPool.SafetyLimits memory limits,
+        mapping(address => DirectPaymentsPool.LimitsData) storage memberLimits,
+        DirectPaymentsPool.PoolSettings memory settings,
+        uint256 _nftId,
+        ProvableNFT.NFTData memory _data
+    ) public {
+        uint totalRewards;
+        uint rewardsBalance = settings.rewardToken.balanceOf(address(this));
+
+        bool allowRewardOverride = settings.allowRewardOverride;
+        for (uint256 i = 0; i < _data.events.length; i++) {
+            uint reward = (
+                allowRewardOverride && _data.events[i].rewardOverride > 0
+                    ? _data.events[i].rewardOverride
+                    : _eventReward(settings, _data.events[i].subtype)
+            ) * _data.events[i].quantity;
+            if (reward > 0) {
+                totalRewards += reward;
+                if (totalRewards > rewardsBalance) revert NO_BALANCE();
+                rewardsBalance -= totalRewards;
+
+                _sendReward(
+                    globalLimits,
+                    limits,
+                    memberLimits,
+                    settings,
+                    _data.events[i].contributers,
+                    uint128(reward)
+                );
+                emit EventRewardClaimed(
+                    _nftId,
+                    _data.events[i].subtype,
+                    _data.events[i].timestamp,
+                    _data.events[i].quantity,
+                    _data.events[i].eventUri,
+                    _data.events[i].contributers,
+                    uint128(reward / _data.events[i].contributers.length)
+                );
+            }
+        }
+
+        emit NFTClaimed(_nftId, totalRewards);
+    }
+
+    /**
+     * @dev Returns the reward amount for the specified event type.
+     * @param _eventType The type of the event to get the reward for.
+     * @return reward amount for the specified event type.
+     */
+    function _eventReward(
+        DirectPaymentsPool.PoolSettings memory settings,
+        uint16 _eventType
+    ) internal pure returns (uint128 reward) {
+        for (uint i = 0; i < settings.validEvents.length; i++) {
+            if (_eventType == settings.validEvents[i]) return settings.rewardPerEvent[i];
+        }
+        return 0;
+    }
+
+    /**
+     * @dev Returns the current month.
+     * @return month current month as a uint64 value.
+     */
+    function _month() internal view returns (uint64 month) {
+        return uint64(block.timestamp / (60 * 60 * 24 * 30));
     }
 }

package/contracts/DirectPayments/DirectPaymentsPool.sol

@@ -9,7 +9,7 @@ import { IERC721ReceiverUpgradeable } from "@openzeppelin/contracts-upgradeable/
 
 import { ProvableNFT } from "./ProvableNFT.sol";
 import { DirectPaymentsFactory } from "./DirectPaymentsFactory.sol";
-import { DirectPayemntsLibrary } from "./DirectPaymentsLibrary.sol";
+import { DirectPaymentsLibrary } from "./DirectPaymentsLibrary.sol";
 import "../GoodCollective/GoodCollectiveSuperApp.sol";
 
 interface IMembersValidator {
@@ -18,7 +18,7 @@ interface IMembersValidator {
         address operator,
         address member,
         bytes memory extraData
-    ) external returns (bool);
+    ) external view returns (bool);
 }
 
 interface IIdentityV2 {
@@ -48,6 +48,7 @@ contract DirectPaymentsPool is
     error NO_BALANCE();
     error NFTTYPE_CHANGED();
     error EMPTY_MANAGER();
+    error LENGTH_MISMATCH();
 
     bytes32 public constant MANAGER_ROLE = keccak256("MANAGER_ROLE");
     bytes32 public constant MEMBER_ROLE = keccak256("MEMBER_ROLE");
@@ -74,7 +75,15 @@ contract DirectPaymentsPool is
         uint256 rewardPerContributer
     );
     event NFTClaimed(uint256 indexed tokenId, uint256 totalRewards);
-    event NOT_MEMBER_OR_WHITELISTED(address contributer);
+    /**
+     * @dev Emitted when a contributor is skipped during reward distribution.
+     * This occurs when a contributor is either:
+     * - Not a member of the pool (does not have MEMBER_ROLE)
+     * - Not whitelisted (uniquenessValidator returns address(0))
+     * - Exceeds member limits (daily or monthly limits exceeded)
+     * @param contributer The address of the contributor that was skipped
+     */
+    event NOT_MEMBER_OR_WHITELISTED_OR_LIMITS(address contributer);
 
     // Define functions
     struct PoolSettings {
@@ -181,127 +190,20 @@ contract DirectPaymentsPool is
     function claim(uint256 _nftId, ProvableNFT.NFTData memory _data) public {
         nft.proveNFTData(_nftId, _data);
         if (claimedNfts[_nftId]) revert ALREADY_CLAIMED(_nftId);
-
+        claimedNfts[_nftId] = true;
         // TODO: should pool own the NFTs?
         // if (settings.collectNfts && nft.ownerOf(_nftId) != address(this)) revert NFT_MISSING(_nftId);
 
-        _claim(_nftId, _data);
-    }
-
-    /**
-     * @dev Claims rewards for the specified NFT ID.
-     * @param _nftId The ID of the NFT to claim rewards for.
-     * @param _data The NFTData struct containing data about the NFT.
-     */
-    function _claim(uint256 _nftId, ProvableNFT.NFTData memory _data) internal {
-        claimedNfts[_nftId] = true;
-        uint totalRewards;
-        uint rewardsBalance = settings.rewardToken.balanceOf(address(this));
-
-        bool allowRewardOverride = settings.allowRewardOverride;
+        // Loop through the events in the NFT data and add members
         for (uint256 i = 0; i < _data.events.length; i++) {
-            uint reward = (
-                allowRewardOverride && _data.events[i].rewardOverride > 0
-                    ? _data.events[i].rewardOverride
-                    : _eventReward(_data.events[i].subtype)
-            ) * _data.events[i].quantity;
-            if (reward > 0) {
-                totalRewards += reward;
-                if (totalRewards > rewardsBalance) revert NO_BALANCE();
-                rewardsBalance -= totalRewards;
-                _sendReward(_data.events[i].contributers, uint128(reward));
-                emit EventRewardClaimed(
-                    _nftId,
-                    _data.events[i].subtype,
-                    _data.events[i].timestamp,
-                    _data.events[i].quantity,
-                    _data.events[i].eventUri,
-                    _data.events[i].contributers,
-                    uint128(reward / _data.events[i].contributers.length)
-                );
-            }
-        }
-
-        emit NFTClaimed(_nftId, totalRewards);
-    }
-
-    /**
-     * @dev Returns the reward amount for the specified event type.
-     * @param _eventType The type of the event to get the reward for.
-     * @return reward amount for the specified event type.
-     */
-    function _eventReward(uint16 _eventType) internal view returns (uint128 reward) {
-        for (uint i = 0; i < settings.validEvents.length; i++) {
-            if (_eventType == settings.validEvents[i]) return settings.rewardPerEvent[i];
-        }
-        return 0;
-    }
-
-    /**
-     * @dev Sends rewards to the specified recipients.
-     * @param recipients The addresses of the recipients to send rewards to.
-     * @param reward The total amount of rewards to send.
-     */
-    function _sendReward(address[] memory recipients, uint128 reward) internal {
-        uint128 perReward = uint128(reward / recipients.length);
-        uint128 totalSent;
-        for (uint i = 0; i < recipients.length; i++) {
-            bool valid = _enforceAndUpdateMemberLimits(recipients[i], perReward);
-            if (valid) {
-                settings.rewardToken.safeTransfer(recipients[i], perReward);
-                totalSent += perReward;
-            } else {
-                emit NOT_MEMBER_OR_WHITELISTED(recipients[i]);
+            for (uint j = 0; j < _data.events[i].contributers.length; j++) {
+                //dont revert on non valid members, just dont reward them (their reward is lost)
+                _addMember(_data.events[i].contributers[j], "");
             }
         }
-        _enforceAndUpdateGlobalLimits(totalSent);
+        DirectPaymentsLibrary._claim(globalLimits, limits, memberLimits, settings, _nftId, _data);
     }
 
-    /**
-     * @dev Enforces and updates the reward limits for the specified member.
-     * @param member The address of the member to enforce and update limits for.
-     * @param reward The amount of rewards to enforce and update limits for.
-     */
-    function _enforceAndUpdateMemberLimits(address member, uint128 reward) internal returns (bool) {
-        //dont revert on non valid members, just dont reward them (their reward is lost)
-        if (_addMember(member, "") == false) {
-            return false;
-        }
-
-        DirectPayemntsLibrary._updateMemberLimits(memberLimits[member], reward, _month());
-
-        if (
-            memberLimits[member].daily > limits.maxMemberPerDay ||
-            memberLimits[member].monthly > limits.maxMemberPerMonth
-        ) revert OVER_MEMBER_LIMITS(member);
-
-        return true;
-    }
-
-    /**
-     * @dev Enforces and updates the global reward limits.
-     * @param reward The amount of rewards to enforce and update limits for.
-     */
-    function _enforceAndUpdateGlobalLimits(uint128 reward) internal {
-        DirectPayemntsLibrary._updateGlobalLimits(globalLimits, reward, _month());
-
-        if (globalLimits.monthly > limits.maxTotalPerMonth) revert OVER_GLOBAL_LIMITS();
-    }
-
-    /**
-     * @dev Returns the current month.
-     * @return month current month as a uint64 value.
-     */
-    function _month() internal view returns (uint64 month) {
-        return uint64(block.timestamp / (60 * 60 * 24 * 30));
-    }
-
-    /**
-     * @dev Adds a member to the contract.
-     * @param member The address of the member to add.
-     * @param extraData Additional data to validate the member.
-     */
-
     function _addMember(address member, bytes memory extraData) internal returns (bool isMember) {
         if (hasRole(MEMBER_ROLE, member)) return true;
 
@@ -321,6 +223,19 @@ contract DirectPaymentsPool is
         return true;
     }
 
+    /**
+     * @dev Adds multiple members to the pool in a single transaction.
+     * @param members Array of member addresses to add.
+     * @param extraData Array of additional validation data for each member.
+     */
+    function addMembers(address[] calldata members, bytes[] calldata extraData) external onlyRole(MANAGER_ROLE) {
+        if (members.length != extraData.length) revert LENGTH_MISMATCH();
+
+        for (uint i = 0; i < members.length; i++) {
+            _addMember(members[i], extraData[i]);
+        }
+    }
+
     function _grantRole(bytes32 role, address account) internal virtual override {
         if (role == MEMBER_ROLE) {
             registry.addMember(account);

package/contracts/GoodCollective/GoodCollectiveSuperApp.sol

@@ -3,7 +3,7 @@
 pragma solidity >=0.8.0;
 
 import { SuperAppBaseFlow } from "./SuperAppBaseFlow.sol";
-import { ISuperfluid, ISuperToken, SuperAppDefinitions } from "@superfluid-finance/ethereum-contracts/contracts/interfaces/superfluid/ISuperfluid.sol";
+import { ISuperfluid, ISuperToken, SuperAppDefinitions, ISuperApp } from "@superfluid-finance/ethereum-contracts/contracts/interfaces/superfluid/ISuperfluid.sol";
 import { ISuperGoodDollar } from "@gooddollar/goodprotocol/contracts/token/superfluid/ISuperGoodDollar.sol";
 import { SuperTokenV1Library } from "@superfluid-finance/ethereum-contracts/contracts/apps/SuperTokenV1Library.sol";
 import { CFAv1Library, IConstantFlowAgreementV1 } from "@superfluid-finance/ethereum-contracts/contracts/apps/CFAv1Library.sol";
@@ -90,11 +90,8 @@ abstract contract GoodCollectiveSuperApp is SuperAppBaseFlow {
         // Set the super token address
         superToken = _superToken;
 
-        // Define the callback definitions for the app
-        uint256 callBackDefinitions = SuperAppDefinitions.APP_LEVEL_FINAL;
-
-        // Register the app with the host
-        host.registerApp(callBackDefinitions);
+        // // try to register the app with the host, required for backward compatability with unit tests
+        if (host.isApp(this) == false) try host.registerApp(SuperAppDefinitions.APP_LEVEL_FINAL) {} catch {}
 
         //initialize InitData struct, and set equal to cfaV1
         cfaV1 = CFAv1Library.InitData(
@@ -366,6 +363,10 @@ abstract contract GoodCollectiveSuperApp is SuperAppBaseFlow {
         TransferHelper.safeTransfer(address(superToken), recipient, fee);
     }
 
+    function recoverFunds(address _recipient, uint256 amount) external {
+        HelperLibrary.recoverFunds(superToken, _recipient, amount);
+    }
+
     /**
      * for methods that can be called via superfluid batch or directly
      */

package/contracts/GoodCollective/IGoodCollectiveSuperApp.sol

@@ -5,6 +5,8 @@ interface IRegistry {
     function feeRecipient() external view returns (address);
 
     function feeBps() external view returns (uint32);
+
+    function hasRole(bytes32 role, address account) external view returns (bool);
 }
 
 interface IGoodCollectiveSuperApp {
@@ -21,4 +23,6 @@ interface IGoodCollectiveSuperApp {
     }
 
     function getAdminFee() external view returns (address admin, uint32 feeBps);
+
+    function getRegistry() external view returns (IRegistry);
 }

package/contracts/GoodCollective/SuperAppBaseFlow.sol

@@ -6,6 +6,12 @@ import { SuperTokenV1Library } from "@superfluid-finance/ethereum-contracts/cont
 
 // import "hardhat/console.sol";
 
+interface IRegisterSuperapp {
+    function registerApp(address app, uint256 configWord) external;
+
+    function registerAppByFactory(address app, uint256 configWord) external;
+}
+
 abstract contract SuperAppBaseFlow is ISuperApp {
     using SuperTokenV1Library for ISuperToken;
 

package/contracts/UBI/UBIPool.sol

@@ -5,7 +5,6 @@ import { UUPSUpgradeable } from "@openzeppelin/contracts-upgradeable/proxy/utils
 import { IERC721Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol";
 import { SafeERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol";
 import { IERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
-import { IERC721ReceiverUpgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol";
 
 import "../GoodCollective/GoodCollectiveSuperApp.sol";
 import "./UBIPoolFactory.sol";
@@ -23,6 +22,7 @@ contract UBIPool is AccessControlUpgradeable, GoodCollectiveSuperApp, UUPSUpgrad
     error EMPTY_MANAGER();
     error MAX_MEMBERS_REACHED();
     error MAX_PERIOD_CLAIMERS_REACHED(uint256 claimers);
+    error LENGTH_MISMATCH();
 
     bytes32 public constant MANAGER_ROLE = keccak256("MANAGER_ROLE");
     bytes32 public constant MEMBER_ROLE = keccak256("MEMBER_ROLE");
@@ -189,10 +189,8 @@ contract UBIPool is AccessControlUpgradeable, GoodCollectiveSuperApp, UUPSUpgrad
 
         nextPeriodPool = status.dailyCyclePool;
         nextDailyUbi;
-        if (
-            (currentDayInCycle() + 1) >= status.currentCycleLength || shouldStartEarlyCycle
-        ) //start of cycle or first time
-        {
+        if ((currentDayInCycle() + 1) >= status.currentCycleLength || shouldStartEarlyCycle) {
+            //start of cycle or first time
             nextPeriodPool = currentBalance / ubiSettings.cycleLengthDays;
             newCycle = true;
         }
@@ -271,38 +269,83 @@ contract UBIPool is AccessControlUpgradeable, GoodCollectiveSuperApp, UUPSUpgrad
     }
 
     /**
-     * @dev Adds a member to the contract.
+     * @dev Internal function to add a member with validation.
+     * Always validates members, even when called by manager.
      * @param member The address of the member to add.
      * @param extraData Additional data to validate the member.
+     * @return isMember True if member was added, false if validation failed.
      */
+    function _addMember(address member, bytes memory extraData) internal returns (bool isMember) {
+        if (hasRole(MEMBER_ROLE, member)) return true;
 
-    function addMember(address member, bytes memory extraData) external returns (bool isMember) {
         if (address(settings.uniquenessValidator) != address(0)) {
             address rootAddress = settings.uniquenessValidator.getWhitelistedRoot(member);
-            if (rootAddress == address(0)) revert NOT_WHITELISTED(member);
+            if (rootAddress == address(0)) return false;
         }
 
-        if (address(settings.membersValidator) != address(0) && hasRole(MANAGER_ROLE, msg.sender) == false) {
+        // Always check membersValidator if it exists, regardless of caller role
+        if (address(settings.membersValidator) != address(0)) {
             if (settings.membersValidator.isMemberValid(address(this), msg.sender, member, extraData) == false) {
-                revert NOT_MEMBER(member);
+                return false;
             }
         }
         // if no members validator then if members only only manager can add members
         else if (ubiSettings.onlyMembers && hasRole(MANAGER_ROLE, msg.sender) == false) {
-            revert NOT_MANAGER(member);
+            return false;
         }
 
         _grantRole(MEMBER_ROLE, member);
         return true;
     }
 
+    /**
+     * @dev Adds a member to the contract.
+     * @param member The address of the member to add.
+     * @param extraData Additional data to validate the member.
+     */
+    function addMember(address member, bytes memory extraData) public returns (bool isMember) {
+        bool success = _addMember(member, extraData);
+        
+        if (!success) {
+            // Determine the specific error to revert with
+            if (address(settings.uniquenessValidator) != address(0)) {
+                address rootAddress = settings.uniquenessValidator.getWhitelistedRoot(member);
+                if (rootAddress == address(0)) revert NOT_WHITELISTED(member);
+            }
+            
+            if (address(settings.membersValidator) != address(0) && hasRole(MANAGER_ROLE, msg.sender) == false) {
+                revert NOT_MEMBER(member);
+            }
+            
+            if (ubiSettings.onlyMembers && hasRole(MANAGER_ROLE, msg.sender) == false) {
+                revert NOT_MANAGER(member);
+            }
+        }
+        
+        return success;
+    }
+
+    /**
+     * @dev Adds multiple members to the pool in a single transaction.
+     * Invalid members are skipped instead of causing the transaction to revert.
+     * @param members Array of member addresses to add.
+     * @param extraData Array of additional validation data for each member.
+     */
+    function addMembers(address[] calldata members, bytes[] calldata extraData) external onlyRole(MANAGER_ROLE) {
+        if (members.length != extraData.length) revert LENGTH_MISMATCH();
+
+        for (uint i = 0; i < members.length; i++) {
+            _addMember(members[i], extraData[i]);
+        }
+    }
+
     function removeMember(address member) external onlyRole(MANAGER_ROLE) {
         _revokeRole(MEMBER_ROLE, member);
     }
 
     function _grantRole(bytes32 role, address account) internal virtual override {
         if (role == MEMBER_ROLE && hasRole(MEMBER_ROLE, account) == false) {
-            if (ubiSettings.maxMembers > 0 && status.membersCount > ubiSettings.maxMembers)
+            if (ubiSettings.maxMembers > 0 && status.membersCount >= ubiSettings.maxMembers)
                 revert MAX_MEMBERS_REACHED();
             registry.addMember(account);
             status.membersCount += 1;
@@ -357,11 +400,8 @@ contract UBIPool is AccessControlUpgradeable, GoodCollectiveSuperApp, UUPSUpgrad
     }
 
     function _verifyPoolSettings(PoolSettings memory _poolSettings) internal pure {
-        if (
-            _poolSettings.manager == address(0) ||
-            address(_poolSettings.uniquenessValidator) == address(0) ||
-            address(_poolSettings.rewardToken) == address(0)
-        ) revert INVALID_0_VALUE();
+        if (_poolSettings.manager == address(0) || address(_poolSettings.rewardToken) == address(0))
+            revert INVALID_0_VALUE();
     }
 
     function estimateNextDailyUBI() public view returns (uint256 nextDailyUbi) {
@@ -391,7 +431,11 @@ contract UBIPool is AccessControlUpgradeable, GoodCollectiveSuperApp, UUPSUpgrad
     }
 
     function hasClaimed(address _member) public view returns (bool) {
-        address whitelistedRoot = IIdentityV2(settings.uniquenessValidator).getWhitelistedRoot(_member);
+        address whitelistedRoot = _member;
+        if (address(settings.uniquenessValidator) != address(0)) {
+            whitelistedRoot = IIdentityV2(settings.uniquenessValidator).getWhitelistedRoot(_member);
+        }
+        whitelistedRoot = IIdentityV2(settings.uniquenessValidator).getWhitelistedRoot(_member);
         return status.lastClaimed[whitelistedRoot] == getCurrentDay();
     }