@gooddollar/goodcollective-contracts 1.0.0 → 1.0.2

package/contracts/DirectPayments/DirectPaymentsPool.sol

@@ -9,6 +9,7 @@ import { IERC721ReceiverUpgradeable } from "@openzeppelin/contracts-upgradeable/
 
 import { ProvableNFT } from "./ProvableNFT.sol";
 import { DirectPaymentsFactory } from "./DirectPaymentsFactory.sol";
+import "../GoodCollective/GoodCollectiveSuperApp.sol";
 
 interface IMembersValidator {
     function isMemberValid(
@@ -30,7 +31,12 @@ interface IIdentityV2 {
  - factory -> register the pool, claim nfttype, deploy pool
  - events
  */
-contract DirectPaymentsPool is IERC721ReceiverUpgradeable, AccessControlUpgradeable, UUPSUpgradeable {
+contract DirectPaymentsPool is
+    IERC721ReceiverUpgradeable,
+    AccessControlUpgradeable,
+    GoodCollectiveSuperApp,
+    UUPSUpgradeable
+{
     using SafeERC20Upgradeable for IERC20Upgradeable;
     error NOT_MANAGER();
     error ALREADY_CLAIMED(uint256);
@@ -86,6 +92,9 @@ contract DirectPaymentsPool is IERC721ReceiverUpgradeable, AccessControlUpgradea
     LimitsData public globalLimits;
     address public createdBy;
 
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    constructor(ISuperfluid _host, ISwapRouter _swapRouter) GoodCollectiveSuperApp(_host, _swapRouter) {}
+
     /**
      * @dev Authorizes an upgrade for the implementation contract.
      * @param impl The address of the new implementation contract.
@@ -103,13 +112,14 @@ contract DirectPaymentsPool is IERC721ReceiverUpgradeable, AccessControlUpgradea
         PoolSettings memory _settings,
         SafetyLimits memory _limits
     ) external initializer {
-        uint l = 5;
         createdBy = msg.sender;
         settings = _settings;
         limits = _limits;
         nft = _nft;
         _setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
         _setupRole(DEFAULT_ADMIN_ROLE, _settings.manager);
+
+        setSuperToken(ISuperToken(address(settings.rewardToken)));
     }
 
     function upgradeToLatest(bytes memory data) external payable virtual onlyProxy {

package/contracts/GoodCollective/GoodCollectiveSuperApp.sol

@@ -0,0 +1,264 @@
+// SPDX-License-Identifier: MIT
+
+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 { ISuperGoodDollar } from "@gooddollar/goodprotocol/contracts/token/superfluid/ISuperGoodDollar.sol";
+import { SuperTokenV1Library } from "@superfluid-finance/ethereum-contracts/contracts/apps/SuperTokenV1Library.sol";
+
+import "@uniswap/v3-periphery/contracts/libraries/TransferHelper.sol";
+import "@uniswap/v3-periphery/contracts/interfaces/ISwapRouter.sol";
+
+// import "hardhat/console.sol";
+
+abstract contract GoodCollectiveSuperApp is SuperAppBaseFlow {
+    using SuperTokenV1Library for ISuperToken;
+
+    error ZERO_ADDRESS();
+    error ZERO_AMOUNT();
+    error UNSUPPORTED_TOKEN();
+    error ONLY_HOST_OR_SENDER(address);
+
+    event SupporterUpdated(address indexed supporter, uint256 contribution, int96 flowRate, uint256 lastUpdated);
+
+    //TODO: ask about "view" for beforeagreement functions
+    // 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 timestamp;
+        bytes path;
+    }
+
+    struct SupporterData {
+        uint256 contribution;
+        int96 flowRate;
+        uint128 lastUpdated;
+    }
+
+    ISuperToken public superToken;
+
+    mapping(address => SupporterData) public supporters;
+
+    uint256[50] private _reserved;
+
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    constructor(ISuperfluid _host, ISwapRouter _swapRouter) SuperAppBaseFlow(_host) {
+        if (address(_host) == address(0)) revert ZERO_ADDRESS();
+        swapRouter = _swapRouter;
+    }
+
+    /**
+     * @dev Sets the address of the super token and registers the app with the host
+     * @param _superToken The address of the super token contract
+     */
+    function setSuperToken(ISuperToken _superToken) internal {
+        if (address(_superToken) == address(0)) revert ZERO_ADDRESS();
+
+        // 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);
+    }
+
+    function isAcceptedSuperToken(ISuperToken _superToken) public view override returns (bool) {
+        return address(superToken) == address(_superToken);
+    }
+
+    function getRealtimeContribution(address _user) public view returns (uint256) {
+        SupporterData memory supporter = supporters[_user];
+        if (supporter.flowRate == 0) return supporter.contribution;
+        return supporter.contribution + uint96(supporter.flowRate) * (block.timestamp - supporter.lastUpdated);
+    }
+
+    /**
+     * @dev This function is called when a token transfer occurs
+     * @param _sender The address of the sender
+     * @param _amount The amount of tokens being transferred
+     * @return bool Returns true to indicate that the transfer was successful
+     */
+    function onTokenTransfer(address _sender, uint256 _amount, bytes calldata /*_data*/) external returns (bool) {
+        if (msg.sender != address(superToken)) revert UNSUPPORTED_TOKEN();
+        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);
+
+        return true;
+    }
+
+    /**
+     * @dev This function supports the Superfluid protocol by allowing a sender to contribute tokens to the network.
+     * @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
+     * @return Returns the context of the transaction.
+     */
+    function support(
+        address _sender,
+        uint256 _amount,
+        bytes memory _ctx
+    ) external onlyHostOrSender(_sender) returns (bytes memory) {
+        if (_amount == 0) revert ZERO_AMOUNT();
+
+        // Transfer the tokens from the sender to this contract
+        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);
+
+        return _ctx;
+    }
+
+    /**
+     * @dev Handles the swap of tokens using the SwapData struct
+     * @param _customData The SwapData struct containing information about the swap
+     * @param _sender The address of the sender of the transaction
+     * @param _ctx The context of the transaction for superfluid
+     * @return Returns the context of the transaction
+     */
+    function handleSwap(
+        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.timestamp,
+                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.timestamp,
+                amountIn: _customData.amount,
+                amountOutMinimum: _customData.minReturn,
+                sqrtPriceLimitX96: 0
+            });
+
+            // Execute the swap using `exactInputSingle`
+            swapRouter.exactInputSingle(params);
+        }
+
+        // Return the context of the transaction
+        return _ctx;
+    }
+
+    /**
+     * @dev Called when a new flow is created
+     * @param _sender The address of the sender of the transaction
+     * @param _ctx The context of the transaction
+     * @return Returns the new context of the transaction
+     */
+    function onFlowCreated(
+        ISuperToken /*superToken*/,
+        address _sender,
+        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;
+    }
+
+    /**
+     * @dev Called when an existing flow is updated
+     * @param _sender The address of the sender of the transaction
+     * @param _previousFlowRate The previous flow rate of the stream
+     * @param _lastUpdated The timestamp of the last update to the stream
+     * @param _ctx The context of the transaction
+     * @return Returns the new context of the transaction
+     */
+    function onFlowUpdated(
+        ISuperToken /*superToken*/,
+        address _sender,
+        int96 _previousFlowRate,
+        uint256 _lastUpdated,
+        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;
+    }
+
+    /**
+     * @dev Called when an existing flow is deleted
+     * @param _sender The address of the sender of the transaction
+     * @param _previousFlowRate The previous flow rate of the stream
+     * @param _lastUpdated The timestamp of the last update to the stream
+     * @param _ctx The context of the transaction
+     * @return Returns the new context of the transaction
+     */
+    function onFlowDeleted(
+        ISuperToken /*superToken*/,
+        address _sender,
+        address /*receiver*/,
+        int96 _previousFlowRate,
+        uint256 _lastUpdated,
+        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;
+    }
+
+    /**
+     * @dev Updates the information for a supporter
+     * @param _supporter The address of the supporter
+     * @param _previousFlowRate The previous flow rate of the stream
+     * @param _lastUpdated The timestamp of the last update to the stream
+     */
+    function _updateSupporter(address _supporter, int96 _previousFlowRate, uint256 _lastUpdated) internal {
+        // Get the current flow rate for the supporter
+        (, int96 flowRate, , ) = superToken.getFlowInfo(_supporter, address(this));
+
+        // 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);
+    }
+
+    modifier onlyHostOrSender(address _sender) {
+        if (msg.sender != _sender && msg.sender != address(host)) revert ONLY_HOST_OR_SENDER(msg.sender);
+        _;
+    }
+}

