diff --git a/tests/Base.t.sol b/tests/Base.t.sol
index 0115d4d2..7527e77e 100644
--- a/tests/Base.t.sol
+++ b/tests/Base.t.sol
@@ -2,9 +2,14 @@
 pragma solidity >=0.8.22 <0.9.0;
 
 import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import { Arrays } from "@openzeppelin/contracts/utils/Arrays.sol";
+import { ud2x18 } from "@prb/math/src/UD2x18.sol";
+import { ud } from "@prb/math/src/UD60x18.sol";
 import { ISablierLockup } from "@sablier/lockup/src/interfaces/ISablierLockup.sol";
 import { LockupNFTDescriptor } from "@sablier/lockup/src/LockupNFTDescriptor.sol";
 import { SablierLockup } from "@sablier/lockup/src/SablierLockup.sol";
+import { LockupTranched } from "@sablier/lockup/src/types/DataTypes.sol";
+import { Merkle } from "murky/src/Merkle.sol";
 import { ISablierMerkleBase } from "src/interfaces/ISablierMerkleBase.sol";
 import { ISablierMerkleFactoryInstant } from "src/interfaces/ISablierMerkleFactoryInstant.sol";
 import { ISablierMerkleFactoryLL } from "src/interfaces/ISablierMerkleFactoryLL.sol";
@@ -26,13 +31,15 @@ import { MerkleInstant, MerkleLL, MerkleLT, MerkleVCA } from "src/types/DataType
 import { ERC20Mock } from "./mocks/erc20/ERC20Mock.sol";
 import { Assertions } from "./utils/Assertions.sol";
 import { Constants } from "./utils/Constants.sol";
-import { Defaults } from "./utils/Defaults.sol";
 import { DeployOptimized } from "./utils/DeployOptimized.sol";
+import { MerkleBuilder } from "./utils/MerkleBuilder.sol";
 import { Modifiers } from "./utils/Modifiers.sol";
 import { Users } from "./utils/Types.sol";
 
 /// @notice Base test contract with common logic needed by all tests.
-abstract contract Base_Test is Assertions, Constants, DeployOptimized, Modifiers {
+abstract contract Base_Test is Assertions, Constants, DeployOptimized, Merkle, Modifiers {
+    using MerkleBuilder for uint256[];
+
     /*//////////////////////////////////////////////////////////////////////////
                                      VARIABLES
     //////////////////////////////////////////////////////////////////////////*/
@@ -44,7 +51,6 @@ abstract contract Base_Test is Assertions, Constants, DeployOptimized, Modifiers
     //////////////////////////////////////////////////////////////////////////*/
 
     ERC20Mock internal dai;
-    Defaults internal defaults;
     ISablierLockup internal lockup;
     ISablierMerkleFactoryInstant internal merkleFactoryInstant;
     ISablierMerkleFactoryLL internal merkleFactoryLL;
@@ -70,9 +76,6 @@ abstract contract Base_Test is Assertions, Constants, DeployOptimized, Modifiers
         users.admin = payable(makeAddr({ name: "Admin" }));
         vm.startPrank({ msgSender: users.admin });
 
-        // Deploy the defaults contract.
-        defaults = new Defaults();
-
         // Deploy the Lockup contract.
         LockupNFTDescriptor nftDescriptor = new LockupNFTDescriptor();
         lockup = new SablierLockup(users.admin, nftDescriptor, 1000);
@@ -90,11 +93,11 @@ abstract contract Base_Test is Assertions, Constants, DeployOptimized, Modifiers
         users.recipient4 = createUser("Recipient4");
         users.sender = createUser("Sender");
 
-        defaults.setUsers(users);
-        defaults.initMerkleTree();
+        // Initialize the Merkle tree.
+        initMerkleTree();
 
         // Set the variables in Modifiers contract.
-        setVariables(defaults, users);
+        setVariables(users);
 
         // Set sender as the default caller for the tests.
         resetPrank({ msgSender: users.sender });
@@ -128,13 +131,13 @@ abstract contract Base_Test is Assertions, Constants, DeployOptimized, Modifiers
     /// @dev Deploys the Merkle Factory contracts conditionally based on the test profile.
     function deployMerkleFactoriesConditionally() internal {
         if (!isTestOptimizedProfile()) {
-            merkleFactoryInstant = new SablierMerkleFactoryInstant(users.admin, defaults.MINIMUM_FEE());
-            merkleFactoryLL = new SablierMerkleFactoryLL(users.admin, defaults.MINIMUM_FEE());
-            merkleFactoryLT = new SablierMerkleFactoryLT(users.admin, defaults.MINIMUM_FEE());
-            merkleFactoryVCA = new SablierMerkleFactoryVCA(users.admin, defaults.MINIMUM_FEE());
+            merkleFactoryInstant = new SablierMerkleFactoryInstant(users.admin, MINIMUM_FEE);
+            merkleFactoryLL = new SablierMerkleFactoryLL(users.admin, MINIMUM_FEE);
+            merkleFactoryLT = new SablierMerkleFactoryLT(users.admin, MINIMUM_FEE);
+            merkleFactoryVCA = new SablierMerkleFactoryVCA(users.admin, MINIMUM_FEE);
         } else {
             (merkleFactoryInstant, merkleFactoryLL, merkleFactoryLT, merkleFactoryVCA) =
-                deployOptimizedMerkleFactories(users.admin, defaults.MINIMUM_FEE());
+                deployOptimizedMerkleFactories(users.admin, MINIMUM_FEE);
         }
         vm.label({ account: address(merkleFactoryInstant), newLabel: "MerkleFactoryInstant" });
         vm.label({ account: address(merkleFactoryLL), newLabel: "MerkleFactoryLL" });
@@ -142,6 +145,43 @@ abstract contract Base_Test is Assertions, Constants, DeployOptimized, Modifiers
         vm.label({ account: address(merkleFactoryVCA), newLabel: "MerkleFactoryVCA" });
     }
 
+    /*//////////////////////////////////////////////////////////////////////////
+                                    MERKLE-BUILDER
+    //////////////////////////////////////////////////////////////////////////*/
+
+    function index1Proof() public view returns (bytes32[] memory) {
+        return indexProof(INDEX1, users.recipient1);
+    }
+
+    function index2Proof() public view returns (bytes32[] memory) {
+        return indexProof(INDEX2, users.recipient2);
+    }
+
+    function index3Proof() public view returns (bytes32[] memory) {
+        return indexProof(INDEX3, users.recipient3);
+    }
+
+    function index4Proof() public view returns (bytes32[] memory) {
+        return indexProof(INDEX4, users.recipient4);
+    }
+
+    function indexProof(uint256 index, address recipient) public view returns (bytes32[] memory) {
+        uint256 leaf = MerkleBuilder.computeLeaf(index, recipient, CLAIM_AMOUNT);
+        uint256 pos = Arrays.findUpperBound(LEAVES, leaf);
+        return getProof(LEAVES.toBytes32(), pos);
+    }
+
+    /// @dev We need a separate function to initialize the Merkle tree because, at the construction time, the users are
+    /// not yet set.
+    function initMerkleTree() public {
+        LEAVES[0] = MerkleBuilder.computeLeaf(INDEX1, users.recipient1, CLAIM_AMOUNT);
+        LEAVES[1] = MerkleBuilder.computeLeaf(INDEX2, users.recipient2, CLAIM_AMOUNT);
+        LEAVES[2] = MerkleBuilder.computeLeaf(INDEX3, users.recipient3, CLAIM_AMOUNT);
+        LEAVES[3] = MerkleBuilder.computeLeaf(INDEX4, users.recipient4, CLAIM_AMOUNT);
+        MerkleBuilder.sortLeaves(LEAVES);
+        MERKLE_ROOT = getRoot(LEAVES.toBytes32());
+    }
+
     /*//////////////////////////////////////////////////////////////////////////
                                 CALL EXPECTS - IERC20
     //////////////////////////////////////////////////////////////////////////*/
@@ -186,33 +226,40 @@ abstract contract Base_Test is Assertions, Constants, DeployOptimized, Modifiers
         vm.expectCall(
             merkleLockup,
             msgValue,
-            abi.encodeCall(
-                ISablierMerkleBase.claim,
-                (defaults.INDEX1(), users.recipient1, defaults.CLAIM_AMOUNT(), defaults.index1Proof())
-            )
+            abi.encodeCall(ISablierMerkleBase.claim, (INDEX1, users.recipient1, CLAIM_AMOUNT, index1Proof()))
         );
     }
 
     /*//////////////////////////////////////////////////////////////////////////
-                                HELPERS - MERKLE LOCKUP
+                                  MERKLE-INSTANT
     //////////////////////////////////////////////////////////////////////////*/
 
+    function computeMerkleInstantAddress(address campaignOwner, uint40 expiration) internal view returns (address) {
+        return computeMerkleInstantAddress({
+            campaignCreator: users.campaignOwner,
+            campaignOwner: campaignOwner,
+            expiration: expiration,
+            merkleRoot: MERKLE_ROOT,
+            tokenAddress: dai
+        });
+    }
+
     function computeMerkleInstantAddress(
         address campaignCreator,
         address campaignOwner,
         uint40 expiration,
         bytes32 merkleRoot,
-        IERC20 token_
+        IERC20 tokenAddress
     )
         internal
         view
         returns (address)
     {
-        MerkleInstant.ConstructorParams memory params = defaults.merkleInstantConstructorParams({
+        MerkleInstant.ConstructorParams memory params = merkleInstantConstructorParams({
             campaignOwner: campaignOwner,
             expiration: expiration,
             merkleRoot: merkleRoot,
-            token_: token_
+            tokenAddress: tokenAddress
         });
 
         bytes32 salt = keccak256(abi.encodePacked(campaignCreator, abi.encode(params)));
@@ -237,23 +284,77 @@ abstract contract Base_Test is Assertions, Constants, DeployOptimized, Modifiers
         });
     }
 
+    function merkleInstantConstructorParams() public view returns (MerkleInstant.ConstructorParams memory) {
+        return merkleInstantConstructorParams(users.campaignOwner, EXPIRATION);
+    }
+
+    function merkleInstantConstructorParams(
+        address campaignOwner,
+        uint40 expiration
+    )
+        public
+        view
+        returns (MerkleInstant.ConstructorParams memory)
+    {
+        return merkleInstantConstructorParams({
+            campaignOwner: campaignOwner,
+            expiration: expiration,
+            merkleRoot: MERKLE_ROOT,
+            tokenAddress: dai
+        });
+    }
+
+    function merkleInstantConstructorParams(
+        address campaignOwner,
+        uint40 expiration,
+        bytes32 merkleRoot,
+        IERC20 tokenAddress
+    )
+        public
+        view
+        returns (MerkleInstant.ConstructorParams memory)
+    {
+        return MerkleInstant.ConstructorParams({
+            campaignName: CAMPAIGN_NAME,
+            expiration: expiration,
+            initialAdmin: campaignOwner,
+            ipfsCID: IPFS_CID,
+            merkleRoot: merkleRoot,
+            token: tokenAddress
+        });
+    }
+
+    /*//////////////////////////////////////////////////////////////////////////
+                                    MERKLE-LL
+    //////////////////////////////////////////////////////////////////////////*/
+
+    function computeMerkleLLAddress(address campaignOwner, uint40 expiration) internal view returns (address) {
+        return computeMerkleLLAddress({
+            campaignCreator: users.campaignOwner,
+            campaignOwner: campaignOwner,
+            expiration: expiration,
+            merkleRoot: MERKLE_ROOT,
+            tokenAddress: dai
+        });
+    }
+
     function computeMerkleLLAddress(
         address campaignCreator,
         address campaignOwner,
         uint40 expiration,
         bytes32 merkleRoot,
-        IERC20 token_
+        IERC20 tokenAddress
     )
         internal
         view
         returns (address)
     {
-        MerkleLL.ConstructorParams memory params = defaults.merkleLLConstructorParams({
+        MerkleLL.ConstructorParams memory params = merkleLLConstructorParams({
             campaignOwner: campaignOwner,
-            lockup: lockup,
+            lockupAddress: lockup,
             expiration: expiration,
             merkleRoot: merkleRoot,
-            token_: token_
+            tokenAddress: tokenAddress
         });
         bytes32 salt = keccak256(abi.encodePacked(campaignCreator, abi.encode(params)));
 
@@ -276,23 +377,90 @@ abstract contract Base_Test is Assertions, Constants, DeployOptimized, Modifiers
         });
     }
 
+    function merkleLLConstructorParams() public view returns (MerkleLL.ConstructorParams memory) {
+        return merkleLLConstructorParams(users.campaignOwner, EXPIRATION);
+    }
+
+    function merkleLLConstructorParams(
+        address campaignOwner,
+        uint40 expiration
+    )
+        public
+        view
+        returns (MerkleLL.ConstructorParams memory)
+    {
+        return merkleLLConstructorParams({
+            campaignOwner: campaignOwner,
+            expiration: expiration,
+            lockupAddress: lockup,
+            merkleRoot: MERKLE_ROOT,
+            tokenAddress: dai
+        });
+    }
+
+    function merkleLLConstructorParams(
+        address campaignOwner,
+        uint40 expiration,
+        ISablierLockup lockupAddress,
+        bytes32 merkleRoot,
+        IERC20 tokenAddress
+    )
+        public
+        view
+        returns (MerkleLL.ConstructorParams memory)
+    {
+        return MerkleLL.ConstructorParams({
+            campaignName: CAMPAIGN_NAME,
+            cancelable: CANCELABLE,
+            expiration: expiration,
+            initialAdmin: campaignOwner,
+            ipfsCID: IPFS_CID,
+            lockup: lockupAddress,
+            merkleRoot: merkleRoot,
+            schedule: MerkleLL.Schedule({
+                startTime: ZERO,
+                startPercentage: START_PERCENTAGE,
+                cliffDuration: CLIFF_DURATION,
+                cliffPercentage: CLIFF_PERCENTAGE,
+                totalDuration: TOTAL_DURATION
+            }),
+            shape: SHAPE,
+            token: tokenAddress,
+            transferable: TRANSFERABLE
+        });
+    }
+
+    /*//////////////////////////////////////////////////////////////////////////
+                                    MERKLE-LT
+    //////////////////////////////////////////////////////////////////////////*/
+
+    function computeMerkleLTAddress(address campaignOwner, uint40 expiration) internal view returns (address) {
+        return computeMerkleLTAddress({
+            campaignCreator: users.campaignOwner,
+            campaignOwner: campaignOwner,
+            expiration: expiration,
+            merkleRoot: MERKLE_ROOT,
+            tokenAddress: dai
+        });
+    }
+
     function computeMerkleLTAddress(
         address campaignCreator,
         address campaignOwner,
         uint40 expiration,
         bytes32 merkleRoot,
-        IERC20 token_
+        IERC20 tokenAddress
     )
         internal
         view
         returns (address)
     {
-        MerkleLT.ConstructorParams memory params = defaults.merkleLTConstructorParams({
+        MerkleLT.ConstructorParams memory params = merkleLTConstructorParams({
             campaignOwner: campaignOwner,
-            lockup: lockup,
+            lockupAddress: lockup,
             expiration: expiration,
             merkleRoot: merkleRoot,
-            token_: token_
+            tokenAddress: tokenAddress
         });
         bytes32 salt = keccak256(abi.encodePacked(campaignCreator, abi.encode(params)));
 
@@ -316,24 +484,124 @@ abstract contract Base_Test is Assertions, Constants, DeployOptimized, Modifiers
         });
     }
 
+    function merkleLTConstructorParams() public view returns (MerkleLT.ConstructorParams memory) {
+        return merkleLTConstructorParams(users.campaignOwner, EXPIRATION);
+    }
+
+    function merkleLTConstructorParams(
+        address campaignOwner,
+        uint40 expiration
+    )
+        public
+        view
+        returns (MerkleLT.ConstructorParams memory)
+    {
+        return merkleLTConstructorParams({
+            campaignOwner: campaignOwner,
+            expiration: expiration,
+            lockupAddress: lockup,
+            merkleRoot: MERKLE_ROOT,
+            tokenAddress: dai
+        });
+    }
+
+    function merkleLTConstructorParams(
+        address campaignOwner,
+        uint40 expiration,
+        ISablierLockup lockupAddress,
+        bytes32 merkleRoot,
+        IERC20 tokenAddress
+    )
+        public
+        view
+        returns (MerkleLT.ConstructorParams memory)
+    {
+        MerkleLT.TrancheWithPercentage[] memory tranchesWithPercentages_ = new MerkleLT.TrancheWithPercentage[](2);
+        tranchesWithPercentages_[0] =
+            MerkleLT.TrancheWithPercentage({ unlockPercentage: ud2x18(0.2e18), duration: 2 days });
+        tranchesWithPercentages_[1] =
+            MerkleLT.TrancheWithPercentage({ unlockPercentage: ud2x18(0.8e18), duration: 8 days });
+
+        return MerkleLT.ConstructorParams({
+            campaignName: CAMPAIGN_NAME,
+            cancelable: CANCELABLE,
+            expiration: expiration,
+            initialAdmin: campaignOwner,
+            ipfsCID: IPFS_CID,
+            lockup: lockupAddress,
+            merkleRoot: merkleRoot,
+            shape: SHAPE,
+            streamStartTime: ZERO,
+            token: tokenAddress,
+            tranchesWithPercentages: tranchesWithPercentages_,
+            transferable: TRANSFERABLE
+        });
+    }
+
+    /// @dev Mirrors the logic from {SablierMerkleLT._calculateStartTimeAndTranches}.
+    function tranchesMerkleLT(
+        uint40 streamStartTime,
+        uint128 totalAmount
+    )
+        public
+        view
+        returns (LockupTranched.Tranche[] memory tranches_)
+    {
+        tranches_ = new LockupTranched.Tranche[](2);
+        if (streamStartTime == 0) {
+            tranches_[0].timestamp = uint40(block.timestamp) + CLIFF_DURATION;
+            tranches_[1].timestamp = uint40(block.timestamp) + TOTAL_DURATION;
+        } else {
+            tranches_[0].timestamp = streamStartTime + CLIFF_DURATION;
+            tranches_[1].timestamp = streamStartTime + TOTAL_DURATION;
+        }
+
+        uint128 amount0 = ud(totalAmount).mul(ud(0.2e18)).intoUint128();
+        uint128 amount1 = ud(totalAmount).mul(ud(0.8e18)).intoUint128();
+
+        tranches_[0].amount = amount0;
+        tranches_[1].amount = amount1;
+
+        uint128 amountsSum = amount0 + amount1;
+
+        if (amountsSum != totalAmount) {
+            tranches_[1].amount += totalAmount - amountsSum;
+        }
+    }
+
+    /*//////////////////////////////////////////////////////////////////////////
+                                    MERKLE-VCA
+    //////////////////////////////////////////////////////////////////////////*/
+
+    function computeMerkleVCAAddress(address campaignOwner, uint40 expiration) internal view returns (address) {
+        return computeMerkleVCAAddress({
+            campaignCreator: users.campaignOwner,
+            campaignOwner: campaignOwner,
+            expiration: expiration,
+            merkleRoot: MERKLE_ROOT,
+            timestamps: merkleVCATimestamps(),
+            tokenAddress: dai
+        });
+    }
+
     function computeMerkleVCAAddress(
         address campaignCreator,
         address campaignOwner,
         uint40 expiration,
         bytes32 merkleRoot,
         MerkleVCA.Timestamps memory timestamps,
-        IERC20 token_
+        IERC20 tokenAddress
     )
         internal
         view
         returns (address)
     {
-        MerkleVCA.ConstructorParams memory params = defaults.merkleVCAConstructorParams({
+        MerkleVCA.ConstructorParams memory params = merkleVCAConstructorParams({
             campaignOwner: campaignOwner,
             expiration: expiration,
             merkleRoot: merkleRoot,
             timestamps: timestamps,
-            token_: token_
+            tokenAddress: tokenAddress
         });
 
         bytes32 salt = keccak256(abi.encodePacked(campaignCreator, abi.encode(params)));
@@ -356,4 +624,51 @@ abstract contract Base_Test is Assertions, Constants, DeployOptimized, Modifiers
             deployer: address(merkleFactoryVCA)
         });
     }
+
+    function merkleVCAConstructorParams() public view returns (MerkleVCA.ConstructorParams memory) {
+        return merkleVCAConstructorParams(users.campaignOwner, EXPIRATION);
+    }
+
+    function merkleVCAConstructorParams(
+        address campaignOwner,
+        uint40 expiration
+    )
+        public
+        view
+        returns (MerkleVCA.ConstructorParams memory)
+    {
+        return merkleVCAConstructorParams({
+            campaignOwner: campaignOwner,
+            expiration: expiration,
+            merkleRoot: MERKLE_ROOT,
+            timestamps: merkleVCATimestamps(),
+            tokenAddress: dai
+        });
+    }
+
+    function merkleVCAConstructorParams(
+        address campaignOwner,
+        uint40 expiration,
+        bytes32 merkleRoot,
+        MerkleVCA.Timestamps memory timestamps,
+        IERC20 tokenAddress
+    )
+        public
+        view
+        returns (MerkleVCA.ConstructorParams memory)
+    {
+        return MerkleVCA.ConstructorParams({
+            campaignName: CAMPAIGN_NAME,
+            expiration: expiration,
+            initialAdmin: campaignOwner,
+            ipfsCID: IPFS_CID,
+            merkleRoot: merkleRoot,
+            timestamps: timestamps,
+            token: tokenAddress
+        });
+    }
+
+    function merkleVCATimestamps() public view returns (MerkleVCA.Timestamps memory) {
+        return MerkleVCA.Timestamps({ start: RANGED_STREAM_START_TIME, end: RANGED_STREAM_END_TIME });
+    }
 }
