feat(smart-contracts):batch conversion xdeployer

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

@@ -57,6 +57,7 @@ export const computeCreate2DeploymentAddressesFromList = async (
         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

@@ -49,6 +49,20 @@ export const getConstructorArgs = (contract: string, network?: string): string[]
         getAdminWalletAddress(contract),
       ];
     }
+    case 'BatchConversionPayments': {
+      if (!network) {
+        throw new Error(
+          'Batch conversion contract requires network parameter to get correct address of erc20FeeProxy, erc20ConversionFeeProxy, ethereumFeeProxy, and ethereumConversionFeeProxy',
+        );
+      }
+      return [
+        '0x0000000000000000000000000000000000000000',
+        '0x0000000000000000000000000000000000000000',
+        '0x0000000000000000000000000000000000000000',
+        '0x0000000000000000000000000000000000000000',
+        getAdminWalletAddress(contract),
+      ];
+    }
     default:
       return [];
   }

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

@@ -5,8 +5,10 @@ import { BigNumber } from 'ethers';
 
 // Fees: 0.5%
 export const REQUEST_SWAP_FEES = 5;
-// Batch Fees: .3%
-export const BATCH_FEE = 3;
+
+// Batch conversion and no conversion fees: .3%
+const BATCH_NO_CONVERSION_FEE = 30;
+const BATCH_CONVERSION_FEE = 30;
 
 export const updateChainlinkConversionPath = async (
   contract: any,
@@ -50,16 +52,26 @@ export const updateRequestSwapFees = async (
   }
 };
 
+/**
+ * Updates batch fees with/out conversion
+ * BATCH_NO_CONVERSION_FEE e.g: payment DAI - DAI
+ * BATCH_CONVERSION_FEE e.g: payment EUR - DAI
+ */
 export const updateBatchPaymentFees = async (
   contract: any,
   nonce: number,
   gasPrice: BigNumber,
+  feesName: 'BatchNoConversionFee' | 'BatchConversionFee',
 ): Promise<void> => {
+  const feesApplied =
+    feesName === 'BatchNoConversionFee' ? BATCH_NO_CONVERSION_FEE : BATCH_CONVERSION_FEE;
   const currentFees = await contract.batchFee();
-  if (currentFees !== BATCH_FEE) {
+  if (currentFees !== feesApplied) {
     // 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(
+      `${feesName}: the current fees: ${currentFees.toString()}, have been replaced by: ${feesApplied}`,
+    );
+    await contract.setBatchFee(feesApplied, { nonce: nonce, gasPrice: gasPrice });
   }
 };
 
@@ -80,17 +92,43 @@ export const updatePaymentErc20FeeProxy = async (
   }
 };
 