package/contracts/GoodCollective/SuperAppBaseFlow.sol

@@ -0,0 +1,204 @@
+// SPDX-License-Identifier: AGPLv3
+pragma solidity >=0.8.0;
+
+import { ISuperfluid, ISuperToken, ISuperApp, SuperAppDefinitions } from "@superfluid-finance/ethereum-contracts/contracts/interfaces/superfluid/ISuperfluid.sol";
+import { SuperTokenV1Library } from "@superfluid-finance/ethereum-contracts/contracts/apps/SuperTokenV1Library.sol";
+
+// import "hardhat/console.sol";
+
+abstract contract SuperAppBaseFlow is ISuperApp {
+    using SuperTokenV1Library for ISuperToken;
+
+    bytes32 public constant CFAV1_TYPE = keccak256("org.superfluid-finance.agreements.ConstantFlowAgreement.v1");
+
+    /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
+    ISuperfluid public immutable host;
+
+    /// @dev Thrown when the callback caller is not the host.
+    error UnauthorizedHost();
+
+    /// @dev Thrown if a required callback wasn't implemented (overridden by the SuperApp)
+    error NotImplemented();
+
+    /// @dev Thrown when SuperTokens not accepted by the SuperApp are streamed to it
+    error NotAcceptedSuperToken();
+
+    /**
+     * @dev Initializes the contract by setting the expected Superfluid Host.
+     *      and register which callbacks the Host can engage when appropriate.
+     */
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    constructor(ISuperfluid host_) {
+        host = host_;
+    }
+
+    /**
+     * @dev Optional (positive) filter for accepting only specific SuperTokens.
+     *      The default implementation accepts all SuperTokens.
+     *      Can be overridden by the SuperApp in order to apply arbitrary filters.
+     */
+    function isAcceptedSuperToken(ISuperToken /*superToken*/) public view virtual returns (bool);
+
+    // ---------------------------------------------------------------------------------------------
+    // CFA specific convenience callbacks
+    // to be overridden and implemented by inheriting SuperApps
+
+    /// @dev override if the SuperApp shall have custom logic invoked when a new flow
+    ///      to it is created.
+    function onFlowCreated(
+        ISuperToken /*superToken*/,
+        address /*sender*/,
+        bytes calldata ctx
+    ) internal virtual returns (bytes memory /*newCtx*/) {
+        return ctx;
+    }
+
+    /// @dev override if the SuperApp shall have custom logic invoked when an existing flow
+    ///      to it is updated (flowrate change).
+    function onFlowUpdated(
+        ISuperToken /*superToken*/,
+        address /*sender*/,
+        int96 /*previousFlowRate*/,
+        uint256 /*lastUpdated*/,
+        bytes calldata ctx
+    ) internal virtual returns (bytes memory /*newCtx*/) {
+        return ctx;
+    }
+
+    /// @dev override if the SuperApp shall have custom logic invoked when an existing flow
+    ///      to it is deleted (flowrate set to 0).
+    ///      Unlike the other callbacks, this method is NOT allowed to revert.
+    ///      Failing to satisfy that requirement leads to jailing (defunct SuperApp).
+    function onFlowDeleted(
+        ISuperToken /*superToken*/,
+        address /*sender*/,
+        address /*receiver*/,
+        int96 /*previousFlowRate*/,
+        uint256 /*lastUpdated*/,
+        bytes calldata ctx
+    ) internal virtual returns (bytes memory /*newCtx*/) {
+        return ctx;
+    }
+
+    function beforeAgreementCreated(
+        ISuperToken superToken,
+        address agreementClass,
+        bytes32 /*agreementId*/,
+        bytes calldata /*agreementData*/,
+        bytes calldata /*ctx*/
+    ) external view returns (bytes memory /*beforeData*/) {
+        if (msg.sender != address(host)) revert UnauthorizedHost();
+        if (!isAcceptedAgreement(agreementClass)) return "0x";
+        if (!isAcceptedSuperToken(superToken)) revert NotAcceptedSuperToken();
+        return "0x";
+    }
+
+    function afterAgreementCreated(
+        ISuperToken superToken,
+        address /*agreementClass*/,
+        bytes32 /*agreementId*/,
+        bytes calldata agreementData,
+        bytes calldata /*cbdata*/,
+        bytes calldata ctx
+    ) external returns (bytes memory newCtx) {
+        (address sender, ) = abi.decode(agreementData, (address, address));
+
+        return
+            onFlowCreated(
+                superToken,
+                sender,
+                ctx // userData can be acquired with `host.decodeCtx(ctx).userData`
+            );
+    }
+
+    // UPDATED callbacks
+
+    function beforeAgreementUpdated(
+        ISuperToken superToken,
+        address agreementClass,
+        bytes32 /*agreementId*/,
+        bytes calldata agreementData,
+        bytes calldata /*ctx*/
+    ) external view returns (bytes memory /*beforeData*/) {
+        if (msg.sender != address(host)) revert UnauthorizedHost();
+        if (!isAcceptedAgreement(agreementClass)) return "0x";
+        if (!isAcceptedSuperToken(superToken)) revert NotAcceptedSuperToken();
+
+        (address sender, ) = abi.decode(agreementData, (address, address));
+        (uint256 lastUpdated, int96 flowRate, , ) = superToken.getFlowInfo(sender, address(this));
+
+        return abi.encode(flowRate, lastUpdated);
+    }
+
+    function afterAgreementUpdated(
+        ISuperToken superToken,
+        address /*agreementClass*/,
+        bytes32 /*agreementId*/,
+        bytes calldata agreementData,
+        bytes calldata cbdata,
+        bytes calldata ctx
+    ) external returns (bytes memory newCtx) {
+        (address sender, ) = abi.decode(agreementData, (address, address));
+        (int96 previousFlowRate, uint256 lastUpdated) = abi.decode(cbdata, (int96, uint256));
+
+        return
+            onFlowUpdated(
+                superToken,
+                sender,
+                previousFlowRate,
+                lastUpdated,
+                ctx // userData can be acquired with `host.decodeCtx(ctx).userData`
+            );
+    }
+
+    // DELETED callbacks
+
+    function beforeAgreementTerminated(
+        ISuperToken superToken,
+        address agreementClass,
+        bytes32 /*agreementId*/,
+        bytes calldata agreementData,
+        bytes calldata /*ctx*/
+    ) external view returns (bytes memory /*beforeData*/) {
+        // we're not allowed to revert in this callback, thus just return empty beforeData on failing checks
+        if (msg.sender != address(host) || !isAcceptedAgreement(agreementClass) || !isAcceptedSuperToken(superToken)) {
+            return "0x";
+        }
+
+        (address sender, address receiver) = abi.decode(agreementData, (address, address));
+        (uint256 lastUpdated, int96 flowRate, , ) = superToken.getFlowInfo(sender, receiver);
+
+        return abi.encode(lastUpdated, flowRate);
+    }
+
+    function afterAgreementTerminated(
+        ISuperToken superToken,
+        address agreementClass,
+        bytes32 /*agreementId*/,
+        bytes calldata agreementData,
+        bytes calldata cbdata,
+        bytes calldata ctx
+    ) external returns (bytes memory newCtx) {
+        // we're not allowed to revert in this callback, thus just return ctx on failing checks
+        if (msg.sender != address(host) || !isAcceptedAgreement(agreementClass) || !isAcceptedSuperToken(superToken)) {
+            return ctx;
+        }
+
+        (address sender, address receiver) = abi.decode(agreementData, (address, address));
+        (uint256 lastUpdated, int96 previousFlowRate) = abi.decode(cbdata, (uint256, int96));
+
+        return onFlowDeleted(superToken, sender, receiver, previousFlowRate, lastUpdated, ctx);
+    }
+
+    // ---------------------------------------------------------------------------------------------
+    // HELPERS
+
+    /**
+     * @dev Expect Super Agreement involved in callback to be an accepted one
+     *      This function can be overridden with custom logic and to revert if desired
+     *      Current implementation expects ConstantFlowAgreement
+     */
+    function isAcceptedAgreement(address agreementClass) internal view virtual returns (bool) {
+        return agreementClass == address(host.getAgreementClass(CFAV1_TYPE));
+    }
+}

