MerkleLockup for LockupTranched

script/CreateMerkleLockupLT.s.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity >=0.8.22 <0.9.0;
+
+import { ISablierV2LockupTranched } from "@sablier/v2-core/src/interfaces/ISablierV2LockupTranched.sol";
+
+import { BaseScript } from "./Base.s.sol";
+
+import { ISablierV2MerkleLockupFactory } from "../src/interfaces/ISablierV2MerkleLockupFactory.sol";
+import { ISablierV2MerkleLockupLT } from "../src/interfaces/ISablierV2MerkleLockupLT.sol";
+import { MerkleLockup, MerkleLockupLT } from "../src/types/DataTypes.sol";
+
+contract CreateMerkleLockupLT is BaseScript {
+    struct Params {
+        MerkleLockup.ConstructorParams baseParams;
+        ISablierV2LockupTranched lockupTranched;
+        MerkleLockupLT.TrancheWithPercentage[] tranchesWithPercentages;
+        uint256 campaignTotalAmount;
+        uint256 recipientsCount;
+    }
+
+    function run(
+        ISablierV2MerkleLockupFactory merkleLockupFactory,
+        Params calldata params
+    )
+        public
+        broadcast
+        returns (ISablierV2MerkleLockupLT merkleLockupLT)
+    {
+        merkleLockupLT = merkleLockupFactory.createMerkleLockupLT(
+            params.baseParams,
+            params.lockupTranched,
+            params.tranchesWithPercentages,
+            params.campaignTotalAmount,
+            params.recipientsCount
+        );
+    }
+}

script/DeployProtocol.s.sol

@@ -4,6 +4,7 @@ pragma solidity >=0.8.22 <0.9.0;
 import { SablierV2Comptroller } from "@sablier/v2-core/src/SablierV2Comptroller.sol";
 import { SablierV2LockupDynamic } from "@sablier/v2-core/src/SablierV2LockupDynamic.sol";
 import { SablierV2LockupLinear } from "@sablier/v2-core/src/SablierV2LockupLinear.sol";
+import { SablierV2LockupTranched } from "@sablier/v2-core/src/SablierV2LockupTranched.sol";
 import { SablierV2NFTDescriptor } from "@sablier/v2-core/src/SablierV2NFTDescriptor.sol";
 import { BaseScript } from "./Base.s.sol";
 