-export const updatePaymentEthFeeProxy = async (
+/**
+ * Update the address of a payment proxy used by batch conversion contract
+ */
+export const updateBatchConversionPaymentProxy = async (
   contract: any,
   network: string,
   nonce: number,
   gasPrice: BigNumber,
+  proxyName: 'eth' | 'ethConversion' | 'erc20' | 'erc20Conversion',
 ): Promise<void> => {
-  const ethereumFeeProxy = artifacts.ethereumFeeProxyArtifact;
-  const ethereumFeeProxyAddress = ethereumFeeProxy.getAddress(network);
-  const currentAddress = await contract.paymentEthFeeProxy();
-  if (currentAddress !== ethereumFeeProxyAddress) {
-    await contract.setPaymentEthFeeProxy(ethereumFeeProxyAddress, {
+  let proxyAddress: string;
+  let batchSetProxy: any;
+  let currentAddress: string;
+  if (proxyName === 'eth') {
+    proxyAddress = artifacts.ethereumFeeProxyArtifact.getAddress(network);
+    batchSetProxy = await contract.setPaymentEthProxy;
+    currentAddress = await contract.paymentEthProxy();
+  } else if (proxyName === 'ethConversion') {
+    proxyAddress = artifacts.ethConversionArtifact.getAddress(network);
+    batchSetProxy = await contract.setPaymentEthConversionProxy;
+    currentAddress = await contract.paymentEthConversionProxy();
+  } else if (proxyName === 'erc20') {
+    proxyAddress = artifacts.erc20FeeProxyArtifact.getAddress(network);
+    batchSetProxy = await contract.setPaymentErc20Proxy;
+    currentAddress = await contract.paymentErc20Proxy();
+  } else {
+    // proxyName === "erc20Conversion"
+    proxyAddress = artifacts.erc20ConversionProxy.getAddress(network);
+    batchSetProxy = await contract.setPaymentErc20ConversionProxy;
+    currentAddress = await contract.paymentErc20ConversionProxy();
+  }
+
+  if (currentAddress !== proxyAddress) {
+    console.log(
+      `${proxyName}: the current address ${currentAddress} has been replaced by: ${proxyAddress}`,
+    );
+    await batchSetProxy(proxyAddress, {
       nonce: nonce,
       gasPrice: gasPrice,
     });

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

@@ -0,0 +1,82 @@
+import { batchConversionPaymentsArtifact } from '../../src/lib';
+import { HardhatRuntimeEnvironmentExtended } from '../types';
+import utils from '@requestnetwork/utils';
+import { updateBatchPaymentFees, updateBatchConversionPaymentProxy } from './adminTasks';
+
+/**
+ * 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(),
+  );
+  await Promise.all(
+    hre.config.xdeploy.networks.map(async (network) => {
+      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 adminNonce = await signer.getTransactionCount();
+      const gasPrice = await provider.getGasPrice();
+
+      // start from the adminNonce, increase gasPrice if needed
+      const gasCoef = 2;
+      await Promise.all([
+        await updateBatchPaymentFees(
+          batchConversionPaymentConnected,
+          adminNonce,
+          gasPrice.mul(gasCoef),
+          'BatchNoConversionFee',
+        ),
+        await updateBatchPaymentFees(
+          batchConversionPaymentConnected,
+          adminNonce + 1,
+          gasPrice.mul(gasCoef),
+          'BatchConversionFee',
+        ),
+        await updateBatchConversionPaymentProxy(
+          batchConversionPaymentConnected,
+          network,
+          adminNonce + 2,
+          gasPrice.mul(gasCoef),
+          'erc20',
+        ),
+        await updateBatchConversionPaymentProxy(
+          batchConversionPaymentConnected,
+          network,
+          adminNonce + 3,
+          gasPrice.mul(gasCoef),
+          'eth',
+        ),
+        await updateBatchConversionPaymentProxy(
+          batchConversionPaymentConnected,
+          network,
+          adminNonce + 4,
+          gasPrice.mul(gasCoef),
+          'erc20Conversion',
+        ),
+        await updateBatchConversionPaymentProxy(
+          batchConversionPaymentConnected,
+          network,
+          adminNonce + 5,
+          gasPrice.mul(gasCoef),
+          'ethConversion',
+        ),
+      ]);
+    }),
+  );
+  console.log('Setup for setupBatchConversionPayment successfull');
+};

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

@@ -1,6 +1,6 @@
 import { HardhatRuntimeEnvironmentExtended } from '../types';
 import { setupETHConversionProxy } from './setupETHConversionProxy';
-import { setupBatchPayments } from './setupBatchPayments';
+import { setupBatchConversionPayments } from './setupBatchConversionPayments';
 import { setupERC20SwapToConversion } from './setupERC20SwapToConversion';
 
 /**
@@ -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: {

packages/smart-contracts/scripts-create2/deploy.ts

@@ -4,7 +4,7 @@ import { HardhatRuntimeEnvironmentExtended } from './types';
 import { xdeploy } from './xdeployer';
 import { getConstructorArgs } from './constructor-args';
 import { setupERC20SwapToConversion } from './contract-setup';
-import { setupBatchPayments } from './contract-setup/setupBatchPayments';
+import { setupBatchConversionPayments } from './contract-setup/setupBatchConversionPayments';
 
 // Deploys, set up the contracts and returns the address
 export const deployOneWithCreate2 = async (
@@ -72,11 +72,11 @@ export const deployWithCreate2FromList = async (
         await deployOneWithCreate2({ contract, constructorArgs }, hre);
         break;
       }
-      case 'BatchPayments': {
+      case 'BatchConversionPayments': {
         const network = hre.config.xdeploy.networks[0];
         const constructorArgs = getConstructorArgs(contract, network);
         const address = await deployOneWithCreate2({ contract, constructorArgs }, hre);
-        await setupBatchPayments(address, hre);
+        await setupBatchConversionPayments(address, hre);
         break;
       }
       // Other cases to add when necessary

packages/smart-contracts/scripts-create2/utils.ts

@@ -14,7 +14,7 @@ export const create2ContractDeploymentList = [
   'Erc20ConversionProxy',
   'ERC20SwapToConversion',
   'ERC20EscrowToPay',
-  'BatchPayments',
+  'BatchConversionPayments',
 ];
 
 /**
@@ -49,6 +49,8 @@ export const getArtifact = (contract: string): artifacts.ContractArtifact<Contra
       return artifacts.erc20EscrowToPayArtifact;
     case 'BatchPayments':
       return artifacts.batchPaymentsArtifact;
+    case 'BatchConversionPayments':
+      return artifacts.batchConversionPaymentsArtifact;
     default:
       throw new Error('Contract unknown');
   }

packages/smart-contracts/scripts-create2/verify.ts

@@ -43,7 +43,7 @@ export async function VerifyCreate2FromList(hre: HardhatRuntimeEnvironmentExtend
             await verifyOne(address, { contract, constructorArgs }, hre);
             break;
           }
-          case 'BatchPayments': {
+          case 'BatchConversionPayments': {
             const network = hre.config.xdeploy.networks[0];
             const constructorArgs = getConstructorArgs(contract, network);
             address = await computeCreate2DeploymentAddress({ contract, constructorArgs }, hre);

packages/smart-contracts/src/lib/artifacts/BatchConversionPayments/index.ts

@@ -13,6 +13,51 @@ export const batchConversionPaymentsArtifact = new ContractArtifact<BatchConvers
           address: '0x2e335F247E91caa168c64b63104C4475b2af3942',
           creationBlockNumber: 0,
         },
+        rinkeby: {
+          address: '0x42c466ccF141A8EBE0Aa2ECEF06A4f4BE9a9B526',
+          creationBlockNumber: 11338182,
+        },
+        goerli: {
+          address: '0x42c466ccF141A8EBE0Aa2ECEF06A4f4BE9a9B526',
+          creationBlockNumber: 7546738,
+        },
+        mainnet: {
+          address: '0x42c466ccF141A8EBE0Aa2ECEF06A4f4BE9a9B526',
+          creationBlockNumber: 15537996,
+        },
+        matic: {
+          address: '0x42c466ccF141A8EBE0Aa2ECEF06A4f4BE9a9B526',
+          creationBlockNumber: 32800551,
+        },
+        bsc: {
+          address: '0x42c466ccF141A8EBE0Aa2ECEF06A4f4BE9a9B526',
+          creationBlockNumber: 21349159,
+        },
+        celo: {
+          address: '0x42c466ccF141A8EBE0Aa2ECEF06A4f4BE9a9B526',
+          creationBlockNumber: 15112387,
+        },
+        'arbitrum-one': {
+          address: '0x42c466ccF141A8EBE0Aa2ECEF06A4f4BE9a9B526',
+          creationBlockNumber: 24718550,
+        },
+        fantom: {
+          address: '0x42c466ccF141A8EBE0Aa2ECEF06A4f4BE9a9B526',
+          creationBlockNumber: 46977185,
+        },
+        avalanche: {
+          address: '0x42c466ccF141A8EBE0Aa2ECEF06A4f4BE9a9B526',
+          creationBlockNumber: 19892946,
+        },
+        // KO because there are missing proxy: ERC20Conversion
+        // xdai: {
+        //   address: '0x42c466ccF141A8EBE0Aa2ECEF06A4f4BE9a9B526',
+        //   creationBlockNumber: 24192455,
+        // },
+        // fuse: {
+        //   address: '0x42c466ccF141A8EBE0Aa2ECEF06A4f4BE9a9B526',
+        //   creationBlockNumber: 19146859,
+        // },
       },
     },
   },