package/contracts/utils/SwapRouterMock.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "@uniswap/v3-periphery/contracts/interfaces/ISwapRouter.sol";
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+contract SwapRouterMock {
+    IERC20 private immutable _token;
+
+    constructor(address token) {
+        _token = IERC20(token);
+    }
+
+    /// @notice Swaps `amountIn` of one token for as much as possible of another along the specified path
+    /// @param params The parameters necessary for the multi-hop swap, encoded as `ExactInputParams` in calldata
+    /// @return amountOut The amount of the received token
+    function exactInput(ISwapRouter.ExactInputParams calldata params) external payable returns (uint256 amountOut) {
+        amountOut = params.amountOutMinimum;
+
+        // Transfer the output token to the recipient
+        _token.transfer(params.recipient, amountOut);
+    }
+
+    function exactInputSingle(
+        ISwapRouter.ExactInputSingleParams memory params
+    ) external payable returns (uint256 amountOut) {
+        amountOut = params.amountOutMinimum;
+
+        // Transfer the output token to the recipient
+        _token.transfer(params.recipient, amountOut);
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gooddollar/goodcollective-contracts",
   "packageManager": "yarn@3.2.1",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "license": "MIT",
   "types": "./typechain-types/index.ts",
   "files": [
@@ -21,13 +21,16 @@
     "@openzeppelin/contracts-upgradeable": "4.8.3",
     "@openzeppelin/hardhat-upgrades": "1.20.0",
     "@superfluid-finance/ethereum-contracts": "^1.7.0",
+    "@superfluid-finance/sdk-core": "^0.6.6",
     "@typechain/ethers-v5": "^10.1.0",
     "@types/chai": "^4.2.0",
     "@types/mocha": ">=9.1.0",
     "@types/prettier": "^2",
     "@typescript-eslint/eslint-plugin": "^5.60.0",
+    "@uniswap/v3-periphery": "^1.4.3",
     "chai": "^4.2.0",
     "dotenv": "^16.3.1",
+    "graphql": "^16.7.1",
     "hardhat": "2.14.*",
     "hardhat-abi-exporter": "^2.10.1",
     "hardhat-contract-sizer": "^2.10.0",
@@ -54,6 +57,8 @@
     "lint:sol:fix": "solhint 'contracts/**/*.sol' --fix",
     "test": "npx hardhat test",
     "test:coverage": "npx hardhat coverage",
-    "deploy": "hardhat deploy --export-all ./releases/deployment.json"
+    "deploy": "hardhat deploy --export-all ./releases/deployment.json",
+    "prepublish": "yarn version patch && yarn compile",
+    "publish": "yarn npm publish --access public"
   }
 }