functions and test working

Author: olivier7delf

packages/smart-contracts/scripts/test-deploy-batch-conversion-deployment.ts

@@ -76,8 +76,12 @@ export async function deployBatchConversionPayment(
     // Initialize batch conversion fee, useful to others packages.
     const batchConversion = batchConversionPaymentsArtifact.connect(hre.network.name, owner);
     await batchConversion.connect(owner).setBatchFee(30);
-    await batchConversion.connect(owner).setBatchConversionFee(30);
-    await batchConversion.connect(owner).setUSDAddress(currencyManager.fromSymbol('USD')!.hash);
+    await batchConversion
+      .connect(owner)
+      .setETHAndUSDAddress(
+        currencyManager.fromSymbol('ETH')!.hash,
+        currencyManager.fromSymbol('USD')!.hash,
+      );
     await batchConversion.connect(owner).setBatchFeeAmountUSDLimit(300); // * 1_000_000_000_000_000_000);
 
     // ----------------------------------

packages/smart-contracts/src/contracts/BatchConversionPayments.sol

@@ -15,8 +15,7 @@ import './BatchNoConversionPayments.sol';
  *          - fees: conversion proxy fees and additional batch conversion fees are paid to the same address.
  *         batchRouter is the main function to batch all kinds of payments at once.
  *         If one transaction of the batch fails, all transactions are reverted.
- * @dev Note that fees have 4 decimals (instead of 3 in a previous version)
- *      batchRouter is the main function, but other batch payment functions are "public" in order to do
+ * @dev batchRouter is the main function, but other batch payment functions are "public" in order to do
  *      gas optimization in some cases.
  */
 contract BatchConversionPayments is BatchNoConversionPayments {
@@ -25,18 +24,14 @@ contract BatchConversionPayments is BatchNoConversionPayments {
   IERC20ConversionProxy public paymentErc20ConversionProxy;
   IEthConversionProxy public paymentEthConversionProxy;
 
-  uint256 public batchConversionFee;
-
   /**
    * @dev Used by the batchRouter to handle information for heterogeneous batches, grouped by payment network.
    *  - paymentNetworkId: from 0 to 4, cf. `batchRouter()` method.
-   *  - conversionDetails all the data required for conversion requests to be paid, for paymentNetworkId = 0 or 4
-   *  - cryptoDetails all the data required to pay requests without conversion, for paymentNetworkId = 1, 2, or 3
+   *  - conversionDetails all the data required for conversion and no conversion requests to be paid
    */
   struct MetaDetail {
     uint256 paymentNetworkId;
     ConversionDetail[] conversionDetails;
-    CryptoDetails cryptoDetails;
   }
 
   /**
@@ -64,31 +59,33 @@ contract BatchConversionPayments is BatchNoConversionPayments {
   {
     paymentErc20ConversionProxy = IERC20ConversionProxy(_paymentErc20ConversionProxy);
     paymentEthConversionProxy = IEthConversionProxy(_paymentEthConversionFeeProxy);
-    batchConversionFee = 0;
   }
 
   /**
    * @notice Batch payments on different payment networks at once.
-   * @param metaDetails contains paymentNetworkId, conversionDetails, and cryptoDetails
+   * @param metaDetails contains paymentNetworkId and conversionDetails
    * - batchMultiERC20ConversionPayments, paymentNetworkId=0
    * - batchERC20Payments, paymentNetworkId=1
    * - batchMultiERC20Payments, paymentNetworkId=2
    * - batchEthPayments, paymentNetworkId=3
    * - batchEthConversionPayments, paymentNetworkId=4
-   * If metaDetails use paymentNetworkId = 4, it must be at the end of the list, or the transaction can be reverted
-   * @param pathsToUSD The list of paths into USD for every token, used to limit the batch fees, caution,
-                       Caution, the calculation of batchFeeAmountUSD which allows to limit the batch fees takes only 
-                       into consideration these paths. Without paths, there is not limitation.
-   * @param _feeAddress The address where fees should be paid
+   * If metaDetails use paymentNetworkId = 4, it must be at the end of the list, or the transaction can be reverted.
+   * @param pathsToUSD The list of paths into USD for every token, used to limit the batch fees.
+   *                   Without paths, there is not limitation.
+   * @param feeAddress The address where fees should be paid
    * @dev batchRouter only reduces gas consumption when using more than a single payment network.
    *      For single payment network payments, it is more efficient to use the suited batch function.
    */
   function batchRouter(
     MetaDetail[] calldata metaDetails,
     address[][] calldata pathsToUSD,
-    address _feeAddress
+    address feeAddress
   ) external payable {
     require(metaDetails.length < 6, 'more than 5 metaDetails');
+    if (pathsToUSD.length > 0) {
+      // Set to true to limit the batch fee to pay
+      batchPaymentOrigin = true;
+    }
     uint256 batchFeeAmountUSD = 0;
     for (uint256 i = 0; i < metaDetails.length; i++) {
       MetaDetail calldata metaConversionDetail = metaDetails[i];
@@ -97,74 +94,84 @@ contract BatchConversionPayments is BatchNoConversionPayments {
           metaConversionDetail.conversionDetails,
           batchFeeAmountUSD,
           pathsToUSD,
-          _feeAddress
+          feeAddress
         );
       } else if (metaConversionDetail.paymentNetworkId == 1) {
-        batchERC20Payments(
+        batchFeeAmountUSD += batchERC20Payments(
           metaConversionDetail.conversionDetails,
           pathsToUSD,
           batchFeeAmountUSD,
-          _feeAddress
+          feeAddress
         );
       } else if (metaConversionDetail.paymentNetworkId == 2) {
         batchFeeAmountUSD += batchMultiERC20Payments(
           metaConversionDetail.conversionDetails,
           pathsToUSD,
           batchFeeAmountUSD,
-          _feeAddress
+          feeAddress
         );
       } else if (metaConversionDetail.paymentNetworkId == 3) {
         if (metaDetails[metaDetails.length - 1].paymentNetworkId == 4) {
           // Set to false only if batchEthConversionPayments is called after this function
           transferBackRemainingEth = false;
         }
-        batchEthPayments(
-          metaConversionDetail.cryptoDetails.recipients,
-          metaConversionDetail.cryptoDetails.amounts,
-          metaConversionDetail.cryptoDetails.paymentReferences,
-          metaConversionDetail.cryptoDetails.feeAmounts,
-          payable(_feeAddress)
+        batchFeeAmountUSD += batchEthPayments(
+          metaConversionDetail.conversionDetails,
+          batchFeeAmountUSD,
+          payable(feeAddress)
         );
         if (metaDetails[metaDetails.length - 1].paymentNetworkId == 4) {
           transferBackRemainingEth = true;
         }
       } else if (metaConversionDetail.paymentNetworkId == 4) {
-        batchEthConversionPayments(metaConversionDetail.conversionDetails, payable(_feeAddress));
+        batchFeeAmountUSD += batchEthConversionPayments(
+          metaConversionDetail.conversionDetails,
+          batchFeeAmountUSD,
+          payable(feeAddress)
+        );
       } else {
-        revert('wrong paymentNetworkId');
+        revert('Wrong paymentNetworkId');
       }
     }
+    if (pathsToUSD.length > 0) {
+      batchPaymentOrigin = false;
+    }
   }
 
   /**
    * @notice Send a batch of ERC20 payments with amounts based on a request
    * currency (e.g. fiat), with fees and paymentReferences to multiple accounts, with multiple tokens.
-   * @param conversionDetails list of requestInfo, each one containing all the information of a request
-   * @param batchFeeAmountUSD The batchFeeAmountUSD already paid
-   * @param pathsToUSD The list of paths into USD for every token
-   * @param _feeAddress The fee recipient
+   * @param conversionDetails List of ERC20 requests denominated in fiat to pay.
+   * @param batchFeeAmountUSD The batch fee amount in USD already paid.
+   * @param pathsToUSD The list of paths into USD for every token, used to limit the batch fees.
+   *                   Without paths, there is not limitation.
+   * @param feeAddress The fee recipient
    */
   function batchMultiERC20ConversionPayments(
     ConversionDetail[] calldata conversionDetails,
     uint256 batchFeeAmountUSD,
     address[][] calldata pathsToUSD,
-    address _feeAddress
+    address feeAddress
   ) public returns (uint256) {
+    // Avoid the possibility to manually put high value to batchFeeAmountUSD
+    if (batchPaymentOrigin != true) {
+      batchFeeAmountUSD = 0;
+    }
     Token[] memory uTokens = getUTokens(conversionDetails);
 
     IERC20 requestedToken;
     // For each token: check allowance, transfer funds on the contract and approve the paymentProxy to spend if needed
     for (uint256 k = 0; k < uTokens.length && uTokens[k].amountAndFee > 0; k++) {
       requestedToken = IERC20(uTokens[k].tokenAddress);
-      uTokens[k].batchFeeAmount = (uTokens[k].amountAndFee * batchConversionFee) / tenThousand;
+      uTokens[k].batchFeeAmount = (uTokens[k].amountAndFee * batchFee) / feeDenominator;
       // Check proxy's allowance from user, and user's funds to pay approximated amounts.
       require(
         requestedToken.allowance(msg.sender, address(this)) >= uTokens[k].amountAndFee,
         'Insufficient allowance for batch to pay'
       );
       require(
         requestedToken.balanceOf(msg.sender) >= uTokens[k].amountAndFee + uTokens[k].batchFeeAmount,
-        'not enough funds, including fees'
+        'Not enough funds, including fees'
       );
 
       // Transfer the amount and fee required for the token on the batch conversion contract
@@ -191,7 +198,7 @@ contract BatchConversionPayments is BatchNoConversionPayments {
         rI.path,
         rI.paymentReference,
         rI.feeAmount,
-        _feeAddress,
+        feeAddress,
         rI.maxToSpend,
         rI.maxRateTimespan
       );
@@ -208,8 +215,9 @@ contract BatchConversionPayments is BatchNoConversionPayments {
         requestedToken.safeTransfer(msg.sender, excessAmount);
       }
 
-      uint256 batchFeeToPay = ((uTokens[k].amountAndFee - excessAmount) * batchConversionFee) /
-        tenThousand;
+      // Calculate batch fee to pay
+      uint256 batchFeeToPay = ((uTokens[k].amountAndFee - excessAmount) * batchFee) /
+        feeDenominator;
 
       (batchFeeToPay, batchFeeAmountUSD) = calculateBatchFeeToPay(
         batchFeeToPay,
@@ -220,8 +228,8 @@ contract BatchConversionPayments is BatchNoConversionPayments {
 
       // Payer pays the exact batch fees amount
       require(
-        safeTransferFrom(uTokens[k].tokenAddress, _feeAddress, batchFeeToPay),
-        'batch fee transferFrom() failed'
+        safeTransferFrom(uTokens[k].tokenAddress, feeAddress, batchFeeToPay),
+        'Batch fee transferFrom() failed'
       );
     }
     return batchFeeAmountUSD;
@@ -230,9 +238,9 @@ contract BatchConversionPayments is BatchNoConversionPayments {
   /**
    * @notice Send a batch of ETH conversion payments with fees and paymentReferences to multiple accounts.
    *         If one payment fails, the whole batch is reverted.
-   * @param conversionDetails List of requestInfos, each one containing all the information of a request.
-   *                     _maxToSpend is not used in this function.
-   * @param _feeAddress The fee recipient.
+   * @param conversionDetails List of ETH requests denominated in fiat to pay.
+   * @param batchFeeAmountUSD The batch fee amount in USD already paid.
+   * @param feeAddress The fee recipient.
    * @dev It uses EthereumConversionProxy to pay an invoice and fees.
    *      Please:
    *        Note that if there is not enough ether attached to the function call,
@@ -241,50 +249,55 @@ contract BatchConversionPayments is BatchNoConversionPayments {
    */
   function batchEthConversionPayments(
     ConversionDetail[] calldata conversionDetails,
-    address payable _feeAddress
-  ) public payable {
+    uint256 batchFeeAmountUSD,
+    address payable feeAddress
+  ) public payable returns (uint256) {
+    // Avoid the possibility to manually put high value to batchFeeAmountUSD
+    if (batchPaymentOrigin != true) {
+      batchFeeAmountUSD = 0;
+    }
     uint256 contractBalance = address(this).balance;
     payerAuthorized = true;
 
     // Batch contract pays the requests through EthConversionProxy
     for (uint256 i = 0; i < conversionDetails.length; i++) {
+      ConversionDetail memory cD = conversionDetails[i];
       paymentEthConversionProxy.transferWithReferenceAndFee{value: address(this).balance}(
-        payable(conversionDetails[i].recipient),
-        conversionDetails[i].requestAmount,
-        conversionDetails[i].path,
-        conversionDetails[i].paymentReference,
-        conversionDetails[i].feeAmount,
-        _feeAddress,
-        conversionDetails[i].maxRateTimespan
+        payable(cD.recipient),
+        cD.requestAmount,
+        cD.path,
+        cD.paymentReference,
+        cD.feeAmount,
+        feeAddress,
+        cD.maxRateTimespan
       );
     }
 
-    // Check that batch contract has enough funds to pay batch conversion fees
-    uint256 amountBatchFees = (((contractBalance - address(this).balance)) * batchConversionFee) /
-      tenThousand;
-    require(address(this).balance >= amountBatchFees, 'not enough funds for batch conversion fees');
-
     // Batch contract pays batch fee
-    _feeAddress.transfer(amountBatchFees);
+    uint256 batchFeeToPay = (((contractBalance - address(this).balance)) * batchFee) /
+      feeDenominator;
+
+    (batchFeeToPay, batchFeeAmountUSD) = calculateBatchFeeToPay(
+      batchFeeToPay,
+      pathsEthToUSD[0][0],
+      batchFeeAmountUSD,
+      pathsEthToUSD
+    );
+    require(address(this).balance >= batchFeeToPay, 'Not enough funds for batch conversion fees');
+    feeAddress.transfer(batchFeeToPay);
 
     // Batch contract transfers the remaining ethers to the payer
     (bool sendBackSuccess, ) = payable(msg.sender).call{value: address(this).balance}('');
     require(sendBackSuccess, 'Could not send remaining funds to the payer');
     payerAuthorized = false;
+
+    return batchFeeAmountUSD;
   }
 
   /*
-   * Admin functions to edit the conversion proxies address and fees
+   * Admin functions to edit the conversion proxies address and fees.
    */
 
-  /**
-   * @notice fees added when using Erc20/Eth conversion batch functions
-   * @param _batchConversionFee between 0 and 10000, i.e: batchFee = 50 represent 0.50% of fees
-   */
-  function setBatchConversionFee(uint256 _batchConversionFee) external onlyOwner {
-    batchConversionFee = _batchConversionFee;
-  }
-
   /**
    * @param _paymentErc20ConversionProxy The address of the ERC20 Conversion payment proxy to use.
    *        Update cautiously, the proxy has to match the invoice proxy.
@@ -302,8 +315,8 @@ contract BatchConversionPayments is BatchNoConversionPayments {
   }
 
   /**
-   * @notice Update the conversion path contract used to fetch conversions
-   * @param _chainlinkConversionPathAddress address of the conversion path contract
+   * @notice Update the conversion path contract used to fetch conversions.
+   * @param _chainlinkConversionPathAddress The address of the conversion path contract.
    */
   function setConversionPathAddress(address _chainlinkConversionPathAddress) external onlyOwner {
     chainlinkConversionPath = ChainlinkConversionPath(_chainlinkConversionPathAddress);