feat: implement chainlink oracle

refactor: change the minimum fee to USD price instead of wei

build: set ffi true
test: add a python script to fetch prices
test: add fork tests for the price feeds
test: add a mock price feed contract
test: add a contract to store the addresses

test: update tests accordingly

.github/workflows/ci.yml

@@ -39,10 +39,15 @@ jobs:
     needs: ["lint", "build"]
     secrets:
       MAINNET_RPC_URL: ${{ secrets.MAINNET_RPC_URL }}
+      ARBITRUM_RPC_URL: ${{ secrets.ARBITRUM_RPC_URL }}
+      AVALANCHE_RPC_URL: ${{ secrets.AVALANCHE_RPC_URL }}
+      OPTIMISM_RPC_URL: ${{ secrets.OPTIMISM_RPC_URL }}
+      POLYGON_RPC_URL: ${{ secrets.POLYGON_RPC_URL }}
     uses: "sablier-labs/reusable-workflows/.github/workflows/forge-test.yml@main"
     with:
       foundry-fuzz-runs: 20
       foundry-profile: "test-optimized"
+      # install-python: true
       match-path: "tests/fork/**/*.sol"
       name: "Fork tests"
 

foundry.toml

@@ -2,6 +2,7 @@
   auto_detect_solc = false
   bytecode_hash = "none"
   evm_version = "shanghai"