@@ -14,7 +15,7 @@ import { SablierV2Batch } from "../src/SablierV2Batch.sol";
 contract DeployProtocol is BaseScript {
     function run(
         address initialAdmin,
-        uint256 maxSegmentCount
+        uint256 maxCount
     )
         public
         virtual
@@ -23,6 +24,7 @@ contract DeployProtocol is BaseScript {
             SablierV2Comptroller comptroller,
             SablierV2LockupDynamic lockupDynamic,
             SablierV2LockupLinear lockupLinear,
+            SablierV2LockupTranched lockupTranched,
             SablierV2NFTDescriptor nftDescriptor,
             SablierV2Batch batch,
             SablierV2MerkleLockupFactory merkleLockupFactory
@@ -31,8 +33,9 @@ contract DeployProtocol is BaseScript {
         // Deploy V2 Core.
         comptroller = new SablierV2Comptroller(initialAdmin);
         nftDescriptor = new SablierV2NFTDescriptor();
-        lockupDynamic = new SablierV2LockupDynamic(initialAdmin, comptroller, nftDescriptor, maxSegmentCount);
+        lockupDynamic = new SablierV2LockupDynamic(initialAdmin, comptroller, nftDescriptor, maxCount);
         lockupLinear = new SablierV2LockupLinear(initialAdmin, comptroller, nftDescriptor);
+        lockupTranched = new SablierV2LockupTranched(initialAdmin, comptroller, nftDescriptor, maxCount);
 
         batch = new SablierV2Batch();
         merkleLockupFactory = new SablierV2MerkleLockupFactory();

shell/prepare-artifacts.sh

@@ -27,11 +27,13 @@ FOUNDRY_PROFILE=optimized forge build
 cp out-optimized/SablierV2Batch.sol/SablierV2Batch.json $artifacts
 cp out-optimized/SablierV2MerkleLockupFactory.sol/SablierV2MerkleLockupFactory.json $artifacts
 cp out-optimized/SablierV2MerkleLockupLL.sol/SablierV2MerkleLockupLL.json $artifacts
+cp out-optimized/SablierV2MerkleLockupLT.sol/SablierV2MerkleLockupLT.json $artifacts
 
 interfaces=./artifacts/interfaces
 cp out-optimized/ISablierV2Batch.sol/ISablierV2Batch.json $interfaces
 cp out-optimized/ISablierV2MerkleLockupFactory.sol/ISablierV2MerkleLockupFactory.json $interfaces
 cp out-optimized/ISablierV2MerkleLockupLL.sol/ISablierV2MerkleLockupLL.json $interfaces
+cp out-optimized/ISablierV2MerkleLockupLT.sol/ISablierV2MerkleLockupLT.json $interfaces
 
 erc20=./artifacts/interfaces/erc20
 cp out-optimized/IERC20.sol/IERC20.json $erc20

src/SablierV2MerkleLockupFactory.sol

@@ -1,13 +1,18 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity >=0.8.22;
 
+import { UD60x18, ud } from "@prb/math/src/UD60x18.sol";
 import { LockupLinear } from "@sablier/v2-core/src/types/DataTypes.sol";
+import { ISablierV2LockupTranched } from "@sablier/v2-core/src/interfaces/ISablierV2LockupTranched.sol";
 import { ISablierV2LockupLinear } from "@sablier/v2-core/src/interfaces/ISablierV2LockupLinear.sol";
 
 import { SablierV2MerkleLockupLL } from "./SablierV2MerkleLockupLL.sol";
+import { SablierV2MerkleLockupLT } from "./SablierV2MerkleLockupLT.sol";
 import { ISablierV2MerkleLockupFactory } from "./interfaces/ISablierV2MerkleLockupFactory.sol";
 import { ISablierV2MerkleLockupLL } from "./interfaces/ISablierV2MerkleLockupLL.sol";
-import { MerkleLockup } from "./types/DataTypes.sol";
+import { ISablierV2MerkleLockupLT } from "./interfaces/ISablierV2MerkleLockupLT.sol";
+import { Errors } from "./libraries/Errors.sol";
+import { MerkleLockup, MerkleLockupLT } from "./types/DataTypes.sol";
 
 /// @title SablierV2MerkleLockupFactory
 /// @notice See the documentation in {ISablierV2MerkleLockupFactory}.
@@ -51,4 +56,53 @@ contract SablierV2MerkleLockupFactory is ISablierV2MerkleLockupFactory {
             merkleLockupLL, baseParams, lockupLinear, streamDurations, aggregateAmount, recipientsCount
         );
     }
+
+    /// @notice inheritdoc ISablierV2MerkleLockupFactory
+    function createMerkleLockupLT(
+        MerkleLockup.ConstructorParams memory baseParams,
+        ISablierV2LockupTranched lockupTranched,
+        MerkleLockupLT.TrancheWithPercentage[] memory tranchesWithPercentages,
+        uint256 aggregateAmount,
+        uint256 recipientsCount
+    )
+        external
+        returns (ISablierV2MerkleLockupLT merkleLockupLT)
+    {
+        // Calculate the sum of percentages across all tranches.
+        UD60x18 percentagesSum;
+        uint256 trancheCount = tranchesWithPercentages.length;
+        for (uint256 i = 0; i < trancheCount; ++i) {
+            UD60x18 percentage = (tranchesWithPercentages[i].amountPercentage).intoUD60x18();
+            percentagesSum = percentagesSum.add(percentage);
+        }
+
+        // Checks: the sum percentage equal 100%.
+        if (!percentagesSum.eq(ud(1e18))) {
+            revert Errors.SablierV2MerkleLockupFactory_PercentageSumNotEqualOneHundred(percentagesSum.intoUint256());
+        }
+
+        // Hash the parameters to generate a salt.
+        bytes32 salt = keccak256(
+            abi.encodePacked(
+                baseParams.initialAdmin,
+                baseParams.asset,
+                abi.encode(baseParams.ipfsCID),
+                bytes32(abi.encodePacked(baseParams.name)),
+                baseParams.merkleRoot,
+                baseParams.expiration,
+                baseParams.cancelable,
+                baseParams.transferable,
+                lockupTranched,
+                abi.encode(tranchesWithPercentages)
+            )
+        );
+
+        // Deploy the Merkle Lockup contract with CREATE2.
+        merkleLockupLT = new SablierV2MerkleLockupLT{ salt: salt }(baseParams, lockupTranched, tranchesWithPercentages);
+
+        // Log the creation of the Merkle Lockup, including some metadata that is not stored on-chain.
+        emit CreateMerkleLockupLT(
+            merkleLockupLT, baseParams, lockupTranched, tranchesWithPercentages, aggregateAmount, recipientsCount
+        );
+    }
 }

src/SablierV2MerkleLockupLT.sol

@@ -0,0 +1,171 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity >=0.8.22;
+
+import { BitMaps } from "@openzeppelin/contracts/utils/structs/BitMaps.sol";
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import { ISablierV2LockupTranched } from "@sablier/v2-core/src/interfaces/ISablierV2LockupTranched.sol";
+import { Broker, LockupTranched } from "@sablier/v2-core/src/types/DataTypes.sol";
+import { ud, UD60x18 } from "@prb/math/src/UD60x18.sol";
+
+import { SablierV2MerkleLockup } from "./abstracts/SablierV2MerkleLockup.sol";
+import { ISablierV2MerkleLockupLT } from "./interfaces/ISablierV2MerkleLockupLT.sol";
+import { MerkleLockup, MerkleLockupLT } from "./types/DataTypes.sol";
+
+/// @title SablierV2MerkleLockupLT
+/// @notice See the documentation in {ISablierV2MerkleLockupLT}.
+contract SablierV2MerkleLockupLT is
+    ISablierV2MerkleLockupLT, // 2 inherited components
+    SablierV2MerkleLockup // 4 inherited components
+{
+    using BitMaps for BitMaps.BitMap;
+    using SafeERC20 for IERC20;
+
+    /*//////////////////////////////////////////////////////////////////////////
+                                  STATE VARIABLES
+    //////////////////////////////////////////////////////////////////////////*/
+
+    /// @inheritdoc ISablierV2MerkleLockupLT
+    ISablierV2LockupTranched public immutable override LOCKUP_TRANCHED;
+
+    /// @dev The tranches with their respective percentages and durations.
+    MerkleLockupLT.TrancheWithPercentage[] internal _tranchesWithPercentages;
+
+    /*//////////////////////////////////////////////////////////////////////////
+                                    CONSTRUCTOR
+    //////////////////////////////////////////////////////////////////////////*/
+
+    /// @dev Constructs the contract by initializing the immutable state variables, and max approving the Sablier
+    /// contract.
+    constructor(
+        MerkleLockup.ConstructorParams memory baseParams,
+        ISablierV2LockupTranched lockupTranched,
+        MerkleLockupLT.TrancheWithPercentage[] memory tranchesWithPercentages
+    )
+        SablierV2MerkleLockup(baseParams)
+    {
+        LOCKUP_TRANCHED = lockupTranched;
+
+        // Since Solidity lacks a syntax for copying arrays directly from memory to storage,
+        // a manual approach is necessary. See https://github.com/ethereum/solidity/issues/12783.
+        uint256 count = tranchesWithPercentages.length;
+        for (uint256 i = 0; i < count; i++) {
+            _tranchesWithPercentages.push(tranchesWithPercentages[i]);
+        }
+
+        // Max approve the Sablier contract to spend funds from the Merkle Lockup contract.
+        ASSET.forceApprove(address(LOCKUP_TRANCHED), type(uint256).max);
+    }
+
+    /*//////////////////////////////////////////////////////////////////////////
+                           USER-FACING CONSTANT FUNCTIONS
+    //////////////////////////////////////////////////////////////////////////*/
+
+    /// @inheritdoc ISablierV2MerkleLockupLT
+    function getTranchesWithPercentages()
+        external
+        view
+        override
+        returns (MerkleLockupLT.TrancheWithPercentage[] memory)
+    {
+        return _tranchesWithPercentages;
+    }
+
+    /*//////////////////////////////////////////////////////////////////////////
+                         USER-FACING NON-CONSTANT FUNCTIONS
+    //////////////////////////////////////////////////////////////////////////*/
+
+    /// @inheritdoc ISablierV2MerkleLockupLT
+    function claim(
+        uint256 index,
+        address recipient,
+        uint128 amount,
+        bytes32[] calldata merkleProof
+    )
+        external
+        override
+        returns (uint256 streamId)
+    {
+        // Generate the Merkle tree leaf by hashing the corresponding parameters. Hashing twice prevents second
+        // preimage attacks.
+        bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(index, recipient, amount))));
+
+        // Checks: validate the function.
+        _checkClaim(index, leaf, merkleProof);
+
+        // Calculate the tranches based on the `amount`.
+        LockupTranched.TrancheWithDuration[] memory tranches = _calculateTranches(amount);
+
+        // Effects: mark the index as claimed.
+        _claimedBitMap.set(index);
+
+        // Interactions: create the stream via {SablierV2LockupTranched}.
+        streamId = LOCKUP_TRANCHED.createWithDurations(
+            LockupTranched.CreateWithDurations({
+                sender: admin,
+                recipient: recipient,
+                totalAmount: amount,
+                asset: ASSET,
+                cancelable: CANCELABLE,
+                transferable: TRANSFERABLE,
+                tranches: tranches,
+                broker: Broker({ account: address(0), fee: ud(0) })
+            })
+        );
+
+        // Log the claim.
+        emit Claim(index, recipient, amount, streamId);
+    }
+
+    /// @dev Calculates the stream tranches based on Merkle tree amount and predefined percentage for each tranche.
+    function _calculateTranches(uint128 amount)
+        internal
+        view
+        returns (LockupTranched.TrancheWithDuration[] memory tranches)
+    {
+        // Load the tranches in memory to save gas.
+        MerkleLockupLT.TrancheWithPercentage[] memory tranchesWithPercentages = _tranchesWithPercentages;
+
+        // Declare the variables need for calculation.
+        UD60x18 trancheAmountsSum;
+        uint256 trancheCount = tranchesWithPercentages.length;
+        tranches = new LockupTranched.TrancheWithDuration[](trancheCount);
+
+        UD60x18 udAmount = ud(amount);
+
+        // Iterate over each tranche to calculate its amount based on its percentage.
+        for (uint256 i = 0; i < trancheCount; ++i) {
+            // Convert the tranche's percentage to `UD60x18` for calculation.
+            UD60x18 percentage = (tranchesWithPercentages[i].amountPercentage).intoUD60x18();
+
+            // Calculate the tranche's amount by applying its percentage to the `amount`.
+            UD60x18 trancheAmount = udAmount.mul(percentage);
+
+            // Sum all tranche amounts.
+            trancheAmountsSum = trancheAmountsSum.add(trancheAmount);
+
+            // Assign calculated amount and duration to the tranche.
+            tranches[i] = LockupTranched.TrancheWithDuration({
+                amount: trancheAmount.intoUint128(),
+                duration: tranchesWithPercentages[i].duration
+            });
+        }
+
+        // Safe Interactions: query the protocol fee. This is safe because it's a known Sablier contract that does
+        // not call other unknown contracts.
+        UD60x18 protocolFee = LOCKUP_TRANCHED.comptroller().protocolFees(ASSET);
+
+        // Adjust the last tranche amount if the protocol fee is greater than zero.
+        // This is needed to ensure the protocol invariat: sum of tranche amounts equals the deposit amount.
+        if (protocolFee.gt(ud(0))) {
+            UD60x18 protocolFeeAmount = udAmount.mul(protocolFee);
+            tranches[trancheCount - 1].amount -= protocolFeeAmount.intoUint128();
+        }
+
+        // Although this should never happen because the sum of percentages equals 100%, we adjust
+        // the last tranche amount to prevent claim failure due to rounding differences during calculations.
+        if (!udAmount.eq(trancheAmountsSum)) {
+            tranches[trancheCount - 1].amount += udAmount.intoUint128() - trancheAmountsSum.intoUint128();
+        }
+    }
+}

