feat: add CreateBatchLockup event in BatchLockup (#1274)

* feat: emit funder in Lockup create events
feat: emit event in BatchLockup create functions

* refactor: rename to CreateBatchLockup

---------

Co-authored-by: Paul Razvan Berg <[email protected]>

Author: smol-ninja

src/SablierBatchLockup.sol

@@ -83,6 +83,9 @@ contract SablierBatchLockup is ISablierBatchLockup {
                 batch[i].segmentsWithDuration
             );
         }
+
+        // Log the creation of the batch of streams.
+        emit ISablierBatchLockup.CreateLockupBatch({ funder: msg.sender, lockup: lockup, streamIds: streamIds });
     }
 
     /// @inheritdoc ISablierBatchLockup
@@ -139,6 +142,9 @@ contract SablierBatchLockup is ISablierBatchLockup {
                 batch[i].segments
             );
         }
+
+        // Log the creation of the batch of streams.
+        emit ISablierBatchLockup.CreateLockupBatch({ funder: msg.sender, lockup: lockup, streamIds: streamIds });
     }
 
     /// @inheritdoc ISablierBatchLockup
@@ -188,6 +194,9 @@ contract SablierBatchLockup is ISablierBatchLockup {
                 batch[i].durations
             );
         }
+
+        // Log the creation of the batch of streams.
+        emit ISablierBatchLockup.CreateLockupBatch({ funder: msg.sender, lockup: lockup, streamIds: streamIds });
     }
 
     /// @inheritdoc ISablierBatchLockup
@@ -238,6 +247,9 @@ contract SablierBatchLockup is ISablierBatchLockup {
                 batch[i].cliffTime
             );
         }
+
+        // Log the creation of the batch of streams.
+        emit ISablierBatchLockup.CreateLockupBatch({ funder: msg.sender, lockup: lockup, streamIds: streamIds });
     }
 
     /// @inheritdoc ISablierBatchLockup
@@ -286,6 +298,9 @@ contract SablierBatchLockup is ISablierBatchLockup {
                 batch[i].tranchesWithDuration
             );
         }
+
+        // Log the creation of the batch of streams.
+        emit ISablierBatchLockup.CreateLockupBatch({ funder: msg.sender, lockup: lockup, streamIds: streamIds });
     }
 
     /// @inheritdoc ISablierBatchLockup
@@ -342,6 +357,9 @@ contract SablierBatchLockup is ISablierBatchLockup {
                 batch[i].tranches
             );
         }
+
+        // Log the creation of the batch of streams.
+        emit ISablierBatchLockup.CreateLockupBatch({ funder: msg.sender, lockup: lockup, streamIds: streamIds });
     }
 
     /*//////////////////////////////////////////////////////////////////////////

src/abstracts/SablierLockupDynamic.sol

@@ -138,6 +138,7 @@ abstract contract SablierLockupDynamic is
         emit ISablierLockupDynamic.CreateLockupDynamicStream({
             streamId: streamId,
             commonParams: Lockup.CreateEventCommon({
+                funder: msg.sender,
                 sender: sender,
                 recipient: recipient,
                 depositAmount: depositAmount,

src/abstracts/SablierLockupLinear.sol

@@ -144,6 +144,7 @@ abstract contract SablierLockupLinear is
         emit ISablierLockupLinear.CreateLockupLinearStream({
             streamId: streamId,
             commonParams: Lockup.CreateEventCommon({
+                funder: msg.sender,
                 sender: sender,
                 recipient: recipient,
                 depositAmount: depositAmount,

src/abstracts/SablierLockupTranched.sol

@@ -138,6 +138,7 @@ abstract contract SablierLockupTranched is
         emit ISablierLockupTranched.CreateLockupTranchedStream({
             streamId: streamId,
             commonParams: Lockup.CreateEventCommon({
+                funder: msg.sender,
                 sender: sender,
                 recipient: recipient,
                 depositAmount: depositAmount,

src/interfaces/ISablierBatchLockup.sol

@@ -9,6 +9,16 @@ import { ISablierLockup } from "./ISablierLockup.sol";
 /// @title ISablierBatchLockup
 /// @notice Helper to batch create Lockup streams.
 interface ISablierBatchLockup {
+    /*//////////////////////////////////////////////////////////////////////////
+                                       EVENTS
+    //////////////////////////////////////////////////////////////////////////*/
+
+    /// @notice Emitted when a batch of Lockup streams are created.
+    /// @param funder The address funding the streams.
+    /// @param lockup The address of the {SablierLockup} contract used to create the streams.
+    /// @param streamIds The ids of the newly created streams, the ones that were successfully created.
+    event CreateLockupBatch(address indexed funder, ISablierLockup indexed lockup, uint256[] streamIds);
+
     /*//////////////////////////////////////////////////////////////////////////
                         USER-FACING STATE-CHANGING FUNCTIONS
     //////////////////////////////////////////////////////////////////////////*/

