feat: transfer tokens to recipient if claim time exceeds vesting endtime in merkle lockup

docs: add notes in claim natspecs
feat: add a new Claim event in merkle lockup interface
test: fuzz start time in merkle lockup
test: use ranged streams as default streams for integration tests

perf: use schedule in memory
docs: polish natspecs

test(fork): assertEq for expected lockup stream

test(fork): move hasClaimed assert outside if block
test(claim): re order tree branches
test: don't use variable names in tree branches
chore: set max-line-length rule to 128

test: polish comment

Co-authored-by: Andrei Vlad Birgaoanu <andreivladbrg@gmail.com>

Author: smol-ninja

.solhint.json

@@ -11,7 +11,7 @@
     "gas-custom-errors": "off",
     "max-states-count": ["warn", 20],
     "imports-order": "warn",
-    "max-line-length": ["error", 124],
+    "max-line-length": ["error", 128],
     "named-parameters-mapping": "warn",
     "no-empty-blocks": "off",
     "not-rely-on-time": "off",

src/SablierMerkleLL.sol

@@ -86,46 +86,62 @@ contract SablierMerkleLL is
 
     /// @inheritdoc SablierMerkleBase
     function _claim(uint256 index, address recipient, uint128 amount) internal override {
+        // Load schedule from storage into memory.
+        MerkleLL.Schedule memory schedule = _schedule;
+
         // Calculate the timestamps for the stream.
         Lockup.Timestamps memory timestamps;
-        if (_schedule.startTime == 0) {
+        if (schedule.startTime == 0) {
             timestamps.start = uint40(block.timestamp);
         } else {
-            timestamps.start = _schedule.startTime;
+            timestamps.start = schedule.startTime;
         }
 
-        uint40 cliffTime;
+        timestamps.end = timestamps.start + schedule.totalDuration;
+
+        // If the stream end time is not in the future, transfer the amount directly to the recipient.
+        if (timestamps.end <= block.timestamp) {
+            // Interaction: transfer the token.
+            TOKEN.safeTransfer(recipient, amount);
 
-        if (_schedule.cliffDuration > 0) {
-            cliffTime = timestamps.start + _schedule.cliffDuration;
+            // Log the claim.
+            emit Claim(index, recipient, amount);
+        }
+        // Otherwise, create the Lockup stream.
+        else {
+            uint40 cliffTime;
+
+            // Calculate cliff time if the cliff duration is greater than 0.
+            if (schedule.cliffDuration > 0) {
+                cliffTime = timestamps.start + schedule.cliffDuration;
+            }
+
+            // Calculate the unlock amounts based on the percentages.
+            LockupLinear.UnlockAmounts memory unlockAmounts;
+            unlockAmounts.start = ud60x18(amount).mul(schedule.startPercentage.intoUD60x18()).intoUint128();
+            unlockAmounts.cliff = ud60x18(amount).mul(schedule.cliffPercentage.intoUD60x18()).intoUint128();
+
+            // Interaction: create the stream via {SablierLockup}.
+            uint256 streamId = LOCKUP.createWithTimestampsLL(
+                Lockup.CreateWithTimestamps({
+                    sender: admin,
+                    recipient: recipient,
+                    depositAmount: amount,
+                    token: TOKEN,
+                    cancelable: STREAM_CANCELABLE,
+                    transferable: STREAM_TRANSFERABLE,
+                    timestamps: timestamps,
+                    shape: shape
+                }),
+                unlockAmounts,
+                cliffTime
+            );
+
+            // Effect: push the stream ID into the `_claimedStreams` array for the recipient.
+            _claimedStreams[recipient].push(streamId);
+
+            // Log the claim.
+            emit Claim(index, recipient, amount, streamId);
         }
-        timestamps.end = timestamps.start + _schedule.totalDuration;
-
-        // Calculate the unlock amounts based on the percentages.
-        LockupLinear.UnlockAmounts memory unlockAmounts;
-        unlockAmounts.start = ud60x18(amount).mul(_schedule.startPercentage.intoUD60x18()).intoUint128();
-        unlockAmounts.cliff = ud60x18(amount).mul(_schedule.cliffPercentage.intoUD60x18()).intoUint128();
-
-        // Interaction: create the stream via {SablierLockup}.
-        uint256 streamId = LOCKUP.createWithTimestampsLL(
-            Lockup.CreateWithTimestamps({
-                sender: admin,
-                recipient: recipient,
-                depositAmount: amount,
-                token: TOKEN,
-                cancelable: STREAM_CANCELABLE,
-                transferable: STREAM_TRANSFERABLE,
-                timestamps: timestamps,
-                shape: shape
-            }),
-            unlockAmounts,
-            cliffTime
-        );
-
-        // Effect: push the stream ID into the `_claimedStreams` array for the recipient.
-        _claimedStreams[recipient].push(streamId);
-
-        // Log the claim.
-        emit Claim(index, recipient, amount, streamId);
     }
 }

src/SablierMerkleLT.sol

@@ -119,26 +119,37 @@ contract SablierMerkleLT is
             endTime = tranches[tranches.length - 1].timestamp;
         }
 