src/interfaces/ISablierV2MerkleLockupFactory.sol

@@ -2,10 +2,12 @@
 pragma solidity >=0.8.22;
 
 import { ISablierV2LockupLinear } from "@sablier/v2-core/src/interfaces/ISablierV2LockupLinear.sol";
+import { ISablierV2LockupTranched } from "@sablier/v2-core/src/interfaces/ISablierV2LockupTranched.sol";
 import { LockupLinear } from "@sablier/v2-core/src/types/DataTypes.sol";
 
 import { ISablierV2MerkleLockupLL } from "./ISablierV2MerkleLockupLL.sol";
-import { MerkleLockup } from "../types/DataTypes.sol";
+import { ISablierV2MerkleLockupLT } from "./ISablierV2MerkleLockupLT.sol";
+import { MerkleLockup, MerkleLockupLT } from "../types/DataTypes.sol";
 
 /// @title ISablierV2MerkleLockupFactory
 /// @notice Deploys new Lockup Linear Merkle lockups via CREATE2.
@@ -24,6 +26,16 @@ interface ISablierV2MerkleLockupFactory {
         uint256 recipientsCount
     );
 
+    /// @notice Emitted when a Sablier V2 Lockup Tranched Merkle Lockup is created.
+    event CreateMerkleLockupLT(
+        ISablierV2MerkleLockupLT indexed merkleLockupLT,
+        MerkleLockup.ConstructorParams indexed baseParams,
+        ISablierV2LockupTranched lockupTranched,
+        MerkleLockupLT.TrancheWithPercentage[] tranchesWithPercentages,
+        uint256 aggregateAmount,
+        uint256 recipientsCount
+    );
+
     /*//////////////////////////////////////////////////////////////////////////
                                NON-CONSTANT FUNCTIONS
     //////////////////////////////////////////////////////////////////////////*/
