@gooddollar/goodcollective-contracts 1.0.2 → 1.0.4

package/contracts/DirectPayments/DirectPaymentsFactory.sol

@@ -31,9 +31,11 @@ contract DirectPaymentsFactory is AccessControlUpgradeable, UUPSUpgradeable {
     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,16 +57,32 @@ 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,
+        address _nftimpl,
+        address _feeRecipient,
+        uint32 _feeBps
+    ) external initializer {
         nextNftType = 1;
         impl = _dpimpl;
-        bytes memory initCall = abi.encodeWithSelector(ProvableNFT.initialize.selector, "DirectPayments NFT", "DPNFT");
+        bytes memory initCall = abi.encodeWithSelector(ProvableNFT.initialize.selector, "GoodCollective NFT", "GC-NFT");
         nft = ProvableNFT(address(new ERC1967Proxy(_nftimpl, initCall)));
+        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) {}
+
     function createPool(
         string memory _projectId,
         string memory _ipfs,
@@ -74,7 +92,13 @@ contract DirectPaymentsFactory is AccessControlUpgradeable, UUPSUpgradeable {
         //TODO: add check if msg.sender is whitelisted
 
         _settings.nftType = nextNftType;
-        bytes memory initCall = abi.encodeWithSelector(DirectPaymentsPool.initialize.selector, nft, _settings, _limits);
+        bytes memory initCall = abi.encodeWithSelector(
+            DirectPaymentsPool.initialize.selector,
+            nft,
+            _settings,
+            _limits,
+            address(this)
+        );
         pool = DirectPaymentsPool(address(new ERC1967Proxy(impl, initCall)));
 
         nft.grantRole(nft.getManagerRole(nextNftType), _settings.manager);
@@ -105,4 +129,9 @@ contract DirectPaymentsFactory is AccessControlUpgradeable, UUPSUpgradeable {
         impl = _impl;
         emit UpdatedImpl(_impl);
     }
+
+    function setFeeInfo(address _feeRecipient, uint32 _feeBps) external onlyRole(DEFAULT_ADMIN_ROLE) {
+        feeBps = _feeBps;
+        feeRecipient = _feeRecipient;
+    }
 }

package/contracts/DirectPayments/DirectPaymentsPool.sol

@@ -55,7 +55,8 @@ contract DirectPaymentsPool is
     event PoolLimitsChanged(SafetyLimits limits);
     event MemberAdded(address member);
     event MemberRemoved(address member);
-    event RewardClaimed(uint256 indexed tokenId, uint256 totalRewards);
+    event EventRewardClaimed(uint256 indexed tokenId, ProvableNFT.EventData eventData);
+    event NFTClaimed(uint256 indexed tokenId, uint256 totalRewards);
 
     // Define functions
     struct PoolSettings {
@@ -64,7 +65,7 @@ contract DirectPaymentsPool is
         uint128[] rewardPerEvent;
         address manager;
         IMembersValidator membersValidator;
-        IIdentityV2 uniqunessValidator;
+        IIdentityV2 uniquenessValidator;
         IERC20Upgradeable rewardToken;
     }
 
@@ -90,7 +91,7 @@ contract DirectPaymentsPool is
     mapping(address => bool) public members;
     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) {}
@@ -101,6 +102,10 @@ contract DirectPaymentsPool is
      */
     function _authorizeUpgrade(address impl) internal virtual override {}
 
