DecentSablier module

contracts/DecentSablierStreamManagement.sol

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: MIT
+pragma solidity =0.8.19;
+
+import {Enum} from "@gnosis.pm/safe-contracts/contracts/common/Enum.sol";
+import {IAvatar} from "@gnosis.pm/zodiac/contracts/interfaces/IAvatar.sol";
+import {ISablierV2LockupLinear} from "./interfaces/sablier/ISablierV2LockupLinear.sol";
+import {LockupLinear} from "./interfaces/sablier/LockupLinear.sol";
+
+contract DecentSablierStreamManagement {
+    string public constant NAME = "DecentSablierStreamManagement";
+
+    function withdrawMaxFromStream(
+        ISablierV2LockupLinear sablier,
+        address recipientHatAccount,
+        uint256 streamId,
+        address to
+    ) public {
+        // Check if there are funds to withdraw
+        uint128 withdrawableAmount = sablier.withdrawableAmountOf(streamId);
+        if (withdrawableAmount == 0) {
+            return;
+        }
+
+        // Proxy the Sablier withdrawMax call through IAvatar (Safe)
+        IAvatar(msg.sender).execTransactionFromModule(
+            recipientHatAccount,
+            0,
+            abi.encodeWithSignature(
+                "execute(address,uint256,bytes,uint8)",
+                address(sablier),
+                0,
+                abi.encodeWithSignature(
+                    "withdrawMax(uint256,address)",
+                    streamId,
+                    to
+                ),
+                0
+            ),
+            Enum.Operation.Call
+        );
+    }
+
+    function cancelStream(
+        ISablierV2LockupLinear sablier,
+        uint256 streamId
+    ) public {
+        // Check if the stream can be cancelled
+        LockupLinear.Status streamStatus = sablier.statusOf(streamId);
+        if (
+            streamStatus != LockupLinear.Status.PENDING &&
+            streamStatus != LockupLinear.Status.STREAMING
+        ) {
+            return;
+        }
+
+        IAvatar(msg.sender).execTransactionFromModule(
+            address(sablier),
+            0,
+            abi.encodeWithSignature("cancel(uint256)", streamId),
+            Enum.Operation.Call
+        );
+    }
+}

contracts/interfaces/sablier/ISablierV2Lockup.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+import {LockupLinear} from "../sablier/LockupLinear.sol";
+
+interface ISablierV2Lockup {
+    function withdrawableAmountOf(
+        uint256 streamId
+    ) external view returns (uint128 withdrawableAmount);
+
+    function isCancelable(uint256 streamId) external view returns (bool result);
+
+    function withdrawMax(
+        uint256 streamId,
+        address to
+    ) external returns (uint128 withdrawnAmount);
+
+    function getStream(
+        uint256 streamId
+    ) external view returns (LockupLinear.Stream memory);
+
+    function cancel(uint256 streamId) external;
+
+    function statusOf(
+        uint256 streamId
+    ) external view returns (LockupLinear.Status status);
+}

contracts/interfaces/sablier/ISablierV2LockupLinear.sol

@@ -2,9 +2,10 @@
 pragma solidity ^0.8.0;
 
 import {LockupLinear} from "./LockupLinear.sol";
+import {ISablierV2Lockup} from "./ISablierV2Lockup.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 
-interface ISablierV2LockupLinear {
+interface ISablierV2LockupLinear is ISablierV2Lockup {
     function createWithTimestamps(
         LockupLinear.CreateWithTimestamps calldata params
     ) external returns (uint256 streamId);

contracts/interfaces/sablier/LockupLinear.sol

@@ -25,4 +25,31 @@ library LockupLinear {
         address account;
         uint256 fee;
     }
+
+    struct Stream {
+        address sender;
+        uint40 startTime;
+        uint40 endTime;
+        uint40 cliffTime;
+        bool cancelable;
+        bool wasCanceled;
+        address asset;
+        bool transferable;
+        uint128 totalAmount;
+        address recipient;
+    }
+
+    /// @notice Enum representing the different statuses of a stream.
+    /// @custom:value0 PENDING Stream created but not started; assets are in a pending state.
+    /// @custom:value1 STREAMING Active stream where assets are currently being streamed.
+    /// @custom:value2 SETTLED All assets have been streamed; recipient is due to withdraw them.
+    /// @custom:value3 CANCELED Canceled stream; remaining assets await recipient's withdrawal.
+    /// @custom:value4 DEPLETED Depleted stream; all assets have been withdrawn and/or refunded.
+    enum Status {
+        PENDING,
+        STREAMING,
+        SETTLED,
+        CANCELED,
+        DEPLETED
+    }
 }

contracts/mocks/MockHatsAccount.sol

@@ -22,4 +22,15 @@ contract MockHatsAccount {
         }
         return abi.decode(footer, (address));
     }
