feat(smart-contracts): BatchConversionContract 0.2.0 mainnet artifact

packages/smart-contracts/README.md

@@ -67,7 +67,7 @@ The package stores the following smart contracts:
 - `RequestOpenHashSubmitter` entry point to add hashes in `RequestHashStorage`. It gives the rules to get the right to submit hashes and collect the fees. This contract must be whitelisted in `RequestHashStorage`. The only condition for adding hash is to pay the fees.
 - `StorageFeeCollector` parent contract (not deployed) of `RequestOpenHashSubmitter`, computes the fees and send them to the burner.
 
-**Smart contracts for advanced-logic package**
+**Smart contracts for payments (advanced-logic package)**
 
 - `TestERC20` minimal erc20 token used for tests.
 - `ERC20Proxy` used to pay requests with an ERC20 proxy contract payment network

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

@@ -40,6 +40,10 @@ export async function computeCreate2DeploymentAddress(
     );
     return computedAddress;
   } catch (e) {
+    console.warn('Error while computing the deployment address', {
+      'deploymentParams.contract': deploymentParams.contract,
+      WEB3_PROVIDER_URL: process.env.WEB3_PROVIDER_URL,
+    });
     throw new Error(e.toString());
   }
 }

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

@@ -15,23 +15,26 @@ import { setupContract } from './contract-setup/setups';
 export const deployOneWithCreate2 = async (
   deploymentParams: IDeploymentParams,
   hre: HardhatRuntimeEnvironmentExtended,
-): Promise<string> => {
+): Promise<{ deployed: 'success' | 'yes' | 'no'; address: string }> => {
   if (!hre.config.xdeploy.networks || hre.config.xdeploy.networks.length === 0) {
     throw new Error('Invalid networks');
   }
   // Deploy the contract on several network through xdeployer
+  let deployed: 'success' | 'yes' | 'no' = 'no';
   const deploymentResult = await xdeploy(deploymentParams, hre);
   hre.config.xdeploy.networks.forEach((network, i) => {
     if (deploymentResult[i].deployed) {
       console.log(`${deploymentParams.contract} successfully deployed:`);
       console.log(`         On network:        ${network}`);
       console.log(`         At address:        ${deploymentResult[i].address}`);
       console.log(`         At block:          ${deploymentResult[i].receipt.blockNumber}`);
+      deployed = 'success';
     } else {
       if (isContractDeployed(deploymentParams.contract, network, deploymentResult[i].address)) {
         console.log(`${deploymentParams.contract} already deployed:`);
         console.log(`         On network:        ${network}`);
         console.log(`         At address:        ${deploymentResult[i].address}`);
+        deployed = 'yes';
       } else {
         console.log(`${deploymentParams.contract} has not been deployed:`);
         console.log(`         On network:        ${network}`);
@@ -42,7 +45,7 @@ export const deployOneWithCreate2 = async (
       }
     }
   });
-  return deploymentResult[0].address;
+  return { deployed, address: deploymentResult[0].address };
 };
 
 /**
@@ -53,11 +56,15 @@ export const deployOneWithCreate2 = async (
 export const deployWithCreate2FromList = async (
   hre: HardhatRuntimeEnvironmentExtended,
 ): Promise<void> => {
+  const network = hre.config.xdeploy.networks[0];
+  EvmChains.assertChainSupported(network);
   for (const contract of create2ContractDeploymentList) {
-    const network = hre.config.xdeploy.networks[0];
-    EvmChains.assertChainSupported(network);
     const constructorArgs = getConstructorArgs(contract, network);
-    const address = await deployOneWithCreate2({ contract, constructorArgs }, hre);
+    const { deployed, address } = await deployOneWithCreate2({ contract, constructorArgs }, hre);
+    if (deployed === 'no') {
+      console.warn('Skipping contract setup');
+      continue;
+    }
     await setupContract({
       contractAddress: address,
       contractName: contract,

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

@@ -34,6 +34,9 @@ export async function VerifyCreate2FromList(hre: HardhatRuntimeEnvironmentExtend
     };
 
     let address: string;
+    const network = hre.config.xdeploy.networks[0];
+    EvmChains.assertChainSupported(network);
+    console.debug(`Verifying ${create2ContractDeploymentList.length} contracts on ${network}`);
     for (const contract of create2ContractDeploymentList) {
       try {
         await delay();
@@ -53,11 +56,11 @@ export async function VerifyCreate2FromList(hre: HardhatRuntimeEnvironmentExtend
           case 'SingleRequestProxyFactory':
           case 'ERC20RecurringPaymentProxy':
           case 'ERC20CommerceEscrowWrapper': {
-            const network = hre.config.xdeploy.networks[0];
-            EvmChains.assertChainSupported(network);
             const constructorArgs = getConstructorArgs(contract, network);
             address = await computeCreate2DeploymentAddress({ contract, constructorArgs }, hre);
+            console.debug(`Verifying ${contract} at ${address} on ${network}`);
             await verifyOne(address, { contract, constructorArgs }, hre);
+            console.debug(`Verified ${contract} on ${network}`);
             break;
           }
           // Other cases to add when necessary

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

@@ -16,6 +16,9 @@ export const xdeploy = async (
   hre: HardhatRuntimeEnvironmentExtended,
 ): Promise<Array<IDeploymentResult>> => {
   const { contract, constructorArgs } = deploymentParams;
+  if (!hre.config.xdeploy.signer) {
+    throw new Error('Xdeployer signer (process.env.ADMIN_PRIVATE_KEY) missing');
+  }
   console.log(
     `Deployment of ${contract} through xdeployer starting now, with ${
       new hre.ethers.Wallet(hre.config.xdeploy.signer).address
@@ -73,6 +76,7 @@ export const xdeploy = async (
         'Contract address could not be computed, check your contract name and arguments',
       );
     }
+    console.log(`... at ${computedContractAddress}`);
 
     let receipt = undefined;
     let deployed = false;
@@ -99,7 +103,11 @@ export const xdeploy = async (
       receipt = createReceipt;
       deployed = true;
     } catch (err) {
-      error = err;
+      if (err?.message?.match(/insufficient funds for intrinsic transaction cost/)) {
+        error = 'Insufficient funds';
+      } else {
+        error = err;
+      }
     }
     result.push({
       network,