@@ -46,4 +58,27 @@ interface ISablierV2MerkleLockupFactory {
     )
         external
         returns (ISablierV2MerkleLockupLL merkleLockupLL);
+
+    /// @notice Creates a new Merkle Lockup that uses Lockup Tranched.
+    /// @dev Emits a {CreateMerkleLockupLT} event.
+    ///
+    /// Requirements:
+    /// - The sum of the tranches percantages must equal 100% = 1e18.
+    ///
+    /// @param baseParams Struct encapsulating the {SablierV2MerkleLockup} parameters, which are documented in
+    /// {DataTypes}.
+    /// @param lockupTranched The address of the {SablierV2LockupTranched} contract.
+    /// @param tranchesWithPercentages The tranches with their respective percentages.
+    /// @param aggregateAmount Total amount of ERC-20 assets to be streamed to all recipients.
+    /// @param recipientsCount Total number of recipients eligible to claim.
+    /// @return merkleLockupLT The address of the newly created Merkle Lockup contract.
+    function createMerkleLockupLT(
+        MerkleLockup.ConstructorParams memory baseParams,
+        ISablierV2LockupTranched lockupTranched,
+        MerkleLockupLT.TrancheWithPercentage[] memory tranchesWithPercentages,
+        uint256 aggregateAmount,
+        uint256 recipientsCount
+    )
+        external
+        returns (ISablierV2MerkleLockupLT merkleLockupLT);
 }