chore(smart-contracts): publish to tenderly

packages/smart-contracts/README.md

@@ -108,7 +108,7 @@ The deployer contract should be deployed at `0xE99Ab70a5FAE59551544FA326fA048f7B
 
 Be sure to run `yarn build:sol` before deploying the deployer or a contract.
 
-The contracts implemented are listed in the array `create2ContractDeploymentList` in [Utils](./scripts-create2/utils.ts).
+The contracts implemented are listed in the array `create2ContractDeploymentList` in [Utils](scripts-create2/utils/index.ts).
 
 ### Deploy the request deployer (once per chain)
 
@@ -166,6 +166,16 @@ See `hardhat.config.ts`.
 yarn hardhat verify-contract-from-deployer --network <NETWORK>
 ```
 
+### Add the contracts to Tenderly
+
+Once the contract has been added to the artifacts (`./src/lib/artifacts`), run the following command to synchronize
+contracts with the Tenderly account.
+Environment variables needed: `TENDERLY_...` (see `hardhat.config.ts`).
+
+```bash
+yarn hardhat tenderly-monitor-contracts
+```
+
 #### Verify the contracts manually With Hardhat (legacy)
 
 A more generic way to verify any contract by setting constructor argments manually:

packages/smart-contracts/hardhat.config.ts

@@ -15,6 +15,7 @@ import { VerifyCreate2FromList } from './scripts-create2/verify';
 import { deployWithCreate2FromList } from './scripts-create2/deploy';
 import { NUMBER_ERRORS } from './scripts/utils';
 import { networkRpcs } from '@requestnetwork/utils';
+import { tenderlyImportAll } from './scripts-create2/tenderly';
 
 config();
 
@@ -180,6 +181,11 @@ export default {
       },
     ],
   },
+  tenderly: {
+    project: process.env.TENDERLY_PROJECT,
+    username: process.env.TENDERLY_USERNAME,
+    accessKey: process.env.TENDERLY_ACCESS_KEY,
+  },
   typechain: {
     outDir: 'src/types',
     target: 'ethers-v5',
@@ -267,6 +273,12 @@ task(
   await VerifyCreate2FromList(hre as HardhatRuntimeEnvironmentExtended);
 });
 
