feat: flow examples

flow/FlowBatchable.sol

@@ -0,0 +1,167 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity >=0.8.22;
+
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import { ud21x18, UD21x18 } from "@prb/math/src/UD21x18.sol";
+import { ud60x18, UD60x18 } from "@prb/math/src/UD60x18.sol";
+
+import { Broker, SablierFlow } from "@sablier/flow/src/SablierFlow.sol";
+
+/// @dev The `Batch` contract, inherited in SablierFlow, allows multiple function calls to be batched together.
+/// This enables any possible combination of functions to be executed within a single transaction.
+contract FlowBatchable {
+    IERC20 public constant USDC = IERC20(0xf08A50178dfcDe18524640EA6618a1f965821715);
+    SablierFlow public immutable SABLIER_FLOW;
+
+    constructor(SablierFlow sablierFlow_) {
+        SABLIER_FLOW = sablierFlow_;
+    }
+
+    /// @dev A function to adjust the rate per second and deposits into a stream.
+    function adjustRatePerSecondAndDeposit(uint256 streamId) external {
+        UD21x18 newRatePerSecond = ud21x18(0.0001e18);
+        uint128 depositAmount = 1000e6;
+
+        // Transfer to this contract the amount to deposit in both streams.
+        USDC.transferFrom(msg.sender, address(this), depositAmount);
+
+        // Approve the Sablier contract to spend USDC
+        USDC.approve(address(SABLIER_FLOW), depositAmount);
+
+        // The call data declared as bytes
+        bytes[] memory calls = new bytes[](2);
+        calls[0] = abi.encodeCall(SABLIER_FLOW.adjustRatePerSecond, (streamId, newRatePerSecond));
+        calls[1] = abi.encodeCall(SABLIER_FLOW.deposit, (streamId, depositAmount, msg.sender, address(0xCAFE)));
+
+        SABLIER_FLOW.batch(calls);
+    }
+
+    /// @dev A function to create multiple streams in a single transaction.
+    function createMultiple() external returns (uint256[] memory streamIds) {
+        address sender = msg.sender;
+        address firstRecipient = address(0xCAFE);
+        address secondRecipient = address(0xBEEF);
+        UD21x18 firstRatePerSecond = ud21x18(0.0001e18);
+        UD21x18 secondRatePerSecond = ud21x18(0.0002e18);
+
+        // The call data declared as bytes
+        bytes[] memory calls = new bytes[](2);
+        calls[0] = abi.encodeCall(SABLIER_FLOW.create, (sender, firstRecipient, firstRatePerSecond, USDC, true));
+        calls[1] = abi.encodeCall(SABLIER_FLOW.create, (sender, secondRecipient, secondRatePerSecond, USDC, true));
+
+        // Prepare the `streamIds` array to return them
+        uint256 nextStreamId = SABLIER_FLOW.nextStreamId();
+        streamIds = new uint256[](2);
+        streamIds[0] = nextStreamId;
+        streamIds[1] = nextStreamId + 1;
+
+        // Execute multiple calls in a single transaction using the prepared call data.
+        SABLIER_FLOW.batch(calls);
+    }
+
+    /// @dev A function to create a stream and deposit via a broker in a single transaction.
+    function createAndDepositViaBroker() external returns (uint256 streamId) {
+        address sender = msg.sender;
+        address recipient = address(0xCAFE);
+        UD21x18 ratePerSecond = ud21x18(0.0001e18);
+        uint128 depositAmount = 1000e6;
+
+        // The broker struct
+        Broker memory broker = Broker({
+            account: address(0xDEAD),
+            fee: ud60x18(0.0001e18) // the fee percentage
+         });
+
+        // Transfer to this contract the amount to deposit in both streams.
+        USDC.transferFrom(msg.sender, address(this), depositAmount);
+
+        // Approve the Sablier contract to spend USDC
+        USDC.approve(address(SABLIER_FLOW), depositAmount);
+
+        streamId = SABLIER_FLOW.nextStreamId();
+
+        // The call data declared as bytes
+        bytes[] memory calls = new bytes[](2);
+        calls[0] = abi.encodeCall(SABLIER_FLOW.create, (sender, recipient, ratePerSecond, USDC, true));
+        calls[1] = abi.encodeCall(SABLIER_FLOW.depositViaBroker, (streamId, depositAmount, sender, recipient, broker));
+
+        // Execute multiple calls in a single transaction using the prepared call data.
+        SABLIER_FLOW.batch(calls);
+    }
+
+    /// @dev A function to create multiple streams and deposit via a broker in a single transaction.
+    function createMultipleAndDepositViaBroker() external returns (uint256[] memory streamIds) {
+        address sender = msg.sender;
+        address firstRecipient = address(0xCAFE);
+        address secondRecipient = address(0xBEEF);
+        UD21x18 ratePerSecond = ud21x18(0.0001e18);
+        uint128 depositAmount = 1000e6;
+
+        // Transfer the deposit amount of USDC tokens to this contract for both streams
+        USDC.transferFrom(msg.sender, address(this), 2 * depositAmount);
+
+        // Approve the Sablier contract to spend USDC
+        USDC.approve(address(SABLIER_FLOW), 2 * depositAmount);
+
+        // The broker struct
+        Broker memory broker = Broker({
+            account: address(0xDEAD),
+            fee: ud60x18(0.0001e18) // the fee percentage
+         });
+
+        uint256 nextStreamId = SABLIER_FLOW.nextStreamId();
+        streamIds = new uint256[](2);
+        streamIds[0] = nextStreamId;
+        streamIds[1] = nextStreamId + 1;
+
+        // We need to have 4 different function calls, 2 for creating streams and 2 for depositing via broker
+        bytes[] memory calls = new bytes[](4);
+        calls[0] = abi.encodeCall(SABLIER_FLOW.create, (sender, firstRecipient, ratePerSecond, USDC, true));
+        calls[1] = abi.encodeCall(SABLIER_FLOW.create, (sender, secondRecipient, ratePerSecond, USDC, true));
+        calls[2] =
+            abi.encodeCall(SABLIER_FLOW.depositViaBroker, (streamIds[0], depositAmount, sender, firstRecipient, broker));
+        calls[3] = abi.encodeCall(
+            SABLIER_FLOW.depositViaBroker, (streamIds[1], depositAmount, sender, secondRecipient, broker)
+        );
+
+        // Execute multiple calls in a single transaction using the prepared call data.
+        SABLIER_FLOW.batch(calls);
+    }
+
+    /// @dev A function to pause a stream and withdraw the maximum available funds.
+    function pauseAndWithdrawMax(uint256 streamId) external {
+        // The call data declared as bytes
+        bytes[] memory calls = new bytes[](2);
+        calls[0] = abi.encodeCall(SABLIER_FLOW.pause, (streamId));
+        calls[1] = abi.encodeCall(SABLIER_FLOW.withdrawMax, (streamId, address(0xCAFE)));
+
+        // Execute multiple calls in a single transaction using the prepared call data.
+        SABLIER_FLOW.batch(calls);
+    }
+
+    /// @dev A function to void a stream and withdraw what is left.
+    function voidAndWithdrawMax(uint256 streamId) external {
+        // The call data declared as bytes
+        bytes[] memory calls = new bytes[](2);
+        calls[0] = abi.encodeCall(SABLIER_FLOW.void, (streamId));
+        calls[1] = abi.encodeCall(SABLIER_FLOW.withdrawMax, (streamId, address(0xCAFE)));
+
+        // Execute multiple calls in a single transaction using the prepared call data.
+        SABLIER_FLOW.batch(calls);
+    }
+
+    /// @dev A function to withdraw maximum available funds from multiple streams in a single transaction.
+    function withdrawMaxMultiple(uint256[] calldata streamIds) external {
+        uint256 count = streamIds.length;
+
+        // Iterate over the streamIds and prepare the call data for each stream
+        bytes[] memory calls = new bytes[](count);
+        for (uint256 i = 0; i < count; ++i) {
+            address recipient = SABLIER_FLOW.getRecipient(streamIds[i]);
+            calls[i] = abi.encodeCall(SABLIER_FLOW.withdrawMax, (streamIds[i], recipient));
+        }
+
+        // Execute multiple calls in a single transaction using the prepared call data.
+        SABLIER_FLOW.batch(calls);
+    }
+}