+
+    function execute(
+        address to,
+        uint256 value,
+        bytes calldata data,
+        uint8
+    ) external returns (bytes memory) {
+        (bool success, bytes memory result) = to.call{value: value}(data);
+        require(success, "HatsAccount: execution failed");
+        return result;
+    }
 }

contracts/mocks/MockSablierV2LockupLinear.sol

@@ -6,20 +6,7 @@ import "../interfaces/sablier/ISablierV2LockupLinear.sol";
 import {LockupLinear} from "../interfaces/sablier/LockupLinear.sol";
 
 contract MockSablierV2LockupLinear is ISablierV2LockupLinear {
-    // Define the Stream struct here
-    struct Stream {
-        address sender;
-        address recipient;
-        uint128 totalAmount;
-        address asset;
-        bool cancelable;
-        bool transferable;
-        uint40 startTime;
-        uint40 cliffTime;
-        uint40 endTime;
-    }
-
-    mapping(uint256 => Stream) public streams;
+    mapping(uint256 => LockupLinear.Stream) public streams;
     uint256 public nextStreamId = 1;
 
     // Add this event declaration at the contract level
@@ -49,12 +36,13 @@ contract MockSablierV2LockupLinear is ISablierV2LockupLinear {
         );
 
         streamId = nextStreamId++;
-        streams[streamId] = Stream({
+        streams[streamId] = LockupLinear.Stream({
             sender: params.sender,
             recipient: params.recipient,
             totalAmount: params.totalAmount,
             asset: address(params.asset),
             cancelable: params.cancelable,
+            wasCanceled: false,
             transferable: params.transferable,
             startTime: params.timestamps.start,
             cliffTime: params.timestamps.cliff,
@@ -78,14 +66,16 @@ contract MockSablierV2LockupLinear is ISablierV2LockupLinear {
         return streamId;
     }
 
-    function getStream(uint256 streamId) external view returns (Stream memory) {
+    function getStream(
+        uint256 streamId
+    ) external view returns (LockupLinear.Stream memory) {
         return streams[streamId];
     }
 
     function withdrawableAmountOf(
         uint256 streamId
     ) public view returns (uint128) {
-        Stream memory stream = streams[streamId];
+        LockupLinear.Stream memory stream = streams[streamId];
         if (block.timestamp <= stream.startTime) {
             return 0;
         }
@@ -99,27 +89,35 @@ contract MockSablierV2LockupLinear is ISablierV2LockupLinear {
             );
     }
 
-    function withdraw(uint256 streamId, uint128 amount) external {
-        Stream storage stream = streams[streamId];
-        require(msg.sender == stream.recipient, "Only recipient can withdraw");
+    function withdrawMax(
+        uint256 streamId,
+        address to
+    ) external returns (uint128 withdrawnAmount) {
+        withdrawnAmount = withdrawableAmountOf(streamId);
+        LockupLinear.Stream storage stream = streams[streamId];
+
         require(
-            amount <= withdrawableAmountOf(streamId),
+            msg.sender == stream.recipient,
+            "Only recipient can call withdraw"
+        );
+        require(
+            withdrawnAmount <= withdrawableAmountOf(streamId),
             "Insufficient withdrawable amount"
         );
 
-        stream.totalAmount -= amount;
-        IERC20(stream.asset).transfer(stream.recipient, amount);
+        stream.totalAmount -= withdrawnAmount;
+        IERC20(stream.asset).transfer(to, withdrawnAmount);
     }
 
     function cancel(uint256 streamId) external {
-        Stream memory stream = streams[streamId];
+        LockupLinear.Stream memory stream = streams[streamId];
         require(stream.cancelable, "Stream is not cancelable");
         require(msg.sender == stream.sender, "Only sender can cancel");
 
         uint128 withdrawableAmount = withdrawableAmountOf(streamId);
         uint128 refundAmount = stream.totalAmount - withdrawableAmount;
 
-        delete streams[streamId];
+        streams[streamId].wasCanceled = true;
 
         if (withdrawableAmount > 0) {
             IERC20(stream.asset).transfer(stream.recipient, withdrawableAmount);
@@ -129,31 +127,29 @@ contract MockSablierV2LockupLinear is ISablierV2LockupLinear {
         }
     }
 
-    function renounce(uint256 streamId) external {
-        Stream memory stream = streams[streamId];
-        require(msg.sender == stream.recipient, "Only recipient can renounce");
-
-        uint128 withdrawableAmount = withdrawableAmountOf(streamId);
-        uint128 refundAmount = stream.totalAmount - withdrawableAmount;
-
-        delete streams[streamId];
+    function isCancelable(uint256 streamId) external view returns (bool) {
+        return streams[streamId].cancelable;
+    }
 
-        if (withdrawableAmount > 0) {
-            IERC20(stream.asset).transfer(stream.recipient, withdrawableAmount);
-        }
-        if (refundAmount > 0) {
-            IERC20(stream.asset).transfer(stream.sender, refundAmount);
+    /// @dev Retrieves the stream's status without performing a null check.
+    function statusOf(
+        uint256 streamId
+    ) public view returns (LockupLinear.Status) {
+        uint256 withdrawableAmount = withdrawableAmountOf(streamId);
+        if (withdrawableAmount == 0) {
+            return LockupLinear.Status.DEPLETED;
+        } else if (streams[streamId].wasCanceled) {
+            return LockupLinear.Status.CANCELED;
         }
-    }
 
-    function transferFrom(uint256 streamId, address recipient) external {
-        Stream storage stream = streams[streamId];
-        require(stream.transferable, "Stream is not transferable");
-        require(
-            msg.sender == stream.recipient,
-            "Only current recipient can transfer"
-        );
+        if (block.timestamp < streams[streamId].startTime) {
+            return LockupLinear.Status.PENDING;
+        }
 
-        stream.recipient = recipient;
+        if (block.timestamp < streams[streamId].endTime) {
+            return LockupLinear.Status.STREAMING;
+        } else {
+            return LockupLinear.Status.SETTLED;
+        }
     }
 }

test/DecentHats_0_1_0.test.ts

@@ -29,47 +29,11 @@ import {
 import {
   buildSafeTransaction,
   buildSignatureBytes,
+  executeSafeTransaction,
   predictGnosisSafeAddress,
   safeSignTypedData,
 } from "./helpers";
 
-const executeSafeTransaction = async ({
-  safe,
-  to,
-  transactionData,
-  signers,
-}: {
-  safe: GnosisSafeL2;
-  to: string;
-  transactionData: string;
-  signers: SignerWithAddress[];
-}) => {
-  const safeTx = buildSafeTransaction({
-    to,
-    data: transactionData,
-    nonce: await safe.nonce(),
-  });
-
-  const sigs = await Promise.all(
-    signers.map(async (signer) => await safeSignTypedData(signer, safe, safeTx))
-  );
-
-  const tx = await safe.execTransaction(
-    safeTx.to,
-    safeTx.value,
-    safeTx.data,
-    safeTx.operation,
-    safeTx.safeTxGas,
-    safeTx.baseGas,
-    safeTx.gasPrice,
-    safeTx.gasToken,
-    safeTx.refundReceiver,
-    buildSignatureBytes(sigs)
-  );
-
-  return tx;
-};
-
 describe("DecentHats_0_1_0", () => {
   let dao: SignerWithAddress;
 
@@ -166,7 +130,7 @@ describe("DecentHats_0_1_0", () => {
     await mockERC20.mint(gnosisSafeAddress, ethers.parseEther("1000000"));
   });
 
-  describe("DecentHats as a Module", () => {
+  describe("DecentHats", () => {
     let enableModuleTx: ethers.ContractTransactionResponse;
 
     beforeEach(async () => {
@@ -182,14 +146,16 @@ describe("DecentHats_0_1_0", () => {
       });
     });
 
-    it("Emits an ExecutionSuccess event", async () => {
-      await expect(enableModuleTx).to.emit(gnosisSafe, "ExecutionSuccess");
-    });
+    describe("Enabled as a module", () => {
+      it("Emits an ExecutionSuccess event", async () => {
+        await expect(enableModuleTx).to.emit(gnosisSafe, "ExecutionSuccess");
+      });
 
-    it("Emits an EnabledModule event", async () => {
-      await expect(enableModuleTx)
-        .to.emit(gnosisSafe, "EnabledModule")
-        .withArgs(decentHatsAddress);
+      it("Emits an EnabledModule event", async () => {
+        await expect(enableModuleTx)
+          .to.emit(gnosisSafe, "EnabledModule")
+          .withArgs(decentHatsAddress);
+      });
     });
 
     describe("Creating a new Top Hat and Tree", () => {