@gooddollar/goodcollective-contracts 1.1.0 → 1.3.0

package/contracts/UBI/UBIPool.sol

@@ -9,30 +9,20 @@ import { IERC721ReceiverUpgradeable } from "@openzeppelin/contracts-upgradeable/
 
 import "../GoodCollective/GoodCollectiveSuperApp.sol";
 import "./UBIPoolFactory.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);
-}
+import "../Interfaces.sol";
 
 contract UBIPool is AccessControlUpgradeable, GoodCollectiveSuperApp, UUPSUpgradeable {
     using SafeERC20Upgradeable for IERC20Upgradeable;
 
     error CLAIMFOR_DISABLED();
     error NOT_MEMBER(address claimer);
-    error NOT_WHITELISTED(address claimer);
-    error ALREADY_CLAIMED(address claimer);
+    error NOT_MANAGER(address manager);
+    error NOT_WHITELISTED(address whitelistedRoot);
+    error ALREADY_CLAIMED(address whitelistedRoot);
     error INVALID_0_VALUE();
     error EMPTY_MANAGER();
     error MAX_MEMBERS_REACHED();
+    error MAX_PERIOD_CLAIMERS_REACHED(uint256 claimers);
 
     bytes32 public constant MANAGER_ROLE = keccak256("MANAGER_ROLE");
     bytes32 public constant MEMBER_ROLE = keccak256("MEMBER_ROLE");
@@ -52,13 +42,6 @@ contract UBIPool is AccessControlUpgradeable, GoodCollectiveSuperApp, UUPSUpgrad
     event UBICycleCalculated(uint256 day, uint256 pool, uint256 cycleLength, uint256 dailyUBIPool);
 
     event UBIClaimed(address indexed whitelistedRoot, address indexed claimer, uint256 amount);
-    // Define functions
-    struct PoolSettings {
-        address manager;
-        IMembersValidator membersValidator;
-        IIdentityV2 uniquenessValidator;
-        IERC20Upgradeable rewardToken;
-    }
 
     struct UBISettings {
         //number of days of each UBI pool cycle
@@ -69,8 +52,11 @@ contract UBIPool is AccessControlUpgradeable, GoodCollectiveSuperApp, UUPSUpgrad
         uint32 minActiveUsers;
         // can you trigger claim for someone else
         bool claimForEnabled;
+        // max daily claim amount
         uint maxClaimAmount;
+        // max number of members in a pool
         uint32 maxMembers;
+        bool onlyMembers;
     }
 
     struct PoolStatus {
@@ -91,11 +77,21 @@ contract UBIPool is AccessControlUpgradeable, GoodCollectiveSuperApp, UUPSUpgrad
         uint32 membersCount;
     }
 
+    struct ExtendedSettings {
+        // max number of members that can claim in a day maxPeriodClaimers <= maxMembers
+        uint32 maxPeriodClaimers;
+        // min daily claim amount, daily amount will be 0 if <minClaimAmount
+        uint minClaimAmount;
+        // fees taken from income to the pool manager
+        uint32 managerFeeBps;
+    }
+
     PoolSettings public settings;
     UBISettings public ubiSettings;
     PoolStatus public status;
 
     UBIPoolFactory public registry;
+    ExtendedSettings public extendedSettings;
 
     /// @custom:oz-upgrades-unsafe-allow constructor
     constructor(ISuperfluid _host, IV3SwapRouter _swapRouter) GoodCollectiveSuperApp(_host, _swapRouter) {}
@@ -110,6 +106,10 @@ contract UBIPool is AccessControlUpgradeable, GoodCollectiveSuperApp, UUPSUpgrad
         return IRegistry(address(registry));
     }
 