flow/FlowBatchable.t.sol

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity >=0.8.22;
+
+import { Test } from "forge-std/src/Test.sol";
+
+import { FlowBatchable } from "./FlowBatchable.sol";
+
+import { IFlowNFTDescriptor, SablierFlow } from "@sablier/flow/src/SablierFlow.sol";
+
+contract FlowBatchable_Test is Test {
+    FlowBatchable internal batchable;
+    SablierFlow internal flow;
+    address internal user;
+
+    function setUp() external {
+        // Fork Ethereum Sepolia
+        vm.createSelectFork({ urlOrAlias: "sepolia", blockNumber: 6_240_816 });
+
+        // Deploy a SablierFlow contract
+        flow = new SablierFlow({ initialAdmin: address(this), initialNFTDescriptor: IFlowNFTDescriptor(address(this)) });
+
+        // Deploy the batchable contract
+        batchable = new FlowBatchable(flow);
+
+        user = makeAddr("User");
+
+        // Mint some DAI tokens to the test user, which will be pulled by the creator contract
+        deal({ token: address(batchable.USDC()), to: user, give: 1_000_000e6 });
+
+        // Make the test user the `msg.sender` in all following calls
+        vm.startPrank({ msgSender: user });
+
+        // Approve the batchable contract to pull USDC tokens from the test user
+        batchable.USDC().approve({ spender: address(batchable), value: 1_000_000e6 });
+    }
+
+    function test_CreateMultiple() external {
+        uint256 nextStreamIdBefore = flow.nextStreamId();
+
+        uint256[] memory actualStreamIds = batchable.createMultiple();
+        uint256[] memory expectedStreamIds = new uint256[](2);
+        expectedStreamIds[0] = nextStreamIdBefore;
+        expectedStreamIds[1] = nextStreamIdBefore + 1;
+
+        assertEq(actualStreamIds, expectedStreamIds);
+    }
+
+    function test_CreateAndDepositViaBroker() external {
+        uint256 nextStreamIdBefore = flow.nextStreamId();
+
+        uint256[] memory actualStreamIds = batchable.createMultipleAndDepositViaBroker();
+        uint256[] memory expectedStreamIds = new uint256[](2);
+        expectedStreamIds[0] = nextStreamIdBefore;
+        expectedStreamIds[1] = nextStreamIdBefore + 1;
+
+        assertEq(actualStreamIds, expectedStreamIds);
+    }
+}

