added flowWithCtx and flowWith

d10r · d10r · commit 6f047b4ae175 · 2024-12-06T22:08:26.000+01:00
diff --git a/packages/ethereum-contracts/CHANGELOG.md b/packages/ethereum-contracts/CHANGELOG.md
@@ -7,7 +7,9 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 
 ### Added
 
-- `SuperTokenV1Library`: overloaded `claimAll` for the msg.sender to claim for themselves.
+- `SuperTokenV1Library`
+  - overloaded `claimAll` for the msg.sender to claim for themselves
+  - added `flowWithCtx` and `flowFromWithCtx`
 
 ## [v1.12.0]
 
diff --git a/packages/ethereum-contracts/contracts/apps/SuperTokenV1Library.sol b/packages/ethereum-contracts/contracts/apps/SuperTokenV1Library.sol
@@ -264,6 +264,7 @@ library SuperTokenV1Library {
             } // else no change, do nothing
             return true;
         } else {
+            // can't set negative flowrate
             revert IConstantFlowAgreementV1.CFA_INVALID_FLOW_RATE();
         }
     }
@@ -802,7 +803,78 @@ library SuperTokenV1Library {
     /** CFA With CTX FUNCTIONS ************************************* */
 
     /**
-     * @dev Create flow with context and userData
+     * @dev Set CFA flowrate with context
+     * @param token Super token address
+     * @param receiver The receiver of the flow
+     * @param flowRate The wanted flowrate in wad/second. Only positive values are valid here.
+     * @param ctx Context bytes (see ISuperfluid.sol for Context struct)
+     * @return newCtx The updated context after the execution of the agreement function
+     */
+    function flowWithCtx(
+        ISuperToken token,
+        address receiver,
+        int96 flowRate,
+        bytes memory ctx
+    ) internal returns (bytes memory newCtx) {
+        // note: from the lib's perspective, the caller is "this", NOT "msg.sender"
+        address sender = address(this);
+        int96 prevFlowRate = getCFAFlowRate(token, sender, receiver);
+
+        if (flowRate > 0) {
+            if (prevFlowRate == 0) {
+                return createFlowWithCtx(token, receiver, flowRate, ctx);
+            } else if (prevFlowRate != flowRate) {
+                return updateFlowWithCtx(token, receiver, flowRate, ctx);
+            } // else no change, do nothing
+            return ctx;
+        } else if (flowRate == 0) {
+            if (prevFlowRate > 0) {
+                return deleteFlowWithCtx(token, sender, receiver, ctx);
+            } // else no change, do nothing
+            return ctx;
+        } else {
+            // can't set negative flowrate
+            revert IConstantFlowAgreementV1.CFA_INVALID_FLOW_RATE();
+        }
+    }
+
+    /**
+     * @notice Like `flowFrom`, with context
+     * @param token Super token address
+     * @param sender The sender of the flow
+     * @param receiver The receiver of the flow
+     * @param flowRate The wanted flowRate in wad/second. Only positive values are valid here.
+     * @param ctx Context bytes (see ISuperfluid.sol for Context struct)
+     * @return newCtx The updated context after the execution of the agreement function
+     */
+    function flowFromWithCtx(
+        ISuperToken token,
+        address sender,
+        address receiver,
+        int96 flowRate,
+        bytes memory ctx
+    ) internal returns (bytes memory newCtx) {
+        int96 prevFlowRate = getCFAFlowRate(token, sender, receiver);
+
+        if (flowRate > 0) {
+            if (prevFlowRate == 0) {
+                return createFlowFromWithCtx(token, sender, receiver, flowRate, ctx);
+            } else if (prevFlowRate != flowRate) {
+                return updateFlowFromWithCtx(token, sender, receiver, flowRate, ctx);
+            } // else no change, do nothing
+            return ctx;
+        } else if (flowRate == 0) {
+            if (prevFlowRate > 0) {
+                return deleteFlowFromWithCtx(token, sender, receiver, ctx);
+            } // else no change, do nothing
+            return ctx;
+        } else {
+            revert IConstantFlowAgreementV1.CFA_INVALID_FLOW_RATE();
+        }
+    }
+
+    /**
+     * @dev Create flow with context
      * @param token The token to flow
      * @param receiver The receiver of the flow
      * @param flowRate The desired flowRate
@@ -1378,6 +1450,8 @@ library SuperTokenV1Library {
 
     /**
      * @dev Tries to distribute flow at `requestedFlowRate` of `token` from `from` to `pool`.
+     * Note: the "actual" flowrate set can also be less than `requestedFlowRate, depending on the
+     * current total pool units. In order to know beforehand, use `estimateDistributionActualAmount`.
      * NOTE: The ability to set the `from` argument is needed only when liquidating a GDA flow.
      * The GDA currently doesn't have ACL support.
      * @param token The Super Token address.
diff --git a/packages/ethereum-contracts/test/foundry/apps/SuperTokenV1Library.t.sol b/packages/ethereum-contracts/test/foundry/apps/SuperTokenV1Library.t.sol
@@ -1,9 +1,11 @@
 // SPDX-License-Identifier: AGPLv3
 pragma solidity ^0.8.23;
 
-import { IConstantFlowAgreementV1 } from "../../../contracts/interfaces/agreements/IConstantFlowAgreementV1.sol";
-import { FoundrySuperfluidTester, ISuperToken, SuperTokenV1Library, ISuperfluidPool }
-    from "../FoundrySuperfluidTester.t.sol";
+import { IConstantFlowAgreementV1, ISuperfluid, ISuperToken, ISuperfluidPool, ISuperApp }
+    from "../../../contracts/interfaces/superfluid/ISuperfluid.sol";
+import { CFASuperAppBase } from "../../../contracts/apps/CFASuperAppBase.sol";
+import { SuperTokenV1Library } from "../../../contracts/apps/SuperTokenV1Library.sol";
+import { FoundrySuperfluidTester } from "../FoundrySuperfluidTester.t.sol";
 
 /*
 * Note: since libs are used by contracts, not EOAs, do NOT try to use
@@ -314,15 +316,60 @@ contract SuperTokenV1LibraryTest is FoundrySuperfluidTester {
         assert(lastUpdated2 > lastUpdated1);
     }
 
+    function testFlowWithCtx(bool useACL) external {
+        SuperAppMock superApp = new SuperAppMock(sf.host);
+        superApp.selfRegister(true, true, true);
+        address superAppAddr = address(superApp);
+
+        address flowSender = superAppAddr;
+        address flowReceiver = address(this);
+
+        if (useACL) {
+            vm.startPrank(alice);
+            superApp.setACLFlowSender();
+            sf.host.callAgreement(
+                sf.cfa,
+                abi.encodeCall(sf.cfa.authorizeFlowOperatorWithFullControl, (superToken, superAppAddr, new bytes(0))),
+                new bytes(0) // userData
+            );
+            vm.stopPrank();
+            flowSender = alice;
+        }
+
+        // initial createFlow
+        superToken.flow(superAppAddr, DEFAULT_FLOWRATE);
+        assertEq(_getCFAFlowRate(flowSender, flowReceiver), DEFAULT_FLOWRATE, "createFlow unexpected result");
+
+        // double it -> updateFlow
+        superToken.flow(superAppAddr, DEFAULT_FLOWRATE * 2);
+        assertEq(_getCFAFlowRate(flowSender, flowReceiver), DEFAULT_FLOWRATE * 2, "updateFlow unexpected result");
+
+        if (! useACL) {
+            // delete the mirrored flow (check if remains sticky)
+            superToken.deleteFlow(superAppAddr, address(this));
+            assertEq(_getCFAFlowRate(flowSender, flowReceiver), DEFAULT_FLOWRATE * 2, "flow not sticky");
+        }
+
+        // set to 0 -> deleteFlow
+        superToken.flow(superAppAddr, 0);
+        assertEq(_getCFAFlowRate(flowSender, flowReceiver), 0, "deleteFlow unexpected result");
+
+        // invalid flowrate
+        vm.expectRevert(IConstantFlowAgreementV1.CFA_INVALID_FLOW_RATE.selector);
+        this.__externalflow(flowSender, superAppAddr, -1);
+
+        assertFalse(sf.host.isAppJailed(ISuperApp(superAppAddr)), "superApp is jailed");
+    }
+
     // HELPER FUNCTIONS ========================================================================================
 
-        // direct use of the agreement for assertions
-    function _getCFAFlowRate(address sender, address receiver) public view returns (int96 flowRate) {
+    // direct use of the agreement for assertions
+    function _getCFAFlowRate(address sender, address receiver) internal view returns (int96 flowRate) {
         (,flowRate,,) = sf.cfa.getFlow(superToken, sender, receiver);
     }
 
     // Note: this is without adjustmentFR
-    function _getGDAFlowRate(address sender, ISuperfluidPool pool) public view returns (int96 flowRate) {
+    function _getGDAFlowRate(address sender, ISuperfluidPool pool) internal view returns (int96 flowRate) {
         return sf.gda.getFlowRate(superToken, sender, pool);
     }
 
@@ -344,4 +391,66 @@ contract SuperTokenV1LibraryTest is FoundrySuperfluidTester {
         superToken.flowFrom(sender, receiver, flowRate);
         vm.stopPrank();
     }
+}
+
+// SuperApp for testing withCtx methods.
+// mirrors (default mode) or matches (ACL mode) the incoming flow
+contract SuperAppMock is CFASuperAppBase {
+    using SuperTokenV1Library for ISuperToken;
+
+    // if not set (0), the SuperApp itself is the flowSender
+    address aclFlowSender;
+
+    constructor(ISuperfluid host) CFASuperAppBase(host) { }
+
+    // enable ACL mode by setting a sender
+    function setACLFlowSender() external {
+        aclFlowSender = msg.sender;
+    }
+
+    function onFlowCreated(
+        ISuperToken superToken,
+        address sender,
+        bytes calldata ctx
+    ) internal virtual override returns (bytes memory /*newCtx*/) {
+        return _mirrorOrMatchIncomingFlow(superToken, sender, ctx);
+    }
+
+    function onFlowUpdated(
+        ISuperToken superToken,
+        address sender,
+        int96 /*previousFlowRate*/,
+        uint256 /*lastUpdated*/,
+        bytes calldata ctx
+    ) internal virtual override returns (bytes memory /*newCtx*/) {
+        return _mirrorOrMatchIncomingFlow(superToken, sender, ctx);
+    }
+
+    function onFlowDeleted(
+        ISuperToken superToken,
+        address sender,
+        address receiver,
+        int96 previousFlowRate,
+        uint256 /*lastUpdated*/,
+        bytes calldata ctx
+    ) internal virtual override returns (bytes memory /*newCtx*/) {
+        if (receiver == address(this)) {
+            return _mirrorOrMatchIncomingFlow(superToken, sender, ctx);
+        } else {
+            // outflow was deleted by the sender we mirror to,
+            // we make it "sticky" by simply restoring it.
+            return superToken.flowWithCtx(receiver, previousFlowRate, ctx);
+        }
+    }
+
+    function _mirrorOrMatchIncomingFlow(ISuperToken superToken, address senderAndReceiver, bytes memory ctx)
+        internal returns (bytes memory newCtx)
+    {
+        int96 flowRate = superToken.getFlowRate(senderAndReceiver, address(this));
+        if (aclFlowSender == address(0)) {
+            return superToken.flowWithCtx(senderAndReceiver, flowRate, ctx);
+        } else {
+            return superToken.flowFromWithCtx(aclFlowSender, senderAndReceiver, flowRate, ctx);
+        }
+    }
 }
