@gooddollar/goodcollective-contracts 1.1.0 → 1.3.0

package/README.md

@@ -1 +1,14 @@
-# contracts
+# Contracts
+
+## Structs
+
+### Pool Settings
+
+-   `nftType`: 1, // when you update the settings with setPoolSettings, `nftType` should always match what has been set when creating the pool
+-   `uniquenessValidator`: `ethers.constants.AddressZero`,
+-   `rewardPerEvent`: `[100, 300]`,
+-   `validEvents`: `[1, 2]`, // to be defined
+-   `manager`: `<address of the owner/creator of the pool>`,
+-   `membersValidator`: `ethers.constants.AddressZero`, // used to only accept certain members (address zero for anyone can join)
+-   `rewardToken`: `'0x62B8B11039FcfE5aB0C56E502b1C372A3d2a9c7A'`, // what token will a steward/member receive. currently only supports production G$'s
+-   `allowRewardOverride`: `false`,

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,17 +119,15 @@ 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.encodeWithSelector(
-            DirectPaymentsPool.initialize.selector,
-            nft,
-            _settings,
-            _limits,
-            address(this)
+        bytes memory initCall = abi.encodeCall(
+            DirectPaymentsPool.initialize,
+            (nft, _settings, _limits, _managerFeeBps, this)
         );
 
         if (useBeacon) {
@@ -136,9 +136,7 @@ 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));
-        pool.grantRole(pool.MINTER_ROLE(), _settings.manager);
 
         //access control to project is determinted by the first pool access control rules
         if (address(projectIdToControlPool[keccak256(bytes(_projectId))]) == address(0))
@@ -146,6 +144,7 @@ contract DirectPaymentsFactory is AccessControlUpgradeable, UUPSUpgradeable {
         registry[address(pool)].ipfs = _ipfs;
         registry[address(pool)].projectId = _projectId;
 
+        pool.grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
         pool.renounceRole(DEFAULT_ADMIN_ROLE, address(this));
         pools.push(address(pool));
 
@@ -174,7 +173,16 @@ contract DirectPaymentsFactory is AccessControlUpgradeable, UUPSUpgradeable {
         feeRecipient = _feeRecipient;
     }
 
-    function addMember(address account) external onlyPool {
-        memberPools[account].push(msg.sender);
+    function addMember(address member) external onlyPool {
+        memberPools[member].push(msg.sender);
+    }
+
+    function removeMember(address member) external onlyPool {
+        for (uint i = 0; i < memberPools[member].length; i++) {
+            if (memberPools[member][i] == msg.sender) {
+                memberPools[member][i] = memberPools[member][memberPools[member].length - 1];
+                memberPools[member].pop();
+            }
+        }
     }
 }

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,14 +141,18 @@ 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;
-        _setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
-        _setupRole(DEFAULT_ADMIN_ROLE, _settings.manager);
+        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);
+
         setSuperToken(ISuperToken(address(settings.rewardToken)));
     }
 
@@ -257,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 ||
@@ -289,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();
     }
@@ -352,6 +328,13 @@ contract DirectPaymentsPool is
         super._grantRole(role, account);
     }
 
