feat(smart-contracts):batch conversion xdeployer

packages/smart-contracts/README.md

@@ -157,7 +157,8 @@ This command will output details about each contract deployment on each chain:
 
 ### Verify the contracts
 
-Verify and publish the contract code automatically to blockchain explorers, right after smart contracts compilation. You should first set the `ETHERSCAN_API_KEY` environment variable.
+Verify and publish the contract code automatically to blockchain explorers, right after smart contracts compilation.
+Environment variables needed: `ADMIN_...` key and wallet, `ETHERSCAN_API_KEY`, and `REQUEST_DEPLOYER_LIVE`. If you deploy on mainnet, add `WEB3_PROVIDER_URL`.
 
 ```bash
 yarn hardhat verify-contract-from-deployer --network <NETWORK>

packages/smart-contracts/hardhat.config.ts

@@ -165,7 +165,7 @@ export default {
     signer: process.env.ADMIN_PRIVATE_KEY,
     networks: process.env.NETWORK
       ? [process.env.NETWORK]
-      : ['mainnet', 'matic', 'bsc', 'celo', 'xdai', 'fuse', 'arbitrum-one', 'fantom', 'avalanche'],
+      : ['matic', 'bsc', 'celo', 'xdai', 'fuse', 'arbitrum-one', 'fantom', 'avalanche', 'mainnet'],
     gasLimit: undefined,
     deployerAddress: requestDeployer,
   },

packages/smart-contracts/scripts-create2/compute-one-address.ts

@@ -56,7 +56,7 @@ export const computeCreate2DeploymentAddressesFromList = async (
         case 'ERC20FeeProxy':
         case 'Erc20ConversionProxy':
         case 'ERC20EscrowToPay':
-        case 'BatchPayments':
+        case 'BatchConversionPayments':
         case 'ERC20SwapToConversion': {
           try {
             const constructorArgs = getConstructorArgs(contract, hre.network.name);

packages/smart-contracts/scripts-create2/constructor-args.ts

@@ -37,13 +37,16 @@ export const getConstructorArgs = (contract: string, network?: string): string[]
       const erc20FeeProxyAddress = erc20FeeProxy.getAddress(network);
       return [erc20FeeProxyAddress, getAdminWalletAddress(contract)];
     }
-    case 'BatchPayments': {
+    case 'BatchConversionPayments': {
       if (!network) {
         throw new Error(
-          'Batch contract requires network parameter to get correct address of erc20FeeProxy and ethereumFeeProxy',
+          'Batch conversion contract requires network parameter to get correct address of erc20FeeProxy, erc20ConversionFeeProxy, ethereumFeeProxy, ethereumConversionFeeProxy, and chainlinkConversionPath',
         );
       }
       return [
+        '0x0000000000000000000000000000000000000000',
+        '0x0000000000000000000000000000000000000000',
+        '0x0000000000000000000000000000000000000000',
         '0x0000000000000000000000000000000000000000',
         '0x0000000000000000000000000000000000000000',
         getAdminWalletAddress(contract),

packages/smart-contracts/scripts-create2/contract-setup/adminTasks.ts

@@ -5,8 +5,12 @@ import { BigNumber } from 'ethers';
 
 // Fees: 0.5%
 export const REQUEST_SWAP_FEES = 5;
-// Batch Fees: .3%
-export const BATCH_FEE = 3;
+
+// Batch fee: temporarily at 0%
+const BATCH_FEE = 30;
+
+// Batch fee amount in USD Limit: 150 * 1e8 ($150)
+const BATCH_FEE_AMOUNT_USD_LIMIT = 150 * 1e8;
 
 export const updateChainlinkConversionPath = async (
   contract: any,
@@ -17,10 +21,11 @@ export const updateChainlinkConversionPath = async (
   const currentChainlinkAddress = await contract.chainlinkConversionPath();
   const chainlinkConversionPathAddress = chainlinkConversionPath.getAddress(network, '0.1.0');
   if (currentChainlinkAddress !== chainlinkConversionPathAddress) {
-    await contract.updateConversionPathAddress(chainlinkConversionPathAddress, {
+    const tx = await contract.updateConversionPathAddress(chainlinkConversionPathAddress, {
       nonce: nonce,
       gasPrice: gasPrice,
     });
+    await tx.wait();
   }
 };
 
@@ -50,16 +55,32 @@ export const updateRequestSwapFees = async (
   }
 };
 
-export const updateBatchPaymentFees = async (
+export const updateBatchPaymentFees = async (contract: any, gasPrice: BigNumber): Promise<void> => {
+  const currentFees = (await contract.batchFee()) as number;
+  if (currentFees - BATCH_FEE !== 0) {
+    const tx = await contract.setBatchFee(BATCH_FEE, { gasPrice: gasPrice });
+    await tx.wait();
+    // Log is useful to have a direct view on was is being updated
+    console.log(
+      `Batch: the current fees: ${currentFees.toString()}, have been replaced by: ${BATCH_FEE}`,
+    );
+  }
+};
+
+export const updateBatchPaymentFeeAmountUSDLimit = async (
   contract: any,
-  nonce: number,
   gasPrice: BigNumber,
 ): Promise<void> => {
-  const currentFees = await contract.batchFee();
-  if (currentFees !== BATCH_FEE) {
+  const currentFeeAmountUSDLimit = (await contract.batchFeeAmountUSDLimit()) as number;
+  if (currentFeeAmountUSDLimit - BATCH_FEE_AMOUNT_USD_LIMIT !== 0) {
+    const tx = await contract.setBatchFeeAmountUSDLimit(BATCH_FEE_AMOUNT_USD_LIMIT, {
+      gasPrice: gasPrice,
+    });
+    await tx.wait();
     // Log is useful to have a direct view on was is being updated
-    console.log(`currentFees: ${currentFees.toString()}, new fees: ${BATCH_FEE}`);
-    await contract.setBatchFee(BATCH_FEE, { nonce: nonce, gasPrice: gasPrice });
+    console.log(
+      `Batch: the current fee amount in USD limit: ${currentFeeAmountUSDLimit.toString()}, have been replaced by: ${BATCH_FEE_AMOUNT_USD_LIMIT}. ($1 = 1e8)`,
+    );
   }
 };
 
@@ -71,28 +92,92 @@ export const updatePaymentErc20FeeProxy = async (
 ): Promise<void> => {
   const erc20FeeProxy = artifacts.erc20FeeProxyArtifact;
   const erc20FeeProxyAddress = erc20FeeProxy.getAddress(network);
-  const currentAddress = await contract.paymentErc20FeeProxy();
-  if (currentAddress !== erc20FeeProxyAddress) {
+  const currentAddress = (await contract.paymentErc20FeeProxy()) as string;
+  if (currentAddress.toLocaleLowerCase() !== erc20FeeProxyAddress.toLocaleLowerCase()) {
     await contract.setPaymentErc20FeeProxy(erc20FeeProxyAddress, {
       nonce: nonce,
       gasPrice: gasPrice,
     });
   }
 };
 
-export const updatePaymentEthFeeProxy = async (
+/**
+ * Update the address of a proxy used by batch conversion contract
+ */
+export const updateBatchConversionProxy = async (
   contract: any,
   network: string,
-  nonce: number,
   gasPrice: BigNumber,
+  proxyName:
+    | 'native'
+    | 'nativeConversion'
+    | 'erc20'
+    | 'erc20Conversion'
+    | 'chainlinkConversionPath',
 ): Promise<void> => {
-  const ethereumFeeProxy = artifacts.ethereumFeeProxyArtifact;
-  const ethereumFeeProxyAddress = ethereumFeeProxy.getAddress(network);
-  const currentAddress = await contract.paymentEthFeeProxy();
-  if (currentAddress !== ethereumFeeProxyAddress) {
-    await contract.setPaymentEthFeeProxy(ethereumFeeProxyAddress, {
-      nonce: nonce,
+  try {
+    let proxyAddress: string;
+    let batchSetProxy: any;
+    let currentAddress: string;
+    if (proxyName === 'native') {
+      proxyAddress = artifacts.ethereumFeeProxyArtifact.getAddress(network);
+      batchSetProxy = await contract.setPaymentNativeProxy;
+      currentAddress = await contract.paymentNativeProxy();
+    } else if (proxyName === 'nativeConversion') {
+      proxyAddress = artifacts.ethConversionArtifact.getAddress(network);
+      batchSetProxy = await contract.setPaymentNativeConversionProxy;
+      currentAddress = await contract.paymentNativeConversionProxy();
+    } else if (proxyName === 'erc20') {
+      proxyAddress = artifacts.erc20FeeProxyArtifact.getAddress(network);
+      batchSetProxy = await contract.setPaymentErc20Proxy;
+      currentAddress = await contract.paymentErc20Proxy();
+    } else if (proxyName === 'erc20Conversion') {
+      proxyAddress = artifacts.erc20ConversionProxy.getAddress(network);
+      batchSetProxy = await contract.setPaymentErc20ConversionProxy;
+      currentAddress = await contract.paymentErc20ConversionProxy();
+    } else {
+      // (proxyName === 'chainlinkConversionPath')
+      proxyAddress = artifacts.chainlinkConversionPath.getAddress(network);
+      batchSetProxy = await contract.setChainlinkConversionPath;
+      currentAddress = await contract.chainlinkConversionPath();
+    }
+
+    if (currentAddress.toLocaleLowerCase() !== proxyAddress.toLocaleLowerCase()) {
+      const tx = await batchSetProxy(proxyAddress, {
+        gasPrice: gasPrice,
+      });
+      await tx.wait();
+      console.log(
+        `${proxyName}: the current address ${currentAddress} has been replaced by: ${proxyAddress}`,
+      );
+    }
+  } catch (e) {
+    console.log(`Cannot update ${proxyName} proxy, it might not exist on this network`);
+    console.log(e);
+  }
+};
+
+export const updateNativeAndUSDAddress = async (
+  contract: any,
+  NativeAddress: string,
+  USDAddress: string,
+  gasPrice: BigNumber,
+): Promise<void> => {
+  const currentUSDAddress = (await contract.USDAddress()).toLocaleLowerCase();
+  const currentNativeAddress = (await contract.NativeAddress()).toLocaleLowerCase();
+  if (
+    currentNativeAddress !== NativeAddress.toLocaleLowerCase() ||
+    currentUSDAddress !== USDAddress.toLocaleLowerCase()
+  ) {
+    console.log(
+      `Batch: the current NativeAddress: ${currentNativeAddress}, have been replaced by: ${NativeAddress}`,
+    );
+    console.log(
+      `Batch: the current USDAddress: ${currentUSDAddress}, have been replaced by: ${USDAddress}`,
+    );
+    const tx = await contract.setNativeAndUSDAddress(NativeAddress, USDAddress, {
       gasPrice: gasPrice,
     });
+    await tx.wait();
   }
 };

packages/smart-contracts/scripts-create2/contract-setup/setupBatchConversionPayments.ts

@@ -0,0 +1,95 @@
+import { batchConversionPaymentsArtifact } from '../../src/lib';
+import { HardhatRuntimeEnvironmentExtended } from '../types';
+import utils from '@requestnetwork/utils';
+import {
+  updateBatchPaymentFees,
+  updateBatchConversionProxy,
+  updateBatchPaymentFeeAmountUSDLimit,
+  updateNativeAndUSDAddress,
+} from './adminTasks';
+import { CurrencyManager } from '@requestnetwork/currency';
+import { RequestLogicTypes } from '@requestnetwork/types';
+/**
+ * Updates the values of the batch fees of the BatchConversionPayments contract, if needed
+ * @param contractAddress address of the BatchConversionPayments Proxy
+ * @param hre Hardhat runtime environment
+ */
+export const setupBatchConversionPayments = async (
+  contractAddress: string,
+  hre: HardhatRuntimeEnvironmentExtended,
+): Promise<void> => {
+  // Setup contract parameters
+  const batchConversionPaymentContract = new hre.ethers.Contract(
+    contractAddress,
+    batchConversionPaymentsArtifact.getContractAbi(),
+  );
+  // constants related to chainlink and conversion rate
+  const currencyManager = CurrencyManager.getDefault();
+  for (const network of hre.config.xdeploy.networks) {
+    await Promise.all(
+      [network].map(async (network) => {
+        const NativeAddress = currencyManager.getNativeCurrency(
+          RequestLogicTypes.CURRENCY.ETH,
+          network,
+        )!.hash;
+        const USDAddress = currencyManager.fromSymbol('USD')!.hash;
+        console.log(`Setup BatchConversionPayments on ${network}`);
+        let provider;
+        if (network === 'celo') {
+          provider = utils.getCeloProvider();
+        } else {
+          provider = utils.getDefaultProvider(network);
+        }
+        const wallet = new hre.ethers.Wallet(hre.config.xdeploy.signer, provider);
+        const signer = wallet.connect(provider);
+        const batchConversionPaymentConnected = batchConversionPaymentContract.connect(signer);
+        const gasPrice = await provider.getGasPrice();
+
+        // start from the adminNonce, increase gasPrice if needed
+        const gasCoef = 3;
+        await updateBatchPaymentFees(batchConversionPaymentConnected, gasPrice.mul(gasCoef));
+        await updateBatchPaymentFeeAmountUSDLimit(
+          batchConversionPaymentConnected,
+          gasPrice.mul(gasCoef),
+        );
+        await updateBatchConversionProxy(
+          batchConversionPaymentConnected,
+          network,
+          gasPrice.mul(gasCoef),
+          'erc20',
+        );
+        await updateBatchConversionProxy(
+          batchConversionPaymentConnected,
+          network,
+          gasPrice.mul(gasCoef),
+          'native',
+        );
+        await updateBatchConversionProxy(
+          batchConversionPaymentConnected,
+          network,
+          gasPrice.mul(gasCoef),
+          'erc20Conversion',
+        );
+        await updateBatchConversionProxy(
+          batchConversionPaymentConnected,
+          network,
+          gasPrice.mul(gasCoef),
+          'nativeConversion',
+        );
+        await updateBatchConversionProxy(
+          batchConversionPaymentConnected,
+          network,
+          gasPrice.mul(gasCoef),
+          'chainlinkConversionPath',
+        );
+        await updateNativeAndUSDAddress(
+          batchConversionPaymentConnected,
+          NativeAddress,
+          USDAddress,
+          gasPrice.mul(gasCoef),
+        );
+      }),
+    );
+  }
+  console.log('Setup for setupBatchConversionPayment successfull');
+};

packages/smart-contracts/scripts-create2/contract-setup/setups.ts

@@ -1,10 +1,10 @@
 import { HardhatRuntimeEnvironmentExtended } from '../types';
 import { setupETHConversionProxy } from './setupETHConversionProxy';
-import { setupBatchPayments } from './setupBatchPayments';
+import { setupBatchConversionPayments } from './setupBatchConversionPayments';
 import { setupERC20SwapToConversion } from './setupERC20SwapToConversion';
 
 /**
- * Updates the values of either BatchPayments, ETHConversionProxy, or ERC20SwapToConversion contract, if needed
+ * Updates the values of either BatchConversionPayments, ETHConversionProxy, or ERC20SwapToConversion contract, if needed
  * @param contractAddress address of the proxy
  * @param hre Hardhat runtime environment
  * @param contractName name of the contract
@@ -23,8 +23,8 @@ export const setupContract = async (
       await setupERC20SwapToConversion(contractAddress, hre);
       break;
     }
-    case 'BatchPayments': {
-      await setupBatchPayments(contractAddress, hre);
+    case 'BatchConversionPayments': {
+      await setupBatchConversionPayments(contractAddress, hre);
       break;
     }
     default: {