-        // Interaction: create the stream via {SablierLockup-createWithTimestampsLT}.
-        uint256 streamId = LOCKUP.createWithTimestampsLT(
-            Lockup.CreateWithTimestamps({
-                sender: admin,
-                recipient: recipient,
-                depositAmount: amount,
-                token: TOKEN,
-                cancelable: STREAM_CANCELABLE,
-                transferable: STREAM_TRANSFERABLE,
-                timestamps: Lockup.Timestamps({ start: startTime, end: endTime }),
-                shape: shape
-            }),
-            tranches
-        );
-
-        // Effect: push the stream ID into the `_claimedStreams` array for the recipient.
-        _claimedStreams[recipient].push(streamId);
-
-        // Log the claim.
-        emit Claim(index, recipient, amount, streamId);
+        // If the stream end time is not in the future, transfer the amount directly to the recipient.
+        if (endTime <= block.timestamp) {
+            // Interaction: transfer the token.
+            TOKEN.safeTransfer(recipient, amount);
+
+            // Log the claim.
+            emit Claim(index, recipient, amount);
+        }
+        // Otherwise, create the Lockup stream.
+        else {
+            // Interaction: create the stream via {SablierLockup-createWithTimestampsLT}.
+            uint256 streamId = LOCKUP.createWithTimestampsLT(
+                Lockup.CreateWithTimestamps({
+                    sender: admin,
+                    recipient: recipient,
+                    depositAmount: amount,
+                    token: TOKEN,
+                    cancelable: STREAM_CANCELABLE,
+                    transferable: STREAM_TRANSFERABLE,
+                    timestamps: Lockup.Timestamps({ start: startTime, end: endTime }),
+                    shape: shape
+                }),
+                tranches
+            );
+
+            // Effect: push the stream ID into the `_claimedStreams` array for the recipient.
+            _claimedStreams[recipient].push(streamId);
+
+            // Log the claim.
+            emit Claim(index, recipient, amount, streamId);
+        }
     }
 
     /*//////////////////////////////////////////////////////////////////////////

src/interfaces/ISablierMerkleBase.sol

@@ -73,18 +73,22 @@ interface ISablierMerkleBase is IAdminable {
 
     /// @notice Makes the claim.
     ///
-    /// @dev Depending on the Merkle campaign, it either transfers tokens to the recipient or creates a Lockup stream
-    /// with an NFT minted to the recipient.
+    /// @dev Emits a {Claim} event.
+    ///
+    /// Notes:
+    /// - For Merkle Instant and Merkle VCA campaigns, it transfers the tokens directly to the recipient.
+    /// - For Merkle Lockup campaigns, it creates a Lockup stream only if vesting end time is in the future. Otherwise,
+    /// it transfers the tokens directly to the recipient.
     ///
     /// Requirements:
     /// - The campaign must not have expired.
-    /// - The stream must not have been claimed already.
+    /// - The airdrop must not have been claimed already.
     /// - The Merkle proof must be valid.
     /// - The `msg.value` must not be less than `minimumFee`.
     ///
     /// @param index The index of the recipient in the Merkle tree.
     /// @param recipient The address of the airdrop recipient.
-    /// @param amount The amount of ERC-20 tokens to be transferred to the recipient.
+    /// @param amount The amount of ERC-20 tokens allocated to the recipient.
     /// @param merkleProof The proof of inclusion in the Merkle tree.
     function claim(uint256 index, address recipient, uint128 amount, bytes32[] calldata merkleProof) external payable;
 

src/interfaces/ISablierMerkleLockup.sol

@@ -11,7 +11,10 @@ interface ISablierMerkleLockup is ISablierMerkleBase {
                                        EVENTS
     //////////////////////////////////////////////////////////////////////////*/
 
