@gooddollar/goodcollective-contracts 1.3.0 → 1.3.1

package/contracts/DirectPayments/DirectPaymentsFactory.sol

@@ -4,10 +4,10 @@ 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";
 
@@ -15,6 +15,7 @@ import { UUPSUpgradeable } from "@openzeppelin/contracts-upgradeable/proxy/utils
 
 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();
         }
 
         _;
@@ -136,6 +137,19 @@ contract DirectPaymentsFactory is AccessControlUpgradeable, UUPSUpgradeable {
             pool = DirectPaymentsPool(address(new ERC1967Proxy(impl.implementation(), initCall)));
         }
 
+        // 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
@@ -153,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

@@ -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 {
@@ -74,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 {
@@ -181,127 +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)
-                );
-            }
-        }
-
-        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;
 

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/UBIPoolFactory.sol

@@ -11,11 +11,14 @@ import { AccessControlUpgradeable } from "@openzeppelin/contracts-upgradeable/ac
 import { UUPSUpgradeable } from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
 
 import "../Interfaces.sol";
+import "../GoodCollective/GoodCollectiveSuperApp.sol";
+import "../GoodCollective/SuperAppBaseFlow.sol";
 
 // import "hardhat/console.sol";
 
 contract UBIPoolFactory is AccessControlUpgradeable, UUPSUpgradeable {
     error NOT_PROJECT_OWNER();
+    error NOT_PROJECT_MANAGER();
     error NOT_POOL();
 
     event PoolCreated(
@@ -58,8 +61,8 @@ contract UBIPoolFactory is AccessControlUpgradeable, UUPSUpgradeable {
         _;
     }
 
-    modifier onlyPoolOwner(UBIPool pool) {
-        if (pool.hasRole(pool.DEFAULT_ADMIN_ROLE(), msg.sender) == false) {
+    modifier onlyPoolManager(UBIPool pool) {
+        if (pool.hasRole(pool.MANAGER_ROLE(), msg.sender) == false) {
             revert NOT_PROJECT_OWNER();
         }
 
@@ -121,6 +124,19 @@ contract UBIPoolFactory is AccessControlUpgradeable, UUPSUpgradeable {
             pool = UBIPool(address(new ERC1967Proxy(impl.implementation(), initCall)));
         }
 
+        // 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
+                );
+            }
+        }
+
         //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;
@@ -134,7 +150,7 @@ contract UBIPoolFactory is AccessControlUpgradeable, UUPSUpgradeable {
         emit PoolCreated(address(pool), _projectId, _ipfs, _settings, _limits);
     }
 
-    function changePoolDetails(UBIPool _pool, string memory _ipfs) external onlyPoolOwner(_pool) {
+    function changePoolDetails(UBIPool _pool, string memory _ipfs) external onlyPoolManager(_pool) {
         registry[address(_pool)].ipfs = _ipfs;
         emit PoolDetailsChanged(address(_pool), _ipfs);
     }

package/contracts/utils/HelperLibrary.sol

@@ -16,6 +16,9 @@ library HelperLibrary {
     using SuperTokenV1Library for ISuperToken;
     using CFAv1Library for CFAv1Library.InitData;
 
+    error ZERO_AMOUNT();
+    error ZERO_ADDRESS();
+
     /**
      * @dev A struct containing information about a token swap
      * @param swapFrom The address of the token being swapped
@@ -179,4 +182,11 @@ library HelperLibrary {
             }
         } else if (newFeeRate > 0) newCtx = cfaV1.createFlowWithCtx(newCtx, recipient, superToken, newFeeRate); //passing in the ctx which is sent to the callback here
     }
+
+    function recoverFunds(ISuperToken superToken, address recipient, uint256 amount) external {
+        require(IGoodCollectiveSuperApp(address(this)).getRegistry().hasRole(0x00, msg.sender), "not owner");
+        if (amount == 0) revert ZERO_AMOUNT();
+        if (recipient == address(0)) revert ZERO_ADDRESS();
+        superToken.transfer(recipient, amount);
+    }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gooddollar/goodcollective-contracts",
   "packageManager": "yarn@3.2.1",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "license": "MIT",
   "types": "./typechain-types/index.ts",
   "files": [
@@ -35,11 +35,11 @@
     "dotenv": "^16.3.1",
     "ethereum-waffle": "^3.0.0",
     "graphql": "^16.7.1",
-    "hardhat": "^2.17.1",
+    "hardhat": "^2.26.2",
     "hardhat-abi-exporter": "^2.10.1",
     "hardhat-celo": "^0.0.4",
     "hardhat-contract-sizer": "^2.10.0",
-    "hardhat-deploy": "^0.12.4",
+    "hardhat-deploy": "^1.0.4",
     "hardhat-gas-reporter": "^1.0.8",
     "prettier": "^2.8.8",
     "prettier-plugin-solidity": "^1.1.3",