+    function getManagerFee() public view override returns (address feeRecipient, uint32 feeBps) {
+        return (settings.manager, extendedSettings.managerFeeBps);
+    }
+
     /**
      * @dev Initializes the contract with the given settings and limits.
      * @param _settings The PoolSettings struct containing pool settings.
@@ -118,13 +118,16 @@ contract UBIPool is AccessControlUpgradeable, GoodCollectiveSuperApp, UUPSUpgrad
     function initialize(
         PoolSettings memory _settings,
         UBISettings memory _ubiSettings,
+        ExtendedSettings memory _extendedSettings,
         UBIPoolFactory _registry
     ) external initializer {
         registry = _registry;
         settings = _settings;
         ubiSettings = _ubiSettings;
+        extendedSettings = _extendedSettings;
+        _verifyPoolSettings(_settings);
         _verifyUBISettings(_ubiSettings);
-        _setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
+        _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);
         setSuperToken(ISuperToken(address(settings.rewardToken)));
     }
@@ -145,35 +148,22 @@ contract UBIPool is AccessControlUpgradeable, GoodCollectiveSuperApp, UUPSUpgrad
      * the daily balance is determined by dividing current pool by the cycle length
      * @return The amount of GoodDollar the user can claim
      */
-    function distributionFormula() internal returns (uint256) {
+    function distributionFormula() public returns (uint256) {
         // once every claim cycle
         uint256 currentDay = getCurrentDay();
-        if (currentDay > status.currentDay + ubiSettings.claimPeriodDays) {
-            status.currentDay = currentDay;
-            uint32 cycleLength = ubiSettings.cycleLengthDays;
-            uint256 currentBalance = settings.rewardToken.balanceOf(address(this));
-            //start early cycle if daily pool size is +%5 previous pool or not enough until end of cycle
-            uint256 nextDailyPool = currentBalance / cycleLength;
-            bool shouldStartEarlyCycle = nextDailyPool > (status.dailyCyclePool * 105) / 100 ||
-                currentBalance < (status.dailyCyclePool * (cycleLength - currentDayInCycle()));
-
-            if (
-                currentDayInCycle() >= status.currentCycleLength || shouldStartEarlyCycle
-            ) //start of cycle or first time
-            {
+        if (currentDay >= status.currentDay + ubiSettings.claimPeriodDays) {
+            (uint256 nextDailyPool, uint256 nextDailyUbi, bool newCycle) = _calcNextDailyUBI();
+            if (newCycle) {
+                uint256 currentBalance = settings.rewardToken.balanceOf(address(this));
                 status.dailyCyclePool = nextDailyPool;
-                status.currentCycleLength = cycleLength;
+                status.currentCycleLength = ubiSettings.cycleLengthDays;
                 status.startOfCycle = currentDay;
-                emit UBICycleCalculated(currentDay, currentBalance, cycleLength, nextDailyPool);
+                emit UBICycleCalculated(currentDay, currentBalance, ubiSettings.cycleLengthDays, nextDailyPool);
             }
 
-            uint256 prevPeriodClaimers = status.periodClaimers;
-            status.dailyUbi = min(
-                ubiSettings.maxClaimAmount,
-                status.dailyCyclePool / max((prevPeriodClaimers * 10500) / 10000, ubiSettings.minActiveUsers)
-            );
-            //update minActiveUsers as claimers grow
-            ubiSettings.minActiveUsers = uint32(max(prevPeriodClaimers / 2, ubiSettings.minActiveUsers));
+            status.currentDay = currentDay;
+            status.dailyUbi = nextDailyUbi;
+            if (status.dailyUbi <= extendedSettings.minClaimAmount) status.dailyUbi = 0;
 
             emit UBICalculated(
                 currentDay,
@@ -189,6 +179,32 @@ contract UBIPool is AccessControlUpgradeable, GoodCollectiveSuperApp, UUPSUpgrad
         return status.dailyUbi;
     }
 
+    function _calcNextDailyUBI() internal view returns (uint256 nextPeriodPool, uint256 nextDailyUbi, bool newCycle) {
+        uint256 currentBalance = settings.rewardToken.balanceOf(address(this));
+        //start early cycle if we can increase the daily UBI pool
+        uint256 nextDailyPool = currentBalance / ubiSettings.cycleLengthDays;
+        bool shouldStartEarlyCycle = nextDailyPool > (status.dailyCyclePool * 105) / 100 ||
+            (currentDayInCycle() <= status.currentCycleLength &&
+                currentBalance < (status.dailyCyclePool * (status.currentCycleLength - currentDayInCycle())));
+
+        nextPeriodPool = status.dailyCyclePool;
+        nextDailyUbi;
+        if (
+            (currentDayInCycle() + 1) >= status.currentCycleLength || shouldStartEarlyCycle
+        ) //start of cycle or first time
+        {
+            nextPeriodPool = currentBalance / ubiSettings.cycleLengthDays;
+            newCycle = true;
+        }
+
+        nextDailyUbi = min(
+            ubiSettings.maxClaimAmount,
+            nextPeriodPool / max((status.periodClaimers * 10500) / 10000, ubiSettings.minActiveUsers)
+        );
+
+        if (nextDailyUbi < extendedSettings.minClaimAmount) nextDailyUbi = 0;
+    }
+
     /**
      * @dev returns the day count since start of current cycle
      */
@@ -225,9 +241,17 @@ contract UBIPool is AccessControlUpgradeable, GoodCollectiveSuperApp, UUPSUpgrad
     function _claim(address claimer, bool sendToWhitelistedRoot) internal {
         address whitelistedRoot = IIdentityV2(settings.uniquenessValidator).getWhitelistedRoot(claimer);
         if (whitelistedRoot == address(0)) revert NOT_WHITELISTED(claimer);
-        if (address(settings.membersValidator) != address(0) && hasRole(MEMBER_ROLE, claimer) == false)
+
+        // if open for anyone but has limits, we add the first claimers as members to handle the max claimers
+        if ((ubiSettings.maxMembers > 0 && ubiSettings.onlyMembers == false)) _grantRole(MEMBER_ROLE, claimer);
+
+        // check membership if has claimers limits or limited to members only
+        if ((ubiSettings.maxMembers > 0 || ubiSettings.onlyMembers) && hasRole(MEMBER_ROLE, claimer) == false)
             revert NOT_MEMBER(claimer);
 
+        if (extendedSettings.maxPeriodClaimers > 0 && status.periodClaimers >= extendedSettings.maxPeriodClaimers)
+            revert MAX_PERIOD_CLAIMERS_REACHED(status.periodClaimers);
+
         // calculats the formula up today ie on day 0 there are no active users, on day 1 any user
         // (new or active) will trigger the calculation with the active users count of the day before
         // and so on. the new or inactive users that will become active today, will not take into account
@@ -246,18 +270,6 @@ contract UBIPool is AccessControlUpgradeable, GoodCollectiveSuperApp, UUPSUpgrad
         emit UBIClaimed(whitelistedRoot, claimer, dailyUbi);
     }
 
-    function addMemberByManager(address member) external onlyRole(MANAGER_ROLE) returns (bool) {
-        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);
-        }
-
-        _grantRole(MEMBER_ROLE, member);
-        return true;
-    }
-
     /**
      * @dev Adds a member to the contract.
      * @param member The address of the member to add.
@@ -265,37 +277,43 @@ contract UBIPool is AccessControlUpgradeable, GoodCollectiveSuperApp, UUPSUpgrad
      */
 
     function addMember(address member, bytes memory extraData) external 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 no members validator then anyone can join the pool
-        if (address(settings.membersValidator) != address(0)) {
+        if (address(settings.membersValidator) != address(0) && hasRole(MANAGER_ROLE, msg.sender) == false) {
             if (settings.membersValidator.isMemberValid(address(this), msg.sender, member, extraData) == false) {
-                return false;
+                revert NOT_MEMBER(member);
             }
         }
+        // if no members validator then if members only only manager can add members
+        else if (ubiSettings.onlyMembers && hasRole(MANAGER_ROLE, msg.sender) == false) {
+            revert NOT_MANAGER(member);
+        }
 
         _grantRole(MEMBER_ROLE, member);
         return true;
     }
 
+    function removeMember(address member) external onlyRole(MANAGER_ROLE) {
+        _revokeRole(MEMBER_ROLE, member);
+    }
+
     function _grantRole(bytes32 role, address account) internal virtual override {
-        if (role == MEMBER_ROLE) {
-            registry.addMember(account);
+        if (role == MEMBER_ROLE && hasRole(MEMBER_ROLE, account) == false) {
             if (ubiSettings.maxMembers > 0 && status.membersCount > ubiSettings.maxMembers)
                 revert MAX_MEMBERS_REACHED();
+            registry.addMember(account);
             status.membersCount += 1;
         }
         super._grantRole(role, account);
     }
 
     function _revokeRole(bytes32 role, address account) internal virtual override {
-        if (role == MEMBER_ROLE) {
+        if (role == MEMBER_ROLE && hasRole(MEMBER_ROLE, account)) {
             status.membersCount -= 1;
+            registry.removeMember(account);
         }
         super._revokeRole(role, account);
     }
@@ -304,9 +322,13 @@ contract UBIPool is AccessControlUpgradeable, GoodCollectiveSuperApp, UUPSUpgrad
      * @dev Sets the safety limits for the pool.
      * @param _ubiSettings The new safety limits.
      */
-    function setUBISettings(UBISettings memory _ubiSettings) public onlyRole(MANAGER_ROLE) {
+    function setUBISettings(
+        UBISettings memory _ubiSettings,
+        ExtendedSettings memory _extendedSettings
+    ) public onlyRole(MANAGER_ROLE) {
         _verifyUBISettings(_ubiSettings);
         ubiSettings = _ubiSettings;
+        extendedSettings = _extendedSettings;
         emit UBISettingsChanged(_ubiSettings);
     }
 
@@ -324,7 +346,7 @@ contract UBIPool is AccessControlUpgradeable, GoodCollectiveSuperApp, UUPSUpgrad
      * @param _settings The new pool settings.
      */
     function setPoolSettings(PoolSettings memory _settings) public onlyRole(MANAGER_ROLE) {
-        if (_settings.manager == address(0)) revert EMPTY_MANAGER();
+        _verifyPoolSettings(_settings);
 
         if (_settings.manager != settings.manager) {
             _revokeRole(MANAGER_ROLE, settings.manager);
@@ -334,27 +356,16 @@ contract UBIPool is AccessControlUpgradeable, GoodCollectiveSuperApp, UUPSUpgrad
         emit PoolSettingsChanged(_settings);
     }
 
-    function estimateNextDailyUBI() public view returns (uint256) {
-        uint256 currentBalance = settings.rewardToken.balanceOf(address(this));
-        //start early cycle if we can increase the daily UBI pool
-        uint256 nextDailyPool = currentBalance / ubiSettings.cycleLengthDays;
-        bool shouldStartEarlyCycle = nextDailyPool > (status.dailyCyclePool * 105) / 100 ||
-            currentBalance < (status.dailyCyclePool * (status.currentCycleLength - currentDayInCycle()));
-
-        uint256 _dailyCyclePool = status.dailyCyclePool;
-        uint256 _dailyUbi;
+    function _verifyPoolSettings(PoolSettings memory _poolSettings) internal pure {
         if (
-            (currentDayInCycle() + 1) >= status.currentCycleLength || shouldStartEarlyCycle
-        ) //start of cycle or first time
-        {
-            _dailyCyclePool = currentBalance / ubiSettings.cycleLengthDays;
-        }
+            _poolSettings.manager == address(0) ||
+            address(_poolSettings.uniquenessValidator) == address(0) ||
+            address(_poolSettings.rewardToken) == address(0)
+        ) revert INVALID_0_VALUE();
+    }
 
-        _dailyUbi = min(
-            ubiSettings.maxClaimAmount,
-            _dailyCyclePool / max((status.periodClaimers * 10500) / 10000, ubiSettings.minActiveUsers)
-        );
-        return _dailyUbi;
+    function estimateNextDailyUBI() public view returns (uint256 nextDailyUbi) {
+        (, nextDailyUbi, ) = _calcNextDailyUBI();
     }
 
     function checkEntitlement() public view returns (uint256) {
@@ -372,6 +383,8 @@ contract UBIPool is AccessControlUpgradeable, GoodCollectiveSuperApp, UUPSUpgrad
         // current day has already been updated which means
         // that the dailyUbi has been updated
         if (status.currentDay == getCurrentDay() && status.dailyUbi > 0) {
+            if (extendedSettings.maxPeriodClaimers > 0 && status.periodClaimers >= extendedSettings.maxPeriodClaimers)
+                return 0;
             return hasClaimed(_member) ? 0 : status.dailyUbi;
         }
         return estimateNextDailyUBI();
@@ -379,10 +392,10 @@ contract UBIPool is AccessControlUpgradeable, GoodCollectiveSuperApp, UUPSUpgrad
 
     function hasClaimed(address _member) public view returns (bool) {
         address whitelistedRoot = IIdentityV2(settings.uniquenessValidator).getWhitelistedRoot(_member);
-        return status.lastClaimed[whitelistedRoot] == status.currentDay;
+        return status.lastClaimed[whitelistedRoot] == getCurrentDay();
     }
 
     function nextClaimTime() public view returns (uint256) {
-        return getCurrentDay() * (1 days) - (12 hours);
+        return (getCurrentDay() + ubiSettings.claimPeriodDays) * (1 days) + 12 hours;
     }
 }

package/contracts/UBI/UBIPoolFactory.sol

@@ -10,7 +10,9 @@ 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 "../Interfaces.sol";
+
+// import "hardhat/console.sol";
 
 contract UBIPoolFactory is AccessControlUpgradeable, UUPSUpgradeable {
     error NOT_PROJECT_OWNER();
@@ -20,7 +22,7 @@ contract UBIPoolFactory is AccessControlUpgradeable, UUPSUpgradeable {
         address indexed pool,
         string indexed projectId,
         string ipfs,
-        UBIPool.PoolSettings poolSettings,
+        PoolSettings poolSettings,
         UBIPool.UBISettings poolLimits
     );
 
@@ -84,31 +86,34 @@ contract UBIPoolFactory is AccessControlUpgradeable, UUPSUpgradeable {
     function createManagedPool(
         string memory _projectId,
         string memory _ipfs,
-        UBIPool.PoolSettings memory _settings,
-        UBIPool.UBISettings memory _limits
+        PoolSettings memory _settings,
+        UBIPool.UBISettings memory _limits,
+        UBIPool.ExtendedSettings memory _extendedSettings
     ) external onlyProjectOwnerOrNon(_projectId) returns (UBIPool pool) {
-        return _createPool(_projectId, _ipfs, _settings, _limits, true);
+        return _createPool(_projectId, _ipfs, _settings, _limits, _extendedSettings, true);
     }
 
     function createPool(
         string memory _projectId,
         string memory _ipfs,
-        UBIPool.PoolSettings memory _settings,
-        UBIPool.UBISettings memory _limits
+        PoolSettings memory _settings,
+        UBIPool.UBISettings memory _limits,
+        UBIPool.ExtendedSettings memory _extendedSettings
     ) external onlyProjectOwnerOrNon(_projectId) returns (UBIPool pool) {
-        return _createPool(_projectId, _ipfs, _settings, _limits, false);
+        return _createPool(_projectId, _ipfs, _settings, _limits, _extendedSettings, false);
     }
 
     function _createPool(
         string memory _projectId,
         string memory _ipfs,
-        UBIPool.PoolSettings memory _settings,
+        PoolSettings memory _settings,
         UBIPool.UBISettings memory _limits,
+        UBIPool.ExtendedSettings memory _extendedSettings,
         bool useBeacon
     ) internal returns (UBIPool pool) {
         //TODO: add check if msg.sender is whitelisted
 
-        bytes memory initCall = abi.encodeWithSelector(UBIPool.initialize.selector, _settings, _limits, address(this));
+        bytes memory initCall = abi.encodeCall(UBIPool.initialize, (_settings, _limits, _extendedSettings, this));
 
         if (useBeacon) {
             pool = UBIPool(address(new BeaconProxy(address(impl), initCall)));
@@ -153,6 +158,15 @@ contract UBIPoolFactory is AccessControlUpgradeable, UUPSUpgradeable {
         memberPools[account].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();
+            }
+        }
+    }
+
     function getMemberPools(address member) external view returns (address[] memory) {
         return memberPools[member];
     }

package/contracts/test/HelperLibraryTest.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+import "../utils/HelperLibrary.sol";
+
+contract HelperLibraryTest {
+    function handleSwap(
+        IV3SwapRouter swapRouter,
+        HelperLibrary.SwapData memory _customData,
+        address outTokenIfNoPath,
+        address _sender
+    ) external returns (uint256 amountOut) {
+        return HelperLibrary.handleSwap(swapRouter, _customData, outTokenIfNoPath, _sender, _sender);
+    }
+}

package/contracts/utils/HelperLibrary.sol

@@ -6,11 +6,15 @@ import "@uniswap/v3-periphery/contracts/libraries/TransferHelper.sol";
 import "@uniswap/swap-router-contracts/contracts/interfaces/IV3SwapRouter.sol";
 import { ISuperToken } from "@superfluid-finance/ethereum-contracts/contracts/interfaces/superfluid/ISuperfluid.sol";
 import { SuperTokenV1Library } from "@superfluid-finance/ethereum-contracts/contracts/apps/SuperTokenV1Library.sol";
+import { CFAv1Library } from "@superfluid-finance/ethereum-contracts/contracts/apps/CFAv1Library.sol";
 
 import "../GoodCollective/IGoodCollectiveSuperApp.sol";
 
+// import "hardhat/console.sol";
+
 library HelperLibrary {
     using SuperTokenV1Library for ISuperToken;
+    using CFAv1Library for CFAv1Library.InitData;
 
     /**
      * @dev A struct containing information about a token swap
@@ -33,7 +37,17 @@ library HelperLibrary {
         SwapData memory _customData,
         address outTokenIfNoPath,
         address _sender
-    ) external {
+    ) external returns (uint256 amountOut) {
+        return handleSwap(swapRouter, _customData, outTokenIfNoPath, _sender, _sender);
+    }
+
+    function handleSwap(
+        IV3SwapRouter swapRouter,
+        SwapData memory _customData,
+        address outTokenIfNoPath,
+        address _sender,
+        address _recipient
+    ) public returns (uint256 amountOut) {
         // Transfer the tokens from the sender to this contract
         TransferHelper.safeTransferFrom(_customData.swapFrom, _sender, address(this), _customData.amount);
 
@@ -44,38 +58,125 @@ library HelperLibrary {
             // If a path is provided, execute a multi-hop swap
             IV3SwapRouter.ExactInputParams memory params = IV3SwapRouter.ExactInputParams({
                 path: _customData.path,
-                recipient: _sender,
+                recipient: _recipient,
                 amountIn: _customData.amount,
                 amountOutMinimum: _customData.minReturn
             });
-            swapRouter.exactInput(params);
+            return swapRouter.exactInput(params);
         } else {
             // If no path is provided, execute a single-hop swap
             IV3SwapRouter.ExactInputSingleParams memory params = IV3SwapRouter.ExactInputSingleParams({
                 tokenIn: _customData.swapFrom,
                 tokenOut: outTokenIfNoPath,
                 fee: 10000,
-                recipient: _sender,
+                recipient: _recipient,
                 amountIn: _customData.amount,
                 amountOutMinimum: _customData.minReturn,
                 sqrtPriceLimitX96: 0
             });
 
             // Execute the swap using `exactInputSingle`
-            swapRouter.exactInputSingle(params);
+            return swapRouter.exactInputSingle(params);
         }
     }
 
     function getRealtimeStats(
         IGoodCollectiveSuperApp.Stats memory stats,
         ISuperToken superToken
-    ) external view returns (uint256 netIncome, uint256 totalFees, int96 incomeFlowRate, int96 feeRate) {
+    )
+        external
+        view
+        returns (
+            uint256 netIncome,
+            uint256 totalFees,
+            uint256 protocolFees,
+            uint256 managerFees,
+            int96 incomeFlowRate,
+            int96 feeRate,
+            int96 managerFeeRate
+        )
+    {
         incomeFlowRate = stats.lastIncomeRate;
         netIncome = stats.netIncome + uint96(stats.lastIncomeRate) * (block.timestamp - stats.lastUpdate);
         feeRate = superToken.getFlowRate(address(this), stats.lastFeeRecipient);
-        totalFees =
-            stats.totalFees +
+        managerFeeRate = superToken.getFlowRate(address(this), stats.lastManagerFeeRecipient);
+
+        protocolFees =
+            stats.protocolFees +
             uint96(superToken.getFlowRate(address(this), stats.lastFeeRecipient)) *
             (block.timestamp - stats.lastUpdate);
+        managerFees =
+            stats.managerFees +
+            uint96(superToken.getFlowRate(address(this), stats.lastManagerFeeRecipient)) *
+            (block.timestamp - stats.lastUpdate);
+        totalFees = protocolFees + managerFees;
+    }
+
+    // this should be called before any flow rate changes
+    function updateStats(
+        IGoodCollectiveSuperApp.Stats storage stats,
+        ISuperToken superToken,
+        IRegistry registry,
+        uint32 managerFeeBps,
+        uint256 _amount
+    ) external {
+        uint feeBps;
+        if (address(registry) != address(0)) {
+            feeBps = registry.feeBps();
+        }
+        //use last rate before the current possible rate update
+        stats.netIncome += uint96(stats.lastIncomeRate) * (block.timestamp - stats.lastUpdate);
+        if (stats.lastFeeRecipient != address(0)) {
+            //fees sent to last recipient, the flowRate to recipient still wasnt updated.
+            stats.protocolFees +=
+                uint96(superToken.getFlowRate(address(this), stats.lastFeeRecipient)) *
+                (block.timestamp - stats.lastUpdate);
+        }
+        if (stats.lastManagerFeeRecipient != address(0)) {
+            //fees sent to last recipient, the flowRate to recipient still wasnt updated.
+            stats.managerFees +=
+                uint96(superToken.getFlowRate(address(this), stats.lastManagerFeeRecipient)) *
+                (block.timestamp - stats.lastUpdate);
+        }
+
+        if (_amount > 0) {
+            stats.netIncome += (_amount * (10000 - feeBps - managerFeeBps)) / 10000;
+            stats.protocolFees += (_amount * feeBps) / 10000;
+            stats.managerFees += (_amount * managerFeeBps) / 10000;
+        }
+        stats.totalFees = stats.managerFees + stats.protocolFees;
+        stats.lastUpdate = block.timestamp;
+    }
+
+    function takeFeeFlow(
+        CFAv1Library.InitData storage cfaV1,
+        ISuperToken superToken,
+        address prevRecipient,
+        address recipient,
+        uint32 feeBps,
+        int96 _diffRate,
+        bytes memory _ctx
+    ) public returns (bytes memory newCtx) {
+        newCtx = _ctx;
+        if (address(recipient) == address(0)) return newCtx;
+        int96 curFeeRate = superToken.getFlowRate(address(this), prevRecipient);
+        bool newRecipient;
+        if (recipient != prevRecipient) {
+            newRecipient = true;
+            if (prevRecipient != address(0)) {
+                //delete old recipient flow
+                if (curFeeRate > 0) newCtx = cfaV1.deleteFlowWithCtx(newCtx, address(this), prevRecipient, superToken); //passing in the ctx which is sent to the callback here
+            }
+        }
+        if (recipient == address(0)) return newCtx;
+
+        int96 newFeeRate = curFeeRate + (_diffRate * int32(feeBps)) / 10000;
+        if (newRecipient == false && curFeeRate > 0) {
+            if (newFeeRate <= 0) {
+                newCtx = cfaV1.deleteFlowWithCtx(newCtx, address(this), recipient, superToken); //passing in the ctx which is sent to the callback here
+            } else {
+                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
     }
 }

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@gooddollar/goodcollective-contracts",
   "packageManager": "yarn@3.2.1",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "license": "MIT",
   "types": "./typechain-types/index.ts",
   "files": [
     "contracts",
+    "artifacts/contracts",
     "typechain-types",
     "releases"
   ],
@@ -63,9 +64,9 @@
     "test": "npx hardhat test",
     "test:coverage": "npx hardhat coverage",
     "deploy": "hardhat deploy --export-all ./releases/deployment.json",
-    "prepublish": "yarn version patch && yarn compile && git add package.json && git commit -m \"version bump\"",
+    "bump": "yarn version patch && yarn compile && git add package.json && git commit -m \"version bump\"",
     "publish": "yarn npm publish --access public",
     "test:setup": "yarn exec ./scripts/deployContracts.sh",
     "verify": "npx hardhat run scripts/verify.ts --network ${0}"
   }
-}
+}