src/types/Lockup.sol

@@ -20,6 +20,7 @@ library Lockup {
     }
 
     /// @notice Struct encapsulating the common parameters emitted in the stream creation events.
+    /// @param funder The address funding the stream.
     /// @param sender The address distributing the tokens, which is able to cancel the stream.
     /// @param recipient The address receiving the tokens, as well as the NFT owner.
     /// @param depositAmount The deposit amount, denoted in units of the token's decimals.
@@ -30,6 +31,7 @@ library Lockup {
     /// @param shape An optional parameter to specify the shape of the distribution function. This helps differentiate
     /// streams in the UI.
     struct CreateEventCommon {
+        address funder;
         address sender;
         address recipient;
         uint128 depositAmount;

tests/fork/LockupDynamic.t.sol

@@ -59,7 +59,7 @@ abstract contract Lockup_Dynamic_Fork_Test is Lockup_Fork_Test {
         vm.expectEmit({ emitter: address(lockup) });
         emit ISablierLockupDynamic.CreateLockupDynamicStream({
             streamId: vars.streamId,
-            commonParams: defaults.lockupCreateEvent({ params: params.create, token_: FORK_TOKEN }),
+            commonParams: defaults.lockupCreateEvent({ caller: forkTokenHolder, params: params.create, token_: FORK_TOKEN }),
             segments: params.segments
         });
 

tests/fork/LockupLinear.t.sol

@@ -60,7 +60,7 @@ abstract contract Lockup_Linear_Fork_Test is Lockup_Fork_Test {
         vm.expectEmit({ emitter: address(lockup) });
         emit ISablierLockupLinear.CreateLockupLinearStream({
             streamId: vars.streamId,
-            commonParams: defaults.lockupCreateEvent({ params: params.create, token_: FORK_TOKEN }),
+            commonParams: defaults.lockupCreateEvent({ caller: forkTokenHolder, params: params.create, token_: FORK_TOKEN }),
             cliffTime: params.cliffTime,
             unlockAmounts: params.unlockAmounts
         });

tests/fork/LockupTranched.t.sol

@@ -60,7 +60,7 @@ abstract contract Lockup_Tranched_Fork_Test is Lockup_Fork_Test {
         vm.expectEmit({ emitter: address(lockup) });
         emit ISablierLockupTranched.CreateLockupTranchedStream({
             streamId: vars.streamId,
-            commonParams: defaults.lockupCreateEvent({ params: params.create, token_: FORK_TOKEN }),
+            commonParams: defaults.lockupCreateEvent({ caller: forkTokenHolder, params: params.create, token_: FORK_TOKEN }),
             tranches: params.tranches
         });
 

tests/integration/concrete/batch-lockup/create-with-durations-ld/createWithDurationsLD.t.sol

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: UNLICENSED
 pragma solidity >=0.8.22 <0.9.0;
 
+import { ISablierBatchLockup } from "src/interfaces/ISablierBatchLockup.sol";
 import { Errors } from "src/libraries/Errors.sol";
 import { BatchLockup } from "src/types/BatchLockup.sol";
 
@@ -14,6 +15,8 @@ contract CreateWithDurationsLD_Integration_Test is Integration_Test {
     }
 
     function test_WhenBatchSizeNotZero() external {
+        uint256[] memory expectedStreamIds = defaults.incrementalStreamIds({ firstStreamId: lockup.nextStreamId() });
+
         // Token flow: Sender → batchLockup → SablierLockup
         // Expect transfers from Alice to the batchLockup, and then from the batchLockup to the Lockup contract.
         expectCallToTransferFrom({
@@ -34,12 +37,13 @@ contract CreateWithDurationsLD_Integration_Test is Integration_Test {
             value: defaults.DEPOSIT_AMOUNT()
         });
 
-        uint256 firstStreamId = lockup.nextStreamId();
+        // It should emit a {CreateLockupBatch} event.
+        vm.expectEmit({ emitter: address(batchLockup) });
+        emit ISablierBatchLockup.CreateLockupBatch({ funder: users.sender, lockup: lockup, streamIds: expectedStreamIds });
 
         // Assert that the batch of streams has been created successfully.
         uint256[] memory actualStreamIds =
             batchLockup.createWithDurationsLD(lockup, dai, defaults.batchCreateWithDurationsLD());
-        uint256[] memory expectedStreamIds = defaults.incrementalStreamIds({ firstStreamId: firstStreamId });
         assertEq(actualStreamIds, expectedStreamIds, "stream ids mismatch");
     }
 }