+task('tenderly-monitor-contracts', 'Import all contracts to a Tenderly account').setAction(
+  async (_args, hre) => {
+    await tenderlyImportAll(hre as HardhatRuntimeEnvironmentExtended);
+  },
+);
+
 subtask(DEPLOYER_KEY_GUARD, 'prevent usage of the deployer master key').setAction(async () => {
   if (accounts && accounts[0] === process.env.DEPLOYER_MASTER_KEY) {
     throw new Error('The deployer master key should not be used for this action');

packages/smart-contracts/package.json

@@ -70,6 +70,7 @@
     "@types/chai": "4.2.21",
     "@types/mocha": "8.2.3",
     "@types/node": "14.14.16",
+    "axios": "0.27.2",
     "chai": "4.3.4",
     "dotenv": "10.0.0",
     "ethereum-waffle": "3.4.0",

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

@@ -0,0 +1,51 @@
+import { HardhatRuntimeEnvironmentExtended } from './types';
+import axios from 'axios';
+import * as artifacts from '../src/lib/artifacts';
+import { getChainConfig } from './utils/chains';
+import { ContractArtifact } from '../src/lib';
+import { Contract } from 'ethers';
+import * as console from 'console';
+
+const getTenderlyAxiosInstance = (hre: HardhatRuntimeEnvironmentExtended) => {
+  return axios.create({
+    baseURL: 'https://api.tenderly.co',
+    headers: {
+      'X-Access-Key': hre.config.tenderly.accessKey,
+    },
+  });
+};
+
+const capitalizeFirstLetter = (string: string) => string.charAt(0).toUpperCase() + string.slice(1);
+
+export const tenderlyImportAll = async (hre: HardhatRuntimeEnvironmentExtended): Promise<void> => {
+  const { username, project } = hre.config.tenderly;
+  try {
+    const contracts: Array<{ name: string; address: string; networkId: number }> = [];
+    for (const artifactName in artifacts) {
+      const artifact = (artifacts as any)[artifactName] as ContractArtifact<Contract>;
+      const deployments = artifact.getAllAddressesFromAllNetworks();
+      for (const deployment of deployments) {
+        const { networkName } = deployment;
+        if (['private', 'rinkeby', 'bsctest', 'alfajores'].includes(networkName)) continue;
+        const chainConfig = await getChainConfig(networkName);
+        if (!chainConfig) continue;
+        const sanitizedArtifactName = artifactName.replace(/Artifact/i, '');
+        contracts.push({
+          name: `${capitalizeFirstLetter(sanitizedArtifactName)}-${deployment.version}`,
+          address: deployment.address,
+          networkId: chainConfig.chainId,
+        });
+      }
+    }
+    const axiosInstance = getTenderlyAxiosInstance(hre);
+    await axiosInstance.post(`/api/v2/accounts/${username}/projects/${project}/contracts`, {
+      contracts: contracts.map((contract) => ({
+        address: contract.address,
+        display_name: contract.name,
+        network_id: contract.networkId.toString(),
+      })),
+    });
+  } catch (err) {
+    console.error('Error while adding contract(s) to Tenderly', err.response?.data || err);
+  }
+};

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

@@ -14,6 +14,11 @@ export type HardhatRuntimeEnvironmentExtended = HardhatRuntimeEnvironment & {
       deployerAddress: string;
       gasLimit?: number;
     };
+    tenderly: {
+      project: string;
+      username: string;
+      accessKey: string;
+    };
   };
 };
 

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

@@ -0,0 +1,23 @@
+import axios from 'axios';
+
+type ChainConfig = {
+  name: string;
+  chainId: number;
+  rpcUrls: string[];
+};
+
+const cachedChainConfigs: Record<string, ChainConfig> = {};
+
+export const getChainConfig = async (chainName: string) => {
+  try {
+    if (cachedChainConfigs[chainName]) return cachedChainConfigs[chainName];
+    const { data } = await axios.get<ChainConfig>(
+      `https://api.request.network/currency/chains/${chainName}`,
+    );
+    cachedChainConfigs[chainName] = data;
+    return data;
+  } catch (e) {
+    console.warn(e.message);
+    return null;
+  }
+};

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

@@ -1,5 +1,5 @@
 import { Contract } from 'ethers';
-import * as artifacts from '../src/lib';
+import * as artifacts from '../../src/lib';
 
 /**
  * List of smart contract that we deploy using the CREATE2 scheme through the Request Deployer contract

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

@@ -66,7 +66,7 @@ export async function VerifyCreate2FromList(hre: HardhatRuntimeEnvironmentExtend
           // Other cases to add when necessary
           default:
             throw new Error(
-              `The contrat ${contract} is not to be deployed using the CREATE2 scheme`,
+              `The contract ${contract} is not to be deployed using the CREATE2 scheme`,
             );
         }
       } catch (err) {

packages/smart-contracts/src/lib/ContractArtifact.ts

@@ -94,6 +94,24 @@ export class ContractArtifact<TContract extends Contract> {
     }));
   }
 
+  /**
+   * Retrieve all addresses for all versions for all networks
+   * @returns the addresses of the deployed contract and the associated network and version.
+   */
+  getAllAddressesFromAllNetworks(): { version: string; address: string; networkName: string }[] {
+    const deployments = [];
+    for (const version in this.info) {
+      for (const networkName in this.info[version].deployment) {
+        deployments.push({
+          version,
+          address: this.info[version].deployment[networkName].address,
+          networkName,
+        });
+      }
+    }
+    return deployments;
+  }
+
   /**
    * Retrieve the block creation number from the artifact of the used version
    * deployed into the specified network

packages/toolbox/src/commands/transaction/utils.ts

@@ -1,6 +1,6 @@
 import { getDefaultProvider } from '@requestnetwork/payment-detection';
 import { providers, Wallet } from 'ethers';
-import axios from 'axios';
+import { getChainConfig } from '@requestnetwork/smart-contracts/scripts-create2/utils/chains';
 
 export const getWallet = async ({
   chainName,
@@ -31,17 +31,3 @@ export const getProvider = async (chainName: string) => {
   }
   return getDefaultProvider(chainName);
 };
-
-const getChainConfig = async (chainName: string) => {
-  try {
-    const { data } = await axios.get<{
-      name: string;
-      chainId: number;
-      rpcUrls: string[];
-    }>(`https://api.request.network/currency/chains/${chainName}`);
-    return data;
-  } catch (e) {
-    console.warn(e.message);
-    return null;
-  }
-};