-    /// @notice Emitted when a recipient claims a Lockup stream.
+    /// @notice Emitted when the recipient receives the airdrop through a direct transfer.
+    event Claim(uint256 index, address indexed recipient, uint128 amount);
+
+    /// @notice Emitted when the recipient receives the airdrop through a Lockup stream.
     event Claim(uint256 index, address indexed recipient, uint128 amount, uint256 indexed streamId);
 
     /*//////////////////////////////////////////////////////////////////////////

tests/Base.t.sol

@@ -302,6 +302,7 @@ abstract contract Base_Test is Assertions, Constants, DeployOptimized, Merkle, M
             campaignOwner: campaignOwner,
             expiration: expiration,
             merkleRoot: MERKLE_ROOT,
+            startTime: RANGED_STREAM_START_TIME,
             tokenAddress: dai
         });
     }
@@ -311,6 +312,7 @@ abstract contract Base_Test is Assertions, Constants, DeployOptimized, Merkle, M
         address campaignOwner,
         uint40 expiration,
         bytes32 merkleRoot,
+        uint40 startTime,
         IERC20 tokenAddress
     )
         internal
@@ -322,6 +324,7 @@ abstract contract Base_Test is Assertions, Constants, DeployOptimized, Merkle, M
             lockupAddress: lockup,
             expiration: expiration,
             merkleRoot: merkleRoot,
+            startTime: startTime,
             tokenAddress: tokenAddress
         });
         bytes32 salt = keccak256(abi.encodePacked(campaignCreator, abi.encode(params)));
@@ -362,6 +365,7 @@ abstract contract Base_Test is Assertions, Constants, DeployOptimized, Merkle, M
             expiration: expiration,
             lockupAddress: lockup,
             merkleRoot: MERKLE_ROOT,
+            startTime: RANGED_STREAM_START_TIME,
             tokenAddress: dai
         });
     }
@@ -371,6 +375,7 @@ abstract contract Base_Test is Assertions, Constants, DeployOptimized, Merkle, M
         uint40 expiration,
         ISablierLockup lockupAddress,
         bytes32 merkleRoot,
+        uint40 startTime,
         IERC20 tokenAddress
     )
         public
@@ -386,7 +391,7 @@ abstract contract Base_Test is Assertions, Constants, DeployOptimized, Merkle, M
             lockup: lockupAddress,
             merkleRoot: merkleRoot,
             schedule: MerkleLL.Schedule({
-                startTime: ZERO,
+                startTime: startTime,
                 startPercentage: START_PERCENTAGE,
                 cliffDuration: CLIFF_DURATION,
                 cliffPercentage: CLIFF_PERCENTAGE,
@@ -407,6 +412,7 @@ abstract contract Base_Test is Assertions, Constants, DeployOptimized, Merkle, M
             campaignCreator: users.campaignOwner,
             campaignOwner: campaignOwner,
             expiration: expiration,
+            startTime: RANGED_STREAM_START_TIME,
             merkleRoot: MERKLE_ROOT,
             tokenAddress: dai
         });
@@ -417,6 +423,7 @@ abstract contract Base_Test is Assertions, Constants, DeployOptimized, Merkle, M
         address campaignOwner,
         uint40 expiration,
         bytes32 merkleRoot,
+        uint40 startTime,
         IERC20 tokenAddress
     )
         internal
@@ -428,6 +435,7 @@ abstract contract Base_Test is Assertions, Constants, DeployOptimized, Merkle, M
             lockupAddress: lockup,
             expiration: expiration,
             merkleRoot: merkleRoot,
+            startTime: startTime,
             tokenAddress: tokenAddress
         });
         bytes32 salt = keccak256(abi.encodePacked(campaignCreator, abi.encode(params)));
@@ -469,6 +477,7 @@ abstract contract Base_Test is Assertions, Constants, DeployOptimized, Merkle, M
             expiration: expiration,
             lockupAddress: lockup,
             merkleRoot: MERKLE_ROOT,
+            startTime: RANGED_STREAM_START_TIME,
             tokenAddress: dai
         });
     }
@@ -478,6 +487,7 @@ abstract contract Base_Test is Assertions, Constants, DeployOptimized, Merkle, M
         uint40 expiration,
         ISablierLockup lockupAddress,
         bytes32 merkleRoot,
+        uint40 startTime,
         IERC20 tokenAddress
     )
         public
@@ -499,7 +509,7 @@ abstract contract Base_Test is Assertions, Constants, DeployOptimized, Merkle, M
             lockup: lockupAddress,
             merkleRoot: merkleRoot,
             shape: SHAPE,
-            streamStartTime: ZERO,
+            streamStartTime: startTime,
             token: tokenAddress,
             tranchesWithPercentages: tranchesWithPercentages_,
             transferable: TRANSFERABLE