@gooddollar/goodcollective-contracts 1.0.3 → 1.0.5-beta.7a2c704

package/contracts/DirectPayments/DirectPaymentsFactory.sol

@@ -5,6 +5,9 @@ pragma solidity >=0.8.0;
 import "./DirectPaymentsPool.sol";
 import "./ProvableNFT.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";
 
@@ -13,7 +16,15 @@ import "hardhat/console.sol";
 contract DirectPaymentsFactory is AccessControlUpgradeable, UUPSUpgradeable {
     error NOT_PROJECT_OWNER();
 
-    event PoolCreated(address indexed pool, string indexed projectId, string ipfs, uint32 indexed nftType);
+    event PoolCreated(
+        address indexed pool,
+        string indexed projectId,
+        string ipfs,
+        uint32 indexed nftType,
+        DirectPaymentsPool.PoolSettings poolSettings,
+        DirectPaymentsPool.SafetyLimits poolLimits
+    );
+
     event PoolDetailsChanged(address indexed pool, string ipfs);
     event PoolVerifiedChanged(address indexed pool, bool isVerified);
     event UpdatedImpl(address indexed impl);
@@ -24,16 +35,18 @@ contract DirectPaymentsFactory is AccessControlUpgradeable, UUPSUpgradeable {
         string projectId;
     }
 
-    address public impl;
+    UpgradeableBeacon public impl;
     ProvableNFT public nft;
     uint32 public nextNftType;
 
     mapping(address => PoolRegistry) public registry;
     mapping(bytes32 => DirectPaymentsPool) public projectIdToControlPool;
 
+    address public feeRecipient;
+    uint32 public feeBps;
+
     modifier onlyProjectOwnerOrNon(string memory projectId) {
         DirectPaymentsPool controlPool = projectIdToControlPool[keccak256(bytes(projectId))];
-        console.log("control:%s sender:%s %s", address(controlPool), msg.sender);
         // console.log("result %s", controlPool.hasRole(controlPool.DEFAULT_ADMIN_ROLE(), msg.sender));
         if (address(controlPool) != address(0)) {
             if (controlPool.hasRole(controlPool.DEFAULT_ADMIN_ROLE(), msg.sender) == false) {
@@ -55,38 +68,77 @@ contract DirectPaymentsFactory is AccessControlUpgradeable, UUPSUpgradeable {
 
     function _authorizeUpgrade(address _impl) internal virtual override onlyRole(DEFAULT_ADMIN_ROLE) {}
 
-    function initialize(address _owner, address _dpimpl, address _nftimpl) external initializer {
+    function initialize(
+        address _owner,
+        address _dpimpl,
+        ProvableNFT _nft,
+        address _feeRecipient,
+        uint32 _feeBps
+    ) external initializer {
         nextNftType = 1;
-        impl = _dpimpl;
-        bytes memory initCall = abi.encodeWithSelector(ProvableNFT.initialize.selector, "DirectPayments NFT", "DPNFT");
-        nft = ProvableNFT(address(new ERC1967Proxy(_nftimpl, initCall)));
+        impl = new UpgradeableBeacon(_dpimpl);
+        nft = _nft;
+        feeRecipient = _feeRecipient;
+        feeBps = _feeBps;
 
-        nft.grantRole(DEFAULT_ADMIN_ROLE, _owner);
         _setupRole(DEFAULT_ADMIN_ROLE, _owner);
     }
 
+    //TODO: implement a pool that's auto upgradeable using beacon method
+    function createBeaconPool(
+        string memory _projectId,
+        string memory _ipfs,
+        DirectPaymentsPool.PoolSettings memory _settings,
+        DirectPaymentsPool.SafetyLimits memory _limits
+    ) external onlyProjectOwnerOrNon(_projectId) returns (DirectPaymentsPool pool) {
+        return _createPool(_projectId, _ipfs, _settings, _limits, true);
+    }
+
     function createPool(
         string memory _projectId,
         string memory _ipfs,
         DirectPaymentsPool.PoolSettings memory _settings,
         DirectPaymentsPool.SafetyLimits memory _limits
     ) external onlyProjectOwnerOrNon(_projectId) returns (DirectPaymentsPool pool) {
+        return _createPool(_projectId, _ipfs, _settings, _limits, false);
+    }
+
+    function _createPool(
+        string memory _projectId,
+        string memory _ipfs,
+        DirectPaymentsPool.PoolSettings memory _settings,
+        DirectPaymentsPool.SafetyLimits memory _limits,
+        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);
-        pool = DirectPaymentsPool(address(new ERC1967Proxy(impl, initCall)));
+        bytes memory initCall = abi.encodeWithSelector(
+            DirectPaymentsPool.initialize.selector,
+            nft,
+            _settings,
+            _limits,
+            address(this)
+        );
+
+        if (useBeacon) {
+            pool = DirectPaymentsPool(address(new BeaconProxy(address(impl), initCall)));
+        } else {
+            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);
 
-        projectIdToControlPool[keccak256(bytes(_projectId))] = pool;
+        //access control to project is determinted by the first pool access control rules
+        if (address(projectIdToControlPool[keccak256(bytes(_projectId))]) == address(0))
+            projectIdToControlPool[keccak256(bytes(_projectId))] = pool;
         registry[address(pool)].ipfs = _ipfs;
         registry[address(pool)].projectId = _projectId;
 
         pool.renounceRole(DEFAULT_ADMIN_ROLE, address(this));
-        emit PoolCreated(address(pool), _projectId, _ipfs, nextNftType);
+        emit PoolCreated(address(pool), _projectId, _ipfs, nextNftType, _settings, _limits);
 
         nextNftType++;
     }
@@ -102,7 +154,12 @@ contract DirectPaymentsFactory is AccessControlUpgradeable, UUPSUpgradeable {
     }
 
     function updateImpl(address _impl) external onlyRole(DEFAULT_ADMIN_ROLE) {
-        impl = _impl;
+        impl.upgradeTo(_impl);
         emit UpdatedImpl(_impl);
     }
+
+    function setFeeInfo(address _feeRecipient, uint32 _feeBps) external onlyRole(DEFAULT_ADMIN_ROLE) {
+        feeBps = _feeBps;
+        feeRecipient = _feeRecipient;
+    }
 }

package/contracts/DirectPayments/DirectPaymentsPool.sol

@@ -41,21 +41,39 @@ contract DirectPaymentsPool is
     error NOT_MANAGER();
     error ALREADY_CLAIMED(uint256);
     error NFT_MISSING(uint256);
-    error NOT_MEMBER(address);
-    error NOT_WHITELISTED(address);
     error OVER_MEMBER_LIMITS(address);
     error OVER_GLOBAL_LIMITS();
     error UNSUPPORTED_NFT();
     error NO_BALANCE();
+    error NFTTYPE_CHANGED();
+    error EMPTY_MANAGER();
 
     bytes32 public constant MANAGER_ROLE = keccak256("MANAGER_ROLE");
+    bytes32 public constant MEMBER_ROLE = keccak256("MEMBER_ROLE");
     bytes32 public constant MINTER_ROLE = keccak256("MINTER");
 
+    event PoolCreated(
+        address indexed pool,
+        string indexed projectId,
+        string ipfs,
+        uint32 indexed nftType,
+        DirectPaymentsPool.PoolSettings poolSettings,
+        DirectPaymentsPool.SafetyLimits poolLimits
+    );
+
     event PoolSettingsChanged(PoolSettings settings);
     event PoolLimitsChanged(SafetyLimits limits);
-    event MemberAdded(address member);
-    event MemberRemoved(address member);
-    event RewardClaimed(uint256 indexed tokenId, uint256 totalRewards);
+    event EventRewardClaimed(
+        uint256 indexed tokenId,
+        uint16 eventType,
+        uint32 eventTimestamp,
+        uint256 eventQuantity,
+        string eventUri,
+        address[] contributers,
+        uint256 rewardPerContributer
+    );
+    event NFTClaimed(uint256 indexed tokenId, uint256 totalRewards);
+    event NOT_MEMBER_OR_WHITELISTED(address contributer);
 
     // Define functions
     struct PoolSettings {
@@ -66,6 +84,7 @@ contract DirectPaymentsPool is
         IMembersValidator membersValidator;
         IIdentityV2 uniquenessValidator;
         IERC20Upgradeable rewardToken;
+        bool allowRewardOverride;
     }
 
     struct SafetyLimits {
@@ -87,10 +106,10 @@ contract DirectPaymentsPool is
     ProvableNFT public nft;
 
     mapping(uint256 => bool) public claimedNfts;
-    mapping(address => bool) public members;
+    mapping(address => bool) private members_unused; // using access control instead
     mapping(address => LimitsData) public memberLimits;
     LimitsData public globalLimits;
-    address public createdBy;
+    DirectPaymentsFactory public registry;
 
     /// @custom:oz-upgrades-unsafe-allow constructor
     constructor(ISuperfluid _host, ISwapRouter _swapRouter) GoodCollectiveSuperApp(_host, _swapRouter) {}
@@ -99,7 +118,11 @@ contract DirectPaymentsPool is
      * @dev Authorizes an upgrade for the implementation contract.
      * @param impl The address of the new implementation contract.
      */
-    function _authorizeUpgrade(address impl) internal virtual override {}
+    function _authorizeUpgrade(address impl) internal virtual override onlyRole(DEFAULT_ADMIN_ROLE) {}
+
+    function getRegistry() public view override returns (DirectPaymentsFactory) {
+        return DirectPaymentsFactory(registry);
+    }
 
     /**
      * @dev Initializes the contract with the given settings and limits.
@@ -110,20 +133,20 @@ contract DirectPaymentsPool is
     function initialize(
         ProvableNFT _nft,
         PoolSettings memory _settings,
-        SafetyLimits memory _limits
+        SafetyLimits memory _limits,
+        DirectPaymentsFactory _registry
     ) external initializer {
-        createdBy = msg.sender;
+        registry = _registry;
         settings = _settings;
         limits = _limits;
         nft = _nft;
         _setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
         _setupRole(DEFAULT_ADMIN_ROLE, _settings.manager);
-
         setSuperToken(ISuperToken(address(settings.rewardToken)));
     }
 
-    function upgradeToLatest(bytes memory data) external payable virtual onlyProxy {
-        address impl = DirectPaymentsFactory(createdBy).impl();
+    function upgradeToLatest(bytes memory data) external payable virtual {
+        address impl = address(DirectPaymentsFactory(registry).impl());
         _authorizeUpgrade(impl);
         _upgradeToAndCallUUPS(impl, data, false);
     }
@@ -164,17 +187,31 @@ contract DirectPaymentsPool is
         uint totalRewards;
         uint rewardsBalance = settings.rewardToken.balanceOf(address(this));
 
+        bool allowRewardOverride = settings.allowRewardOverride;
         for (uint256 i = 0; i < _data.events.length; i++) {
-            uint128 reward = _eventReward(_data.events[i].subtype);
+            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 * _data.events[i].quantity;
+                totalRewards += reward;
                 if (totalRewards > rewardsBalance) revert NO_BALANCE();
                 rewardsBalance -= totalRewards;
-                _sendReward(_data.events[i].contributers, uint128(reward * _data.events[i].quantity));
+                _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 RewardClaimed(_nftId, totalRewards);
+        emit NFTClaimed(_nftId, totalRewards);
     }
 
     /**
@@ -196,11 +233,17 @@ contract DirectPaymentsPool is
      */
     function _sendReward(address[] memory recipients, uint128 reward) internal {
         uint128 perReward = uint128(reward / recipients.length);
+        uint128 totalSent;
         for (uint i = 0; i < recipients.length; i++) {
-            _enforceAndUpdateMemberLimits(recipients[i], perReward);
-            settings.rewardToken.safeTransfer(recipients[i], perReward);
+            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(reward);
+        _enforceAndUpdateGlobalLimits(totalSent);
     }
 
     /**
@@ -208,8 +251,11 @@ contract DirectPaymentsPool is
      * @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 {
-        if (members[member] == false) revert NOT_MEMBER(member);
+    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
@@ -234,6 +280,8 @@ contract DirectPaymentsPool is
             memberLimits[member].daily > limits.maxMemberPerDay ||
             memberLimits[member].monthly > limits.maxMemberPerMonth
         ) revert OVER_MEMBER_LIMITS(member);
+
+        return true;
     }
 
     /**
@@ -278,32 +326,23 @@ contract DirectPaymentsPool is
      * @param extraData Additional data to validate the member.
      */
 
-    function addMember(address member, bytes memory extraData) external {
+    function _addMember(address member, bytes memory extraData) internal returns (bool isMember) {
+        if (hasRole(MEMBER_ROLE, member)) return true;
+
         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 no members validator then anyone can join the pool
         if (address(settings.membersValidator) != address(0)) {
             if (settings.membersValidator.isMemberValid(address(this), msg.sender, member, extraData) == false) {
-                revert NOT_MEMBER(member);
+                return false;
             }
-        } else {
-            // if no members validator then only admin can add members
-            if (hasRole(DEFAULT_ADMIN_ROLE, msg.sender) == false) revert NOT_MANAGER();
         }
 
-        members[member] = true;
-        emit MemberAdded(member);
-    }
-
-    /**
-     * @dev Removes a member from the contract.
-     * @param member The address of the member to remove.
-     */
-    function removeMember(address member) external onlyRole(DEFAULT_ADMIN_ROLE) {
-        members[member] = false;
-        emit MemberRemoved(member);
+        _setupRole(MEMBER_ROLE, member);
+        return true;
     }
 
     function mintNFT(address _to, ProvableNFT.NFTData memory _nftData, bool withClaim) external onlyRole(MINTER_ROLE) {
@@ -314,7 +353,7 @@ contract DirectPaymentsPool is
     }
 
     /**
-     * @dev Receives an ERC721 token and triggers a claim for rewards.
+     * @dev Receives an ERC721 token
      * @param operator The address of the operator that sent the token.
      * @param from The address of the sender that sent the token.
      * @param tokenId The ID of the token received.
@@ -340,4 +379,27 @@ contract DirectPaymentsPool is
         if (nftData.nftType != settings.nftType) revert UNSUPPORTED_NFT();
         return DirectPaymentsPool.onERC721Received.selector;
     }
+
+    /**
+     * @dev Sets the safety limits for the pool.
+     * @param _limits The new safety limits.
+     */
+    function setPoolLimits(SafetyLimits memory _limits) public onlyRole(DEFAULT_ADMIN_ROLE) {
+        limits = _limits;
+        emit PoolLimitsChanged(_limits);
+    }
+
+    /**
+     * @dev Sets the settings for the pool.
+     * @param _settings The new pool settings.
+     */
+    function setPoolSettings(PoolSettings memory _settings) public onlyRole(DEFAULT_ADMIN_ROLE) {
+        if (_settings.nftType != settings.nftType) revert NFTTYPE_CHANGED();
+        if (_settings.manager == address(0)) revert EMPTY_MANAGER();
+
+        _revokeRole(DEFAULT_ADMIN_ROLE, settings.manager);
+        settings = _settings;
+        _setupRole(DEFAULT_ADMIN_ROLE, _settings.manager);
+        emit PoolSettingsChanged(_settings);
+    }
 }

package/contracts/DirectPayments/ProvableNFT.sol

@@ -19,12 +19,15 @@ contract ProvableNFT is ERC721Upgradeable, AccessControlUpgradeable, UUPSUpgrade
     bytes32 public constant MINTER_ROLE = keccak256(abi.encodePacked("MINTER"));
     bytes16 private constant _SYMBOLS = "0123456789abcdef";
 
+    event ProvableNftMinted(uint256 tokenId, address to, bytes32 nftDataHash);
+
     struct EventData {
         uint16 subtype;
         uint32 timestamp;
         uint256 quantity;
         string eventUri; //extra data related to event
         address[] contributers;
+        uint128 rewardOverride; //override reward defined per 1 quantity of event, pool will use this instead of its own reward if allowRewardOverride is true
     }
 
     struct NFTData {
@@ -41,7 +44,9 @@ contract ProvableNFT is ERC721Upgradeable, AccessControlUpgradeable, UUPSUpgrade
         _setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
     }
 
-    function _authorizeUpgrade(address newimpl) internal virtual override onlyManager(0) {}
+    function _authorizeUpgrade(address /*newimpl*/) internal virtual override {
+        _onlyManager(0);
+    }
 
     function supportsInterface(
         bytes4 interfaceId
@@ -49,14 +54,13 @@ contract ProvableNFT is ERC721Upgradeable, AccessControlUpgradeable, UUPSUpgrade
         return super.supportsInterface(interfaceId);
     }
 
-    modifier onlyManager(uint32 nftType) {
+    function _onlyManager(uint32 nftType) internal view {
         if (
             ((nftType > 0 && hasRole(getManagerRole(nftType), msg.sender)) ||
                 hasRole(DEFAULT_ADMIN_ROLE, msg.sender)) == false
         ) {
             revert NOT_MANAGER(nftType);
         }
-        _;
     }
 
     /**
@@ -72,23 +76,24 @@ contract ProvableNFT is ERC721Upgradeable, AccessControlUpgradeable, UUPSUpgrade
      * @param _nftDataHash The hash of the NFT's data.
      * @return tokenId ID of the newly minted NFT.
      */
-    function mint(
-        address _to,
-        string memory _uri,
-        bytes32 _nftDataHash
-    ) public onlyManager(0) returns (uint256 tokenId) {
-        return _mint(_to, _uri, _nftDataHash, ""); //send false in calldata, assuming default receiver is a directpaymentspool. without nft data on chain it will fail.
+    function mint(address _to, string memory _uri, bytes32 _nftDataHash) public returns (uint256 tokenId) {
+        _onlyManager(0);
+        NFTData memory nftData;
+
+        return _mint(_to, _uri, _nftDataHash, nftData, ""); //send false in calldata, assuming default receiver is a directpaymentspool. without nft data on chain it will fail.
     }
 
     function _mint(
         address _to,
         string memory _uri,
         bytes32 _nftDataHash,
+        NFTData memory /*_nftData*/,
         bytes memory _callData
     ) internal returns (uint256 tokenId) {
         tokenId = uint256(_nftDataHash);
         nftDatas[tokenId].nftUri = _uri;
         _safeMint(_to, tokenId, _callData);
+        emit ProvableNftMinted(tokenId, _to, _nftDataHash);
     }
 
     /**
@@ -109,7 +114,8 @@ contract ProvableNFT is ERC721Upgradeable, AccessControlUpgradeable, UUPSUpgrade
         NFTData memory _nftData,
         bool _withStore,
         bytes memory _callData
-    ) external onlyManager(_nftData.nftType) returns (uint256 tokenId) {
+    ) external returns (uint256 tokenId) {
+        _onlyManager(_nftData.nftType);
         if (_nftData.nftType == 0) revert BAD_NFTTYPE();
 
         bytes32 dataHash = keccak256(abi.encode(_nftData));
@@ -123,7 +129,7 @@ contract ProvableNFT is ERC721Upgradeable, AccessControlUpgradeable, UUPSUpgrade
                 store.events.push(_nftData.events[i]);
             }
         }
-        _mint(_to, _nftData.nftUri, dataHash, _callData);
+        _mint(_to, _nftData.nftUri, dataHash, _nftData, _callData);
     }
 
     function proveNFTData(uint256 _tokenId, NFTData memory _nftData) public view returns (NFTData memory data) {