flow/FlowManager.sol

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity >=0.8.22;
+
+import { ud21x18, UD21x18 } from "@prb/math/src/UD21x18.sol";
+
+import { ISablierFlow } from "@sablier/flow/src/interfaces/ISablierFlow.sol";
+
+contract FlowManager {
+    ISablierFlow public immutable sablierFlow;
+
+    constructor(ISablierFlow sablierFlow_) {
+        sablierFlow = sablierFlow_;
+    }
+
+    function adjustRatePerSecond(uint256 streamId) external {
+        sablierFlow.adjustRatePerSecond({ streamId: streamId, newRatePerSecond: ud21x18(0.0001e18) });
+    }
+
+    function deposit(uint256 streamId) external {
+        sablierFlow.deposit(streamId, 3.14159e18, msg.sender, address(0xCAFE));
+    }
+
+    function depositAndPause(uint256 streamId) external {
+        sablierFlow.depositAndPause(streamId, 3.14159e18);
+    }
+
+    function pause(uint256 streamId) external {
+        sablierFlow.pause(streamId);
+    }
+
+    function refund(uint256 streamId) external {
+        sablierFlow.refund({ streamId: streamId, amount: 1.61803e18 });
+    }
+
+    function refundAndPause(uint256 streamId) external {
+        sablierFlow.refundAndPause({ streamId: streamId, amount: 1.61803e18 });
+    }
+
+    function restart(uint256 streamId) external {
+        sablierFlow.restart({ streamId: streamId, ratePerSecond: ud21x18(0.0001e18) });
+    }
+
+    function restartAndDeposit(uint256 streamId) external {
+        sablierFlow.restartAndDeposit({ streamId: streamId, ratePerSecond: ud21x18(0.0001e18), amount: 2.71828e18 });
+    }
+
+    function void(uint256 streamId) external {
+        sablierFlow.void(streamId);
+    }
+
+    function withdraw(uint256 streamId) external {
+        sablierFlow.withdraw({ streamId: streamId, to: address(0xCAFE), amount: 2.71828e18 });
+    }
+
+    function withdrawMax(uint256 streamId) external {
+        sablierFlow.withdrawMax({ streamId: streamId, to: address(0xCAFE) });
+    }
+}

