@gooddollar/goodcollective-contracts 1.2.0 → 1.3.1

package/contracts/DirectPayments/DirectPaymentsFactory.sol

@@ -4,17 +4,18 @@ pragma solidity >=0.8.0;
 // import the DirectPayments contract
 import "./DirectPaymentsPool.sol";
 import "./ProvableNFT.sol";
+import "../GoodCollective/SuperAppBaseFlow.sol";
 import "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
 import "@openzeppelin/contracts/proxy/beacon/BeaconProxy.sol";
 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();
+    error NOT_PROJECT_MANAGER();
     error NOT_POOL();
 
     event PoolCreated(
@@ -60,9 +61,9 @@ contract DirectPaymentsFactory is AccessControlUpgradeable, UUPSUpgradeable {
         _;
     }
 
-    modifier onlyPoolOwner(DirectPaymentsPool pool) {
-        if (pool.hasRole(pool.DEFAULT_ADMIN_ROLE(), msg.sender) == false) {
-            revert NOT_PROJECT_OWNER();
+    modifier onlyPoolManager(DirectPaymentsPool pool) {
+        if (pool.hasRole(pool.MANAGER_ROLE(), msg.sender) == false) {
+            revert NOT_PROJECT_MANAGER();
         }
 
         _;
@@ -98,18 +99,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 +120,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 +137,19 @@ contract DirectPaymentsFactory is AccessControlUpgradeable, UUPSUpgradeable {
             pool = DirectPaymentsPool(address(new ERC1967Proxy(impl.implementation(), initCall)));
         }
 
-        nft.grantRole(nft.getManagerRole(nextNftType), _settings.manager);
+        // Register the app with the host
+        if (pool.host().isApp(pool) == false) {
+            try
+                IRegisterSuperapp(address(pool.host())).registerApp(address(pool), SuperAppDefinitions.APP_LEVEL_FINAL)
+            {} catch {
+                //fallback for older versions of superfluid used in unit tests
+                IRegisterSuperapp(address(pool.host())).registerAppByFactory(
+                    address(pool),
+                    SuperAppDefinitions.APP_LEVEL_FINAL
+                );
+            }
+        }
+
         nft.grantRole(nft.getManagerRole(nextNftType), address(pool));
 
         //access control to project is determinted by the first pool access control rules
@@ -148,7 +167,7 @@ contract DirectPaymentsFactory is AccessControlUpgradeable, UUPSUpgradeable {
         nextNftType++;
     }
 
-    function changePoolDetails(DirectPaymentsPool _pool, string memory _ipfs) external onlyPoolOwner(_pool) {
+    function changePoolDetails(DirectPaymentsPool _pool, string memory _ipfs) external onlyPoolManager(_pool) {
         registry[address(_pool)].ipfs = _ipfs;
         emit PoolDetailsChanged(address(_pool), _ipfs);
     }

package/contracts/DirectPayments/DirectPaymentsLibrary.sol

@@ -0,0 +1,208 @@
+// 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 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;
+        } else {
+            memberStats.daily += reward;
+        }
+
+        if (memberStats.lastMonth < _month()) //month switched
+        {
+            memberStats.monthly = reward;
+        } else {
+            memberStats.monthly += reward;
+        }
+
+        memberStats.total += reward;
+        memberStats.lastReward = uint64(block.timestamp);
+        memberStats.lastMonth = _month();
+    }
+
+    /**
+     * @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,
+        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;
+        } else {
+            globalLimits.daily += reward;
+        }
+
+        if (globalLimits.lastMonth < _month()) //month switched
+        {
+            globalLimits.monthly = reward;
+        } else {
+            globalLimits.monthly += reward;
+        }
+
+        globalLimits.total += reward;
+        globalLimits.lastReward = uint64(block.timestamp);
+        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,6 +9,7 @@ import { IERC721ReceiverUpgradeable } from "@openzeppelin/contracts-upgradeable/
 
 import { ProvableNFT } from "./ProvableNFT.sol";
 import { DirectPaymentsFactory } from "./DirectPaymentsFactory.sol";
+import { DirectPaymentsLibrary } from "./DirectPaymentsLibrary.sol";
 import "../GoodCollective/GoodCollectiveSuperApp.sol";
 
 interface IMembersValidator {
@@ -17,7 +18,7 @@ interface IMembersValidator {
         address operator,
         address member,
         bytes memory extraData
-    ) external returns (bool);
+    ) external view returns (bool);
 }
 
 interface IIdentityV2 {
@@ -73,7 +74,7 @@ contract DirectPaymentsPool is
         uint256 rewardPerContributer
     );
     event NFTClaimed(uint256 indexed tokenId, uint256 totalRewards);
-    event NOT_MEMBER_OR_WHITELISTED(address contributer);
+    event NOT_MEMBER_OR_WHITELISTED_OR_LIMITS(address contributer);
 
     // Define functions
     struct PoolSettings {
@@ -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);
@@ -172,162 +181,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)
-                );
+            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], "");
             }
         }
-
-        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]);
-            }
-        }
-        _enforceAndUpdateGlobalLimits(totalSent);
-    }
-
-    /**
-     * @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;
-        }
-
-        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;
-
-        if (
-            memberLimits[member].daily > limits.maxMemberPerDay ||
-            memberLimits[member].monthly > limits.maxMemberPerMonth
-        ) revert OVER_MEMBER_LIMITS(member);
-
-        return true;
+        DirectPaymentsLibrary._claim(globalLimits, limits, memberLimits, settings, _nftId, _data);
     }
 
-    /**
-     * @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 {
-        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;
-
-        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;
 
@@ -409,7 +276,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();