+  ffi = true
   fs_permissions = [
     { access = "read", path = "./out-optimized" },
     { access = "read", path = "package.json" },

package.json

@@ -11,6 +11,7 @@
     "url": "https://github.com/sablier-labs/airdrops/issues"
   },
   "dependencies": {
+    "@chainlink/contracts": "^1.3.0",
     "@openzeppelin/contracts": "5.0.2",
     "@prb/math": "4.1.0",
     "@sablier/lockup": "github:sablier-labs/lockup#723a956",

remappings.txt

@@ -1,3 +1,4 @@
+@chainlink/contracts/=node_modules/@chainlink/contracts/
 @openzeppelin/contracts/=node_modules/@openzeppelin/contracts/
 @prb/math/=node_modules/@prb/math/
 @sablier/evm-utils/=node_modules/@sablier/evm-utils/

script/CreateMerkleInstant.s.sol

@@ -12,7 +12,8 @@ contract CreateMerkleInstant is BaseScript {
     /// @dev Deploy via Forge.
     function run() public broadcast returns (ISablierMerkleInstant merkleInstant) {
         // TODO: Load deployed addresses from Ethereum mainnet.
-        SablierMerkleFactoryInstant merkleFactory = new SablierMerkleFactoryInstant(DEFAULT_SABLIER_ADMIN, 0);
+        SablierMerkleFactoryInstant merkleFactory =
+            new SablierMerkleFactoryInstant(DEFAULT_SABLIER_ADMIN, address(0), 0);
 
         // Prepare the constructor parameters.
         MerkleInstant.ConstructorParams memory params;

script/CreateMerkleLL.s.sol

@@ -14,7 +14,7 @@ contract CreateMerkleLL is BaseScript {
     /// @dev Deploy via Forge.
     function run() public broadcast returns (ISablierMerkleLL merkleLL) {
         // TODO: Load deployed addresses from Ethereum mainnet.
-        SablierMerkleFactoryLL merkleFactory = new SablierMerkleFactoryLL(DEFAULT_SABLIER_ADMIN, 0);
+        SablierMerkleFactoryLL merkleFactory = new SablierMerkleFactoryLL(DEFAULT_SABLIER_ADMIN, address(0), 0);
 
         // Prepare the constructor parameters.
         MerkleLL.ConstructorParams memory params;

script/CreateMerkleLT.s.sol

@@ -16,7 +16,7 @@ contract CreateMerkleLT is BaseScript {
     /// @dev Deploy via Forge.
     function run() public broadcast returns (ISablierMerkleLT merkleLT) {
         // TODO: Load deployed addresses from Ethereum mainnet.
-        SablierMerkleFactoryLT merkleFactory = new SablierMerkleFactoryLT(DEFAULT_SABLIER_ADMIN, 0);
+        SablierMerkleFactoryLT merkleFactory = new SablierMerkleFactoryLT(DEFAULT_SABLIER_ADMIN, address(0), 0);
 
         // Prepare the constructor parameters.
         MerkleLT.ConstructorParams memory params;

script/CreateMerkleVCA.s.sol

@@ -12,7 +12,7 @@ contract CreateMerkleVCA is BaseScript {
     /// @dev Deploy via Forge.
     function run() public broadcast returns (ISablierMerkleVCA merkleVCA) {
         // TODO: Load deployed addresses from Ethereum mainnet.
-        SablierMerkleFactoryVCA merkleFactory = new SablierMerkleFactoryVCA(DEFAULT_SABLIER_ADMIN, 0);
+        SablierMerkleFactoryVCA merkleFactory = new SablierMerkleFactoryVCA(DEFAULT_SABLIER_ADMIN, address(0), 0);
 
         // Prepare the constructor parameters.
         MerkleVCA.ConstructorParams memory params;

script/DeployDeterministicMerkleFactories.s.sol

@@ -7,13 +7,15 @@ import { SablierMerkleFactoryInstant } from "../src/SablierMerkleFactoryInstant.
 import { SablierMerkleFactoryLL } from "../src/SablierMerkleFactoryLL.sol";
 import { SablierMerkleFactoryLT } from "../src/SablierMerkleFactoryLT.sol";
 import { SablierMerkleFactoryVCA } from "../src/SablierMerkleFactoryVCA.sol";
+import { ChainlinkPriceFeedAddresses } from "../src/tests/ChainlinkPriceFeedAddresses.sol";
+import { InitialMinimumFees } from "../src/tests/InitialMinimumFees.sol";
 
 /// @notice Deploys Merkle factory contracts at deterministic address.
 ///
 /// @dev Reverts if any contract has already been deployed.
-contract DeployDeterministicMerkleFactories is BaseScript {
+contract DeployDeterministicMerkleFactories is BaseScript, ChainlinkPriceFeedAddresses, InitialMinimumFees {
     /// @dev Deploy via Forge.
-    function run(uint256 initialMinimumFee)
+    function run()
         public
         broadcast
         returns (
@@ -23,9 +25,16 @@ contract DeployDeterministicMerkleFactories is BaseScript {
             SablierMerkleFactoryVCA merkleFactoryVCA
         )
     {
-        merkleFactoryInstant = new SablierMerkleFactoryInstant{ salt: SALT }(protocolAdmin(), initialMinimumFee);
-        merkleFactoryLL = new SablierMerkleFactoryLL{ salt: SALT }(protocolAdmin(), initialMinimumFee);
-        merkleFactoryLT = new SablierMerkleFactoryLT{ salt: SALT }(protocolAdmin(), initialMinimumFee);
-        merkleFactoryVCA = new SablierMerkleFactoryVCA{ salt: SALT }(protocolAdmin(), initialMinimumFee);
+        address initialAdmin = protocolAdmin();
+        address initialChainlinkPriceFeed = getPriceFeedAddress();
+        uint256 initialMinimumFee = getMinimumFee();
+        merkleFactoryInstant =
+            new SablierMerkleFactoryInstant{ salt: SALT }(initialAdmin, initialChainlinkPriceFeed, initialMinimumFee);
+        merkleFactoryLL =
+            new SablierMerkleFactoryLL{ salt: SALT }(initialAdmin, initialChainlinkPriceFeed, initialMinimumFee);
+        merkleFactoryLT =
+            new SablierMerkleFactoryLT{ salt: SALT }(initialAdmin, initialChainlinkPriceFeed, initialMinimumFee);
+        merkleFactoryVCA =
+            new SablierMerkleFactoryVCA{ salt: SALT }(initialAdmin, initialChainlinkPriceFeed, initialMinimumFee);
     }
 }

script/DeployMerkleFactories.s.sol

@@ -7,11 +7,13 @@ import { SablierMerkleFactoryInstant } from "../src/SablierMerkleFactoryInstant.
 import { SablierMerkleFactoryLL } from "../src/SablierMerkleFactoryLL.sol";
 import { SablierMerkleFactoryLT } from "../src/SablierMerkleFactoryLT.sol";
 import { SablierMerkleFactoryVCA } from "../src/SablierMerkleFactoryVCA.sol";
+import { ChainlinkPriceFeedAddresses } from "../src/tests/ChainlinkPriceFeedAddresses.sol";
+import { InitialMinimumFees } from "../src/tests/InitialMinimumFees.sol";
 
 /// @notice Deploys Merkle factory contracts.
-contract DeployMerkleFactories is BaseScript {
+contract DeployMerkleFactories is BaseScript, ChainlinkPriceFeedAddresses, InitialMinimumFees {
     /// @dev Deploy via Forge.
-    function run(uint256 initialMinimumFee)
+    function run()
         public
         broadcast
         returns (
@@ -21,9 +23,13 @@ contract DeployMerkleFactories is BaseScript {
             SablierMerkleFactoryVCA merkleFactoryVCA
         )
     {
-        merkleFactoryInstant = new SablierMerkleFactoryInstant(protocolAdmin(), initialMinimumFee);
-        merkleFactoryLL = new SablierMerkleFactoryLL(protocolAdmin(), initialMinimumFee);
-        merkleFactoryLT = new SablierMerkleFactoryLT(protocolAdmin(), initialMinimumFee);
-        merkleFactoryVCA = new SablierMerkleFactoryVCA(protocolAdmin(), initialMinimumFee);
+        address initialAdmin = protocolAdmin();
+        address initialChainlinkPriceFeed = getPriceFeedAddress();
+        uint256 initialMinimumFee = getMinimumFee();
+        merkleFactoryInstant =
+            new SablierMerkleFactoryInstant(initialAdmin, initialChainlinkPriceFeed, initialMinimumFee);
+        merkleFactoryLL = new SablierMerkleFactoryLL(initialAdmin, initialChainlinkPriceFeed, initialMinimumFee);
+        merkleFactoryLT = new SablierMerkleFactoryLT(initialAdmin, initialChainlinkPriceFeed, initialMinimumFee);
+        merkleFactoryVCA = new SablierMerkleFactoryVCA(initialAdmin, initialChainlinkPriceFeed, initialMinimumFee);
     }
 }

src/SablierMerkleFactoryInstant.sol

@@ -15,12 +15,14 @@ contract SablierMerkleFactoryInstant is ISablierMerkleFactoryInstant, SablierMer
     //////////////////////////////////////////////////////////////////////////*/
 
     /// @param initialAdmin The address of the initial contract admin.
+    /// @param initialChainlinkPriceFeed The initial Chainlink price feed contract.
     /// @param initialMinimumFee The initial minimum fee charged for claiming an airdrop.
     constructor(
         address initialAdmin,
+        address initialChainlinkPriceFeed,
         uint256 initialMinimumFee
     )
-        SablierMerkleFactoryBase(initialAdmin, initialMinimumFee)
+        SablierMerkleFactoryBase(initialAdmin, initialChainlinkPriceFeed, initialMinimumFee)
     { }
 
     /*//////////////////////////////////////////////////////////////////////////

src/SablierMerkleFactoryLL.sol

@@ -15,12 +15,14 @@ contract SablierMerkleFactoryLL is ISablierMerkleFactoryLL, SablierMerkleFactory
     //////////////////////////////////////////////////////////////////////////*/
 
     /// @param initialAdmin The address of the initial contract admin.
+    /// @param initialChainlinkPriceFeed The initial Chainlink price feed contract.
     /// @param initialMinimumFee The initial minimum fee charged for claiming an airdrop.
     constructor(
         address initialAdmin,
+        address initialChainlinkPriceFeed,
         uint256 initialMinimumFee
     )
-        SablierMerkleFactoryBase(initialAdmin, initialMinimumFee)
+        SablierMerkleFactoryBase(initialAdmin, initialChainlinkPriceFeed, initialMinimumFee)
     { }
 
     /*//////////////////////////////////////////////////////////////////////////

src/SablierMerkleFactoryLT.sol

@@ -2,6 +2,7 @@
 pragma solidity >=0.8.22;
 
 import { uUNIT } from "@prb/math/src/UD2x18.sol";
+
 import { SablierMerkleFactoryBase } from "./abstracts/SablierMerkleFactoryBase.sol";
 import { ISablierMerkleFactoryLT } from "./interfaces/ISablierMerkleFactoryLT.sol";
 import { ISablierMerkleLT } from "./interfaces/ISablierMerkleLT.sol";
@@ -16,12 +17,14 @@ contract SablierMerkleFactoryLT is ISablierMerkleFactoryLT, SablierMerkleFactory
     //////////////////////////////////////////////////////////////////////////*/
 
     /// @param initialAdmin The address of the initial contract admin.
+    /// @param initialChainlinkPriceFeed The initial Chainlink price feed contract.
     /// @param initialMinimumFee The initial minimum fee charged for claiming an airdrop.
     constructor(
         address initialAdmin,
+        address initialChainlinkPriceFeed,
         uint256 initialMinimumFee
     )
-        SablierMerkleFactoryBase(initialAdmin, initialMinimumFee)
+        SablierMerkleFactoryBase(initialAdmin, initialChainlinkPriceFeed, initialMinimumFee)
     { }
 
     /*//////////////////////////////////////////////////////////////////////////

src/SablierMerkleFactoryVCA.sol

@@ -15,12 +15,14 @@ contract SablierMerkleFactoryVCA is ISablierMerkleFactoryVCA, SablierMerkleFacto
     //////////////////////////////////////////////////////////////////////////*/
 
     /// @param initialAdmin The address of the initial contract admin.
+    /// @param initialChainlinkPriceFeed The initial Chainlink price feed contract.
     /// @param initialMinimumFee The initial minimum fee charged for claiming an airdrop.
     constructor(
         address initialAdmin,
+        address initialChainlinkPriceFeed,
         uint256 initialMinimumFee
     )
-        SablierMerkleFactoryBase(initialAdmin, initialMinimumFee)
+        SablierMerkleFactoryBase(initialAdmin, initialChainlinkPriceFeed, initialMinimumFee)
     { }
 
     /*//////////////////////////////////////////////////////////////////////////

src/abstracts/SablierMerkleBase.sol

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: BUSL-1.1
 pragma solidity >=0.8.22;
 
+import { AggregatorV3Interface } from "@chainlink/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol";
 import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import { MerkleProof } from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
@@ -24,6 +25,9 @@ abstract contract SablierMerkleBase is
                                   STATE VARIABLES
     //////////////////////////////////////////////////////////////////////////*/
 
+    /// @inheritdoc ISablierMerkleBase
+    address public immutable override CHAINLINK_PRICE_FEED;
+
     /// @inheritdoc ISablierMerkleBase
     uint40 public immutable override EXPIRATION;
 
@@ -67,19 +71,25 @@ abstract contract SablierMerkleBase is
     )
         Adminable(initialAdmin)
     {
-        campaignName = _campaignName;
-        EXPIRATION = expiration;
         FACTORY = msg.sender;
-        MINIMUM_FEE = ISablierMerkleFactoryBase(FACTORY).getFee(campaignCreator);
+        CHAINLINK_PRICE_FEED = ISablierMerkleFactoryBase(FACTORY).chainlinkPriceFeed();
+        EXPIRATION = expiration;
         MERKLE_ROOT = merkleRoot;
+        MINIMUM_FEE = ISablierMerkleFactoryBase(FACTORY).getFee(campaignCreator);
         TOKEN = token;
+        campaignName = _campaignName;
         ipfsCID = _ipfsCID;
     }
 
     /*//////////////////////////////////////////////////////////////////////////
                            USER-FACING CONSTANT FUNCTIONS
     //////////////////////////////////////////////////////////////////////////*/
 
+    /// @inheritdoc ISablierMerkleBase
+    function calculateMinimumFeeInWei() external view returns (uint256) {
+        return _calculateMinimumFeeInWei();
+    }
+
     /// @inheritdoc ISablierMerkleBase
     function getFirstClaimTime() external view override returns (uint40) {
         return _firstClaimTime;
@@ -115,9 +125,12 @@ abstract contract SablierMerkleBase is
             revert Errors.SablierMerkleBase_CampaignExpired({ blockTimestamp: block.timestamp, expiration: EXPIRATION });
         }
 
+        // Calculate the minimum fee in wei.
+        uint256 minimumFeeInWei = _calculateMinimumFeeInWei();
+
         // Check: `msg.value` is not less than the minimum fee.
-        if (msg.value < MINIMUM_FEE) {
-            revert Errors.SablierMerkleBase_InsufficientFeePayment(msg.value, MINIMUM_FEE);
+        if (msg.value < minimumFeeInWei) {
+            revert Errors.SablierMerkleBase_InsufficientFeePayment(msg.value, minimumFeeInWei);
         }
 
         // Check: the index has not been claimed.
@@ -167,8 +180,8 @@ abstract contract SablierMerkleBase is
     /// @inheritdoc ISablierMerkleBase
     function collectFees(address factoryAdmin) external override returns (uint256 feeAmount) {
         // Check: the caller is the FACTORY.
-        if (msg.sender != FACTORY) {
-            revert Errors.SablierMerkleBase_CallerNotFactory(FACTORY, msg.sender);
+        if (msg.sender != address(FACTORY)) {
+            revert Errors.SablierMerkleBase_CallerNotFactory(address(FACTORY), msg.sender);
         }
 
         feeAmount = address(this).balance;
@@ -186,6 +199,26 @@ abstract contract SablierMerkleBase is
                             INTERNAL CONSTANT FUNCTIONS
     //////////////////////////////////////////////////////////////////////////*/
 
+    /// @dev See the documentation for the user-facing functions that call this internal function.
+    function _calculateMinimumFeeInWei() internal view returns (uint256) {
+        // If the Chainlink price feed is not set, return 0.
+        if (CHAINLINK_PRICE_FEED == address(0)) {
+            return 0;
+        }
+
+        // If the minimum fee is 0, return 0.
+        if (MINIMUM_FEE == 0) {
+            return 0;
+        }
+
+        // Q: should we do a low-level call here instead?
+        (, int256 price,,,) = AggregatorV3Interface(CHAINLINK_PRICE_FEED).latestRoundData();
+        // Q: should we check the price is greater than 0 ? If yes, should we revert?
+
+        // Calculate the minimum fee in wei.
+        return 1e18 * MINIMUM_FEE / uint256(price);
+    }
+
     /// @notice Returns a flag indicating whether the grace period has passed.
     /// @dev The grace period is 7 days after the first claim.
     function _hasGracePeriodPassed() internal view returns (bool) {

src/abstracts/SablierMerkleFactoryBase.sol

@@ -17,6 +17,9 @@ abstract contract SablierMerkleFactoryBase is
                                   STATE VARIABLES
     //////////////////////////////////////////////////////////////////////////*/
 
+    /// @inheritdoc ISablierMerkleFactoryBase
+    address public override chainlinkPriceFeed;
+
     /// @inheritdoc ISablierMerkleFactoryBase
     uint256 public override minimumFee;
 
@@ -28,8 +31,16 @@ abstract contract SablierMerkleFactoryBase is
     //////////////////////////////////////////////////////////////////////////*/
 
     /// @param initialAdmin The address of the initial contract admin.
+    /// @param initialChainlinkPriceFeed The initial Chainlink price feed contract address.
     /// @param initialMinimumFee The initial minimum fee charged for claiming an airdrop.
-    constructor(address initialAdmin, uint256 initialMinimumFee) Adminable(initialAdmin) {
+    constructor(
+        address initialAdmin,
+        address initialChainlinkPriceFeed,
+        uint256 initialMinimumFee
+    )
+        Adminable(initialAdmin)
+    {
+        chainlinkPriceFeed = initialChainlinkPriceFeed;
         minimumFee = initialMinimumFee;
     }
 
@@ -68,6 +79,15 @@ abstract contract SablierMerkleFactoryBase is
         emit ResetCustomFee({ admin: msg.sender, campaignCreator: campaignCreator });
     }
 
+    /// @inheritdoc ISablierMerkleFactoryBase
+    function setChainlinkPriceFeed(address newChainlinkPriceFeed) external override onlyAdmin {
+        // Effect: update the Chainlink price feed.
+        chainlinkPriceFeed = newChainlinkPriceFeed;
+
+        // Log the update.
+        emit SetChainlinkPriceFeed({ admin: msg.sender, chainlinkPriceFeed: newChainlinkPriceFeed });
+    }
+
     /// @inheritdoc ISablierMerkleFactoryBase
     function setCustomFee(address campaignCreator, uint256 newFee) external override onlyAdmin {
         MerkleFactory.CustomFee storage customFeeByUser = _customFees[campaignCreator];
@@ -85,11 +105,12 @@ abstract contract SablierMerkleFactoryBase is
     }
 
     /// @inheritdoc ISablierMerkleFactoryBase
-    function setMinimumFee(uint256 newFee) external override onlyAdmin {
+    function setMinimumFee(uint256 newMinimumFee) external override onlyAdmin {
         // Effect: update the minimum fee.
-        minimumFee = newFee;
+        minimumFee = newMinimumFee;
 
-        emit SetMinimumFee({ admin: msg.sender, minimumFee: newFee });
+        // Log the update.
+        emit SetMinimumFee({ admin: msg.sender, minimumFee: newMinimumFee });
     }
 
     /*//////////////////////////////////////////////////////////////////////////