+    function getRegistry() public view override returns (DirectPaymentsFactory) {
+        return DirectPaymentsFactory(registry);
+    }
+
     /**
      * @dev Initializes the contract with the given settings and limits.
      * @param _nft The ProvableNFT contract address.
@@ -110,9 +115,10 @@ 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;
@@ -123,7 +129,7 @@ contract DirectPaymentsPool is
     }
 
     function upgradeToLatest(bytes memory data) external payable virtual onlyProxy {
-        address impl = DirectPaymentsFactory(createdBy).impl();
+        address impl = DirectPaymentsFactory(registry).impl();
         _authorizeUpgrade(impl);
         _upgradeToAndCallUUPS(impl, data, false);
     }
@@ -171,10 +177,11 @@ contract DirectPaymentsPool is
                 if (totalRewards > rewardsBalance) revert NO_BALANCE();
                 rewardsBalance -= totalRewards;
                 _sendReward(_data.events[i].contributers, uint128(reward * _data.events[i].quantity));
+                emit EventRewardClaimed(_nftId, _data.events[i]);
             }
         }
 
-        emit RewardClaimed(_nftId, totalRewards);
+        emit NFTClaimed(_nftId, totalRewards);
     }
 
     /**
@@ -279,8 +286,8 @@ contract DirectPaymentsPool is
      */
 
     function addMember(address member, bytes memory extraData) external {
-        if (address(settings.uniqunessValidator) != address(0)) {
-            address rootAddress = settings.uniqunessValidator.getWhitelistedRoot(member);
+        if (address(settings.uniquenessValidator) != address(0)) {
+            address rootAddress = settings.uniquenessValidator.getWhitelistedRoot(member);
             if (rootAddress == address(0)) revert NOT_WHITELISTED(member);
         }
 

package/contracts/GoodCollective/GoodCollectiveSuperApp.sol

@@ -6,21 +6,45 @@ import { SuperAppBaseFlow } from "./SuperAppBaseFlow.sol";
 import { ISuperfluid, ISuperToken, SuperAppDefinitions } 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";
 
 import "@uniswap/v3-periphery/contracts/libraries/TransferHelper.sol";
 import "@uniswap/v3-periphery/contracts/interfaces/ISwapRouter.sol";
 
+import "../DirectPayments/DirectPaymentsFactory.sol";
+
 // import "hardhat/console.sol";
 
 abstract contract GoodCollectiveSuperApp is SuperAppBaseFlow {
+    int96 public constant MIN_FLOW_RATE = 386e9;
+
     using SuperTokenV1Library for ISuperToken;
+    using CFAv1Library for CFAv1Library.InitData;
 
     error ZERO_ADDRESS();
     error ZERO_AMOUNT();
     error UNSUPPORTED_TOKEN();
     error ONLY_HOST_OR_SENDER(address);
+    error FEE_FLOW_FAILED(int96 curFeeRate, int96 newFeeRate);
+    error MIN_FLOWRATE(int96 flowRate);
 
-    event SupporterUpdated(address indexed supporter, uint256 contribution, int96 flowRate, uint256 lastUpdated);
+    /**
+     * @dev Emitted when a supporter's contribution or flow rate is updated
+     * @param supporter The address of the supporter
+     * @param previousContribution The previous total contribution amount
+     * @param contribution The new total contribution amount
+     * @param previousFlowRate The previous flow rate if isFlowUpdate otherwise 0
+     * @param flowRate The new flow rate
+     * @param isFlowUpdate True if the update was a flow rate update, false if it was a single contribution update
+     */
+    event SupporterUpdated(
+        address indexed supporter,
+        uint256 previousContribution,
+        uint256 contribution,
+        int96 previousFlowRate,
+        int96 flowRate,
+        bool isFlowUpdate
+    );
 
     //TODO: ask about "view" for beforeagreement functions
     // ask about "receiver" can it be different then app?
@@ -40,7 +64,7 @@ abstract contract GoodCollectiveSuperApp is SuperAppBaseFlow {
         address swapFrom;
         uint256 amount;
         uint256 minReturn;
-        uint256 timestamp;
+        uint256 deadline;
         bytes path;
     }
 
@@ -50,11 +74,24 @@ abstract contract GoodCollectiveSuperApp is SuperAppBaseFlow {
         uint128 lastUpdated;
     }
 
+    struct Stats {
+        uint256 netIncome; //without fees
+        uint256 totalFees;
+        uint256 lastUpdate;
+        address lastFeeRecipient;
+        int96 lastIncomeRate;
+    }
+
     ISuperToken public superToken;
 
     mapping(address => SupporterData) public supporters;
 
-    uint256[50] private _reserved;
+    //initialize cfaV1 variable
+    CFAv1Library.InitData public cfaV1;
+
+    Stats public stats;
+
+    uint256[48] private _reserved;
 
     /// @custom:oz-upgrades-unsafe-allow constructor
     constructor(ISuperfluid _host, ISwapRouter _swapRouter) SuperAppBaseFlow(_host) {
@@ -62,6 +99,8 @@ abstract contract GoodCollectiveSuperApp is SuperAppBaseFlow {
         swapRouter = _swapRouter;
     }
 
+    function getRegistry() public view virtual returns (DirectPaymentsFactory);
+
     /**
      * @dev Sets the address of the super token and registers the app with the host
      * @param _superToken The address of the super token contract
@@ -77,6 +116,14 @@ abstract contract GoodCollectiveSuperApp is SuperAppBaseFlow {
 
         // Register the app with the host
         host.registerApp(callBackDefinitions);
+
+        //initialize InitData struct, and set equal to cfaV1
+        cfaV1 = CFAv1Library.InitData(
+            host,
+            IConstantFlowAgreementV1(
+                address(host.getAgreementClass(keccak256("org.superfluid-finance.agreements.ConstantFlowAgreement.v1")))
+            )
+        );
     }
 
     function isAcceptedSuperToken(ISuperToken _superToken) public view override returns (bool) {
@@ -89,6 +136,20 @@ abstract contract GoodCollectiveSuperApp is SuperAppBaseFlow {
         return supporter.contribution + uint96(supporter.flowRate) * (block.timestamp - supporter.lastUpdated);
     }
 
+    function getRealtimeStats()
+        public
+        view
+        returns (uint256 netIncome, uint256 totalFees, int96 incomeFlowRate, int96 feeRate)
+    {
+        incomeFlowRate = stats.lastIncomeRate;
+        netIncome = stats.netIncome + uint96(stats.lastIncomeRate) * (block.timestamp - stats.lastUpdate);
+        feeRate = superToken.getFlowRate(address(this), stats.lastFeeRecipient);
+        totalFees =
+            stats.totalFees +
+            uint96(superToken.getFlowRate(address(this), stats.lastFeeRecipient)) *
+            (block.timestamp - stats.lastUpdate);
+    }
+
     /**
      * @dev This function is called when a token transfer occurs
      * @param _sender The address of the sender
@@ -100,16 +161,16 @@ abstract contract GoodCollectiveSuperApp is SuperAppBaseFlow {
         if (_amount == 0) revert ZERO_AMOUNT();
 
         // Update the contribution amount for the sender in the supporters mapping
-        _updateSupporter(_sender, int96(int256(_amount / 1000)), block.timestamp - 1000);
+        _updateSupporter(_sender, int256(_amount), 0, "");
 
         return true;
     }
 
     /**
-     * @dev This function supports the Superfluid protocol by allowing a sender to contribute tokens to the network.
+     * @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 _amount The amount of tokens being contributed.
-     * @param _ctx The context of the transaction for superfluid
+     * @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 support(
@@ -123,7 +184,7 @@ abstract contract GoodCollectiveSuperApp is SuperAppBaseFlow {
         TransferHelper.safeTransferFrom(address(superToken), _sender, address(this), _amount);
 
         // Update the contribution amount for the sender in the supporters mapping
-        _updateSupporter(_sender, int96(int256(_amount / 1000)), block.timestamp - 1000);
+        _updateSupporter(_sender, int256(_amount), 0, ""); //we pass empty ctx since this is not a flow but a single donation
 
         return _ctx;
     }
@@ -151,7 +212,7 @@ abstract contract GoodCollectiveSuperApp is SuperAppBaseFlow {
             ISwapRouter.ExactInputParams memory params = ISwapRouter.ExactInputParams({
                 path: _customData.path,
                 recipient: _sender,
-                deadline: _customData.timestamp,
+                deadline: _customData.deadline,
                 amountIn: _customData.amount,
                 amountOutMinimum: _customData.minReturn
             });
@@ -163,7 +224,7 @@ abstract contract GoodCollectiveSuperApp is SuperAppBaseFlow {
                 tokenOut: address(superToken),
                 fee: 10000,
                 recipient: _sender,
-                deadline: _customData.timestamp,
+                deadline: _customData.deadline,
                 amountIn: _customData.amount,
                 amountOutMinimum: _customData.minReturn,
                 sqrtPriceLimitX96: 0
@@ -189,10 +250,7 @@ abstract contract GoodCollectiveSuperApp is SuperAppBaseFlow {
         bytes calldata _ctx
     ) internal virtual override returns (bytes memory /*newCtx*/) {
         // Update the supporter's information
-        _updateSupporter(_sender, 0, 0);
-
-        // Return the context of the transaction
-        return _ctx;
+        return _updateSupporter(_sender, 0, 0, _ctx);
     }
 
     /**
@@ -211,10 +269,7 @@ abstract contract GoodCollectiveSuperApp is SuperAppBaseFlow {
         bytes calldata _ctx
     ) internal virtual override returns (bytes memory /*newCtx*/) {
         // Update the supporter's information
-        _updateSupporter(_sender, _previousFlowRate, _lastUpdated);
-
-        // Return the context of the transaction
-        return _ctx;
+        return _updateSupporter(_sender, _previousFlowRate, _lastUpdated, _ctx);
     }
 
     /**
@@ -234,27 +289,107 @@ abstract contract GoodCollectiveSuperApp is SuperAppBaseFlow {
         bytes calldata _ctx
     ) internal virtual override returns (bytes memory /*newCtx*/) {
         // Update the supporter's information
-        _updateSupporter(_sender, _previousFlowRate, _lastUpdated);
-
-        // Return the context of the transaction
-        return _ctx;
+        return _updateSupporter(_sender, _previousFlowRate, _lastUpdated, _ctx);
     }
 
     /**
      * @dev Updates the information for a supporter
      * @param _supporter The address of the supporter
-     * @param _previousFlowRate The previous flow rate of the stream
+     * @param _previousFlowRateOrAmount The previous flow rate of the stream or single donation amount
      * @param _lastUpdated The timestamp of the last update to the stream
+     * @param _ctx flow context
      */
-    function _updateSupporter(address _supporter, int96 _previousFlowRate, uint256 _lastUpdated) internal {
+    function _updateSupporter(
+        address _supporter,
+        int256 _previousFlowRateOrAmount,
+        uint256 _lastUpdated,
+        bytes memory _ctx
+    ) internal returns (bytes memory newCtx) {
+        newCtx = _ctx;
+        bool _isFlow = _ctx.length > 0;
+        _updateStats(_isFlow ? 0 : uint256(_previousFlowRateOrAmount));
         // Get the current flow rate for the supporter
-        (, int96 flowRate, , ) = superToken.getFlowInfo(_supporter, address(this));
+        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);
+            // Update the supporter's information
+            supporters[_supporter].lastUpdated = uint128(block.timestamp);
+            supporters[_supporter].flowRate = flowRate;
+            supporters[_supporter].contribution +=
+                uint96(int96(_previousFlowRateOrAmount)) *
+                (block.timestamp - _lastUpdated);
+            newCtx = _takeFeeFlow(flowRate - int96(_previousFlowRateOrAmount), _ctx);
+            // we update the last rate after we do all changes to our own flows
+            stats.lastIncomeRate = superToken.getNetFlowRate(address(this));
+        } else {
+            supporters[_supporter].contribution += uint256(_previousFlowRateOrAmount);
+            _takeFeeSingle(uint256(_previousFlowRateOrAmount));
+        }
 
-        // Update the supporter's information
-        supporters[_supporter].lastUpdated = uint128(block.timestamp);
-        supporters[_supporter].flowRate = flowRate;
-        supporters[_supporter].contribution += uint96(_previousFlowRate) * (block.timestamp - _lastUpdated);
-        emit SupporterUpdated(_supporter, supporters[_supporter].contribution, flowRate, block.timestamp);
+        emit SupporterUpdated(
+            _supporter,
+            prevContribution,
+            supporters[_supporter].contribution,
+            _isFlow ? int96(int256(_previousFlowRateOrAmount)) : int96(0),
+            flowRate,
+            _isFlow
+        );
+    }
+
+    // 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();
+        if (recipient == address(0)) return;
+
+        uint256 fee = (_amount * getRegistry().feeBps()) / 10000;
+        TransferHelper.safeTransfer(address(superToken), recipient, fee);
     }
 
     modifier onlyHostOrSender(address _sender) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gooddollar/goodcollective-contracts",
   "packageManager": "yarn@3.2.1",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "license": "MIT",
   "types": "./typechain-types/index.ts",
   "files": [