refactor: constructor params (#326)

* refactor: alphabetical constructor params * refactor: update precompiles test: update formatting in comments * test: dev comments --------- Co-authored-by: smol-ninja <shubhamy2015@gmail.com>
sablier-labs · Apr 12, 2024 · a57b2e1 · a57b2e1
1 parent 7c3ca60
commit a57b2e1
Show file tree

Hide file tree

Showing 8 changed files with 59 additions and 59 deletions.
diff --git a/precompiles/Precompiles.sol b/precompiles/Precompiles.sol
diff --git a/src/SablierV2MerkleLockupFactory.sol b/src/SablierV2MerkleLockupFactory.sol
@@ -35,13 +35,13 @@ contract SablierV2MerkleLockupFactory is ISablierV2MerkleLockupFactory {
         // Hash the parameters to generate a salt.
         bytes32 salt = keccak256(
             abi.encodePacked(
-                baseParams.initialAdmin,
                 baseParams.asset,
+                baseParams.cancelable,
+                baseParams.expiration,
+                baseParams.initialAdmin,
                 abi.encode(baseParams.ipfsCID),
-                bytes32(abi.encodePacked(baseParams.name)),
                 baseParams.merkleRoot,
-                baseParams.expiration,
-                baseParams.cancelable,
+                bytes32(abi.encodePacked(baseParams.name)),
                 baseParams.transferable,
                 lockupLinear,
                 abi.encode(streamDurations)
@@ -86,13 +86,13 @@ contract SablierV2MerkleLockupFactory is ISablierV2MerkleLockupFactory {
         // Hash the parameters to generate a salt.
         bytes32 salt = keccak256(
             abi.encodePacked(
-                baseParams.initialAdmin,
                 baseParams.asset,
+                baseParams.cancelable,
+                baseParams.expiration,
+                baseParams.initialAdmin,
                 abi.encode(baseParams.ipfsCID),
-                bytes32(abi.encodePacked(baseParams.name)),
                 baseParams.merkleRoot,
-                baseParams.expiration,
-                baseParams.cancelable,
+                bytes32(abi.encodePacked(baseParams.name)),
                 baseParams.transferable,
                 lockupTranched,
                 abi.encode(tranchesWithPercentages)

diff --git a/src/types/DataTypes.sol b/src/types/DataTypes.sol
@@ -90,22 +90,22 @@ library BatchLockup {
 
 library MerkleLockup {
     /// @notice Struct encapsulating the base constructor parameters of a MerkleLockup campaign.
-    /// @param initialAdmin The initial admin of the MerkleLockup campaign.
     /// @param asset The contract address of the ERC-20 asset to be distributed.
+    /// @param cancelable Indicates if the stream will be cancelable after claiming.
+    /// @param expiration The expiration of the campaign, as a Unix timestamp.
+    /// @param initialAdmin The initial admin of the MerkleLockup campaign.
     /// @param ipfsCID The content identifier for indexing the contract on IPFS.
-    /// @param name The name of the campaign.
     /// @param merkleRoot The Merkle root of the claim data.
-    /// @param expiration The expiration of the campaign, as a Unix timestamp.
-    /// @param cancelable Indicates if the stream will be cancelable after claiming.
+    /// @param name The name of the campaign.
     /// @param transferable Indicates if the stream will be transferable after claiming.
     struct ConstructorParams {
-        address initialAdmin;
         IERC20 asset;
+        bool cancelable;
+        uint40 expiration;
+        address initialAdmin;
         string ipfsCID;
-        string name;
         bytes32 merkleRoot;
-        uint40 expiration;
-        bool cancelable;
+        string name;
         bool transferable;
     }
 }
@@ -114,7 +114,7 @@ library MerkleLT {
     /// @notice Struct encapsulating the unlock percentage and duration of a tranche.
     /// @dev Since users may have different amounts allocated, this struct makes it possible to calculate the amounts
     /// at claim time. An 18-decimal format is used to represent percentages: 100% = 1e18. For more information, see
-    /// the PRBMath documentation on {UD2x18}: https://github.com/PaulRBerg/prb-math
+    /// the PRBMath documentation on UD2x18: https://github.com/PaulRBerg/prb-math
     /// @param unlockPercentage The percentage designated to be unlocked in this tranche.
     /// @param duration The time difference in seconds between this tranche and the previous one.
     struct TrancheWithPercentage {

diff --git a/test/Base.t.sol b/test/Base.t.sol
@@ -286,13 +286,13 @@ abstract contract Base_Test is
     {
         bytes32 salt = keccak256(
             abi.encodePacked(
-                admin,
                 address(asset_),
+                defaults.CANCELABLE(),
+                expiration,
+                admin,
                 abi.encode(defaults.IPFS_CID()),
-                defaults.NAME_BYTES32(),
                 merkleRoot,
-                expiration,
-                defaults.CANCELABLE(),
+                defaults.NAME_BYTES32(),
                 defaults.TRANSFERABLE(),
                 lockupLinear,
                 abi.encode(defaults.durations())
@@ -330,13 +330,13 @@ abstract contract Base_Test is
     {
         bytes32 salt = keccak256(
             abi.encodePacked(
-                admin,
                 address(asset_),
+                defaults.CANCELABLE(),
+                expiration,
+                admin,
                 abi.encode(defaults.IPFS_CID()),
-                defaults.NAME_BYTES32(),
                 merkleRoot,
-                expiration,
-                defaults.CANCELABLE(),
+                defaults.NAME_BYTES32(),
                 defaults.TRANSFERABLE(),
                 lockupTranched,
                 abi.encode(defaults.tranchesWithPercentages())
@@ -361,7 +361,7 @@ abstract contract Base_Test is
         returns (bytes memory)
     {
         bytes memory constructorArgs =
-            abi.encode(defaults.baseParams(admin, asset_, merkleRoot, expiration), lockupLinear, defaults.durations());
+            abi.encode(defaults.baseParams(admin, asset_, expiration, merkleRoot), lockupLinear, defaults.durations());
         if (!isTestOptimizedProfile()) {
             return bytes.concat(type(SablierV2MerkleLL).creationCode, constructorArgs);
         } else {
@@ -381,7 +381,7 @@ abstract contract Base_Test is
         returns (bytes memory)
     {
         bytes memory constructorArgs = abi.encode(
-            defaults.baseParams(admin, asset_, merkleRoot, expiration),
+            defaults.baseParams(admin, asset_, expiration, merkleRoot),
             lockupTranched,
             defaults.tranchesWithPercentages()
         );

diff --git a/test/fork/merkle-lockup/MerkleLT.t.sol b/test/fork/merkle-lockup/MerkleLT.t.sol
@@ -35,11 +35,11 @@ abstract contract MerkleLT_Fork_Test is Fork_Test {
     }
 
     struct Vars {
-        uint256 actualStreamId;
         LockupTranched.StreamLT actualStream;
+        uint256 actualStreamId;
         LockupTranched.Tranche[] actualTranches;
-        uint128[] amounts;
         uint256 aggregateAmount;
+        uint128[] amounts;
         MerkleLockup.ConstructorParams baseParams;
         uint128 clawbackAmount;
         address expectedLT;

diff --git a/test/integration/merkle-lockup/MerkleLockup.t.sol b/test/integration/merkle-lockup/MerkleLockup.t.sol
@@ -62,7 +62,7 @@ abstract contract MerkleLockup_Integration_Test is Integration_Test {
 
     function createMerkleLL(address admin, uint40 expiration) internal returns (ISablierV2MerkleLL) {
         return merkleLockupFactory.createMerkleLL({
-            baseParams: defaults.baseParams(admin, dai, defaults.MERKLE_ROOT(), expiration),
+            baseParams: defaults.baseParams(admin, dai, expiration, defaults.MERKLE_ROOT()),
             lockupLinear: lockupLinear,
             streamDurations: defaults.durations(),
             aggregateAmount: defaults.AGGREGATE_AMOUNT(),
@@ -113,7 +113,7 @@ abstract contract MerkleLockup_Integration_Test is Integration_Test {
 
     function createMerkleLT(address admin, uint40 expiration) internal returns (ISablierV2MerkleLT) {
         return merkleLockupFactory.createMerkleLT({
-            baseParams: defaults.baseParams(admin, dai, defaults.MERKLE_ROOT(), expiration),
+            baseParams: defaults.baseParams(admin, dai, expiration, defaults.MERKLE_ROOT()),
             lockupTranched: lockupTranched,
             tranchesWithPercentages: defaults.tranchesWithPercentages(),
             aggregateAmount: defaults.AGGREGATE_AMOUNT(),

diff --git a/test/utils/BatchLockupBuilder.sol b/test/utils/BatchLockupBuilder.sol
@@ -21,7 +21,7 @@ library BatchLockupBuilder {
         }
     }
 
-    /// @notice Turns the `params` into an array of `BatchLockup.CreateWithDurationsLD` structs.
+    /// @notice Turns the `params` into an array of {BatchLockup.CreateWithDurationsLD} structs.
     function fillBatch(
         LockupDynamic.CreateWithDurations memory params,
         uint256 batchSize
@@ -58,7 +58,7 @@ library BatchLockupBuilder {
         }
     }
 
-    /// @notice Turns the `params` into an array of `BatchLockup.CreateWithDurationsLL` structs.
+    /// @notice Turns the `params` into an array of {BatchLockup.CreateWithDurationsLL} structs.
     function fillBatch(
         LockupLinear.CreateWithDurations memory params,
         uint256 batchSize
@@ -95,7 +95,7 @@ library BatchLockupBuilder {
         }
     }
 
-    /// @notice Turns the `params` into an array of `BatchLockup.CreateWithDurationsLT` structs.
+    /// @notice Turns the `params` into an array of {BatchLockup.CreateWithDurationsLT} structs.
     function fillBatch(
         LockupTranched.CreateWithDurations memory params,
         uint256 batchSize
@@ -132,7 +132,7 @@ library BatchLockupBuilder {
         }
     }
 
-    /// @notice Turns the `params` into an array of `BatchLockup.CreateWithTimestampsLDs` structs.
+    /// @notice Turns the `params` into an array of {BatchLockup.CreateWithTimestampsLDs} structs.
     function fillBatch(
         LockupDynamic.CreateWithTimestamps memory params,
         uint256 batchSize
@@ -170,7 +170,7 @@ library BatchLockupBuilder {
         }
     }
 
-    /// @notice Turns the `params` into an array of `BatchLockup.CreateWithTimestampsLL` structs.
+    /// @notice Turns the `params` into an array of {BatchLockup.CreateWithTimestampsLL} structs.
     function fillBatch(
         LockupLinear.CreateWithTimestamps memory params,
         uint256 batchSize
@@ -207,7 +207,7 @@ library BatchLockupBuilder {
         }
     }
 
-    /// @notice Turns the `params` into an array of `BatchLockup.CreateWithTimestampsLT` structs.
+    /// @notice Turns the `params` into an array of {BatchLockup.CreateWithTimestampsLT} structs.
     function fillBatch(
         LockupTranched.CreateWithTimestamps memory params,
         uint256 batchSize

diff --git a/test/utils/Defaults.sol b/test/utils/Defaults.sol
@@ -119,27 +119,27 @@ contract Defaults is Merkle {
     }
 
     function baseParams() public view returns (MerkleLockup.ConstructorParams memory) {
-        return baseParams(users.admin, asset, MERKLE_ROOT, EXPIRATION);
+        return baseParams(users.admin, asset, EXPIRATION, MERKLE_ROOT);
     }
 
     function baseParams(
         address admin,
         IERC20 asset_,
-        bytes32 merkleRoot,
-        uint40 expiration
+        uint40 expiration,
+        bytes32 merkleRoot
     )
         public
         pure
         returns (MerkleLockup.ConstructorParams memory)
     {
         return MerkleLockup.ConstructorParams({
-            initialAdmin: admin,
             asset: asset_,
+            cancelable: CANCELABLE,
+            expiration: expiration,
+            initialAdmin: admin,
             ipfsCID: IPFS_CID,
-            name: NAME,
             merkleRoot: merkleRoot,
-            expiration: expiration,
-            cancelable: CANCELABLE,
+            name: NAME,
             transferable: TRANSFERABLE
         });
     }
@@ -212,7 +212,7 @@ contract Defaults is Merkle {
         });
     }
 
-    /// @dev Returns a batch of `LockupDynamic.Segment` parameters.
+    /// @dev Returns a batch of {LockupDynamic.Segment} parameters.
     function segments() private view returns (LockupDynamic.Segment[] memory segments_) {
         segments_ = new LockupDynamic.Segment[](2);
         segments_[0] = LockupDynamic.Segment({
@@ -227,12 +227,12 @@ contract Defaults is Merkle {
         });
     }
 
-    /// @dev Returns a batch of `LockupDynamic.SegmentWithDuration` parameters.
+    /// @dev Returns a batch of {LockupDynamic.SegmentWithDuration} parameters.
     function segmentsWithDurations() public pure returns (LockupDynamic.SegmentWithDuration[] memory) {
         return segmentsWithDurations({ amount0: 2500e18, amount1: 7500e18 });
     }
 
-    /// @dev Returns a batch of `LockupDynamic.SegmentWithDuration` parameters.
+    /// @dev Returns a batch of {LockupDynamic.SegmentWithDuration} parameters.
     function segmentsWithDurations(
         uint128 amount0,
         uint128 amount1
@@ -356,12 +356,12 @@ contract Defaults is Merkle {
         }
     }
 
-    /// @dev Returns a batch of `LockupTranched.TrancheWithDuration` parameters.
+    /// @dev Returns a batch of {LockupTranched.TrancheWithDuration} parameters.
     function tranchesWithDurations() public pure returns (LockupTranched.TrancheWithDuration[] memory) {
         return tranchesWithDurations({ amount0: 2500e18, amount1: 7500e18 });
     }
 
-    /// @dev Returns a batch of `LockupTranched.TrancheWithDuration` parameters.
+    /// @dev Returns a batch of {LockupTranched.TrancheWithDuration} parameters.
     function tranchesWithDurations(
         uint128 amount0,
         uint128 amount1
@@ -379,27 +379,27 @@ contract Defaults is Merkle {
                                     BATCH-LOCKUP
     //////////////////////////////////////////////////////////////////////////*/
 
-    /// @dev Returns a default-size batch of `BatchLockup.CreateWithDurationsLD` parameters.
+    /// @dev Returns a default-size batch of {BatchLockup.CreateWithDurationsLD} parameters.
     function batchCreateWithDurationsLD() public view returns (BatchLockup.CreateWithDurationsLD[] memory batch) {
         batch = BatchLockupBuilder.fillBatch(createWithDurationsLD(), BATCH_SIZE);
     }
 
-    /// @dev Returns a default-size batch of `BatchLockup.CreateWithDurationsLL` parameters.
+    /// @dev Returns a default-size batch of {BatchLockup.CreateWithDurationsLL} parameters.
     function batchCreateWithDurationsLL() public view returns (BatchLockup.CreateWithDurationsLL[] memory batch) {
         batch = BatchLockupBuilder.fillBatch(createWithDurationsLL(), BATCH_SIZE);
     }
 
-    /// @dev Returns a default-size batch of `BatchLockup.CreateWithDurationsLT` parameters.
+    /// @dev Returns a default-size batch of {BatchLockup.CreateWithDurationsLT} parameters.
     function batchCreateWithDurationsLT() public view returns (BatchLockup.CreateWithDurationsLT[] memory batch) {
         batch = BatchLockupBuilder.fillBatch(createWithDurationsLT(), BATCH_SIZE);
     }
 
-    /// @dev Returns a default-size batch of `BatchLockup.CreateWithTimestampsLD` parameters.
+    /// @dev Returns a default-size batch of {BatchLockup.CreateWithTimestampsLD} parameters.
     function batchCreateWithTimestampsLD() public view returns (BatchLockup.CreateWithTimestampsLD[] memory batch) {
         batch = batchCreateWithTimestampsLD(BATCH_SIZE);
     }
 
-    /// @dev Returns a batch of `BatchLockup.CreateWithTimestampsLD` parameters.
+    /// @dev Returns a batch of {BatchLockup.CreateWithTimestampsLD} parameters.
     function batchCreateWithTimestampsLD(uint256 batchSize)
         public
         view
@@ -408,12 +408,12 @@ contract Defaults is Merkle {
         batch = BatchLockupBuilder.fillBatch(createWithTimestampsLD(), batchSize);
     }
 
-    /// @dev Returns a default-size batch of `BatchLockup.CreateWithTimestampsLL` parameters.
+    /// @dev Returns a default-size batch of {BatchLockup.CreateWithTimestampsLL} parameters.
     function batchCreateWithTimestampsLL() public view returns (BatchLockup.CreateWithTimestampsLL[] memory batch) {
         batch = batchCreateWithTimestampsLL(BATCH_SIZE);
     }
 
-    /// @dev Returns a batch of `BatchLockup.CreateWithTimestampsLL` parameters.
+    /// @dev Returns a batch of {BatchLockup.CreateWithTimestampsLL} parameters.
     function batchCreateWithTimestampsLL(uint256 batchSize)
         public
         view
@@ -422,12 +422,12 @@ contract Defaults is Merkle {
         batch = BatchLockupBuilder.fillBatch(createWithTimestampsLL(), batchSize);
     }
 
-    /// @dev Returns a default-size batch of `BatchLockup.CreateWithTimestampsLT` parameters.
+    /// @dev Returns a default-size batch of {BatchLockup.CreateWithTimestampsLT} parameters.
     function batchCreateWithTimestampsLT() public view returns (BatchLockup.CreateWithTimestampsLT[] memory batch) {
         batch = batchCreateWithTimestampsLT(BATCH_SIZE);
     }
 
-    /// @dev Returns a batch of `BatchLockup.CreateWithTimestampsLL` parameters.
+    /// @dev Returns a batch of {BatchLockup.CreateWithTimestampsLL} parameters.
     function batchCreateWithTimestampsLT(uint256 batchSize)
         public
         view