diff --git a/tests/fork/Fork.t.sol b/tests/fork/Fork.t.sol
index 272a32ec..26faf019 100644
--- a/tests/fork/Fork.t.sol
+++ b/tests/fork/Fork.t.sol
@@ -2,12 +2,11 @@
 pragma solidity >=0.8.22 <0.9.0;
 
 import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import { Merkle } from "murky/src/Merkle.sol";
 
 import { Base_Test } from "../Base.t.sol";
 
 /// @notice Common logic needed by all fork tests.
-abstract contract Fork_Test is Base_Test, Merkle {
+abstract contract Fork_Test is Base_Test {
     /*//////////////////////////////////////////////////////////////////////////
                                   STATE VARIABLES
     //////////////////////////////////////////////////////////////////////////*/
diff --git a/tests/fork/merkle-campaign/MerkleInstant.t.sol b/tests/fork/merkle-campaign/MerkleInstant.t.sol
index 82b9581b..7007161c 100644
--- a/tests/fork/merkle-campaign/MerkleInstant.t.sol
+++ b/tests/fork/merkle-campaign/MerkleInstant.t.sol
@@ -16,7 +16,7 @@ import { Fork_Test } from "./../Fork.t.sol";
 abstract contract MerkleInstant_Fork_Test is Fork_Test {
     using MerkleBuilder for uint256[];
 
-    constructor(IERC20 token_) Fork_Test(token_) { }
+    constructor(IERC20 tokenAddress) Fork_Test(tokenAddress) { }
 
     /// @dev Encapsulates the data needed to compute a Merkle tree leaf.
     struct LeafData {
@@ -112,14 +112,14 @@ abstract contract MerkleInstant_Fork_Test is Fork_Test {
             campaignOwner: params.campaignOwner,
             expiration: params.expiration,
             merkleRoot: vars.merkleRoot,
-            token_: FORK_TOKEN
+            tokenAddress: FORK_TOKEN
         });
 
-        vars.params = defaults.merkleInstantConstructorParams({
+        vars.params = merkleInstantConstructorParams({
             campaignOwner: params.campaignOwner,
             expiration: params.expiration,
             merkleRoot: vars.merkleRoot,
-            token_: FORK_TOKEN
+            tokenAddress: FORK_TOKEN
         });
 
         vm.expectEmit({ emitter: address(merkleFactoryInstant) });
@@ -128,7 +128,7 @@ abstract contract MerkleInstant_Fork_Test is Fork_Test {
             params: vars.params,
             aggregateAmount: vars.aggregateAmount,
             recipientCount: vars.recipientCount,
-            fee: defaults.MINIMUM_FEE()
+            fee: MINIMUM_FEE
         });
 
         vars.merkleInstant =
@@ -180,7 +180,7 @@ abstract contract MerkleInstant_Fork_Test is Fork_Test {
 
         expectCallToClaimWithData({
             merkleLockup: address(vars.merkleInstant),
-            fee: defaults.MINIMUM_FEE(),
+            fee: MINIMUM_FEE,
             index: vars.indexes[params.posBeforeSort],
             recipient: vars.recipients[params.posBeforeSort],
             amount: vars.amounts[params.posBeforeSort],
@@ -193,7 +193,7 @@ abstract contract MerkleInstant_Fork_Test is Fork_Test {
             value: vars.amounts[params.posBeforeSort]
         });
 
-        vars.merkleInstant.claim{ value: defaults.MINIMUM_FEE() }({
+        vars.merkleInstant.claim{ value: MINIMUM_FEE }({
             index: vars.indexes[params.posBeforeSort],
             recipient: vars.recipients[params.posBeforeSort],
             amount: vars.amounts[params.posBeforeSort],
@@ -231,11 +231,11 @@ abstract contract MerkleInstant_Fork_Test is Fork_Test {
         emit ISablierMerkleFactoryBase.CollectFees({
             admin: factoryAdmin,
             merkleBase: vars.merkleInstant,
-            feeAmount: defaults.MINIMUM_FEE()
+            feeAmount: MINIMUM_FEE
         });
         merkleFactoryInstant.collectFees({ merkleBase: vars.merkleInstant });
 
         assertEq(address(vars.merkleInstant).balance, 0, "merkleInstant ETH balance");
-        assertEq(factoryAdmin.balance, initialAdminBalance + defaults.MINIMUM_FEE(), "admin ETH balance");
+        assertEq(factoryAdmin.balance, initialAdminBalance + MINIMUM_FEE, "admin ETH balance");
     }
 }
diff --git a/tests/fork/merkle-campaign/MerkleLL.t.sol b/tests/fork/merkle-campaign/MerkleLL.t.sol
index 3b8cd3a7..f5bc8215 100644
--- a/tests/fork/merkle-campaign/MerkleLL.t.sol
+++ b/tests/fork/merkle-campaign/MerkleLL.t.sol
@@ -19,7 +19,7 @@ import { Fork_Test } from "./../Fork.t.sol";
 abstract contract MerkleLL_Fork_Test is Fork_Test {
     using MerkleBuilder for uint256[];
 
-    constructor(IERC20 token_) Fork_Test(token_) { }
+    constructor(IERC20 tokenAddress) Fork_Test(tokenAddress) { }
 
     /// @dev Encapsulates the data needed to compute a Merkle tree leaf.
     struct LeafData {
@@ -117,15 +117,15 @@ abstract contract MerkleLL_Fork_Test is Fork_Test {
             campaignOwner: params.campaignOwner,
             expiration: params.expiration,
             merkleRoot: vars.merkleRoot,
-            token_: FORK_TOKEN
+            tokenAddress: FORK_TOKEN
         });
 
-        vars.params = defaults.merkleLLConstructorParams({
+        vars.params = merkleLLConstructorParams({
             campaignOwner: params.campaignOwner,
             expiration: params.expiration,
-            lockup: lockup,
+            lockupAddress: lockup,
             merkleRoot: vars.merkleRoot,
-            token_: FORK_TOKEN
+            tokenAddress: FORK_TOKEN
         });
 
         vm.expectEmit({ emitter: address(merkleFactoryLL) });
@@ -134,7 +134,7 @@ abstract contract MerkleLL_Fork_Test is Fork_Test {
             params: vars.params,
             aggregateAmount: vars.aggregateAmount,
             recipientCount: vars.recipientCount,
-            fee: defaults.MINIMUM_FEE()
+            fee: MINIMUM_FEE
         });
 
         vars.merkleLL = merkleFactoryLL.createMerkleLL(vars.params, vars.aggregateAmount, vars.recipientCount);
@@ -184,14 +184,14 @@ abstract contract MerkleLL_Fork_Test is Fork_Test {
 
         expectCallToClaimWithData({
             merkleLockup: address(vars.merkleLL),
-            fee: defaults.MINIMUM_FEE(),
+            fee: MINIMUM_FEE,
             index: vars.indexes[params.posBeforeSort],
             recipient: vars.recipients[params.posBeforeSort],
             amount: vars.amounts[params.posBeforeSort],
             merkleProof: vars.merkleProof
         });
 
-        vars.merkleLL.claim{ value: defaults.MINIMUM_FEE() }({
+        vars.merkleLL.claim{ value: MINIMUM_FEE }({
             index: vars.indexes[params.posBeforeSort],
             recipient: vars.recipients[params.posBeforeSort],
             amount: vars.amounts[params.posBeforeSort],
@@ -199,18 +199,16 @@ abstract contract MerkleLL_Fork_Test is Fork_Test {
         });
 
         vars.expectedUnlockAmounts.start =
-            ud60x18(vars.amounts[params.posBeforeSort]).mul(defaults.START_PERCENTAGE().intoUD60x18()).intoUint128();
+            ud60x18(vars.amounts[params.posBeforeSort]).mul(START_PERCENTAGE.intoUD60x18()).intoUint128();
         vars.expectedUnlockAmounts.cliff =
-            ud60x18(vars.amounts[params.posBeforeSort]).mul(defaults.CLIFF_PERCENTAGE().intoUD60x18()).intoUint128();
+            ud60x18(vars.amounts[params.posBeforeSort]).mul(CLIFF_PERCENTAGE.intoUD60x18()).intoUint128();
 
         // Assert that the stream has been created successfully.
-        assertEq(
-            lockup.getCliffTime(vars.expectedStreamId), getBlockTimestamp() + defaults.CLIFF_DURATION(), "cliff time"
-        );
+        assertEq(lockup.getCliffTime(vars.expectedStreamId), getBlockTimestamp() + CLIFF_DURATION, "cliff time");
         assertEq(
             lockup.getDepositedAmount(vars.expectedStreamId), vars.amounts[params.posBeforeSort], "deposited amount"
         );
-        assertEq(lockup.getEndTime(vars.expectedStreamId), getBlockTimestamp() + defaults.TOTAL_DURATION(), "end time");
+        assertEq(lockup.getEndTime(vars.expectedStreamId), getBlockTimestamp() + TOTAL_DURATION, "end time");
         assertEq(lockup.getLockupModel(vars.expectedStreamId), Lockup.Model.LOCKUP_LINEAR);
         assertEq(lockup.getRecipient(vars.expectedStreamId), vars.recipients[params.posBeforeSort], "recipient");
         assertEq(lockup.getRefundedAmount(vars.expectedStreamId), 0, "refunded amount");
@@ -228,10 +226,10 @@ abstract contract MerkleLL_Fork_Test is Fork_Test {
             "unlock amounts start"
         );
         assertEq(lockup.getWithdrawnAmount(vars.expectedStreamId), 0, "withdrawn amount");
-        assertEq(lockup.isCancelable(vars.expectedStreamId), defaults.CANCELABLE(), "is cancelable");
+        assertEq(lockup.isCancelable(vars.expectedStreamId), CANCELABLE, "is cancelable");
         assertEq(lockup.isDepleted(vars.expectedStreamId), false, "is depleted");
         assertEq(lockup.isStream(vars.expectedStreamId), true, "is stream");
-        assertEq(lockup.isTransferable(vars.expectedStreamId), defaults.TRANSFERABLE(), "is transferable");
+        assertEq(lockup.isTransferable(vars.expectedStreamId), TRANSFERABLE, "is transferable");
         assertEq(lockup.wasCanceled(vars.expectedStreamId), false, "was canceled");
 
         assertTrue(vars.merkleLL.hasClaimed(vars.indexes[params.posBeforeSort]));
@@ -265,11 +263,11 @@ abstract contract MerkleLL_Fork_Test is Fork_Test {
         emit ISablierMerkleFactoryBase.CollectFees({
             admin: factoryAdmin,
             merkleBase: vars.merkleLL,
-            feeAmount: defaults.MINIMUM_FEE()
+            feeAmount: MINIMUM_FEE
         });
         merkleFactoryLL.collectFees({ merkleBase: vars.merkleLL });
 
         assertEq(address(vars.merkleLL).balance, 0, "merkleLL ETH balance");
-        assertEq(factoryAdmin.balance, initialAdminBalance + defaults.MINIMUM_FEE(), "admin ETH balance");
+        assertEq(factoryAdmin.balance, initialAdminBalance + MINIMUM_FEE, "admin ETH balance");
     }
 }
diff --git a/tests/fork/merkle-campaign/MerkleLT.t.sol b/tests/fork/merkle-campaign/MerkleLT.t.sol
index 82f34975..f943ed6b 100644
--- a/tests/fork/merkle-campaign/MerkleLT.t.sol
+++ b/tests/fork/merkle-campaign/MerkleLT.t.sol
@@ -17,7 +17,7 @@ import { Fork_Test } from "./../Fork.t.sol";
 abstract contract MerkleLT_Fork_Test is Fork_Test {
     using MerkleBuilder for uint256[];
 
-    constructor(IERC20 token_) Fork_Test(token_) { }
+    constructor(IERC20 tokenAddress) Fork_Test(tokenAddress) { }
 
     /// @dev Encapsulates the data needed to compute a Merkle tree leaf.
     struct LeafData {
@@ -115,15 +115,15 @@ abstract contract MerkleLT_Fork_Test is Fork_Test {
             campaignOwner: params.campaignOwner,
             expiration: params.expiration,
             merkleRoot: vars.merkleRoot,
-            token_: FORK_TOKEN
+            tokenAddress: FORK_TOKEN
         });
 
-        vars.params = defaults.merkleLTConstructorParams({
+        vars.params = merkleLTConstructorParams({
             campaignOwner: params.campaignOwner,
             expiration: params.expiration,
-            lockup: lockup,
+            lockupAddress: lockup,
             merkleRoot: vars.merkleRoot,
-            token_: FORK_TOKEN
+            tokenAddress: FORK_TOKEN
         });
 
         vm.expectEmit({ emitter: address(merkleFactoryLT) });
@@ -132,8 +132,8 @@ abstract contract MerkleLT_Fork_Test is Fork_Test {
             params: vars.params,
             aggregateAmount: vars.aggregateAmount,
             recipientCount: vars.recipientCount,
-            totalDuration: defaults.TOTAL_DURATION(),
-            fee: defaults.MINIMUM_FEE()
+            totalDuration: TOTAL_DURATION,
+            fee: MINIMUM_FEE
         });
 
         vars.merkleLT = merkleFactoryLT.createMerkleLT(vars.params, vars.aggregateAmount, vars.recipientCount);
@@ -182,14 +182,14 @@ abstract contract MerkleLT_Fork_Test is Fork_Test {
 
         expectCallToClaimWithData({
             merkleLockup: address(vars.merkleLT),
-            fee: defaults.MINIMUM_FEE(),
+            fee: MINIMUM_FEE,
             index: vars.indexes[params.posBeforeSort],
             recipient: vars.recipients[params.posBeforeSort],
             amount: vars.amounts[params.posBeforeSort],
             merkleProof: vars.merkleProof
         });
 
-        vars.merkleLT.claim{ value: defaults.MINIMUM_FEE() }({
+        vars.merkleLT.claim{ value: MINIMUM_FEE }({
             index: vars.indexes[params.posBeforeSort],
             recipient: vars.recipients[params.posBeforeSort],
             amount: vars.amounts[params.posBeforeSort],
@@ -200,7 +200,7 @@ abstract contract MerkleLT_Fork_Test is Fork_Test {
         assertEq(
             lockup.getDepositedAmount(vars.expectedStreamId), vars.amounts[params.posBeforeSort], "deposited amount"
         );
-        assertEq(lockup.getEndTime(vars.expectedStreamId), getBlockTimestamp() + defaults.TOTAL_DURATION(), "end time");
+        assertEq(lockup.getEndTime(vars.expectedStreamId), getBlockTimestamp() + TOTAL_DURATION, "end time");
         assertEq(lockup.getLockupModel(vars.expectedStreamId), Lockup.Model.LOCKUP_TRANCHED);
         assertEq(lockup.getRecipient(vars.expectedStreamId), vars.recipients[params.posBeforeSort], "recipient");
         assertEq(lockup.getRefundedAmount(vars.expectedStreamId), 0, "refunded amount");
@@ -208,14 +208,14 @@ abstract contract MerkleLT_Fork_Test is Fork_Test {
         assertEq(lockup.getStartTime(vars.expectedStreamId), getBlockTimestamp(), "start time");
         assertEq(
             lockup.getTranches(vars.expectedStreamId),
-            defaults.tranchesMerkleLT({ streamStartTime: ZERO, totalAmount: vars.amounts[params.posBeforeSort] })
+            tranchesMerkleLT({ streamStartTime: ZERO, totalAmount: vars.amounts[params.posBeforeSort] })
         );
         assertEq(lockup.getUnderlyingToken(vars.expectedStreamId), FORK_TOKEN, "token");
         assertEq(lockup.getWithdrawnAmount(vars.expectedStreamId), 0, "withdrawn amount");
-        assertEq(lockup.isCancelable(vars.expectedStreamId), defaults.CANCELABLE(), "is cancelable");
+        assertEq(lockup.isCancelable(vars.expectedStreamId), CANCELABLE, "is cancelable");
         assertEq(lockup.isDepleted(vars.expectedStreamId), false, "is depleted");
         assertEq(lockup.isStream(vars.expectedStreamId), true, "is stream");
-        assertEq(lockup.isTransferable(vars.expectedStreamId), defaults.TRANSFERABLE(), "is transferable");
+        assertEq(lockup.isTransferable(vars.expectedStreamId), TRANSFERABLE, "is transferable");
         assertEq(lockup.wasCanceled(vars.expectedStreamId), false, "was canceled");
 
         assertTrue(vars.merkleLT.hasClaimed(vars.indexes[params.posBeforeSort]));
@@ -250,11 +250,11 @@ abstract contract MerkleLT_Fork_Test is Fork_Test {
         emit ISablierMerkleFactoryBase.CollectFees({
             admin: factoryAdmin,
             merkleBase: vars.merkleLT,
-            feeAmount: defaults.MINIMUM_FEE()
+            feeAmount: MINIMUM_FEE
         });
         merkleFactoryLT.collectFees({ merkleBase: vars.merkleLT });
 
         assertEq(address(vars.merkleLT).balance, 0, "merkleLT ETH balance");
-        assertEq(factoryAdmin.balance, initialAdminBalance + defaults.MINIMUM_FEE(), "admin ETH balance");
+        assertEq(factoryAdmin.balance, initialAdminBalance + MINIMUM_FEE, "admin ETH balance");
     }
 }
diff --git a/tests/fork/merkle-campaign/MerkleVCA.t.sol b/tests/fork/merkle-campaign/MerkleVCA.t.sol
index 9ffcf72b..07a040ff 100644
--- a/tests/fork/merkle-campaign/MerkleVCA.t.sol
+++ b/tests/fork/merkle-campaign/MerkleVCA.t.sol
@@ -16,7 +16,7 @@ import { Fork_Test } from "./../Fork.t.sol";
 abstract contract MerkleVCA_Fork_Test is Fork_Test {
     using MerkleBuilder for uint256[];
 
-    constructor(IERC20 token_) Fork_Test(token_) { }
+    constructor(IERC20 tokenAddress) Fork_Test(tokenAddress) { }
 
     /// @dev Encapsulates the data needed to compute a Merkle tree leaf.
     struct LeafData {
@@ -124,15 +124,15 @@ abstract contract MerkleVCA_Fork_Test is Fork_Test {
             expiration: params.expiration,
             merkleRoot: vars.merkleRoot,
             timestamps: params.timestamps,
-            token_: FORK_TOKEN
+            tokenAddress: FORK_TOKEN
         });
 
-        vars.params = defaults.merkleVCAConstructorParams({
+        vars.params = merkleVCAConstructorParams({
             campaignOwner: params.campaignOwner,
             expiration: params.expiration,
             merkleRoot: vars.merkleRoot,
             timestamps: params.timestamps,
-            token_: FORK_TOKEN
+            tokenAddress: FORK_TOKEN
         });
 
         vm.expectEmit({ emitter: address(merkleFactoryVCA) });
@@ -141,7 +141,7 @@ abstract contract MerkleVCA_Fork_Test is Fork_Test {
             params: vars.params,
             aggregateAmount: vars.aggregateAmount,
             recipientCount: vars.recipientCount,
-            fee: defaults.MINIMUM_FEE()
+            fee: MINIMUM_FEE
         });
 
         vars.merkleVCA = merkleFactoryVCA.createMerkleVCA(vars.params, vars.aggregateAmount, vars.recipientCount);
@@ -198,7 +198,7 @@ abstract contract MerkleVCA_Fork_Test is Fork_Test {
 
         expectCallToClaimWithData({
             merkleLockup: address(vars.merkleVCA),
-            fee: defaults.MINIMUM_FEE(),
+            fee: MINIMUM_FEE,
             index: vars.indexes[params.posBeforeSort],
             recipient: vars.recipients[params.posBeforeSort],
             amount: vars.amounts[params.posBeforeSort],
@@ -211,7 +211,7 @@ abstract contract MerkleVCA_Fork_Test is Fork_Test {
             value: vars.claimableAmount
         });
 
-        vars.merkleVCA.claim{ value: defaults.MINIMUM_FEE() }({
+        vars.merkleVCA.claim{ value: MINIMUM_FEE }({
             index: vars.indexes[params.posBeforeSort],
             recipient: vars.recipients[params.posBeforeSort],
             amount: vars.amounts[params.posBeforeSort],
@@ -250,11 +250,11 @@ abstract contract MerkleVCA_Fork_Test is Fork_Test {
         emit ISablierMerkleFactoryBase.CollectFees({
             admin: factoryAdmin,
             merkleBase: vars.merkleVCA,
-            feeAmount: defaults.MINIMUM_FEE()
+            feeAmount: MINIMUM_FEE
         });
         merkleFactoryVCA.collectFees({ merkleBase: vars.merkleVCA });
 
         assertEq(address(vars.merkleVCA).balance, 0, "merkleVCA ETH balance");
-        assertEq(factoryAdmin.balance, initialAdminBalance + defaults.MINIMUM_FEE(), "admin ETH balance");
+        assertEq(factoryAdmin.balance, initialAdminBalance + MINIMUM_FEE, "admin ETH balance");
     }
 }
diff --git a/tests/integration/Integration.t.sol b/tests/integration/Integration.t.sol
index 7d0176cc..f796270a 100644
--- a/tests/integration/Integration.t.sol
+++ b/tests/integration/Integration.t.sol
@@ -48,10 +48,10 @@ contract Integration_Test is Base_Test {
         merkleVCA = createMerkleVCA();
 
         // Fund the contracts.
-        deal({ token: address(dai), to: address(merkleInstant), give: defaults.AGGREGATE_AMOUNT() });
-        deal({ token: address(dai), to: address(merkleLL), give: defaults.AGGREGATE_AMOUNT() });
-        deal({ token: address(dai), to: address(merkleLT), give: defaults.AGGREGATE_AMOUNT() });
-        deal({ token: address(dai), to: address(merkleVCA), give: defaults.AGGREGATE_AMOUNT() });
+        deal({ token: address(dai), to: address(merkleInstant), give: AGGREGATE_AMOUNT });
+        deal({ token: address(dai), to: address(merkleLL), give: AGGREGATE_AMOUNT });
+        deal({ token: address(dai), to: address(merkleLT), give: AGGREGATE_AMOUNT });
+        deal({ token: address(dai), to: address(merkleVCA), give: AGGREGATE_AMOUNT });
     }
 
     /*//////////////////////////////////////////////////////////////////////////
@@ -59,11 +59,11 @@ contract Integration_Test is Base_Test {
     //////////////////////////////////////////////////////////////////////////*/
 
     function claim() internal {
-        merkleBase.claim{ value: defaults.MINIMUM_FEE() }({
-            index: defaults.INDEX1(),
+        merkleBase.claim{ value: MINIMUM_FEE }({
+            index: INDEX1,
             recipient: users.recipient1,
-            amount: defaults.CLAIM_AMOUNT(),
-            merkleProof: defaults.index1Proof()
+            amount: CLAIM_AMOUNT,
+            merkleProof: index1Proof()
         });
     }
 
@@ -71,22 +71,12 @@ contract Integration_Test is Base_Test {
                                     MERKLE-INSTANT
     //////////////////////////////////////////////////////////////////////////*/
 
-    function computeMerkleInstantAddress(address campaignOwner, uint40 expiration) internal view returns (address) {
-        return computeMerkleInstantAddress({
-            campaignCreator: users.campaignOwner,
-            campaignOwner: campaignOwner,
-            expiration: expiration,
-            merkleRoot: defaults.MERKLE_ROOT(),
-            token_: dai
-        });
-    }
-
     function createMerkleInstant() internal returns (ISablierMerkleInstant) {
-        return createMerkleInstant(users.campaignOwner, defaults.EXPIRATION());
+        return createMerkleInstant(users.campaignOwner, EXPIRATION);
     }
 
     function createMerkleInstant(address campaignOwner) internal returns (ISablierMerkleInstant) {
-        return createMerkleInstant(campaignOwner, defaults.EXPIRATION());
+        return createMerkleInstant(campaignOwner, EXPIRATION);
     }
 
     function createMerkleInstant(uint40 expiration) internal returns (ISablierMerkleInstant) {
@@ -95,57 +85,27 @@ contract Integration_Test is Base_Test {
 
     function createMerkleInstant(address campaignOwner, uint40 expiration) internal returns (ISablierMerkleInstant) {
         return merkleFactoryInstant.createMerkleInstant(
-            defaults.merkleInstantConstructorParams({
+            merkleInstantConstructorParams({
                 campaignOwner: campaignOwner,
                 expiration: expiration,
-                merkleRoot: defaults.MERKLE_ROOT(),
-                token_: dai
+                merkleRoot: MERKLE_ROOT,
+                tokenAddress: dai
             }),
-            defaults.AGGREGATE_AMOUNT(),
-            defaults.RECIPIENT_COUNT()
+            AGGREGATE_AMOUNT,
+            RECIPIENT_COUNT
         );
     }
 
-    function merkleInstantConstructorParams() public view returns (MerkleInstant.ConstructorParams memory) {
-        return merkleInstantConstructorParams(users.campaignOwner, defaults.EXPIRATION());
-    }
-
-    function merkleInstantConstructorParams(
-        address campaignOwner,
-        uint40 expiration
-    )
-        public
-        view
-        returns (MerkleInstant.ConstructorParams memory)
-    {
-        return defaults.merkleInstantConstructorParams({
-            campaignOwner: campaignOwner,
-            expiration: expiration,
-            merkleRoot: defaults.MERKLE_ROOT(),
-            token_: dai
-        });
-    }
-
     /*//////////////////////////////////////////////////////////////////////////
                                     MERKLE-LL
     //////////////////////////////////////////////////////////////////////////*/
 
-    function computeMerkleLLAddress(address campaignOwner, uint40 expiration) internal view returns (address) {
-        return computeMerkleLLAddress({
-            campaignCreator: users.campaignOwner,
-            campaignOwner: campaignOwner,
-            expiration: expiration,
-            merkleRoot: defaults.MERKLE_ROOT(),
-            token_: dai
-        });
-    }
-
     function createMerkleLL() internal returns (ISablierMerkleLL) {
-        return createMerkleLL(users.campaignOwner, defaults.EXPIRATION());
+        return createMerkleLL(users.campaignOwner, EXPIRATION);
     }
 
     function createMerkleLL(address campaignOwner) internal returns (ISablierMerkleLL) {
-        return createMerkleLL(campaignOwner, defaults.EXPIRATION());
+        return createMerkleLL(campaignOwner, EXPIRATION);
     }
 
     function createMerkleLL(uint40 expiration) internal returns (ISablierMerkleLL) {
@@ -154,59 +114,28 @@ contract Integration_Test is Base_Test {
 
     function createMerkleLL(address campaignOwner, uint40 expiration) internal returns (ISablierMerkleLL) {
         return merkleFactoryLL.createMerkleLL(
-            defaults.merkleLLConstructorParams({
+            merkleLLConstructorParams({
                 campaignOwner: campaignOwner,
                 expiration: expiration,
-                lockup: lockup,
-                merkleRoot: defaults.MERKLE_ROOT(),
-                token_: dai
+                lockupAddress: lockup,
+                merkleRoot: MERKLE_ROOT,
+                tokenAddress: dai
             }),
-            defaults.AGGREGATE_AMOUNT(),
-            defaults.RECIPIENT_COUNT()
+            AGGREGATE_AMOUNT,
+            RECIPIENT_COUNT
         );
     }
 
-    function merkleLLConstructorParams() public view returns (MerkleLL.ConstructorParams memory) {
-        return merkleLLConstructorParams(users.campaignOwner, defaults.EXPIRATION());
-    }
-
-    function merkleLLConstructorParams(
-        address campaignOwner,
-        uint40 expiration
-    )
-        public
-        view
-        returns (MerkleLL.ConstructorParams memory)
-    {
-        return defaults.merkleLLConstructorParams({
-            campaignOwner: campaignOwner,
-            expiration: expiration,
-            lockup: lockup,
-            merkleRoot: defaults.MERKLE_ROOT(),
-            token_: dai
-        });
-    }
-
     /*//////////////////////////////////////////////////////////////////////////
                                     MERKLE-LT
     //////////////////////////////////////////////////////////////////////////*/
 
-    function computeMerkleLTAddress(address campaignOwner, uint40 expiration) internal view returns (address) {
-        return computeMerkleLTAddress({
-            campaignCreator: users.campaignOwner,
-            campaignOwner: campaignOwner,
-            expiration: expiration,
-            merkleRoot: defaults.MERKLE_ROOT(),
-            token_: dai
-        });
-    }
-
     function createMerkleLT() internal returns (ISablierMerkleLT) {
-        return createMerkleLT(users.campaignOwner, defaults.EXPIRATION());
+        return createMerkleLT(users.campaignOwner, EXPIRATION);
     }
 
     function createMerkleLT(address campaignOwner) internal returns (ISablierMerkleLT) {
-        return createMerkleLT(campaignOwner, defaults.EXPIRATION());
+        return createMerkleLT(campaignOwner, EXPIRATION);
     }
 
     function createMerkleLT(uint40 expiration) internal returns (ISablierMerkleLT) {
@@ -215,60 +144,28 @@ contract Integration_Test is Base_Test {
 
     function createMerkleLT(address campaignOwner, uint40 expiration) internal returns (ISablierMerkleLT) {
         return merkleFactoryLT.createMerkleLT(
-            defaults.merkleLTConstructorParams({
+            merkleLTConstructorParams({
                 campaignOwner: campaignOwner,
                 expiration: expiration,
-                lockup: lockup,
-                merkleRoot: defaults.MERKLE_ROOT(),
-                token_: dai
+                lockupAddress: lockup,
+                merkleRoot: MERKLE_ROOT,
+                tokenAddress: dai
             }),
-            defaults.AGGREGATE_AMOUNT(),
-            defaults.RECIPIENT_COUNT()
+            AGGREGATE_AMOUNT,
+            RECIPIENT_COUNT
         );
     }
 
-    function merkleLTConstructorParams() public view returns (MerkleLT.ConstructorParams memory) {
-        return merkleLTConstructorParams(users.campaignOwner, defaults.EXPIRATION());
-    }
-
-    function merkleLTConstructorParams(
-        address campaignOwner,
-        uint40 expiration
-    )
-        public
-        view
-        returns (MerkleLT.ConstructorParams memory)
-    {
-        return defaults.merkleLTConstructorParams({
-            campaignOwner: campaignOwner,
-            expiration: expiration,
-            lockup: lockup,
-            merkleRoot: defaults.MERKLE_ROOT(),
-            token_: dai
-        });
-    }
-
     /*//////////////////////////////////////////////////////////////////////////
                                     MERKLE-VCA
     //////////////////////////////////////////////////////////////////////////*/
 
-    function computeMerkleVCAAddress(address campaignOwner, uint40 expiration) internal view returns (address) {
-        return computeMerkleVCAAddress({
-            campaignCreator: users.campaignOwner,
-            campaignOwner: campaignOwner,
-            expiration: expiration,
-            merkleRoot: defaults.MERKLE_ROOT(),
-            timestamps: defaults.merkleVCATimestamps(),
-            token_: dai
-        });
-    }
-
     function createMerkleVCA() internal returns (ISablierMerkleVCA) {
-        return createMerkleVCA(users.campaignOwner, defaults.EXPIRATION());
+        return createMerkleVCA(users.campaignOwner, EXPIRATION);
     }
 
     function createMerkleVCA(address campaignOwner) internal returns (ISablierMerkleVCA) {
-        return createMerkleVCA(campaignOwner, defaults.EXPIRATION());
+        return createMerkleVCA(campaignOwner, EXPIRATION);
     }
 
     function createMerkleVCA(uint40 expiration) internal returns (ISablierMerkleVCA) {
@@ -277,36 +174,15 @@ contract Integration_Test is Base_Test {
 
     function createMerkleVCA(address campaignOwner, uint40 expiration) internal returns (ISablierMerkleVCA) {
         return merkleFactoryVCA.createMerkleVCA(
-            defaults.merkleVCAConstructorParams({
+            merkleVCAConstructorParams({
                 campaignOwner: campaignOwner,
                 expiration: expiration,
-                merkleRoot: defaults.MERKLE_ROOT(),
-                timestamps: defaults.merkleVCATimestamps(),
-                token_: dai
+                merkleRoot: MERKLE_ROOT,
+                timestamps: merkleVCATimestamps(),
+                tokenAddress: dai
             }),
-            defaults.AGGREGATE_AMOUNT(),
-            defaults.RECIPIENT_COUNT()
+            AGGREGATE_AMOUNT,
+            RECIPIENT_COUNT
         );
     }
-
-    function merkleVCAConstructorParams() public view returns (MerkleVCA.ConstructorParams memory) {
-        return merkleVCAConstructorParams(users.campaignOwner, defaults.EXPIRATION());
-    }
-
-    function merkleVCAConstructorParams(
-        address campaignOwner,
-        uint40 expiration
-    )
-        public
-        view
-        returns (MerkleVCA.ConstructorParams memory)
-    {
-        return defaults.merkleVCAConstructorParams({
-            campaignOwner: campaignOwner,
-            expiration: expiration,
-            merkleRoot: defaults.MERKLE_ROOT(),
-            timestamps: defaults.merkleVCATimestamps(),
-            token_: dai
-        });
-    }
 }
diff --git a/tests/integration/concrete/campaign/instant/claim/claim.t.sol b/tests/integration/concrete/campaign/instant/claim/claim.t.sol
index 176e5c51..7f1b5503 100644
--- a/tests/integration/concrete/campaign/instant/claim/claim.t.sol
+++ b/tests/integration/concrete/campaign/instant/claim/claim.t.sol
@@ -24,14 +24,14 @@ contract Claim_MerkleInstant_Integration_Test is Claim_Integration_Test, MerkleI
         uint256 previousFeeAccrued = address(merkleInstant).balance;
 
         vm.expectEmit({ emitter: address(merkleInstant) });
-        emit ISablierMerkleInstant.Claim(defaults.INDEX1(), users.recipient1, defaults.CLAIM_AMOUNT());
+        emit ISablierMerkleInstant.Claim(INDEX1, users.recipient1, CLAIM_AMOUNT);
 
-        expectCallToTransfer({ to: users.recipient1, value: defaults.CLAIM_AMOUNT() });
-        expectCallToClaimWithMsgValue(address(merkleInstant), defaults.MINIMUM_FEE());
+        expectCallToTransfer({ to: users.recipient1, value: CLAIM_AMOUNT });
+        expectCallToClaimWithMsgValue(address(merkleInstant), MINIMUM_FEE);
         claim();
 
-        assertTrue(merkleInstant.hasClaimed(defaults.INDEX1()), "not claimed");
+        assertTrue(merkleInstant.hasClaimed(INDEX1), "not claimed");
 
-        assertEq(address(merkleInstant).balance, previousFeeAccrued + defaults.MINIMUM_FEE(), "fee collected");
+        assertEq(address(merkleInstant).balance, previousFeeAccrued + MINIMUM_FEE, "fee collected");
     }
 }
diff --git a/tests/integration/concrete/campaign/instant/constructor.t.sol b/tests/integration/concrete/campaign/instant/constructor.t.sol
index 9eac793e..f7892afc 100644
--- a/tests/integration/concrete/campaign/instant/constructor.t.sol
+++ b/tests/integration/concrete/campaign/instant/constructor.t.sol
@@ -14,12 +14,12 @@ contract Constructor_MerkleInstant_Integration_Test is MerkleInstant_Integration
             new SablierMerkleInstant(merkleInstantConstructorParams(), users.campaignOwner);
 
         assertEq(constructedInstant.admin(), users.campaignOwner, "admin");
-        assertEq(constructedInstant.campaignName(), defaults.CAMPAIGN_NAME(), "campaign name");
-        assertEq(constructedInstant.EXPIRATION(), defaults.EXPIRATION(), "expiration");
+        assertEq(constructedInstant.campaignName(), CAMPAIGN_NAME, "campaign name");
+        assertEq(constructedInstant.EXPIRATION(), EXPIRATION, "expiration");
         assertEq(constructedInstant.FACTORY(), address(merkleFactoryInstant), "factory");
-        assertEq(constructedInstant.MINIMUM_FEE(), defaults.MINIMUM_FEE(), "minimum fee");
-        assertEq(constructedInstant.ipfsCID(), defaults.IPFS_CID(), "ipfsCID");
-        assertEq(constructedInstant.MERKLE_ROOT(), defaults.MERKLE_ROOT(), "merkleRoot");
+        assertEq(constructedInstant.MINIMUM_FEE(), MINIMUM_FEE, "minimum fee");
+        assertEq(constructedInstant.ipfsCID(), IPFS_CID, "ipfsCID");
+        assertEq(constructedInstant.MERKLE_ROOT(), MERKLE_ROOT, "merkleRoot");
         assertEq(address(constructedInstant.TOKEN()), address(dai), "token");
     }
 }
diff --git a/tests/integration/concrete/campaign/ll/claim/claim.t.sol b/tests/integration/concrete/campaign/ll/claim/claim.t.sol
index 9198d8b5..e07990d7 100644
--- a/tests/integration/concrete/campaign/ll/claim/claim.t.sol
+++ b/tests/integration/concrete/campaign/ll/claim/claim.t.sol
@@ -17,36 +17,31 @@ contract Claim_MerkleLL_Integration_Test is Claim_Integration_Test, MerkleLL_Int
     }
 
     function test_RevertWhen_TotalPercentageGreaterThan100() external whenMerkleProofValid {
-        uint256 fee = defaults.MINIMUM_FEE();
-
         MerkleLL.ConstructorParams memory params = merkleLLConstructorParams();
 
         // Crate a MerkleLL campaign with a total percentage greater than 100.
         params.schedule.startPercentage = ud2x18(0.5e18);
         params.schedule.cliffPercentage = ud2x18(0.6e18);
 
-        merkleLL = merkleFactoryLL.createMerkleLL(params, defaults.AGGREGATE_AMOUNT(), defaults.RECIPIENT_COUNT());
-
-        uint128 depositAmount = defaults.CLAIM_AMOUNT();
-        uint128 startUnlockAmount = ud60x18(depositAmount).mul(ud60x18(0.5e18)).intoUint128();
-        uint128 cliffUnlockAmount = ud60x18(depositAmount).mul(ud60x18(0.6e18)).intoUint128();
-        bytes32[] memory merkleProof = defaults.index1Proof();
+        merkleLL = merkleFactoryLL.createMerkleLL(params, AGGREGATE_AMOUNT, RECIPIENT_COUNT);
+        uint128 startUnlockAmount = ud60x18(CLAIM_AMOUNT).mul(ud60x18(0.5e18)).intoUint128();
+        uint128 cliffUnlockAmount = ud60x18(CLAIM_AMOUNT).mul(ud60x18(0.6e18)).intoUint128();
 
         vm.expectRevert(
             abi.encodeWithSelector(
                 LockupErrors.SablierHelpers_UnlockAmountsSumTooHigh.selector,
-                depositAmount,
+                CLAIM_AMOUNT,
                 startUnlockAmount,
                 cliffUnlockAmount
             )
         );
 
         // Claim the airdrop.
-        merkleLL.claim{ value: fee }({
+        merkleLL.claim{ value: MINIMUM_FEE }({
             index: 1,
             recipient: users.recipient1,
-            amount: depositAmount,
-            merkleProof: merkleProof
+            amount: CLAIM_AMOUNT,
+            merkleProof: index1Proof()
         });
     }
 
@@ -60,7 +55,7 @@ contract Claim_MerkleLL_Integration_Test is Claim_Integration_Test, MerkleLL_Int
         params.schedule.cliffDuration = 0;
         params.schedule.cliffPercentage = ud2x18(0);
 
-        merkleLL = merkleFactoryLL.createMerkleLL(params, defaults.AGGREGATE_AMOUNT(), defaults.RECIPIENT_COUNT());
+        merkleLL = merkleFactoryLL.createMerkleLL(params, AGGREGATE_AMOUNT, RECIPIENT_COUNT);
 
         // It should create a stream with block.timestamp as start time.
         // It should create a stream with cliff as zero.
@@ -75,62 +70,56 @@ contract Claim_MerkleLL_Integration_Test is Claim_Integration_Test, MerkleLL_Int
     {
         // It should create a stream with block.timestamp as start time.
         // It should create a stream with cliff as start time + cliff duration.
-        _test_Claim({ startTime: getBlockTimestamp(), cliffTime: getBlockTimestamp() + defaults.CLIFF_DURATION() });
+        _test_Claim({ startTime: getBlockTimestamp(), cliffTime: getBlockTimestamp() + CLIFF_DURATION });
     }
 
     function test_WhenScheduledStartTimeNotZero() external whenMerkleProofValid whenTotalPercentageNotGreaterThan100 {
         MerkleLL.ConstructorParams memory params = merkleLLConstructorParams();
-        params.schedule.startTime = defaults.RANGED_STREAM_START_TIME();
+        params.schedule.startTime = RANGED_STREAM_START_TIME;
 
-        merkleLL = merkleFactoryLL.createMerkleLL(params, defaults.AGGREGATE_AMOUNT(), defaults.RECIPIENT_COUNT());
+        merkleLL = merkleFactoryLL.createMerkleLL(params, AGGREGATE_AMOUNT, RECIPIENT_COUNT);
 
         // It should create a stream with scheduled start time as start time.
-        _test_Claim({
-            startTime: defaults.RANGED_STREAM_START_TIME(),
-            cliffTime: defaults.RANGED_STREAM_START_TIME() + defaults.CLIFF_DURATION()
-        });
+        _test_Claim({ startTime: RANGED_STREAM_START_TIME, cliffTime: RANGED_STREAM_START_TIME + CLIFF_DURATION });
     }
 
     /// @dev Helper function to test claim.
     function _test_Claim(uint40 startTime, uint40 cliffTime) private {
-        uint256 fee = defaults.MINIMUM_FEE();
-        deal({ token: address(dai), to: address(merkleLL), give: defaults.AGGREGATE_AMOUNT() });
+        deal({ token: address(dai), to: address(merkleLL), give: AGGREGATE_AMOUNT });
 
         uint256 expectedStreamId = lockup.nextStreamId();
         uint256 previousFeeAccrued = address(merkleLL).balance;
 
         // It should emit a {Claim} event.
         vm.expectEmit({ emitter: address(merkleLL) });
-        emit ISablierMerkleLockup.Claim(defaults.INDEX1(), users.recipient1, defaults.CLAIM_AMOUNT(), expectedStreamId);
+        emit ISablierMerkleLockup.Claim(INDEX1, users.recipient1, CLAIM_AMOUNT, expectedStreamId);
 
-        expectCallToTransferFrom({ from: address(merkleLL), to: address(lockup), value: defaults.CLAIM_AMOUNT() });
-        expectCallToClaimWithMsgValue(address(merkleLL), fee);
+        expectCallToTransferFrom({ from: address(merkleLL), to: address(lockup), value: CLAIM_AMOUNT });
+        expectCallToClaimWithMsgValue(address(merkleLL), MINIMUM_FEE);
 
         // Claim the airstream.
-        merkleLL.claim{ value: fee }(
-            defaults.INDEX1(), users.recipient1, defaults.CLAIM_AMOUNT(), defaults.index1Proof()
-        );
+        merkleLL.claim{ value: MINIMUM_FEE }(INDEX1, users.recipient1, CLAIM_AMOUNT, index1Proof());
 
-        uint128 expectedCliffAmount = cliffTime > 0 ? defaults.CLIFF_AMOUNT() : 0;
+        uint128 expectedCliffAmount = cliffTime > 0 ? CLIFF_AMOUNT : 0;
 
         // Assert that the stream has been created successfully.
         assertEq(lockup.getCliffTime(expectedStreamId), cliffTime, "cliff time");
-        assertEq(lockup.getDepositedAmount(expectedStreamId), defaults.CLAIM_AMOUNT(), "depositedAmount");
-        assertEq(lockup.getEndTime(expectedStreamId), startTime + defaults.TOTAL_DURATION(), "end time");
+        assertEq(lockup.getDepositedAmount(expectedStreamId), CLAIM_AMOUNT, "depositedAmount");
+        assertEq(lockup.getEndTime(expectedStreamId), startTime + TOTAL_DURATION, "end time");
         assertEq(lockup.getRecipient(expectedStreamId), users.recipient1, "recipient");
         assertEq(lockup.getSender(expectedStreamId), users.campaignOwner, "sender");
         assertEq(lockup.getStartTime(expectedStreamId), startTime, "start time");
         assertEq(lockup.getUnderlyingToken(expectedStreamId), dai, "token");
         assertEq(lockup.getUnlockAmounts(expectedStreamId).cliff, expectedCliffAmount, "unlock amount cliff");
-        assertEq(lockup.getUnlockAmounts(expectedStreamId).start, defaults.START_AMOUNT(), "unlock amount start");
-        assertEq(lockup.isCancelable(expectedStreamId), defaults.CANCELABLE(), "is cancelable");
+        assertEq(lockup.getUnlockAmounts(expectedStreamId).start, START_AMOUNT, "unlock amount start");
+        assertEq(lockup.isCancelable(expectedStreamId), CANCELABLE, "is cancelable");
         assertEq(lockup.isDepleted(expectedStreamId), false, "is depleted");
         assertEq(lockup.isStream(expectedStreamId), true, "is stream");
-        assertEq(lockup.isTransferable(expectedStreamId), defaults.TRANSFERABLE(), "is transferable");
+        assertEq(lockup.isTransferable(expectedStreamId), TRANSFERABLE, "is transferable");
         assertEq(lockup.wasCanceled(expectedStreamId), false, "was canceled");
 
-        assertTrue(merkleLL.hasClaimed(defaults.INDEX1()), "not claimed");
+        assertTrue(merkleLL.hasClaimed(INDEX1), "not claimed");
 
-        assertEq(address(merkleLL).balance, previousFeeAccrued + defaults.MINIMUM_FEE(), "fee collected");
+        assertEq(address(merkleLL).balance, previousFeeAccrued + MINIMUM_FEE, "fee collected");
     }
 }
diff --git a/tests/integration/concrete/campaign/ll/constructor.t.sol b/tests/integration/concrete/campaign/ll/constructor.t.sol
index 350b7e19..413c2013 100644
--- a/tests/integration/concrete/campaign/ll/constructor.t.sol
+++ b/tests/integration/concrete/campaign/ll/constructor.t.sol
@@ -4,101 +4,36 @@ pragma solidity >=0.8.22 <0.9.0;
 import { SablierMerkleLL } from "src/SablierMerkleLL.sol";
 import { MerkleLL } from "src/types/DataTypes.sol";
 
-import { MerkleLL_Integration_Shared_Test } from "./MerkleLL.t.sol";
-
-contract Constructor_MerkleLL_Integration_Test is MerkleLL_Integration_Shared_Test {
-    /// @dev Needed to prevent "Stack too deep" error
-    struct Vars {
-        address actualAdmin;
-        uint256 actualAllowance;
-        string actualCampaignName;
-        uint40 actualExpiration;
-        address actualFactory;
-        uint256 actualFee;
-        string actualIpfsCID;
-        address actualLockup;
-        bytes32 actualMerkleRoot;
-        MerkleLL.Schedule actualSchedule;
-        bool actualStreamCancelable;
-        bool actualStreamTransferable;
-        address actualToken;
-        address expectedAdmin;
-        uint256 expectedAllowance;
-        string expectedCampaignName;
-        uint40 expectedExpiration;
-        address expectedFactory;
-        uint256 expectedFee;
-        string expectedIpfsCID;
-        address expectedLockup;
-        bytes32 expectedMerkleRoot;
-        bool expectedStreamCancelable;
-        bool expectedStreamTransferable;
-        address expectedToken;
-    }
+import { Integration_Test } from "./../../../Integration.t.sol";
 
+contract Constructor_MerkleLL_Integration_Test is Integration_Test {
     function test_Constructor() external {
         // Make Factory the caller for the constructor test.
         resetPrank(address(merkleFactoryLL));
 
         SablierMerkleLL constructedLL = new SablierMerkleLL(merkleLLConstructorParams(), users.campaignOwner);
 
-        Vars memory vars;
-
-        vars.actualAdmin = constructedLL.admin();
-        vars.expectedAdmin = users.campaignOwner;
-        assertEq(vars.actualAdmin, vars.expectedAdmin, "admin");
-
-        vars.actualAllowance = dai.allowance(address(constructedLL), address(lockup));
-        vars.expectedAllowance = MAX_UINT256;
-        assertEq(vars.actualAllowance, vars.expectedAllowance, "allowance");
-
-        vars.actualCampaignName = constructedLL.campaignName();
-        vars.expectedCampaignName = defaults.CAMPAIGN_NAME();
-        assertEq(vars.actualCampaignName, vars.expectedCampaignName, "campaign name");
-
-        vars.actualExpiration = constructedLL.EXPIRATION();
-        vars.expectedExpiration = defaults.EXPIRATION();
-        assertEq(vars.actualExpiration, vars.expectedExpiration, "expiration");
-
-        vars.actualFactory = constructedLL.FACTORY();
-        vars.expectedFactory = address(merkleFactoryLL);
-        assertEq(vars.actualFactory, vars.expectedFactory, "factory");
-
-        vars.actualFee = constructedLL.MINIMUM_FEE();
-        vars.expectedFee = defaults.MINIMUM_FEE();
-        assertEq(vars.actualFee, vars.expectedFee, "minimum fee");
-
-        vars.actualIpfsCID = constructedLL.ipfsCID();
-        vars.expectedIpfsCID = defaults.IPFS_CID();
-        assertEq(vars.actualIpfsCID, vars.expectedIpfsCID, "ipfsCID");
-
-        vars.actualLockup = address(constructedLL.LOCKUP());
-        vars.expectedLockup = address(lockup);
-        assertEq(vars.actualLockup, vars.expectedLockup, "lockup");
-
-        vars.actualMerkleRoot = constructedLL.MERKLE_ROOT();
-        vars.expectedMerkleRoot = defaults.MERKLE_ROOT();
-        assertEq(vars.actualMerkleRoot, vars.expectedMerkleRoot, "merkleRoot");
-
-        vars.actualSchedule = constructedLL.getSchedule();
-        assertEq(vars.actualSchedule.startTime, ZERO, "schedule.startTime");
-        assertEq(vars.actualSchedule.startPercentage, defaults.START_PERCENTAGE(), "schedule.startPercentage");
-        assertEq(vars.actualSchedule.cliffDuration, defaults.CLIFF_DURATION(), "schedule.cliffDuration");
-        assertEq(vars.actualSchedule.cliffPercentage, defaults.CLIFF_PERCENTAGE(), "schedule.cliffPercentage");
-        assertEq(vars.actualSchedule.totalDuration, defaults.TOTAL_DURATION(), "schedule.totalDuration");
-
-        assertEq(constructedLL.shape(), defaults.SHAPE(), "shape");
-
-        vars.actualStreamCancelable = constructedLL.STREAM_CANCELABLE();
-        vars.expectedStreamCancelable = defaults.CANCELABLE();
-        assertEq(vars.actualStreamCancelable, vars.expectedStreamCancelable, "stream cancelable");
-
-        vars.actualStreamTransferable = constructedLL.STREAM_TRANSFERABLE();
-        vars.expectedStreamTransferable = defaults.TRANSFERABLE();
-        assertEq(vars.actualStreamTransferable, vars.expectedStreamTransferable, "stream transferable");
-
-        vars.actualToken = address(constructedLL.TOKEN());
-        vars.expectedToken = address(dai);
-        assertEq(vars.actualToken, vars.expectedToken, "token");
+        uint256 actualAllowance = dai.allowance(address(constructedLL), address(lockup));
+        assertEq(actualAllowance, MAX_UINT256, "allowance");
+
+        assertEq(constructedLL.admin(), users.campaignOwner, "admin");
+        assertEq(constructedLL.campaignName(), CAMPAIGN_NAME, "campaign name");
+        assertEq(constructedLL.EXPIRATION(), EXPIRATION, "expiration");
+        assertEq(constructedLL.FACTORY(), address(merkleFactoryLL), "factory");
+        assertEq(constructedLL.MINIMUM_FEE(), MINIMUM_FEE, "minimum fee");
+        assertEq(constructedLL.ipfsCID(), IPFS_CID, "ipfsCID");
+        assertEq(address(constructedLL.LOCKUP()), address(lockup), "lockup");
+        assertEq(constructedLL.MERKLE_ROOT(), MERKLE_ROOT, "merkleRoot");
+        assertEq(constructedLL.shape(), SHAPE, "shape");
+        assertEq(constructedLL.STREAM_CANCELABLE(), CANCELABLE, "stream cancelable");
+        assertEq(constructedLL.STREAM_TRANSFERABLE(), TRANSFERABLE, "stream transferable");
+        assertEq(address(constructedLL.TOKEN()), address(dai), "token");
+
+        MerkleLL.Schedule memory actualSchedule = constructedLL.getSchedule();
+        assertEq(actualSchedule.startTime, ZERO, "schedule.startTime");
+        assertEq(actualSchedule.startPercentage, START_PERCENTAGE, "schedule.startPercentage");
+        assertEq(actualSchedule.cliffDuration, CLIFF_DURATION, "schedule.cliffDuration");
+        assertEq(actualSchedule.cliffPercentage, CLIFF_PERCENTAGE, "schedule.cliffPercentage");
+        assertEq(actualSchedule.totalDuration, TOTAL_DURATION, "schedule.totalDuration");
     }
 }
diff --git a/tests/integration/concrete/campaign/lt/claim/claim.t.sol b/tests/integration/concrete/campaign/lt/claim/claim.t.sol
index 9d7567f8..d6f4b9de 100644
--- a/tests/integration/concrete/campaign/lt/claim/claim.t.sol
+++ b/tests/integration/concrete/campaign/lt/claim/claim.t.sol
@@ -16,50 +16,40 @@ contract Claim_MerkleLT_Integration_Test is Claim_Integration_Test, MerkleLT_Int
     }
 
     function test_RevertWhen_TotalPercentageLessThan100() external whenMerkleProofValid whenTotalPercentageNot100 {
-        uint256 fee = defaults.MINIMUM_FEE();
-
         MerkleLT.ConstructorParams memory params = merkleLTConstructorParams();
 
         // Create a MerkleLT campaign with a total percentage less than 100.
         params.tranchesWithPercentages[0].unlockPercentage = ud2x18(0.05e18);
         params.tranchesWithPercentages[1].unlockPercentage = ud2x18(0.2e18);
 
-        merkleLT = merkleFactoryLT.createMerkleLT(params, defaults.AGGREGATE_AMOUNT(), defaults.RECIPIENT_COUNT());
-
-        // Claim the airdrop.
-        bytes32[] memory merkleProof = defaults.index1Proof();
+        merkleLT = merkleFactoryLT.createMerkleLT(params, AGGREGATE_AMOUNT, RECIPIENT_COUNT);
 
         vm.expectRevert(abi.encodeWithSelector(Errors.SablierMerkleLT_TotalPercentageNotOneHundred.selector, 0.25e18));
 
-        merkleLT.claim{ value: fee }({
+        merkleLT.claim{ value: MINIMUM_FEE }({
             index: 1,
             recipient: users.recipient1,
             amount: 10_000e18,
-            merkleProof: merkleProof
+            merkleProof: index1Proof()
         });
     }
 
     function test_RevertWhen_TotalPercentageGreaterThan100() external whenMerkleProofValid whenTotalPercentageNot100 {
-        uint256 fee = defaults.MINIMUM_FEE();
-
         MerkleLT.ConstructorParams memory params = merkleLTConstructorParams();
 
         // Create a MerkleLT campaign with a total percentage less than 100.
         params.tranchesWithPercentages[0].unlockPercentage = ud2x18(0.75e18);
         params.tranchesWithPercentages[1].unlockPercentage = ud2x18(0.8e18);
 
-        merkleLT = merkleFactoryLT.createMerkleLT(params, defaults.AGGREGATE_AMOUNT(), defaults.RECIPIENT_COUNT());
-
-        // Claim the airdrop.
-        bytes32[] memory merkleProof = defaults.index1Proof();
+        merkleLT = merkleFactoryLT.createMerkleLT(params, AGGREGATE_AMOUNT, RECIPIENT_COUNT);
 
         vm.expectRevert(abi.encodeWithSelector(Errors.SablierMerkleLT_TotalPercentageNotOneHundred.selector, 1.55e18));
 
-        merkleLT.claim{ value: fee }({
+        merkleLT.claim{ value: MINIMUM_FEE }({
             index: 1,
             recipient: users.recipient1,
             amount: 10_000e18,
-            merkleProof: merkleProof
+            merkleProof: index1Proof()
         });
     }
 
@@ -70,58 +60,51 @@ contract Claim_MerkleLT_Integration_Test is Claim_Integration_Test, MerkleLT_Int
 
     function test_WhenStreamStartTimeNotZero() external whenMerkleProofValid whenTotalPercentage100 {
         MerkleLT.ConstructorParams memory params = merkleLTConstructorParams();
-        params.streamStartTime = defaults.RANGED_STREAM_START_TIME();
+        params.streamStartTime = RANGED_STREAM_START_TIME;
 
-        merkleLT = merkleFactoryLT.createMerkleLT(params, defaults.AGGREGATE_AMOUNT(), defaults.RECIPIENT_COUNT());
+        merkleLT = merkleFactoryLT.createMerkleLT(params, AGGREGATE_AMOUNT, RECIPIENT_COUNT);
 
         // It should create a stream with `STREAM_START_TIME` as start time.
-        _test_Claim({
-            streamStartTime: defaults.RANGED_STREAM_START_TIME(),
-            startTime: defaults.RANGED_STREAM_START_TIME()
-        });
+        _test_Claim({ streamStartTime: RANGED_STREAM_START_TIME, startTime: RANGED_STREAM_START_TIME });
     }
 
     /// @dev Helper function to test claim.
     function _test_Claim(uint40 streamStartTime, uint40 startTime) private {
-        uint256 fee = defaults.MINIMUM_FEE();
-
-        deal({ token: address(dai), to: address(merkleLT), give: defaults.AGGREGATE_AMOUNT() });
+        deal({ token: address(dai), to: address(merkleLT), give: AGGREGATE_AMOUNT });
 
         uint256 expectedStreamId = lockup.nextStreamId();
         uint256 previousFeeAccrued = address(merkleLL).balance;
 
         // It should emit a {Claim} event.
         vm.expectEmit({ emitter: address(merkleLT) });
-        emit ISablierMerkleLockup.Claim(defaults.INDEX1(), users.recipient1, defaults.CLAIM_AMOUNT(), expectedStreamId);
+        emit ISablierMerkleLockup.Claim(INDEX1, users.recipient1, CLAIM_AMOUNT, expectedStreamId);
 
-        expectCallToTransferFrom({ from: address(merkleLT), to: address(lockup), value: defaults.CLAIM_AMOUNT() });
-        expectCallToClaimWithMsgValue(address(merkleLT), fee);
+        expectCallToTransferFrom({ from: address(merkleLT), to: address(lockup), value: CLAIM_AMOUNT });
+        expectCallToClaimWithMsgValue(address(merkleLT), MINIMUM_FEE);
 
         // Claim the airstream.
-        merkleLT.claim{ value: fee }(
-            defaults.INDEX1(), users.recipient1, defaults.CLAIM_AMOUNT(), defaults.index1Proof()
-        );
+        merkleLT.claim{ value: MINIMUM_FEE }(INDEX1, users.recipient1, CLAIM_AMOUNT, index1Proof());
 
         // Assert that the stream has been created successfully.
-        assertEq(lockup.getDepositedAmount(expectedStreamId), defaults.CLAIM_AMOUNT(), "depositedAmount");
-        assertEq(lockup.getEndTime(expectedStreamId), startTime + defaults.TOTAL_DURATION(), "end time");
+        assertEq(lockup.getDepositedAmount(expectedStreamId), CLAIM_AMOUNT, "depositedAmount");
+        assertEq(lockup.getEndTime(expectedStreamId), startTime + TOTAL_DURATION, "end time");
         assertEq(lockup.getRecipient(expectedStreamId), users.recipient1, "recipient");
         assertEq(lockup.getSender(expectedStreamId), users.campaignOwner, "sender");
         assertEq(lockup.getStartTime(expectedStreamId), startTime, "start time");
         // It should create a stream with `STREAM_START_TIME` as start time.
         assertEq(
             lockup.getTranches(expectedStreamId),
-            defaults.tranchesMerkleLT({ streamStartTime: streamStartTime, totalAmount: defaults.CLAIM_AMOUNT() })
+            tranchesMerkleLT({ streamStartTime: streamStartTime, totalAmount: CLAIM_AMOUNT })
         );
         assertEq(lockup.getUnderlyingToken(expectedStreamId), dai, "token");
-        assertEq(lockup.isCancelable(expectedStreamId), defaults.CANCELABLE(), "is cancelable");
+        assertEq(lockup.isCancelable(expectedStreamId), CANCELABLE, "is cancelable");
         assertEq(lockup.isDepleted(expectedStreamId), false, "is depleted");
         assertEq(lockup.isStream(expectedStreamId), true, "is stream");
-        assertEq(lockup.isTransferable(expectedStreamId), defaults.TRANSFERABLE(), "is transferable");
+        assertEq(lockup.isTransferable(expectedStreamId), TRANSFERABLE, "is transferable");
         assertEq(lockup.wasCanceled(expectedStreamId), false, "was canceled");
 
-        assertTrue(merkleLT.hasClaimed(defaults.INDEX1()), "not claimed");
+        assertTrue(merkleLT.hasClaimed(INDEX1), "not claimed");
 
-        assertEq(address(merkleLT).balance, previousFeeAccrued + defaults.MINIMUM_FEE(), "fee collected");
+        assertEq(address(merkleLT).balance, previousFeeAccrued + MINIMUM_FEE, "fee collected");
     }
 }
diff --git a/tests/integration/concrete/campaign/lt/constructor.t.sol b/tests/integration/concrete/campaign/lt/constructor.t.sol
index 36db2f19..a716a6ba 100644
--- a/tests/integration/concrete/campaign/lt/constructor.t.sol
+++ b/tests/integration/concrete/campaign/lt/constructor.t.sol
@@ -4,42 +4,9 @@ pragma solidity >=0.8.22 <0.9.0;
 import { SablierMerkleLT } from "src/SablierMerkleLT.sol";
 import { MerkleLT } from "src/types/DataTypes.sol";
 
-import { MerkleLT_Integration_Shared_Test } from "./MerkleLT.t.sol";
-
-contract Constructor_MerkleLT_Integration_Test is MerkleLT_Integration_Shared_Test {
-    /// @dev Needed to prevent "Stack too deep" error
-    struct Vars {
-        address actualAdmin;
-        uint256 actualAllowance;
-        string actualCampaignName;
-        uint40 actualExpiration;
-        address actualFactory;
-        string actualIpfsCID;
-        address actualLockup;
-        bytes32 actualMerkleRoot;
-        uint256 actualFee;
-        bool actualStreamCancelable;
-        uint40 actualStreamStartTime;
-        bool actualStreamTransferable;
-        address actualToken;
-        uint64 actualTotalPercentage;
-        MerkleLT.TrancheWithPercentage[] actualTranchesWithPercentages;
-        address expectedAdmin;
-        uint256 expectedAllowance;
-        string expectedCampaignName;
-        uint40 expectedExpiration;
-        address expectedFactory;
-        string expectedIpfsCID;
-        address expectedLockup;
-        bytes32 expectedMerkleRoot;
-        uint256 expectedFee;
-        bool expectedStreamCancelable;
-        bool expectedStreamTransferable;
-        address expectedToken;
-        uint64 expectedTotalPercentage;
-        MerkleLT.TrancheWithPercentage[] expectedTranchesWithPercentages;
-    }
+import { Integration_Test } from "./../../../Integration.t.sol";
 
+contract Constructor_MerkleLT_Integration_Test is Integration_Test {
     function test_Constructor() external {
         // Make Factory the caller for the constructor test.
         resetPrank(address(merkleFactoryLT));
@@ -48,67 +15,23 @@ contract Constructor_MerkleLT_Integration_Test is MerkleLT_Integration_Shared_Te
 
         SablierMerkleLT constructedLT = new SablierMerkleLT(params, users.campaignOwner);
 
-        Vars memory vars;
-
-        vars.actualAdmin = constructedLT.admin();
-        vars.expectedAdmin = users.campaignOwner;
-        assertEq(vars.actualAdmin, vars.expectedAdmin, "admin");
-
-        vars.actualAllowance = dai.allowance(address(constructedLT), address(lockup));
-        vars.expectedAllowance = MAX_UINT256;
-        assertEq(vars.actualAllowance, vars.expectedAllowance, "allowance");
-
-        vars.actualCampaignName = constructedLT.campaignName();
-        vars.expectedCampaignName = defaults.CAMPAIGN_NAME();
-        assertEq(vars.actualCampaignName, vars.expectedCampaignName, "campaign name");
-
-        vars.actualExpiration = constructedLT.EXPIRATION();
-        vars.expectedExpiration = defaults.EXPIRATION();
-        assertEq(vars.actualExpiration, vars.expectedExpiration, "expiration");
-
-        vars.actualFactory = constructedLT.FACTORY();
-        vars.expectedFactory = address(merkleFactoryLT);
-        assertEq(vars.actualFactory, vars.expectedFactory, "factory");
-
-        vars.actualFee = constructedLT.MINIMUM_FEE();
-        vars.expectedFee = defaults.MINIMUM_FEE();
-        assertEq(vars.actualFee, vars.expectedFee, "minimum fee");
-
-        vars.actualIpfsCID = constructedLT.ipfsCID();
-        vars.expectedIpfsCID = defaults.IPFS_CID();
-        assertEq(vars.actualIpfsCID, vars.expectedIpfsCID, "ipfsCID");
-
-        vars.actualLockup = address(constructedLT.LOCKUP());
-        vars.expectedLockup = address(lockup);
-        assertEq(vars.actualLockup, vars.expectedLockup, "lockup");
-
-        vars.actualMerkleRoot = constructedLT.MERKLE_ROOT();
-        vars.expectedMerkleRoot = defaults.MERKLE_ROOT();
-        assertEq(vars.actualMerkleRoot, vars.expectedMerkleRoot, "merkleRoot");
-
-        assertEq(constructedLT.shape(), defaults.SHAPE(), "shape");
-
-        vars.actualStreamCancelable = constructedLT.STREAM_CANCELABLE();
-        vars.expectedStreamCancelable = defaults.CANCELABLE();
-        assertEq(vars.actualStreamCancelable, vars.expectedStreamCancelable, "stream cancelable");
-
-        vars.actualStreamStartTime = constructedLT.STREAM_START_TIME();
-        assertEq(vars.actualStreamStartTime, ZERO, "stream start time");
-
-        vars.actualStreamTransferable = constructedLT.STREAM_TRANSFERABLE();
-        vars.expectedStreamTransferable = defaults.TRANSFERABLE();
-        assertEq(vars.actualStreamTransferable, vars.expectedStreamTransferable, "stream transferable");
-
-        vars.actualToken = address(constructedLT.TOKEN());
-        vars.expectedToken = address(dai);
-        assertEq(vars.actualToken, vars.expectedToken, "token");
-
-        vars.actualTotalPercentage = constructedLT.TOTAL_PERCENTAGE();
-        vars.expectedTotalPercentage = defaults.TOTAL_PERCENTAGE();
-        assertEq(vars.actualTotalPercentage, vars.expectedTotalPercentage, "totalPercentage");
-
-        vars.actualTranchesWithPercentages = constructedLT.getTranchesWithPercentages();
-        vars.expectedTranchesWithPercentages = params.tranchesWithPercentages;
-        assertEq(vars.actualTranchesWithPercentages, vars.expectedTranchesWithPercentages);
+        uint256 actualAllowance = dai.allowance(address(constructedLT), address(lockup));
+        assertEq(actualAllowance, MAX_UINT256, "allowance");
+
+        assertEq(constructedLT.admin(), users.campaignOwner, "admin");
+        assertEq(constructedLT.campaignName(), CAMPAIGN_NAME, "campaign name");
+        assertEq(constructedLT.EXPIRATION(), EXPIRATION, "expiration");
+        assertEq(constructedLT.FACTORY(), address(merkleFactoryLT), "factory");
+        assertEq(constructedLT.MINIMUM_FEE(), MINIMUM_FEE, "minimum fee");
+        assertEq(constructedLT.ipfsCID(), IPFS_CID, "ipfsCID");
+        assertEq(address(constructedLT.LOCKUP()), address(lockup), "lockup");
+        assertEq(constructedLT.MERKLE_ROOT(), MERKLE_ROOT, "merkleRoot");
+        assertEq(constructedLT.shape(), SHAPE, "shape");
+        assertEq(constructedLT.STREAM_CANCELABLE(), CANCELABLE, "stream cancelable");
+        assertEq(constructedLT.STREAM_START_TIME(), ZERO, "stream start time");
+        assertEq(constructedLT.STREAM_TRANSFERABLE(), TRANSFERABLE, "stream transferable");
+        assertEq(address(constructedLT.TOKEN()), address(dai), "token");
+        assertEq(constructedLT.TOTAL_PERCENTAGE(), TOTAL_PERCENTAGE, "totalPercentage");
+        assertEq(constructedLT.getTranchesWithPercentages(), params.tranchesWithPercentages);
     }
 }
diff --git a/tests/integration/concrete/campaign/shared/claim/claim.t.sol b/tests/integration/concrete/campaign/shared/claim/claim.t.sol
index 0ba7c656..98925035 100644
--- a/tests/integration/concrete/campaign/shared/claim/claim.t.sol
+++ b/tests/integration/concrete/campaign/shared/claim/claim.t.sol
@@ -7,33 +7,29 @@ import { Integration_Test } from "../../../../Integration.t.sol";
 
 abstract contract Claim_Integration_Test is Integration_Test {
     function test_RevertGiven_CampaignExpired() external {
-        uint40 expiration = defaults.EXPIRATION();
-        uint256 fee = defaults.MINIMUM_FEE();
-        uint256 warpTime = expiration + 1 seconds;
+        uint256 warpTime = EXPIRATION + 1 seconds;
         bytes32[] memory merkleProof;
         vm.warp({ newTimestamp: warpTime });
-        vm.expectRevert(abi.encodeWithSelector(Errors.SablierMerkleBase_CampaignExpired.selector, warpTime, expiration));
-        merkleBase.claim{ value: fee }({ index: 1, recipient: users.recipient1, amount: 1, merkleProof: merkleProof });
+        vm.expectRevert(abi.encodeWithSelector(Errors.SablierMerkleBase_CampaignExpired.selector, warpTime, EXPIRATION));
+        merkleBase.claim{ value: MINIMUM_FEE }({
+            index: 1,
+            recipient: users.recipient1,
+            amount: 1,
+            merkleProof: merkleProof
+        });
     }
 
     function test_RevertGiven_MsgValueLessThanFee() external givenCampaignNotExpired {
-        uint256 index1 = defaults.INDEX1();
-        uint128 amount = defaults.CLAIM_AMOUNT();
-        bytes32[] memory merkleProof = defaults.index1Proof();
-        uint256 fee = defaults.MINIMUM_FEE();
-
-        vm.expectRevert(abi.encodeWithSelector(Errors.SablierMerkleBase_InsufficientFeePayment.selector, 0, fee));
-        merkleBase.claim{ value: 0 }(index1, users.recipient1, amount, merkleProof);
+        vm.expectRevert(
+            abi.encodeWithSelector(Errors.SablierMerkleBase_InsufficientFeePayment.selector, 0, MINIMUM_FEE)
+        );
+        merkleBase.claim{ value: 0 }(INDEX1, users.recipient1, CLAIM_AMOUNT, index1Proof());
     }
 
     function test_RevertGiven_RecipientClaimed() external givenCampaignNotExpired givenMsgValueNotLessThanFee {
         claim();
-        uint256 index1 = defaults.INDEX1();
-        uint128 amount = defaults.CLAIM_AMOUNT();
-        uint256 fee = defaults.MINIMUM_FEE();
-        bytes32[] memory merkleProof = defaults.index1Proof();
-        vm.expectRevert(abi.encodeWithSelector(Errors.SablierMerkleBase_StreamClaimed.selector, index1));
-        merkleBase.claim{ value: fee }(index1, users.recipient1, amount, merkleProof);
+        vm.expectRevert(abi.encodeWithSelector(Errors.SablierMerkleBase_StreamClaimed.selector, INDEX1));
+        merkleBase.claim{ value: MINIMUM_FEE }(INDEX1, users.recipient1, CLAIM_AMOUNT, index1Proof());
     }
 
     function test_RevertWhen_IndexNotValid()
@@ -43,11 +39,8 @@ abstract contract Claim_Integration_Test is Integration_Test {
         givenRecipientNotClaimed
     {
         uint256 invalidIndex = 1337;
-        uint128 amount = defaults.CLAIM_AMOUNT();
-        uint256 fee = defaults.MINIMUM_FEE();
-        bytes32[] memory merkleProof = defaults.index1Proof();
         vm.expectRevert(Errors.SablierMerkleBase_InvalidProof.selector);
-        merkleBase.claim{ value: fee }(invalidIndex, users.recipient1, amount, merkleProof);
+        merkleBase.claim{ value: MINIMUM_FEE }(invalidIndex, users.recipient1, CLAIM_AMOUNT, index1Proof());
     }
 
     function test_RevertWhen_RecipientNotValid()
@@ -57,13 +50,9 @@ abstract contract Claim_Integration_Test is Integration_Test {
         givenRecipientNotClaimed
         whenIndexValid
     {
-        uint256 index1 = defaults.INDEX1();
         address invalidRecipient = address(1337);
-        uint128 amount = defaults.CLAIM_AMOUNT();
-        uint256 fee = defaults.MINIMUM_FEE();
-        bytes32[] memory merkleProof = defaults.index1Proof();
         vm.expectRevert(Errors.SablierMerkleBase_InvalidProof.selector);
-        merkleBase.claim{ value: fee }(index1, invalidRecipient, amount, merkleProof);
+        merkleBase.claim{ value: MINIMUM_FEE }(INDEX1, invalidRecipient, CLAIM_AMOUNT, index1Proof());
     }
 
     function test_RevertWhen_AmountNotValid()
@@ -74,12 +63,9 @@ abstract contract Claim_Integration_Test is Integration_Test {
         whenIndexValid
         whenRecipientValid
     {
-        uint256 index1 = defaults.INDEX1();
         uint128 invalidAmount = 1337;
-        uint256 fee = defaults.MINIMUM_FEE();
-        bytes32[] memory merkleProof = defaults.index1Proof();
         vm.expectRevert(Errors.SablierMerkleBase_InvalidProof.selector);
-        merkleBase.claim{ value: fee }(index1, users.recipient1, invalidAmount, merkleProof);
+        merkleBase.claim{ value: MINIMUM_FEE }(INDEX1, users.recipient1, invalidAmount, index1Proof());
     }
 
     function test_RevertWhen_MerkleProofNotValid()
@@ -91,12 +77,8 @@ abstract contract Claim_Integration_Test is Integration_Test {
         whenRecipientValid
         whenAmountValid
     {
-        uint256 index1 = defaults.INDEX1();
-        uint128 amount = defaults.CLAIM_AMOUNT();
-        uint256 fee = defaults.MINIMUM_FEE();
-        bytes32[] memory invalidMerkleProof = defaults.index2Proof();
         vm.expectRevert(Errors.SablierMerkleBase_InvalidProof.selector);
-        merkleBase.claim{ value: fee }(index1, users.recipient1, amount, invalidMerkleProof);
+        merkleBase.claim{ value: MINIMUM_FEE }(INDEX1, users.recipient1, CLAIM_AMOUNT, index2Proof());
     }
 
     /// @dev Since the implementation of `_claim()` differs in each Merkle campaign, we declare this dummy test and
diff --git a/tests/integration/concrete/campaign/shared/clawback/clawback.t.sol b/tests/integration/concrete/campaign/shared/clawback/clawback.t.sol
index 2a365743..552c6073 100644
--- a/tests/integration/concrete/campaign/shared/clawback/clawback.t.sol
+++ b/tests/integration/concrete/campaign/shared/clawback/clawback.t.sol
@@ -39,10 +39,7 @@ abstract contract Clawback_Integration_Test is Integration_Test {
     {
         vm.expectRevert(
             abi.encodeWithSelector(
-                Errors.SablierMerkleBase_ClawbackNotAllowed.selector,
-                getBlockTimestamp(),
-                defaults.EXPIRATION(),
-                defaults.FIRST_CLAIM_TIME()
+                Errors.SablierMerkleBase_ClawbackNotAllowed.selector, getBlockTimestamp(), EXPIRATION, FIRST_CLAIM_TIME
             )
         );
         merkleBase.clawback({ to: users.campaignOwner, amount: 1 });
@@ -54,7 +51,7 @@ abstract contract Clawback_Integration_Test is Integration_Test {
         whenFirstClaimMade
         givenSevenDaysPassed
     {
-        vm.warp({ newTimestamp: defaults.EXPIRATION() + 1 seconds });
+        vm.warp({ newTimestamp: EXPIRATION + 1 seconds });
         vm.assume(to != address(0));
         test_Clawback(to);
     }
diff --git a/tests/integration/concrete/campaign/shared/collect-fees/collectFees.t.sol b/tests/integration/concrete/campaign/shared/collect-fees/collectFees.t.sol
index c9a262fa..b4558e9e 100644
--- a/tests/integration/concrete/campaign/shared/collect-fees/collectFees.t.sol
+++ b/tests/integration/concrete/campaign/shared/collect-fees/collectFees.t.sol
@@ -69,6 +69,6 @@ abstract contract CollectFees_Integration_Test is Integration_Test {
         // It should set the ETH balance to 0.
         assertEq(address(merkleBase).balance, 0, "merkle lockup ETH balance");
         // It should transfer fee collected in ETH to the factory admin.
-        assertEq(admin.balance, initialAdminBalance + defaults.MINIMUM_FEE(), "admin ETH balance");
+        assertEq(admin.balance, initialAdminBalance + MINIMUM_FEE, "admin ETH balance");
     }
 }
diff --git a/tests/integration/concrete/campaign/shared/has-claimed/hasClaimed.t.sol b/tests/integration/concrete/campaign/shared/has-claimed/hasClaimed.t.sol
index 435815ce..55e16e9a 100644
--- a/tests/integration/concrete/campaign/shared/has-claimed/hasClaimed.t.sol
+++ b/tests/integration/concrete/campaign/shared/has-claimed/hasClaimed.t.sol
@@ -11,7 +11,7 @@ abstract contract HasClaimed_Integration_Test is Integration_Test {
 
     function test_GivenRecipientNotClaimed() external whenIndexInMerkleTree {
         // It should return false.
-        assertFalse(merkleBase.hasClaimed(defaults.INDEX1()), "claimed");
+        assertFalse(merkleBase.hasClaimed(INDEX1), "claimed");
     }
 
     function test_GivenRecipientClaimed() external whenIndexInMerkleTree {
@@ -19,6 +19,6 @@ abstract contract HasClaimed_Integration_Test is Integration_Test {
         claim();
 
         // It should return true.
-        assertTrue(merkleBase.hasClaimed(defaults.INDEX1()), "not claimed");
+        assertTrue(merkleBase.hasClaimed(INDEX1), "not claimed");
     }
 }
diff --git a/tests/integration/concrete/campaign/shared/has-expired/hasExpired.t.sol b/tests/integration/concrete/campaign/shared/has-expired/hasExpired.t.sol
index 2b661ef3..55b02a4b 100644
--- a/tests/integration/concrete/campaign/shared/has-expired/hasExpired.t.sol
+++ b/tests/integration/concrete/campaign/shared/has-expired/hasExpired.t.sol
@@ -16,12 +16,12 @@ abstract contract HasExpired_Integration_Test is Integration_Test {
     }
 
     function test_WhenTheExpirationInPresent() external whenExpirationNotZero {
-        vm.warp({ newTimestamp: defaults.EXPIRATION() });
+        vm.warp({ newTimestamp: EXPIRATION });
         assertTrue(merkleBase.hasExpired(), "campaign not expired");
     }
 
     function test_WhenTheExpirationInFuture() external whenExpirationNotZero {
-        vm.warp({ newTimestamp: defaults.EXPIRATION() + 1 seconds });
+        vm.warp({ newTimestamp: EXPIRATION + 1 seconds });
         assertTrue(merkleBase.hasExpired(), "campaign not expired");
     }
 }
diff --git a/tests/integration/concrete/campaign/vca/claim/claim.t.sol b/tests/integration/concrete/campaign/vca/claim/claim.t.sol
index 6035f63d..e8b0b9db 100644
--- a/tests/integration/concrete/campaign/vca/claim/claim.t.sol
+++ b/tests/integration/concrete/campaign/vca/claim/claim.t.sol
@@ -13,76 +13,71 @@ contract Claim_MerkleVCA_Integration_Test is Claim_Integration_Test, MerkleVCA_I
     }
 
     function test_RevertWhen_StartTimeInFuture() external whenMerkleProofValid {
-        uint256 fee = defaults.MINIMUM_FEE();
-        uint128 claimAmount = defaults.CLAIM_AMOUNT();
-        bytes32[] memory merkleProof = defaults.index1Proof();
-        uint40 unlockStartTime = defaults.RANGED_STREAM_START_TIME();
-
         // Move back in time so that the unlock start time is in the future.
-        vm.warp({ newTimestamp: unlockStartTime - 1 });
+        vm.warp({ newTimestamp: RANGED_STREAM_START_TIME - 1 });
 
         // It should revert.
-        vm.expectRevert(abi.encodeWithSelector(Errors.SablierMerkleVCA_ClaimNotStarted.selector, unlockStartTime));
+        vm.expectRevert(
+            abi.encodeWithSelector(Errors.SablierMerkleVCA_ClaimNotStarted.selector, RANGED_STREAM_START_TIME)
+        );
 
         // Claim the airdrop.
-        merkleVCA.claim{ value: fee }({
+        merkleVCA.claim{ value: MINIMUM_FEE }({
             index: 1,
             recipient: users.recipient1,
-            amount: claimAmount,
-            merkleProof: merkleProof
+            amount: CLAIM_AMOUNT,
+            merkleProof: index1Proof()
         });
     }
 
     function test_WhenEndTimeInPast() external whenMerkleProofValid whenStartTimeNotInFuture {
         // Forward in time so that the unlock end time is in the past.
-        vm.warp({ newTimestamp: defaults.RANGED_STREAM_END_TIME() });
+        vm.warp({ newTimestamp: RANGED_STREAM_END_TIME });
 
         // It should emit a {Claim} event.
         vm.expectEmit({ emitter: address(merkleVCA) });
-        emit ISablierMerkleVCA.Claim(
-            defaults.INDEX1(), users.recipient1, defaults.CLAIM_AMOUNT(), defaults.CLAIM_AMOUNT()
-        );
+        emit ISablierMerkleVCA.Claim(INDEX1, users.recipient1, CLAIM_AMOUNT, CLAIM_AMOUNT);
 
         // It should transfer the full amount.
-        expectCallToTransfer({ to: users.recipient1, value: defaults.CLAIM_AMOUNT() });
-        expectCallToClaimWithMsgValue(address(merkleVCA), defaults.MINIMUM_FEE());
+        expectCallToTransfer({ to: users.recipient1, value: CLAIM_AMOUNT });
+        expectCallToClaimWithMsgValue(address(merkleVCA), MINIMUM_FEE);
 
-        merkleVCA.claim{ value: defaults.MINIMUM_FEE() }({
+        merkleVCA.claim{ value: MINIMUM_FEE }({
             index: 1,
             recipient: users.recipient1,
-            amount: defaults.CLAIM_AMOUNT(),
-            merkleProof: defaults.index1Proof()
+            amount: CLAIM_AMOUNT,
+            merkleProof: index1Proof()
         });
 
         // It should update the claimed status.
-        assertTrue(merkleVCA.hasClaimed(defaults.INDEX1()), "not claimed");
+        assertTrue(merkleVCA.hasClaimed(INDEX1), "not claimed");
 
         // It should not update forgone amount.
         assertEq(merkleVCA.forgoneAmount(), 0, "forgone amount");
     }
 
     function test_WhenEndTimeNotInPast() external whenMerkleProofValid whenStartTimeNotInFuture {
-        uint128 claimableAmount = (defaults.CLAIM_AMOUNT() * 2 days) / defaults.TOTAL_DURATION();
+        uint128 claimableAmount = (CLAIM_AMOUNT * 2 days) / TOTAL_DURATION;
 
         // It should emit a {Claim} event.
         vm.expectEmit({ emitter: address(merkleVCA) });
-        emit ISablierMerkleVCA.Claim(defaults.INDEX1(), users.recipient1, claimableAmount, defaults.CLAIM_AMOUNT());
+        emit ISablierMerkleVCA.Claim(INDEX1, users.recipient1, claimableAmount, CLAIM_AMOUNT);
 
         // It should transfer a portion of the amount.
         expectCallToTransfer({ to: users.recipient1, value: claimableAmount });
-        expectCallToClaimWithMsgValue(address(merkleVCA), defaults.MINIMUM_FEE());
+        expectCallToClaimWithMsgValue(address(merkleVCA), MINIMUM_FEE);
 
-        merkleVCA.claim{ value: defaults.MINIMUM_FEE() }({
+        merkleVCA.claim{ value: MINIMUM_FEE }({
             index: 1,
             recipient: users.recipient1,
-            amount: defaults.CLAIM_AMOUNT(),
-            merkleProof: defaults.index1Proof()
+            amount: CLAIM_AMOUNT,
+            merkleProof: index1Proof()
         });
 
         // It should update the claimed status.
-        assertTrue(merkleVCA.hasClaimed(defaults.INDEX1()), "not claimed");
+        assertTrue(merkleVCA.hasClaimed(INDEX1), "not claimed");
 
         // It should update forgone amount.
-        assertEq(merkleVCA.forgoneAmount(), defaults.CLAIM_AMOUNT() - claimableAmount, "forgone amount");
+        assertEq(merkleVCA.forgoneAmount(), CLAIM_AMOUNT - claimableAmount, "forgone amount");
     }
 }
diff --git a/tests/integration/concrete/campaign/vca/constructor.t.sol b/tests/integration/concrete/campaign/vca/constructor.t.sol
index 41d86efe..09ce2316 100644
--- a/tests/integration/concrete/campaign/vca/constructor.t.sol
+++ b/tests/integration/concrete/campaign/vca/constructor.t.sol
@@ -13,15 +13,15 @@ contract Constructor_MerkleVCA_Integration_Test is MerkleVCA_Integration_Shared_
         SablierMerkleVCA actualMerkleVCA = new SablierMerkleVCA(merkleVCAConstructorParams(), users.campaignOwner);
 
         assertEq(actualMerkleVCA.admin(), users.campaignOwner, "admin");
-        assertEq(actualMerkleVCA.campaignName(), defaults.CAMPAIGN_NAME(), "campaign name");
-        assertEq(actualMerkleVCA.EXPIRATION(), defaults.EXPIRATION(), "expiration");
+        assertEq(actualMerkleVCA.campaignName(), CAMPAIGN_NAME, "campaign name");
+        assertEq(actualMerkleVCA.EXPIRATION(), EXPIRATION, "expiration");
         assertEq(actualMerkleVCA.FACTORY(), address(merkleFactoryVCA), "factory");
-        assertEq(actualMerkleVCA.MINIMUM_FEE(), defaults.MINIMUM_FEE(), "minimum fee");
-        assertEq(actualMerkleVCA.ipfsCID(), defaults.IPFS_CID(), "ipfsCID");
-        assertEq(actualMerkleVCA.MERKLE_ROOT(), defaults.MERKLE_ROOT(), "merkleRoot");
+        assertEq(actualMerkleVCA.MINIMUM_FEE(), MINIMUM_FEE, "minimum fee");
+        assertEq(actualMerkleVCA.ipfsCID(), IPFS_CID, "ipfsCID");
+        assertEq(actualMerkleVCA.MERKLE_ROOT(), MERKLE_ROOT, "merkleRoot");
         assertEq(actualMerkleVCA.forgoneAmount(), 0, "forgoneAmount");
-        assertEq(actualMerkleVCA.timestamps().start, defaults.RANGED_STREAM_START_TIME(), "unlock start");
-        assertEq(actualMerkleVCA.timestamps().end, defaults.RANGED_STREAM_END_TIME(), "unlock end");
+        assertEq(actualMerkleVCA.timestamps().start, RANGED_STREAM_START_TIME, "unlock start");
+        assertEq(actualMerkleVCA.timestamps().end, RANGED_STREAM_END_TIME, "unlock end");
         assertEq(address(actualMerkleVCA.TOKEN()), address(dai), "token");
     }
 }
diff --git a/tests/integration/concrete/factory/instant/constructor.t.sol b/tests/integration/concrete/factory/instant/constructor.t.sol
index 955558f1..c7b29ddb 100644
--- a/tests/integration/concrete/factory/instant/constructor.t.sol
+++ b/tests/integration/concrete/factory/instant/constructor.t.sol
@@ -8,13 +8,13 @@ import { Integration_Test } from "../../../Integration.t.sol";
 contract Constructor_MerkleFactoryInstant_Integration_Test is Integration_Test {
     function test_Constructor() external {
         SablierMerkleFactoryInstant constructedFactoryInstant =
-            new SablierMerkleFactoryInstant(users.admin, defaults.MINIMUM_FEE());
+            new SablierMerkleFactoryInstant(users.admin, MINIMUM_FEE);
 
         address actualAdmin = constructedFactoryInstant.admin();
         assertEq(actualAdmin, users.admin, "factory admin");
 
         uint256 actualMinimumFee = constructedFactoryInstant.minimumFee();
-        uint256 expectedMinimumFee = defaults.MINIMUM_FEE();
+        uint256 expectedMinimumFee = MINIMUM_FEE;
         assertEq(actualMinimumFee, expectedMinimumFee, "minimum fee");
     }
 }
diff --git a/tests/integration/concrete/factory/instant/create-merkle-instant/createMerkleInstant.t.sol b/tests/integration/concrete/factory/instant/create-merkle-instant/createMerkleInstant.t.sol
index c5ad83e0..c9d25413 100644
--- a/tests/integration/concrete/factory/instant/create-merkle-instant/createMerkleInstant.t.sol
+++ b/tests/integration/concrete/factory/instant/create-merkle-instant/createMerkleInstant.t.sol
@@ -12,12 +12,9 @@ contract CreateMerkleInstant_Integration_Test is Integration_Test {
     function test_RevertGiven_CampaignAlreadyExists() external {
         MerkleInstant.ConstructorParams memory params = merkleInstantConstructorParams();
 
-        uint256 aggregateAmount = defaults.AGGREGATE_AMOUNT();
-        uint256 recipientCount = defaults.RECIPIENT_COUNT();
-
         // Expect a revert due to CREATE2.
         vm.expectRevert();
-        merkleFactoryInstant.createMerkleInstant(params, aggregateAmount, recipientCount);
+        merkleFactoryInstant.createMerkleInstant(params, AGGREGATE_AMOUNT, AGGREGATE_AMOUNT);
     }
 
     function test_GivenCustomFeeSet(
@@ -40,8 +37,8 @@ contract CreateMerkleInstant_Integration_Test is Integration_Test {
         emit ISablierMerkleFactoryInstant.CreateMerkleInstant({
             merkleInstant: ISablierMerkleInstant(expectedMerkleInstant),
             params: merkleInstantConstructorParams(campaignOwner, expiration),
-            aggregateAmount: defaults.AGGREGATE_AMOUNT(),
-            recipientCount: defaults.RECIPIENT_COUNT(),
+            aggregateAmount: AGGREGATE_AMOUNT,
+            recipientCount: RECIPIENT_COUNT,
             fee: customFee
         });
 
@@ -66,9 +63,9 @@ contract CreateMerkleInstant_Integration_Test is Integration_Test {
         emit ISablierMerkleFactoryInstant.CreateMerkleInstant({
             merkleInstant: ISablierMerkleInstant(expectedMerkleInstant),
             params: merkleInstantConstructorParams(campaignOwner, expiration),
-            aggregateAmount: defaults.AGGREGATE_AMOUNT(),
-            recipientCount: defaults.RECIPIENT_COUNT(),
-            fee: defaults.MINIMUM_FEE()
+            aggregateAmount: AGGREGATE_AMOUNT,
+            recipientCount: RECIPIENT_COUNT,
+            fee: MINIMUM_FEE
         });
 
         ISablierMerkleInstant actualInstant = createMerkleInstant(campaignOwner, expiration);
@@ -78,7 +75,7 @@ contract CreateMerkleInstant_Integration_Test is Integration_Test {
         );
 
         // It should create the campaign with custom fee.
-        assertEq(actualInstant.MINIMUM_FEE(), defaults.MINIMUM_FEE(), "minimum fee");
+        assertEq(actualInstant.MINIMUM_FEE(), MINIMUM_FEE, "minimum fee");
 
         // It should set the current factory address.
         assertEq(actualInstant.FACTORY(), address(merkleFactoryInstant), "factory");
diff --git a/tests/integration/concrete/factory/ll/constructor.t.sol b/tests/integration/concrete/factory/ll/constructor.t.sol
index a3da53b9..87f75807 100644
--- a/tests/integration/concrete/factory/ll/constructor.t.sol
+++ b/tests/integration/concrete/factory/ll/constructor.t.sol
@@ -7,13 +7,13 @@ import { Integration_Test } from "../../../Integration.t.sol";
 
 contract Constructor_MerkleFactoryLL_Integration_Test is Integration_Test {
     function test_Constructor() external {
-        SablierMerkleFactoryLL constructedFactoryLL = new SablierMerkleFactoryLL(users.admin, defaults.MINIMUM_FEE());
+        SablierMerkleFactoryLL constructedFactoryLL = new SablierMerkleFactoryLL(users.admin, MINIMUM_FEE);
 
         address actualAdmin = constructedFactoryLL.admin();
         assertEq(actualAdmin, users.admin, "factory admin");
 
         uint256 actualMinimumFee = constructedFactoryLL.minimumFee();
-        uint256 expectedMinimumFee = defaults.MINIMUM_FEE();
+        uint256 expectedMinimumFee = MINIMUM_FEE;
         assertEq(actualMinimumFee, expectedMinimumFee, "minimum fee");
     }
 }
diff --git a/tests/integration/concrete/factory/ll/create-merkle-ll/createMerkleLL.t.sol b/tests/integration/concrete/factory/ll/create-merkle-ll/createMerkleLL.t.sol
index 62ff43d9..bad61230 100644
--- a/tests/integration/concrete/factory/ll/create-merkle-ll/createMerkleLL.t.sol
+++ b/tests/integration/concrete/factory/ll/create-merkle-ll/createMerkleLL.t.sol
@@ -12,12 +12,9 @@ contract CreateMerkleLL_Integration_Test is Integration_Test {
     function test_RevertGiven_CampaignAlreadyExists() external {
         MerkleLL.ConstructorParams memory params = merkleLLConstructorParams();
 
-        uint256 aggregateAmount = defaults.AGGREGATE_AMOUNT();
-        uint256 recipientCount = defaults.RECIPIENT_COUNT();
-
         // Expect a revert due to CREATE2.
         vm.expectRevert();
-        merkleFactoryLL.createMerkleLL(params, aggregateAmount, recipientCount);
+        merkleFactoryLL.createMerkleLL(params, AGGREGATE_AMOUNT, RECIPIENT_COUNT);
     }
 
     function test_GivenCustomFeeSet(
@@ -40,8 +37,8 @@ contract CreateMerkleLL_Integration_Test is Integration_Test {
         emit ISablierMerkleFactoryLL.CreateMerkleLL({
             merkleLL: ISablierMerkleLL(expectedLL),
             params: merkleLLConstructorParams(campaignOwner, expiration),
-            aggregateAmount: defaults.AGGREGATE_AMOUNT(),
-            recipientCount: defaults.RECIPIENT_COUNT(),
+            aggregateAmount: AGGREGATE_AMOUNT,
+            recipientCount: RECIPIENT_COUNT,
             fee: customFee
         });
 
@@ -64,9 +61,9 @@ contract CreateMerkleLL_Integration_Test is Integration_Test {
         emit ISablierMerkleFactoryLL.CreateMerkleLL({
             merkleLL: ISablierMerkleLL(expectedLL),
             params: merkleLLConstructorParams(campaignOwner, expiration),
-            aggregateAmount: defaults.AGGREGATE_AMOUNT(),
-            recipientCount: defaults.RECIPIENT_COUNT(),
-            fee: defaults.MINIMUM_FEE()
+            aggregateAmount: AGGREGATE_AMOUNT,
+            recipientCount: RECIPIENT_COUNT,
+            fee: MINIMUM_FEE
         });
 
         ISablierMerkleLL actualLL = createMerkleLL(campaignOwner, expiration);
@@ -74,10 +71,10 @@ contract CreateMerkleLL_Integration_Test is Integration_Test {
         assertEq(address(actualLL), expectedLL, "MerkleLL contract does not match computed address");
 
         // It should set the correct shape.
-        assertEq(actualLL.shape(), defaults.SHAPE(), "shape");
+        assertEq(actualLL.shape(), SHAPE, "shape");
 
         // It should create the campaign with custom fee.
-        assertEq(actualLL.MINIMUM_FEE(), defaults.MINIMUM_FEE(), "minimum fee");
+        assertEq(actualLL.MINIMUM_FEE(), MINIMUM_FEE, "minimum fee");
 
         // It should set the current factory address.
         assertEq(actualLL.FACTORY(), address(merkleFactoryLL), "factory");
diff --git a/tests/integration/concrete/factory/lt/constructor.t.sol b/tests/integration/concrete/factory/lt/constructor.t.sol
index c4e6aaab..1e9ce4c3 100644
--- a/tests/integration/concrete/factory/lt/constructor.t.sol
+++ b/tests/integration/concrete/factory/lt/constructor.t.sol
@@ -7,13 +7,13 @@ import { Integration_Test } from "../../../Integration.t.sol";
 
 contract Constructor_MerkleFactoryLT_Integration_Test is Integration_Test {
     function test_Constructor() external {
-        SablierMerkleFactoryLT constructedFactoryLT = new SablierMerkleFactoryLT(users.admin, defaults.MINIMUM_FEE());
+        SablierMerkleFactoryLT constructedFactoryLT = new SablierMerkleFactoryLT(users.admin, MINIMUM_FEE);
 
         address actualAdmin = constructedFactoryLT.admin();
         assertEq(actualAdmin, users.admin, "factory admin");
 
         uint256 actualMinimumFee = constructedFactoryLT.minimumFee();
-        uint256 expectedMinimumFee = defaults.MINIMUM_FEE();
+        uint256 expectedMinimumFee = MINIMUM_FEE;
         assertEq(actualMinimumFee, expectedMinimumFee, "minimum fee");
     }
 }
diff --git a/tests/integration/concrete/factory/lt/create-merkle-lt/createMerkleLT.t.sol b/tests/integration/concrete/factory/lt/create-merkle-lt/createMerkleLT.t.sol
index 06c64765..a2497b2d 100644
--- a/tests/integration/concrete/factory/lt/create-merkle-lt/createMerkleLT.t.sol
+++ b/tests/integration/concrete/factory/lt/create-merkle-lt/createMerkleLT.t.sol
@@ -11,12 +11,9 @@ contract CreateMerkleLT_Integration_Test is Integration_Test {
     /// @dev This test reverts because a default MerkleLT contract is deployed in {Integration_Test.setUp}
     function test_RevertGiven_CampaignAlreadyExists() external {
         MerkleLT.ConstructorParams memory params = merkleLTConstructorParams();
-        uint256 aggregateAmount = defaults.AGGREGATE_AMOUNT();
-        uint256 recipientCount = defaults.RECIPIENT_COUNT();
-
         // Expect a revert due to CREATE2.
         vm.expectRevert();
-        merkleFactoryLT.createMerkleLT(params, aggregateAmount, recipientCount);
+        merkleFactoryLT.createMerkleLT(params, AGGREGATE_AMOUNT, RECIPIENT_COUNT);
     }
 
     function test_GivenCustomFeeSet(
@@ -39,9 +36,9 @@ contract CreateMerkleLT_Integration_Test is Integration_Test {
         emit ISablierMerkleFactoryLT.CreateMerkleLT({
             merkleLT: ISablierMerkleLT(expectedLT),
             params: merkleLTConstructorParams(campaignOwner, expiration),
-            aggregateAmount: defaults.AGGREGATE_AMOUNT(),
-            recipientCount: defaults.RECIPIENT_COUNT(),
-            totalDuration: defaults.TOTAL_DURATION(),
+            aggregateAmount: AGGREGATE_AMOUNT,
+            recipientCount: RECIPIENT_COUNT,
+            totalDuration: TOTAL_DURATION,
             fee: customFee
         });
 
@@ -62,10 +59,10 @@ contract CreateMerkleLT_Integration_Test is Integration_Test {
         emit ISablierMerkleFactoryLT.CreateMerkleLT({
             merkleLT: ISablierMerkleLT(expectedLT),
             params: merkleLTConstructorParams(campaignOwner, expiration),
-            aggregateAmount: defaults.AGGREGATE_AMOUNT(),
-            recipientCount: defaults.RECIPIENT_COUNT(),
-            totalDuration: defaults.TOTAL_DURATION(),
-            fee: defaults.MINIMUM_FEE()
+            aggregateAmount: AGGREGATE_AMOUNT,
+            recipientCount: RECIPIENT_COUNT,
+            totalDuration: TOTAL_DURATION,
+            fee: MINIMUM_FEE
         });
 
         ISablierMerkleLT actualLT = createMerkleLT(campaignOwner, expiration);
@@ -73,10 +70,10 @@ contract CreateMerkleLT_Integration_Test is Integration_Test {
         assertEq(address(actualLT), expectedLT, "MerkleLT contract does not match computed address");
 
         // It should set the correct shape.
-        assertEq(actualLT.shape(), defaults.SHAPE(), "shape");
+        assertEq(actualLT.shape(), SHAPE, "shape");
 
         // It should create the campaign with custom fee.
-        assertEq(actualLT.MINIMUM_FEE(), defaults.MINIMUM_FEE(), "minimum fee");
+        assertEq(actualLT.MINIMUM_FEE(), MINIMUM_FEE, "minimum fee");
         // It should set the current factory address.
         assertEq(actualLT.FACTORY(), address(merkleFactoryLT), "factory");
     }
diff --git a/tests/integration/concrete/factory/shared/collect-fees/collectFees.t.sol b/tests/integration/concrete/factory/shared/collect-fees/collectFees.t.sol
index b9f72639..1fbc7f1a 100644
--- a/tests/integration/concrete/factory/shared/collect-fees/collectFees.t.sol
+++ b/tests/integration/concrete/factory/shared/collect-fees/collectFees.t.sol
@@ -57,11 +57,7 @@ abstract contract CollectFees_Integration_Test is Integration_Test {
 
         // It should emit a {CollectFees} event.
         vm.expectEmit({ emitter: address(merkleFactoryBase) });
-        emit ISablierMerkleFactoryBase.CollectFees({
-            admin: admin,
-            merkleBase: merkleBase,
-            feeAmount: defaults.MINIMUM_FEE()
-        });
+        emit ISablierMerkleFactoryBase.CollectFees({ admin: admin, merkleBase: merkleBase, feeAmount: MINIMUM_FEE });
 
         // Make Alice the caller.
         resetPrank({ msgSender: users.eve });
@@ -72,6 +68,6 @@ abstract contract CollectFees_Integration_Test is Integration_Test {
         assertEq(address(merkleBase).balance, 0, "merkle lockup ETH balance");
 
         // It should transfer fee to the factory admin.
-        assertEq(admin.balance, initialAdminBalance + defaults.MINIMUM_FEE(), "admin ETH balance");
+        assertEq(admin.balance, initialAdminBalance + MINIMUM_FEE, "admin ETH balance");
     }
 }
diff --git a/tests/integration/concrete/factory/shared/get-fee/getFee.t.sol b/tests/integration/concrete/factory/shared/get-fee/getFee.t.sol
index 7d36cb41..b357fe77 100644
--- a/tests/integration/concrete/factory/shared/get-fee/getFee.t.sol
+++ b/tests/integration/concrete/factory/shared/get-fee/getFee.t.sol
@@ -6,7 +6,7 @@ import { Integration_Test } from "../../../../Integration.t.sol";
 abstract contract GetFee_Integration_Test is Integration_Test {
     function test_GivenCustomFeeNotSet() external view {
         // It should return minimum fee.
-        assertEq(merkleFactoryBase.getFee(users.campaignOwner), defaults.MINIMUM_FEE(), "minimum fee");
+        assertEq(merkleFactoryBase.getFee(users.campaignOwner), MINIMUM_FEE, "minimum fee");
     }
 
     function test_GivenCustomFeeSet() external {
diff --git a/tests/integration/concrete/factory/vca/constructor.t.sol b/tests/integration/concrete/factory/vca/constructor.t.sol
index 07549a1d..fd906338 100644
--- a/tests/integration/concrete/factory/vca/constructor.t.sol
+++ b/tests/integration/concrete/factory/vca/constructor.t.sol
@@ -7,13 +7,13 @@ import { Integration_Test } from "../../../Integration.t.sol";
 
 contract Constructor_MerkleFactoryVCA_Integration_Test is Integration_Test {
     function test_Constructor() external {
-        SablierMerkleFactoryVCA constructedFactoryVCA = new SablierMerkleFactoryVCA(users.admin, defaults.MINIMUM_FEE());
+        SablierMerkleFactoryVCA constructedFactoryVCA = new SablierMerkleFactoryVCA(users.admin, MINIMUM_FEE);
 
         address actualAdmin = constructedFactoryVCA.admin();
         assertEq(actualAdmin, users.admin, "factory admin");
 
         uint256 actualMinimumFee = constructedFactoryVCA.minimumFee();
-        uint256 expectedMinimumFee = defaults.MINIMUM_FEE();
+        uint256 expectedMinimumFee = MINIMUM_FEE;
         assertEq(actualMinimumFee, expectedMinimumFee, "minimum fee");
     }
 }
diff --git a/tests/integration/concrete/factory/vca/create-merkle-vca/createMerkleVCA.t.sol b/tests/integration/concrete/factory/vca/create-merkle-vca/createMerkleVCA.t.sol
index ec72b292..0b15c986 100644
--- a/tests/integration/concrete/factory/vca/create-merkle-vca/createMerkleVCA.t.sol
+++ b/tests/integration/concrete/factory/vca/create-merkle-vca/createMerkleVCA.t.sol
@@ -11,16 +11,6 @@ import { Integration_Test } from "../../../../Integration.t.sol";
 /// @dev Some of the tests use `users.sender` as the campaign owner to avoid collision with the default MerkleVCA
 /// contract deployed in {Integration_Test.setUp}.
 contract CreateMerkleVCA_Integration_Test is Integration_Test {
-    uint256 internal aggregateAmount;
-    uint256 internal recipientCount;
-
-    function setUp() public override {
-        Integration_Test.setUp();
-
-        aggregateAmount = defaults.AGGREGATE_AMOUNT();
-        recipientCount = defaults.RECIPIENT_COUNT();
-    }
-
     /// @dev This test reverts because a default MerkleVCA contract is deployed in {Integration_Test.setUp}
     function test_RevertGiven_CampaignAlreadyExists() external {
         // This test fails
@@ -30,8 +20,8 @@ contract CreateMerkleVCA_Integration_Test is Integration_Test {
         vm.expectRevert();
         merkleFactoryVCA.createMerkleVCA({
             params: params,
-            aggregateAmount: aggregateAmount,
-            recipientCount: recipientCount
+            aggregateAmount: AGGREGATE_AMOUNT,
+            recipientCount: RECIPIENT_COUNT
         });
     }
 
@@ -43,15 +33,15 @@ contract CreateMerkleVCA_Integration_Test is Integration_Test {
         vm.expectRevert(Errors.SablierMerkleVCA_StartTimeZero.selector);
         merkleFactoryVCA.createMerkleVCA({
             params: params,
-            aggregateAmount: aggregateAmount,
-            recipientCount: recipientCount
+            aggregateAmount: AGGREGATE_AMOUNT,
+            recipientCount: RECIPIENT_COUNT
         });
     }
 
     function test_RevertWhen_EndTimeLessThanStartTime() external givenCampaignNotExists whenStartTimeNotZero {
         MerkleVCA.ConstructorParams memory params = merkleVCAConstructorParams();
         // Set the end time to be less than the start time.
-        params.timestamps.end = defaults.RANGED_STREAM_START_TIME() - 1;
+        params.timestamps.end = RANGED_STREAM_START_TIME - 1;
 
         // It should revert.
         vm.expectRevert(
@@ -61,15 +51,15 @@ contract CreateMerkleVCA_Integration_Test is Integration_Test {
         );
         merkleFactoryVCA.createMerkleVCA({
             params: params,
-            aggregateAmount: aggregateAmount,
-            recipientCount: recipientCount
+            aggregateAmount: AGGREGATE_AMOUNT,
+            recipientCount: RECIPIENT_COUNT
         });
     }
 
     function test_RevertWhen_EndTimeEqualsStartTime() external givenCampaignNotExists whenStartTimeNotZero {
         MerkleVCA.ConstructorParams memory params = merkleVCAConstructorParams();
         // Set the end time equal to the start time.
-        params.timestamps.end = defaults.RANGED_STREAM_START_TIME();
+        params.timestamps.end = RANGED_STREAM_START_TIME;
 
         // It should revert.
         vm.expectRevert(
@@ -79,8 +69,8 @@ contract CreateMerkleVCA_Integration_Test is Integration_Test {
         );
         merkleFactoryVCA.createMerkleVCA({
             params: params,
-            aggregateAmount: aggregateAmount,
-            recipientCount: recipientCount
+            aggregateAmount: AGGREGATE_AMOUNT,
+            recipientCount: RECIPIENT_COUNT
         });
     }
 
@@ -97,8 +87,8 @@ contract CreateMerkleVCA_Integration_Test is Integration_Test {
         vm.expectRevert(Errors.SablierMerkleVCA_ExpiryTimeZero.selector);
         merkleFactoryVCA.createMerkleVCA({
             params: params,
-            aggregateAmount: aggregateAmount,
-            recipientCount: recipientCount
+            aggregateAmount: AGGREGATE_AMOUNT,
+            recipientCount: RECIPIENT_COUNT
         });
     }
 
@@ -110,7 +100,7 @@ contract CreateMerkleVCA_Integration_Test is Integration_Test {
         whenNotZeroExpiry
     {
         MerkleVCA.ConstructorParams memory params = merkleVCAConstructorParams();
-        params.expiration = defaults.RANGED_STREAM_END_TIME() + 1 weeks - 1;
+        params.expiration = RANGED_STREAM_END_TIME + 1 weeks - 1;
 
         // It should revert.
         vm.expectRevert(
@@ -120,7 +110,7 @@ contract CreateMerkleVCA_Integration_Test is Integration_Test {
                 params.expiration
             )
         );
-        merkleFactoryVCA.createMerkleVCA(params, aggregateAmount, recipientCount);
+        merkleFactoryVCA.createMerkleVCA(params, AGGREGATE_AMOUNT, RECIPIENT_COUNT);
     }
 
     function test_GivenCustomFeeSet()
@@ -136,21 +126,19 @@ contract CreateMerkleVCA_Integration_Test is Integration_Test {
         merkleFactoryVCA.setCustomFee(users.campaignOwner, 0);
 
         resetPrank(users.campaignOwner);
-        address expectedMerkleVCA =
-            computeMerkleVCAAddress({ campaignOwner: users.sender, expiration: defaults.EXPIRATION() });
+        address expectedMerkleVCA = computeMerkleVCAAddress({ campaignOwner: users.sender, expiration: EXPIRATION });
 
         // It should emit a {CreateMerkleVCA} event.
         vm.expectEmit(address(merkleFactoryVCA));
         emit ISablierMerkleFactoryVCA.CreateMerkleVCA({
             merkleVCA: ISablierMerkleVCA(address(expectedMerkleVCA)),
-            params: merkleVCAConstructorParams({ campaignOwner: users.sender, expiration: defaults.EXPIRATION() }),
-            aggregateAmount: defaults.AGGREGATE_AMOUNT(),
-            recipientCount: defaults.RECIPIENT_COUNT(),
+            params: merkleVCAConstructorParams({ campaignOwner: users.sender, expiration: EXPIRATION }),
+            aggregateAmount: AGGREGATE_AMOUNT,
+            recipientCount: RECIPIENT_COUNT,
             fee: 0
         });
 
-        ISablierMerkleVCA actualVCA =
-            createMerkleVCA({ campaignOwner: users.sender, expiration: defaults.EXPIRATION() });
+        ISablierMerkleVCA actualVCA = createMerkleVCA({ campaignOwner: users.sender, expiration: EXPIRATION });
         assertGt(address(actualVCA).code.length, 0, "MerkleVCA contract not created");
         assertEq(address(actualVCA), expectedMerkleVCA, "MerkleVCA contract does not match computed address");
 
@@ -161,8 +149,8 @@ contract CreateMerkleVCA_Integration_Test is Integration_Test {
         assertEq(actualVCA.FACTORY(), address(merkleFactoryVCA), "factory");
 
         // It should set return the correct unlock schedule.
-        assertEq(actualVCA.timestamps().start, defaults.RANGED_STREAM_START_TIME(), "unlock start");
-        assertEq(actualVCA.timestamps().end, defaults.RANGED_STREAM_END_TIME(), "unlock end");
+        assertEq(actualVCA.timestamps().start, RANGED_STREAM_START_TIME, "unlock start");
+        assertEq(actualVCA.timestamps().end, RANGED_STREAM_END_TIME, "unlock end");
     }
 
     function test_GivenCustomFeeNotSet()
@@ -173,32 +161,30 @@ contract CreateMerkleVCA_Integration_Test is Integration_Test {
         whenNotZeroExpiry
         whenExpiryNotExceedOneWeekFromEndTime
     {
-        address expectedMerkleVCA =
-            computeMerkleVCAAddress({ campaignOwner: users.sender, expiration: defaults.EXPIRATION() });
+        address expectedMerkleVCA = computeMerkleVCAAddress({ campaignOwner: users.sender, expiration: EXPIRATION });
 
         // It should emit a {CreateMerkleVCA} event.
         vm.expectEmit(address(merkleFactoryVCA));
         emit ISablierMerkleFactoryVCA.CreateMerkleVCA({
             merkleVCA: ISablierMerkleVCA(address(expectedMerkleVCA)),
-            params: merkleVCAConstructorParams({ campaignOwner: users.sender, expiration: defaults.EXPIRATION() }),
-            aggregateAmount: defaults.AGGREGATE_AMOUNT(),
-            recipientCount: defaults.RECIPIENT_COUNT(),
-            fee: defaults.MINIMUM_FEE()
+            params: merkleVCAConstructorParams({ campaignOwner: users.sender, expiration: EXPIRATION }),
+            aggregateAmount: AGGREGATE_AMOUNT,
+            recipientCount: RECIPIENT_COUNT,
+            fee: MINIMUM_FEE
         });
 
-        ISablierMerkleVCA actualVCA =
-            createMerkleVCA({ campaignOwner: users.sender, expiration: defaults.EXPIRATION() });
+        ISablierMerkleVCA actualVCA = createMerkleVCA({ campaignOwner: users.sender, expiration: EXPIRATION });
         assertGt(address(actualVCA).code.length, 0, "MerkleVCA contract not created");
         assertEq(address(actualVCA), expectedMerkleVCA, "MerkleVCA contract does not match computed address");
 
         // It should create the campaign with custom fee.
-        assertEq(actualVCA.MINIMUM_FEE(), defaults.MINIMUM_FEE(), "minimum fee");
+        assertEq(actualVCA.MINIMUM_FEE(), MINIMUM_FEE, "minimum fee");
 
         // It should set the current factory address.
         assertEq(actualVCA.FACTORY(), address(merkleFactoryVCA), "factory");
 
         // It should set return the correct unlock schedule.
-        assertEq(actualVCA.timestamps().start, defaults.RANGED_STREAM_START_TIME(), "unlock start");
-        assertEq(actualVCA.timestamps().end, defaults.RANGED_STREAM_END_TIME(), "unlock end");
+        assertEq(actualVCA.timestamps().start, RANGED_STREAM_START_TIME, "unlock start");
+        assertEq(actualVCA.timestamps().end, RANGED_STREAM_END_TIME, "unlock end");
     }
 }
diff --git a/tests/utils/Constants.sol b/tests/utils/Constants.sol
index 67d03dfa..7a5698a2 100644
--- a/tests/utils/Constants.sol
+++ b/tests/utils/Constants.sol
@@ -1,10 +1,46 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity >=0.8.22;
 
+import { UD2x18, uUNIT } from "@prb/math/src/UD2x18.sol";
+import { ud } from "@prb/math/src/UD60x18.sol";
+
 abstract contract Constants {
+    // Amounts
+    uint256 public constant AGGREGATE_AMOUNT = CLAIM_AMOUNT * RECIPIENT_COUNT;
+    uint128 public constant CLAIM_AMOUNT = 10_000e18;
+    uint128 public constant CLIFF_AMOUNT = (CLAIM_AMOUNT * CLIFF_DURATION) / TOTAL_DURATION;
+    UD2x18 public immutable CLIFF_PERCENTAGE = (ud(CLIFF_AMOUNT).div(ud(CLAIM_AMOUNT)).intoUD2x18());
+    uint256 public constant MINIMUM_FEE = 0.005e18;
+    uint128 public constant START_AMOUNT = 100e18;
+    UD2x18 public immutable START_PERCENTAGE = (ud(START_AMOUNT).div(ud(CLAIM_AMOUNT)).intoUD2x18());
+
+    // Durations and Timestamps
+    uint40 public constant CLIFF_DURATION = 2 days;
+    uint40 public immutable EXPIRATION = JULY_1_2024 + 12 weeks;
+    uint40 public constant FIRST_CLAIM_TIME = JULY_1_2024;
+    uint40 public immutable RANGED_STREAM_START_TIME = JULY_1_2024 - 2 days;
+    uint40 public immutable RANGED_STREAM_END_TIME = RANGED_STREAM_START_TIME + TOTAL_DURATION;
+    uint40 public constant TOTAL_DURATION = 10 days;
+
+    // Merkle Campaigns
+    string public CAMPAIGN_NAME = "Airdrop Campaign";
+    bool public constant CANCELABLE = false;
+    uint256 public constant INDEX1 = 1;
+    uint256 public constant INDEX2 = 2;
+    uint256 public constant INDEX3 = 3;
+    uint256 public constant INDEX4 = 4;
+    string public constant IPFS_CID = "QmbWqxBEKC3P8tqsKc98xmWNzrzDtRLMiMPL8wBuTGsMnR";
+    uint256[] public LEAVES = new uint256[](RECIPIENT_COUNT);
+    uint256 public constant RECIPIENT_COUNT = 4;
+    bytes32 public MERKLE_ROOT;
+    string public SHAPE = "A custom stream shape";
+    bool public constant TRANSFERABLE = false;
+
+    // Global
     uint40 internal constant JULY_1_2024 = 1_719_792_000;
     uint128 internal constant MAX_UINT128 = type(uint128).max;
     uint256 internal constant MAX_UINT256 = type(uint256).max;
     uint40 internal constant MAX_UNIX_TIMESTAMP = 2_147_483_647; // 2^31 - 1
+    uint64 public constant TOTAL_PERCENTAGE = uUNIT;
     uint40 internal constant ZERO = 0;
 }
diff --git a/tests/utils/Defaults.sol b/tests/utils/Defaults.sol
deleted file mode 100644
index ec35816b..00000000
--- a/tests/utils/Defaults.sol
+++ /dev/null
@@ -1,275 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity >=0.8.22;
-
-import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import { Arrays } from "@openzeppelin/contracts/utils/Arrays.sol";
-import { ud2x18, UD2x18, uUNIT } from "@prb/math/src/UD2x18.sol";
-import { ud } from "@prb/math/src/UD60x18.sol";
-import { ISablierLockup } from "@sablier/lockup/src/interfaces/ISablierLockup.sol";
-import { LockupTranched } from "@sablier/lockup/src/types/DataTypes.sol";
-import { Merkle } from "murky/src/Merkle.sol";
-
-import { MerkleInstant, MerkleLL, MerkleLT, MerkleVCA } from "../../src/types/DataTypes.sol";
-
-import { Constants } from "./Constants.sol";
-import { MerkleBuilder } from "./MerkleBuilder.sol";
-import { Users } from "./Types.sol";
-
-/// @notice Contract with default values used throughout the tests.
-contract Defaults is Constants, Merkle {
-    using MerkleBuilder for uint256[];
-
-    /*//////////////////////////////////////////////////////////////////////////
-                                      GENERICS
-    //////////////////////////////////////////////////////////////////////////*/
-
-    uint128 public immutable CLIFF_AMOUNT;
-    uint40 public constant CLIFF_DURATION = 2 days;
-    uint128 public constant START_AMOUNT = 100e18;
-    uint40 public constant TOTAL_DURATION = 10 days;
-
-    /*//////////////////////////////////////////////////////////////////////////
-                                  MERKLE-LOCKUP
-    //////////////////////////////////////////////////////////////////////////*/
-
-    uint256 public constant AGGREGATE_AMOUNT = CLAIM_AMOUNT * RECIPIENT_COUNT;
-    string public CAMPAIGN_NAME = "Airdrop Campaign";
-    bool public constant CANCELABLE = false;
-    uint128 public constant CLAIM_AMOUNT = 10_000e18;
-    UD2x18 public immutable CLIFF_PERCENTAGE;
-    uint40 public immutable EXPIRATION;
-    uint40 public constant FIRST_CLAIM_TIME = JULY_1_2024;
-    uint256 public constant INDEX1 = 1;
-    uint256 public constant INDEX2 = 2;
-    uint256 public constant INDEX3 = 3;
-    uint256 public constant INDEX4 = 4;
-    string public constant IPFS_CID = "QmbWqxBEKC3P8tqsKc98xmWNzrzDtRLMiMPL8wBuTGsMnR";
-    uint256[] public LEAVES = new uint256[](RECIPIENT_COUNT);
-    uint256 public constant MINIMUM_FEE = 0.005e18;
-    uint256 public constant RECIPIENT_COUNT = 4;
-    bytes32 public MERKLE_ROOT;
-    string public SHAPE = "A custom stream shape";
-    UD2x18 public immutable START_PERCENTAGE;
-    uint40 public constant RANGED_STREAM_START_TIME = JULY_1_2024 - 2 days;
-    uint40 public immutable RANGED_STREAM_END_TIME;
-    uint64 public constant TOTAL_PERCENTAGE = uUNIT;
-    bool public constant TRANSFERABLE = false;
-
-    /*//////////////////////////////////////////////////////////////////////////
-                                     VARIABLES
-    //////////////////////////////////////////////////////////////////////////*/
-
-    IERC20 private token;
-    Users private users;
-
-    /*//////////////////////////////////////////////////////////////////////////
-                                    CONSTRUCTOR
-    //////////////////////////////////////////////////////////////////////////*/
-
-    constructor() {
-        CLIFF_AMOUNT = (CLAIM_AMOUNT * CLIFF_DURATION) / TOTAL_DURATION;
-        CLIFF_PERCENTAGE = (ud(CLIFF_AMOUNT).div(ud(CLAIM_AMOUNT)).intoUD2x18()); // 20% of the claim amount
-        EXPIRATION = JULY_1_2024 + 12 weeks;
-        RANGED_STREAM_END_TIME = RANGED_STREAM_START_TIME + TOTAL_DURATION;
-        START_PERCENTAGE = (ud(START_AMOUNT).div(ud(CLAIM_AMOUNT)).intoUD2x18()); // 1% of the claim amount
-    }
-
-    /*//////////////////////////////////////////////////////////////////////////
-                                      HELPERS
-    //////////////////////////////////////////////////////////////////////////*/
-
-    function index1Proof() public view returns (bytes32[] memory) {
-        return indexProof(INDEX1, users.recipient1);
-    }
-
-    function index2Proof() public view returns (bytes32[] memory) {
-        return indexProof(INDEX2, users.recipient2);
-    }
-
-    function index3Proof() public view returns (bytes32[] memory) {
-        return indexProof(INDEX3, users.recipient3);
-    }
-
-    function index4Proof() public view returns (bytes32[] memory) {
-        return indexProof(INDEX4, users.recipient4);
-    }
-
-    function indexProof(uint256 index, address recipient) public view returns (bytes32[] memory) {
-        uint256 leaf = MerkleBuilder.computeLeaf(index, recipient, CLAIM_AMOUNT);
-        uint256 pos = Arrays.findUpperBound(LEAVES, leaf);
-        return getProof(LEAVES.toBytes32(), pos);
-    }
-
-    /// @dev We need a separate function to initialize the Merkle tree because, at the construction time, the users are
-    /// not yet set.
-    function initMerkleTree() public {
-        LEAVES[0] = MerkleBuilder.computeLeaf(INDEX1, users.recipient1, CLAIM_AMOUNT);
-        LEAVES[1] = MerkleBuilder.computeLeaf(INDEX2, users.recipient2, CLAIM_AMOUNT);
-        LEAVES[2] = MerkleBuilder.computeLeaf(INDEX3, users.recipient3, CLAIM_AMOUNT);
-        LEAVES[3] = MerkleBuilder.computeLeaf(INDEX4, users.recipient4, CLAIM_AMOUNT);
-        MerkleBuilder.sortLeaves(LEAVES);
-        MERKLE_ROOT = getRoot(LEAVES.toBytes32());
-    }
-
-    function setUsers(Users memory users_) public {
-        users = users_;
-    }
-
-    /*//////////////////////////////////////////////////////////////////////////
-                                  MERKLE-INSTANT
-    //////////////////////////////////////////////////////////////////////////*/
-
-    function merkleInstantConstructorParams(
-        address campaignOwner,
-        uint40 expiration,
-        bytes32 merkleRoot,
-        IERC20 token_
-    )
-        public
-        view
-        returns (MerkleInstant.ConstructorParams memory)
-    {
-        return MerkleInstant.ConstructorParams({
-            campaignName: CAMPAIGN_NAME,
-            expiration: expiration,
-            initialAdmin: campaignOwner,
-            ipfsCID: IPFS_CID,
-            merkleRoot: merkleRoot,
-            token: token_
-        });
-    }
-
-    /*//////////////////////////////////////////////////////////////////////////
-                                    MERKLE-LL
-    //////////////////////////////////////////////////////////////////////////*/
-
-    function merkleLLConstructorParams(
-        address campaignOwner,
-        uint40 expiration,
-        ISablierLockup lockup,
-        bytes32 merkleRoot,
-        IERC20 token_
-    )
-        public
-        view
-        returns (MerkleLL.ConstructorParams memory)
-    {
-        return MerkleLL.ConstructorParams({
-            campaignName: CAMPAIGN_NAME,
-            cancelable: CANCELABLE,
-            expiration: expiration,
-            initialAdmin: campaignOwner,
-            ipfsCID: IPFS_CID,
-            lockup: lockup,
-            merkleRoot: merkleRoot,
-            schedule: MerkleLL.Schedule({
-                startTime: ZERO,
-                startPercentage: START_PERCENTAGE,
-                cliffDuration: CLIFF_DURATION,
-                cliffPercentage: CLIFF_PERCENTAGE,
-                totalDuration: TOTAL_DURATION
-            }),
-            shape: SHAPE,
-            token: token_,
-            transferable: TRANSFERABLE
-        });
-    }
-
-    /*//////////////////////////////////////////////////////////////////////////
-                                    MERKLE-LT
-    //////////////////////////////////////////////////////////////////////////*/
-
-    function merkleLTConstructorParams(
-        address campaignOwner,
-        uint40 expiration,
-        ISablierLockup lockup,
-        bytes32 merkleRoot,
-        IERC20 token_
-    )
-        public
-        view
-        returns (MerkleLT.ConstructorParams memory)
-    {
-        MerkleLT.TrancheWithPercentage[] memory tranchesWithPercentages_ = new MerkleLT.TrancheWithPercentage[](2);
-        tranchesWithPercentages_[0] =
-            MerkleLT.TrancheWithPercentage({ unlockPercentage: ud2x18(0.2e18), duration: 2 days });
-        tranchesWithPercentages_[1] =
-            MerkleLT.TrancheWithPercentage({ unlockPercentage: ud2x18(0.8e18), duration: 8 days });
-
-        return MerkleLT.ConstructorParams({
-            campaignName: CAMPAIGN_NAME,
-            cancelable: CANCELABLE,
-            expiration: expiration,
-            initialAdmin: campaignOwner,
-            ipfsCID: IPFS_CID,
-            lockup: lockup,
-            merkleRoot: merkleRoot,
-            shape: SHAPE,
-            streamStartTime: ZERO,
-            token: token_,
-            tranchesWithPercentages: tranchesWithPercentages_,
-            transferable: TRANSFERABLE
-        });
-    }
-
-    /// @dev Mirrors the logic from {SablierMerkleLT._calculateStartTimeAndTranches}.
-    function tranchesMerkleLT(
-        uint40 streamStartTime,
-        uint128 totalAmount
-    )
-        public
-        view
-        returns (LockupTranched.Tranche[] memory tranches_)
-    {
-        tranches_ = new LockupTranched.Tranche[](2);
-        if (streamStartTime == 0) {
-            tranches_[0].timestamp = uint40(block.timestamp) + CLIFF_DURATION;
-            tranches_[1].timestamp = uint40(block.timestamp) + TOTAL_DURATION;
-        } else {
-            tranches_[0].timestamp = streamStartTime + CLIFF_DURATION;
-            tranches_[1].timestamp = streamStartTime + TOTAL_DURATION;
-        }
-
-        uint128 amount0 = ud(totalAmount).mul(ud(0.2e18)).intoUint128();
-        uint128 amount1 = ud(totalAmount).mul(ud(0.8e18)).intoUint128();
-
-        tranches_[0].amount = amount0;
-        tranches_[1].amount = amount1;
-
-        uint128 amountsSum = amount0 + amount1;
-
-        if (amountsSum != totalAmount) {
-            tranches_[1].amount += totalAmount - amountsSum;
-        }
-    }
-
-    /*//////////////////////////////////////////////////////////////////////////
-                                    MERKLE-VCA
-    //////////////////////////////////////////////////////////////////////////*/
-
-    function merkleVCAConstructorParams(
-        address campaignOwner,
-        uint40 expiration,
-        bytes32 merkleRoot,
-        MerkleVCA.Timestamps memory timestamps,
-        IERC20 token_
-    )
-        public
-        view
-        returns (MerkleVCA.ConstructorParams memory)
-    {
-        return MerkleVCA.ConstructorParams({
-            campaignName: CAMPAIGN_NAME,
-            expiration: expiration,
-            initialAdmin: campaignOwner,
-            ipfsCID: IPFS_CID,
-            merkleRoot: merkleRoot,
-            timestamps: timestamps,
-            token: token_
-        });
-    }
-
-    function merkleVCATimestamps() public view returns (MerkleVCA.Timestamps memory) {
-        return MerkleVCA.Timestamps({ start: RANGED_STREAM_START_TIME, end: RANGED_STREAM_END_TIME });
-    }
-}
diff --git a/tests/utils/Modifiers.sol b/tests/utils/Modifiers.sol
index c0b39308..c4de5c9e 100644
--- a/tests/utils/Modifiers.sol
+++ b/tests/utils/Modifiers.sol
@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity >=0.8.22;
 
-import { Defaults } from "./Defaults.sol";
 import { Users } from "./Types.sol";
 
 import { Utils } from "./Utils.sol";
@@ -11,11 +10,9 @@ abstract contract Modifiers is Utils {
                                      VARIABLES
     //////////////////////////////////////////////////////////////////////////*/
 
-    Defaults private defaults;
     Users private users;
 
-    function setVariables(Defaults _defaults, Users memory _users) public {
-        defaults = _defaults;
+    function setVariables(Users memory _users) public {
         users = _users;
     }