Bulk donation support

contracts/.solhint.json

@@ -2,14 +2,15 @@
   "extends": "solhint:recommended",
   "plugins": ["prettier"],
   "rules": {
-    "code-complexity": ["error", 7],
+    "code-complexity": ["error", 9],
     "compiler-version": ["error", "^0.8.0"],
     "const-name-snakecase": "off",
     "constructor-syntax": "error",
     "func-visibility": ["error", { "ignoreConstructors": true }],
     "max-line-length": "off",
     "not-rely-on-time": "off",
     "prettier/prettier": ["error", { "endOfLine": "auto" }],
-    "reason-string": "off"
+    "reason-string": "off",
+    "reentrancy": "off"
   }
 }

contracts/contracts/GrantRoundManager.sol

@@ -9,20 +9,12 @@ import "./GrantRegistry.sol";
 import "./GrantRound.sol";
 
 contract GrantRoundManager {
+  // --- Libraries ---
   using Address for address;
   using BytesLib for bytes;
   using SafeERC20 for IERC20;
 
-  /// @notice Donation inputs and Uniswap V3 swap inputs: https://docs.uniswap.org/protocol/guides/swaps/multihop-swaps
-  struct Donation {
-    uint96 grantId; // grant ID to which donation is being made
-    GrantRound[] rounds; // rounds against which the donation should be counted
-    bytes path; // swap path, or if user is providing donationToken, the address of the donationToken
-    uint256 deadline; // unix timestamp after which a swap will revert, i.e. swap must be executed before this
-    uint256 amountIn; // amount donated by the user
-    uint256 amountOutMinimum; // minimum amount to be returned after swap
-  }
-
+  // --- Data ---
   /// @notice Address of the GrantRegistry
   GrantRegistry public immutable registry;
 
@@ -32,35 +24,70 @@ contract GrantRoundManager {
   /// @notice Address of the ERC20 token in which donations are made
   IERC20 public immutable donationToken;
 
+  /// @notice Used during donations to temporarily store swap output amounts
+  mapping(IERC20 => uint256) internal swapOutputs;
+
+  /// @notice Used during donations to temporarily store donation ratio sums to ensure totals are always 100%
+  mapping(IERC20 => uint256) internal donationRatios;
+
   /// @notice WETH address
-  address public constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
+  IERC20 public constant WETH = IERC20(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
+
+  /// @notice Scale factor
+  uint256 internal constant WAD = 1e18;
+
+  /// --- Types ---
+  /// @notice Defines the total `amount` of the specified `token` that needs to be swapped to `donationToken`. If
+  /// `path == donationToken`, no swap is required and we just transfer the tokens
+  struct SwapSummary {
+    uint256 amountIn;
+    uint256 amountOutMin; // minimum amount to be returned after swap
+    bytes path;
+  }
 
+  /// @notice Donation inputs and Uniswap V3 swap inputs: https://docs.uniswap.org/protocol/guides/swaps/multihop-swaps
+  struct Donation {
+    uint96 grantId; // grant ID to which donation is being made
+    IERC20 token; // address of the token to donate
+    uint256 ratio; // ratio of `token` to donate, specified as numerator where WAD = 1e18 = 100%
+    GrantRound[] rounds; // rounds against which the donation should be counted
+  }
+
+  // --- Events ---
   /// @notice Emitted when a new GrantRound contract is created
   event GrantRoundCreated(address grantRound);
 
   /// @notice Emitted when a donation has been made
-  event GrantDonation(
-    uint96 indexed grantId,
-    IERC20 indexed tokenIn,
-    uint256 amountIn,
-    uint256 amountOut,
-    GrantRound[] rounds
-  );
+  event GrantDonation(uint96 indexed grantId, IERC20 indexed tokenIn, uint256 donationAmount, GrantRound[] rounds);
 
+  // --- Constructor ---
   constructor(
     GrantRegistry _registry,
     ISwapRouter _router,
     IERC20 _donationToken
   ) {
+    // Validation
     require(_registry.grantCount() >= 0, "GrantRoundManager: Invalid registry");
     require(address(_router).isContract(), "GrantRoundManager: Invalid router"); // Router interface doesn't have a state variable to check
     require(_donationToken.totalSupply() > 0, "GrantRoundManager: Invalid token");
 
+    // Set state
     registry = _registry;
     router = _router;
     donationToken = _donationToken;
+
+    // Token approvals of common tokens
+    // TODO inherit from SwapRouter to remove the need for this approvals and extra safeTransferFrom before swap
+    IERC20(0x6B175474E89094C44Da98b954EedeAC495271d0F).safeApprove(address(_router), type(uint256).max); // DAI
+    IERC20(0xDe30da39c46104798bB5aA3fe8B9e0e1F348163F).safeApprove(address(_router), type(uint256).max); // GTC
+    IERC20(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48).safeApprove(address(_router), type(uint256).max); // USDC
+    IERC20(0xdAC17F958D2ee523a2206206994597C13D831ec7).safeApprove(address(_router), type(uint256).max); // USDT
+    IERC20(0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599).safeApprove(address(_router), type(uint256).max); // WBTC
+    WETH.safeApprove(address(_router), type(uint256).max); // WETH
   }
 
+  // --- Core methods ---
+
   /**
    * @notice Creates a new GrantRound
    * @param _owner Grant round owner that has permission to update the metadata pointer
@@ -99,66 +126,119 @@ contract GrantRoundManager {
   }
 
   /**
-   * @notice Swap and donate to a grant
-   * @param  _donation Donation being made to a grant
+   * @notice Performs swaps if necessary and donates funds as specified
+   * @param _swaps Array of SwapSummary objects describing the swaps required
+   * @param _deadline Unix timestamp after which a swap will revert, i.e. swap must be executed before this
+   * @param _donations Array of donations to execute
+   * @dev `_deadline` is not part of the `_swaps` array since all swaps can use the same `_deadline` to save some gas
+   * @dev Caller must ensure the input tokens to the _swaps array are unique
+   * @dev Does not verify
    */
-  function swapAndDonate(Donation calldata _donation) external payable {
-    // --- Validation ---
-    // Rounds must be specified
-    GrantRound[] calldata _rounds = _donation.rounds;
-    require(_rounds.length > 0, "GrantRoundManager: Must specify at least one round");
-
-    // Only allow value to be sent if the input token is WETH (this limitation should be fixed in #76, as this
-    // require statement prohibits donating WETH)
-    IERC20 _tokenIn = IERC20(_donation.path.toAddress(0));
-    require(
-      (msg.value == 0 && address(_tokenIn) != WETH) || (msg.value > 0 && address(_tokenIn) == WETH),
-      "GrantRoundManager: Invalid token-value pairing"
-    );
+  function donate(
+    SwapSummary[] calldata _swaps,
+    uint256 _deadline,
+    Donation[] calldata _donations
+  ) external payable {
+    // Main logic
+    _validateDonations(_donations);
+    _executeDonationSwaps(_swaps, _deadline);
+    _transferDonations(_donations);
+
+    // Clear storage for refunds (this is set in _executeDonationSwaps)
+    for (uint256 i = 0; i < _swaps.length; i++) {
+      IERC20 _tokenIn = IERC20(_swaps[i].path.toAddress(0));
+      swapOutputs[_tokenIn] = 0;
+      donationRatios[_tokenIn] = 0;
+    }
+  }
 
-    // Ensure grant recieving donation exists in registry
-    uint96 _grantId = _donation.grantId;
-    require(_grantId < registry.grantCount(), "GrantRoundManager: Grant does not exist in registry");
-
-    // Iterate through each GrantRound to verify:
-    //   - The round has the same donationToken as the GrantRoundManager
-    //   - The round is active
-    for (uint256 i = 0; i < _rounds.length; i++) {
-      require(_rounds[i].isActive(), "GrantRoundManager: GrantRound is not active");
-      require(
-        donationToken == _rounds[i].donationToken(),
-        "GrantRoundManager: GrantRound's donation token does not match GrantRoundManager's donation token"
-      );
+  /**
+   * @dev Validates the the inputs to a donation call are valid, and reverts if any requirements are violated
+   * @param _donations Array of donations that will be executed
+   */
+  function _validateDonations(Donation[] calldata _donations) internal {
+    // TODO consider moving this to the section where we already loop through donations in case that saves a lot of
+    // gas. Leaving it here for now to improve readability
+
+    for (uint256 i = 0; i < _donations.length; i++) {
+      // Validate grant exists
+      require(_donations[i].grantId < registry.grantCount(), "GrantRoundManager: Grant does not exist in registry");
+
+      // Used later to validate ratios are correctly provided
+      donationRatios[_donations[i].token] += _donations[i].ratio;
+
+      // Validate round parameters
+      GrantRound[] calldata _rounds = _donations[i].rounds;
+      for (uint256 j = 0; j < _rounds.length; j++) {
+        require(_rounds[j].isActive(), "GrantRoundManager: GrantRound is not active");
+        require(
+          donationToken == _rounds[j].donationToken(),
+          "GrantRoundManager: GrantRound's donation token does not match GrantRoundManager's donation token"
+        );
+      }
     }
+  }
 
-    // --- Swap ---
-    address _payoutAddress = registry.getGrantPayee(_grantId);
-    uint256 _amountIn = _donation.amountIn;
-    uint256 _amountOut = _amountIn; // by default, by may be overwritten in the swap branch below
+  /**
+   * @dev Performs swaps if necessary
+   * @param _swaps Array of SwapSummary objects describing the swaps required
+   * @param _deadline Unix timestamp after which a swap will revert, i.e. swap must be executed before this
+   */
+  function _executeDonationSwaps(SwapSummary[] calldata _swaps, uint256 _deadline) internal {
+    for (uint256 i = 0; i < _swaps.length; i++) {
+      // Validate ratios sum to 100%
+      IERC20 _tokenIn = IERC20(_swaps[i].path.toAddress(0));
+      require(donationRatios[_tokenIn] == WAD, "GrantRoundManager: Ratios do not sum to 100%");
+      require(swapOutputs[_tokenIn] == 0, "GrantRoundManager: Swap parameter has duplicate input tokens");
+
+      // Do nothing if the swap input token equals donationToken
+      if (_tokenIn == donationToken) {
+        swapOutputs[_tokenIn] = _swaps[i].amountIn;
+        continue;
+      }
+
+      // Transfer input token to this contract if required
+      // TODO inherit from SwapRouter to remove the need for this
+      if (_tokenIn != WETH || msg.value == 0) {
+        _tokenIn.safeTransferFrom(msg.sender, address(this), _swaps[i].amountIn);
+      }
 
-    if (_tokenIn == donationToken && msg.value == 0) {
-      // ETH as the donation token is not supported, so ensure msg.value is zero
-      _tokenIn.safeTransferFrom(msg.sender, _payoutAddress, _amountOut); // transfer funds directly to payout address
-    } else {
-      // Swap setup
+      // Otherwise, execute swap
       ISwapRouter.ExactInputParams memory params = ISwapRouter.ExactInputParams(
-        _donation.path,
-        _payoutAddress, // recipient
-        _donation.deadline,
-        _amountIn,
-        _donation.amountOutMinimum
+        _swaps[i].path,
+        address(this), // send output to the contract and it will be transferred later
+        _deadline,
+        _swaps[i].amountIn,
+        _swaps[i].amountOutMin
       );
+      uint256 _value = _tokenIn == WETH && msg.value > 0 ? msg.value : 0;
+      swapOutputs[_tokenIn] = router.exactInput{value: _value}(params); // save off output amount for later
+    }
+  }
 
-      // If user is sending a token, transfer it to this contract and approve the router to spend it
-      if (msg.value == 0) {
-        _tokenIn.safeTransferFrom(msg.sender, address(this), _amountIn);
-        _tokenIn.approve(address(router), type(uint256).max); // TODO optimize so we don't call this every time
+  /**
+   * @dev Core donation logic that transfers funds to grants
+   * @param _donations Array of donations to execute
+   */
+  function _transferDonations(Donation[] calldata _donations) internal {
+    for (uint256 i = 0; i < _donations.length; i++) {
+      // Get data for this donation
+      GrantRound[] calldata _rounds = _donations[i].rounds;
+      uint96 _grantId = _donations[i].grantId;
+      IERC20 _tokenIn = _donations[i].token;
+      uint256 _donationAmount = (swapOutputs[_tokenIn] * _donations[i].ratio) / WAD;
+      require(_donationAmount > 0, "GrantRoundManager: Donation amount must be greater than zero"); // verifies that swap and donation inputs are consistent
+
+      // Execute transfer
+      address _payee = registry.getGrantPayee(_grantId);
+      if (_tokenIn == donationToken) {
+        _tokenIn.safeTransferFrom(msg.sender, _payee, _donationAmount); // transfer token directly from caller
+      } else {
+        donationToken.transfer(_payee, _donationAmount); // transfer swap output
       }
 
-      // Execute swap -- output of swap is sent to the payoutAddress
-      _amountOut = router.exactInput{value: msg.value}(params);
+      // Emit event
+      emit GrantDonation(_grantId, _tokenIn, _donationAmount, _rounds);
     }
-
-    emit GrantDonation(_grantId, _tokenIn, _amountIn, _amountOut, _rounds);
   }
 }

contracts/contracts/test/MockToken.sol

@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: AGPL-3.0-only
 pragma solidity ^0.8.6;
 
 import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
@@ -7,7 +8,7 @@ contract MockToken is ERC20 {
     _mint(msg.sender, initialSupply);
   }
 
-  function mint(uint256 initialSupply) external {
-    _mint(msg.sender, initialSupply);
+  function mint(uint256 amount) external {
+    _mint(msg.sender, amount);
   }
 }