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

package/contracts/GoodCollective/GoodCollectiveSuperApp.sol

@@ -6,44 +6,53 @@ 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 "../utils/HelperLibrary.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);
-
-    //TODO: ask about "view" for beforeagreement functions
+    /**
+     * @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 "receiver" can it be different then app?
 
     /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
     ISwapRouter public immutable swapRouter;
 
-    /**
-     * @dev A struct containing information about a token swap
-     * @param swapFrom The address of the token being swapped
-     * @param amount The amount of tokens being swapped
-     * @param minReturn The minimum amount of tokens to be received in the swap
-     * @param timestamp The deadline for the swap to occur
-     * @param path The path of tokens to take in a uniswap v3 multi-hop swap, encoded as bytes
-     */
-    struct SwapData {
-        address swapFrom;
-        uint256 amount;
-        uint256 minReturn;
-        uint256 deadline;
-        bytes path;
-    }
-
     struct SupporterData {
         uint256 contribution;
         int96 flowRate;
@@ -54,7 +63,12 @@ abstract contract GoodCollectiveSuperApp is SuperAppBaseFlow {
 
     mapping(address => SupporterData) public supporters;
 
-    uint256[50] private _reserved;
+    //initialize cfaV1 variable
+    CFAv1Library.InitData public cfaV1;
+
+    IGoodCollectiveSuperApp.Stats public stats;
+
+    uint256[48] private _reserved;
 
     /// @custom:oz-upgrades-unsafe-allow constructor
     constructor(ISuperfluid _host, ISwapRouter _swapRouter) SuperAppBaseFlow(_host) {
@@ -62,6 +76,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 +93,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 +113,14 @@ 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)
+    {
+        return HelperLibrary.getRealtimeStats(stats, superToken);
+    }
+
     /**
      * @dev This function is called when a token transfer occurs
      * @param _sender The address of the sender
@@ -100,16 +132,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 +155,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;
     }
@@ -136,42 +168,11 @@ abstract contract GoodCollectiveSuperApp is SuperAppBaseFlow {
      * @return Returns the context of the transaction
      */
     function handleSwap(
-        SwapData memory _customData,
+        HelperLibrary.SwapData memory _customData,
         address _sender,
         bytes memory _ctx
     ) external onlyHostOrSender(_sender) returns (bytes memory) {
-        // Transfer the tokens from the sender to this contract
-        TransferHelper.safeTransferFrom(_customData.swapFrom, _sender, address(this), _customData.amount);
-
-        // Approve the router to spend the tokens
-        TransferHelper.safeApprove(_customData.swapFrom, address(swapRouter), _customData.amount);
-
-        if (_customData.path.length > 0) {
-            // If a path is provided, execute a multi-hop swap
-            ISwapRouter.ExactInputParams memory params = ISwapRouter.ExactInputParams({
-                path: _customData.path,
-                recipient: _sender,
-                deadline: _customData.deadline,
-                amountIn: _customData.amount,
-                amountOutMinimum: _customData.minReturn
-            });
-            swapRouter.exactInput(params);
-        } else {
-            // If no path is provided, execute a single-hop swap
-            ISwapRouter.ExactInputSingleParams memory params = ISwapRouter.ExactInputSingleParams({
-                tokenIn: _customData.swapFrom,
-                tokenOut: address(superToken),
-                fee: 10000,
-                recipient: _sender,
-                deadline: _customData.deadline,
-                amountIn: _customData.amount,
-                amountOutMinimum: _customData.minReturn,
-                sqrtPriceLimitX96: 0
-            });
-
-            // Execute the swap using `exactInputSingle`
-            swapRouter.exactInputSingle(params);
-        }
+        HelperLibrary.handleSwap(swapRouter, _customData, address(superToken), _sender);
 
         // Return the context of the transaction
         return _ctx;
@@ -189,10 +190,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 +209,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,29 +229,112 @@ 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);
+    }
+
+    /**
+     * for methods that can be called via superfluid batch or directly
+     */
     modifier onlyHostOrSender(address _sender) {
         if (msg.sender != _sender && msg.sender != address(host)) revert ONLY_HOST_OR_SENDER(msg.sender);
         _;

package/contracts/GoodCollective/IGoodCollectiveSuperApp.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+interface IGoodCollectiveSuperApp {
+    struct Stats {
+        uint256 netIncome; //without fees
+        uint256 totalFees;
+        uint256 lastUpdate;
+        address lastFeeRecipient;
+        int96 lastIncomeRate;
+    }
+}

package/contracts/utils/HelperLibrary.sol

@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+import "@uniswap/v3-periphery/contracts/libraries/TransferHelper.sol";
+import "@uniswap/v3-periphery/contracts/interfaces/ISwapRouter.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 "../GoodCollective/IGoodCollectiveSuperApp.sol";
+
+library HelperLibrary {
+    using SuperTokenV1Library for ISuperToken;
+
+    /**
+     * @dev A struct containing information about a token swap
+     * @param swapFrom The address of the token being swapped
+     * @param amount The amount of tokens being swapped
+     * @param minReturn The minimum amount of tokens to be received in the swap
+     * @param timestamp The deadline for the swap to occur
+     * @param path The path of tokens to take in a uniswap v3 multi-hop swap, encoded as bytes
+     */
+    struct SwapData {
+        address swapFrom;
+        uint256 amount;
+        uint256 minReturn;
+        uint256 deadline;
+        bytes path;
+    }
+
+    function handleSwap(
+        ISwapRouter swapRouter,
+        SwapData memory _customData,
+        address outTokenIfNoPath,
+        address _sender
+    ) external {
+        // Transfer the tokens from the sender to this contract
+        TransferHelper.safeTransferFrom(_customData.swapFrom, _sender, address(this), _customData.amount);
+
+        // Approve the router to spend the tokens
+        TransferHelper.safeApprove(_customData.swapFrom, address(swapRouter), _customData.amount);
+
+        if (_customData.path.length > 0) {
+            // If a path is provided, execute a multi-hop swap
+            ISwapRouter.ExactInputParams memory params = ISwapRouter.ExactInputParams({
+                path: _customData.path,
+                recipient: _sender,
+                deadline: _customData.deadline,
+                amountIn: _customData.amount,
+                amountOutMinimum: _customData.minReturn
+            });
+            swapRouter.exactInput(params);
+        } else {
+            // If no path is provided, execute a single-hop swap
+            ISwapRouter.ExactInputSingleParams memory params = ISwapRouter.ExactInputSingleParams({
+                tokenIn: _customData.swapFrom,
+                tokenOut: outTokenIfNoPath,
+                fee: 10000,
+                recipient: _sender,
+                deadline: _customData.deadline,
+                amountIn: _customData.amount,
+                amountOutMinimum: _customData.minReturn,
+                sqrtPriceLimitX96: 0
+            });
+
+            // Execute the swap using `exactInputSingle`
+            swapRouter.exactInputSingle(params);
+        }
+    }
+
+    function getRealtimeStats(
+        IGoodCollectiveSuperApp.Stats memory stats,
+        ISuperToken superToken
+    ) external 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);
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gooddollar/goodcollective-contracts",
   "packageManager": "yarn@3.2.1",
-  "version": "1.0.3",
+  "version": "1.0.5-beta.7a2c704",
   "license": "MIT",
   "types": "./typechain-types/index.ts",
   "files": [
@@ -10,11 +10,11 @@
     "releases"
   ],
   "devDependencies": {
-    "@gooddollar/goodprotocol": "file:.yalc/@gooddollar/goodprotocol",
+    "@gooddollar/goodprotocol": "^2.0.15",
     "@nomicfoundation/hardhat-chai-matchers": "^1.0.0",
     "@nomicfoundation/hardhat-network-helpers": "^1.0.0",
     "@nomicfoundation/hardhat-toolbox": "2.*",
-    "@nomicfoundation/hardhat-verify": "^1.0.1",
+    "@nomicfoundation/hardhat-verify": "^1.1.1",
     "@nomiclabs/hardhat-ethers": "^2.0.0",
     "@nomiclabs/hardhat-etherscan": "^3.0.0",
     "@openzeppelin/contracts": "^4.9.2",
@@ -26,13 +26,16 @@
     "@types/chai": "^4.2.0",
     "@types/mocha": ">=9.1.0",
     "@types/prettier": "^2",
+    "@types/sinon-chai": "^3.2.3",
     "@typescript-eslint/eslint-plugin": "^5.60.0",
     "@uniswap/v3-periphery": "^1.4.3",
     "chai": "^4.2.0",
     "dotenv": "^16.3.1",
+    "ethereum-waffle": "^3.0.0",
     "graphql": "^16.7.1",
-    "hardhat": "2.14.*",
+    "hardhat": "^2.17.1",
     "hardhat-abi-exporter": "^2.10.1",
+    "hardhat-celo": "^0.0.4",
     "hardhat-contract-sizer": "^2.10.0",
     "hardhat-deploy": "^0.11.31",
     "hardhat-gas-reporter": "^1.0.8",
@@ -44,6 +47,7 @@
     "typescript": "^5.1.3"
   },
   "scripts": {
+    "build": "yarn compile",
     "compile": "npx hardhat compile",
     "clean": "npx hardhat clean",
     "solhint": "solhint ./contracts/**/*.sol",
@@ -58,7 +62,9 @@
     "test": "npx hardhat test",
     "test:coverage": "npx hardhat coverage",
     "deploy": "hardhat deploy --export-all ./releases/deployment.json",
-    "prepublish": "yarn version patch && yarn compile",
-    "publish": "yarn npm publish --access public"
+    "prepublish": "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}"
   }
-}
+}