flow/FlowStreamCreator.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity >=0.8.22;
+
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import { UD21x18 } from "@prb/math/src/UD21x18.sol";
+
+import { ISablierFlow } from "@sablier/flow/src/interfaces/ISablierFlow.sol";
+
+import { FlowUtilities } from "./FlowUtilities.sol";
+
+contract FlowStreamCreator {
+    // Mainnet USDC
+    IERC20 public constant USDC = IERC20(0xf08A50178dfcDe18524640EA6618a1f965821715);
+    ISablierFlow public immutable sablierFlow;
+
+    constructor(ISablierFlow sablierFlow_) {
+        sablierFlow = sablierFlow_;
+    }
+
+    // Create a stream that sends 1000 USDC per month
+    function createStream_1T_PerMonth() external returns (uint256 streamId) {
+        UD21x18 ratePerSecond =
+            FlowUtilities.ratePerSecondWithDuration({ token: address(USDC), amount: 1000e6, duration: 30 days });
+
+        streamId = sablierFlow.create({
+            sender: msg.sender, // The sender will be able to manage the stream
+            recipient: address(0xCAFE), // The recipient of the streamed assets
+            ratePerSecond: ratePerSecond, // The rate per second equivalent to 1000 USDC per month
+            token: USDC, // The token to be streamed
+            transferable: true // Whether the stream will be transferable or not
+         });
+    }
+
+    // Create a stream that sends 1,000,000 USDC per year
+    function createStream_1M_PerYear() external returns (uint256 streamId) {
+        UD21x18 ratePerSecond =
+            FlowUtilities.ratePerSecondWithDuration({ token: address(USDC), amount: 1_000_000e6, duration: 365 days });
+
+        streamId = sablierFlow.create({
+            sender: msg.sender, // The sender will be able to manage the stream
+            recipient: address(0xCAFE), // The recipient of the streamed assets
+            ratePerSecond: ratePerSecond, // The rate per second equivalent to 1,000,00 USDC per year
+            token: USDC, // The token to be streamed
+            transferable: true // Whether the stream will be transferable or not
+         });
+    }
+}

flow/FlowStreamCreator.t.sol

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity >=0.8.22;
+
+import { Test } from "forge-std/src/Test.sol";
+
+import { FlowStreamCreator } from "./FlowStreamCreator.sol";
+
+import { IFlowNFTDescriptor, SablierFlow } from "@sablier/flow/src/SablierFlow.sol";
+
+contract FlowStreamCreator_Test is Test {
+    FlowStreamCreator internal streamCreator;
+    SablierFlow internal flow;
+    address internal user;
+
+    function setUp() external {
+        // Fork Ethereum Sepolia
+        vm.createSelectFork({ urlOrAlias: "sepolia", blockNumber: 6_240_816 });
+
+        // Deploy a SablierFlow contract
+        flow = new SablierFlow({ initialAdmin: address(this), initialNFTDescriptor: IFlowNFTDescriptor(address(this)) });
+
+        // Deploy the FlowStreamCreator contract
+        streamCreator = new FlowStreamCreator(flow);
+
+        user = makeAddr("User");
+
+        // Mint some DAI tokens to the test user, which will be pulled by the creator contract
+        deal({ token: address(streamCreator.USDC()), to: user, give: 1_000_000e6 });
+
+        // Make the test user the `msg.sender` in all following calls
+        vm.startPrank({ msgSender: user });
+
+        // Approve the streamCreator contract to pull USDC tokens from the test user
+        streamCreator.USDC().approve({ spender: address(streamCreator), value: 1_000_000e6 });
+    }
+
+    function test_CreateStream_1T_PerMonth() external {
+        uint256 expectedStreamId = flow.nextStreamId();
+
+        uint256 actualStreamId = streamCreator.createStream_1T_PerMonth();
+        assertEq(actualStreamId, expectedStreamId);
+
+        // Warp more than 30 days into the future to see if the debt accumulated is more than 1 thousand
+        vm.warp({ newTimestamp: block.timestamp + 30 days + 1 seconds });
+
+        assertGe(flow.totalDebtOf(actualStreamId), 1000e6);
+    }
+
+    function test_CreateStream_1M_PerYear() external {
+        uint256 expectedStreamId = flow.nextStreamId();
+
+        uint256 actualStreamId = streamCreator.createStream_1M_PerYear();
+        assertEq(actualStreamId, expectedStreamId);
+
+        // Warp more than 30 days into the future to see if the debt accumulated is more than 1 thousand
+        vm.warp({ newTimestamp: block.timestamp + 365 days + 1 seconds });
+
+        assertGe(flow.totalDebtOf(actualStreamId), 1_000_000e6);
+    }
+}