+    function _revokeRole(bytes32 role, address account) internal virtual override {
+        if (role == MEMBER_ROLE) {
+            registry.removeMember(account);
+        }
+        super._revokeRole(role, account);
+    }
+
     function mintNFT(address _to, ProvableNFT.NFTData memory _nftData, bool withClaim) external onlyRole(MINTER_ROLE) {
         uint nftId = nft.mintPermissioned(_to, _nftData, true, "");
         if (withClaim) {
@@ -391,7 +374,7 @@ contract DirectPaymentsPool is
      * @dev Sets the safety limits for the pool.
      * @param _limits The new safety limits.
      */
-    function setPoolLimits(SafetyLimits memory _limits) public onlyRole(DEFAULT_ADMIN_ROLE) {
+    function setPoolLimits(SafetyLimits memory _limits) public onlyRole(MANAGER_ROLE) {
         limits = _limits;
         emit PoolLimitsChanged(_limits);
     }
@@ -400,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(DEFAULT_ADMIN_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

@@ -16,12 +16,6 @@ import "../utils/HelperLibrary.sol";
 
 // import "hardhat/console.sol";
 
-interface IRegistry {
-    function feeRecipient() external view returns (address);
-
-    function feeBps() external view returns (uint32);
-}
-
 abstract contract GoodCollectiveSuperApp is SuperAppBaseFlow {
     int96 public constant MIN_FLOW_RATE = 386e9;
 
@@ -74,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) {
@@ -84,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
@@ -122,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);
     }
@@ -166,6 +170,28 @@ abstract contract GoodCollectiveSuperApp is SuperAppBaseFlow {
         return _ctx;
     }
 
+    /**
+     * @dev allow single contribution. user needs to approve tokens first. can be used in superfluid batch actions.
+     * @param _sender The address of the sender who is contributing tokens.
+     * @param _customData The SwapData struct containing information about the swap
+     * @param _ctx The context of the transaction for superfluid in case this was used in superfluid batch. otherwise can be empty.
+     * @return Returns the context of the transaction.
+     */
+    function supportWithSwap(
+        address _sender,
+        HelperLibrary.SwapData memory _customData,
+        bytes memory _ctx
+    ) external onlyHostOrSender(_sender) returns (bytes memory) {
+        uint256 balance = superToken.balanceOf(address(this));
+        HelperLibrary.handleSwap(swapRouter, _customData, address(superToken), _sender, address(this));
+        uint256 amountReceived = superToken.balanceOf(address(this)) - balance;
+        if (amountReceived == 0) revert ZERO_AMOUNT();
+
+        // Update the contribution amount for the sender in the supporters mapping
+        _updateSupporter(_sender, int256(amountReceived), 0, ""); //we pass empty ctx since this is not a flow but a single donation
+        return _ctx;
+    }
+
     /**
      * @dev Handles the swap of tokens using the SwapData struct
      * @param _customData The SwapData struct containing information about the swap
@@ -235,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);
     }
 
@@ -253,10 +280,18 @@ abstract contract GoodCollectiveSuperApp is SuperAppBaseFlow {
     ) internal returns (bytes memory newCtx) {
         newCtx = _ctx;
         bool _isFlow = _ctx.length > 0;
-        _updateStats(_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);
@@ -264,14 +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);
-            newCtx = _takeFeeFlow(flowRate - int96(_previousFlowRateOrAmount), _ctx);
+
+            // 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,
+                superToken,
+                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(
@@ -284,57 +359,10 @@ abstract contract GoodCollectiveSuperApp is SuperAppBaseFlow {
         );
     }
 
-    // this should be called before any flow rate changes
-    function _updateStats(uint256 _amount) internal {
-        //use last rate before the current possible rate update
-        stats.netIncome += uint96(stats.lastIncomeRate) * (block.timestamp - stats.lastUpdate);
-        uint feeBps;
-        if (address(getRegistry()) != address(0)) {
-            feeBps = getRegistry().feeBps();
-            //fees sent to last recipient, the flowRate to recipient still wasnt updated.
-            stats.totalFees +=
-                uint96(superToken.getFlowRate(address(this), stats.lastFeeRecipient)) *
-                (block.timestamp - stats.lastUpdate);
-        }
-        if (_amount > 0) {
-            stats.netIncome += (_amount * (10000 - feeBps)) / 10000;
-            stats.totalFees += (_amount * feeBps) / 10000;
-        }
-        stats.lastUpdate = block.timestamp;
-    }
-
-    function _takeFeeFlow(int96 _diffRate, bytes memory _ctx) internal returns (bytes memory newCtx) {
-        newCtx = _ctx;
-        if (address(getRegistry()) == address(0)) return newCtx;
-        address recipient = getRegistry().feeRecipient();
-        int96 curFeeRate = superToken.getFlowRate(address(this), stats.lastFeeRecipient);
-        bool newRecipient;
-        if (recipient != stats.lastFeeRecipient) {
-            newRecipient = true;
-            if (stats.lastFeeRecipient != address(0)) {
-                //delete old recipient flow
-                if (curFeeRate > 0)
-                    newCtx = cfaV1.deleteFlowWithCtx(newCtx, address(this), stats.lastFeeRecipient, superToken); //passing in the ctx which is sent to the callback here
-            }
-            stats.lastFeeRecipient = recipient;
-        }
-        if (recipient == address(0)) return newCtx;
-
-        int96 feeRateChange = (_diffRate * int32(getRegistry().feeBps())) / 10000;
-        int96 newFeeRate = curFeeRate + feeRateChange;
-        if (newFeeRate <= 0 && newRecipient == false) {
-            newCtx = cfaV1.deleteFlowWithCtx(newCtx, address(this), recipient, superToken); //passing in the ctx which is sent to the callback here
-        } else if (curFeeRate > 0 && newRecipient == false) {
-            newCtx = cfaV1.updateFlowWithCtx(newCtx, recipient, superToken, newFeeRate); //passing in the ctx which is sent to the callback here
-        } else if (newFeeRate > 0) newCtx = cfaV1.createFlowWithCtx(newCtx, recipient, superToken, newFeeRate); //passing in the ctx which is sent to the callback here
-    }
-
-    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

@@ -1,6 +1,12 @@
 // SPDX-License-Identifier: MIT
 pragma solidity >=0.8.0;
 
+interface IRegistry {
+    function feeRecipient() external view returns (address);
+
+    function feeBps() external view returns (uint32);
+}
+
 interface IGoodCollectiveSuperApp {
     struct Stats {
         uint256 netIncome; //without fees
@@ -8,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;
+}