feat: use osx-commons-contracts and osx-commons-configs

.env.example

@@ -1,11 +1,11 @@
 # GENERAL
 
 ## The network used for testing purposes
-NETWORK_NAME="mainnet" #  ["mainnet", "goerli", "sepolia", "polygon", "polygonMumbai", "base", "baseGoerli", "arbitrum", "arbitrumGoerli"]
+NETWORK_NAME="sepolia" #  ["mainnet", "sepolia", "polygon", "polygonMumbai", "base", "baseSepolia", "arbitrum", "arbitrumSepolia"]
 
 # CONTRACTS
 
-## Hex encoded private keys separated by a comma `,`a
+## One or multiple hex encoded private keys separated by commas `,` replacing the hardhat default accounts.
 PRIVATE_KEY="0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80" # Default hardhat account 0 private key. DON'T USE FOR DEPLOYMENTS
 
 ## Infura credentials

.gitignore

@@ -21,8 +21,6 @@ packages/subgraph/tests/.bin
 .pnp.*
 coverage.json
 
-plugin-info-testing.json
-
 packages/subgraph/deploy-output.txt
 packages/subgraph/subgraph.yaml
 packages/subgraph/tests/.latest.json

packages/contracts/.solcover.js

@@ -1,7 +1,7 @@
 module.exports = {
-  istanbulReporter: ['html', 'lcov'],
+  istanbulReporter: ['html', 'lcov', 'text'],
   providerOptions: {
     privateKey: process.env.PRIVATE_KEY,
   },
-  skipFiles: ['test'],
+  skipFiles: ['mocks'],
 };

packages/contracts/deploy/00_info/01_account_info.ts

@@ -1,17 +1,54 @@
+import {
+  AragonOSxAsciiArt,
+  getProductionNetworkName,
+  isLocal,
+} from '../../utils/helpers';
+import {getNetworkByNameOrAlias} from '@aragon/osx-commons-configs';
 import {DeployFunction} from 'hardhat-deploy/types';
 import {HardhatRuntimeEnvironment} from 'hardhat/types';
+import path from 'path';
 
+/**
+ * Prints information about the used/forked network and initial deployer wallet balance.
+ * @param {HardhatRuntimeEnvironment} hre
+ */
 const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+  console.log(AragonOSxAsciiArt);
+  console.log(`${'-'.repeat(60)}`);
+  console.log(`\n✨ ${path.basename(__filename)}:`);
+
   const [deployer] = await hre.ethers.getSigners();
+  if (isLocal(hre)) {
+    const productionNetworkName: string = getProductionNetworkName(hre);
+
+    console.log(
+      `Simulated deployment on local network '${hre.network.name}'. Forking production network '${productionNetworkName}'...`
+    );
+
+    // Fork the network provided in the `.env` file
+    const networkConfig = getNetworkByNameOrAlias(productionNetworkName)!;
+    await hre.network.provider.request({
+      method: 'hardhat_reset',
+      params: [
+        {
+          forking: {
+            jsonRpcUrl: networkConfig.url,
+          },
+        },
+      ],
+    });
+  } else {
+    console.log(`Production deployment on network '${hre.network.name}'.`);
+  }
 
   console.log(
-    `Using account "${
+    `Using account '${
       deployer.address
-    }" with a balance of ${hre.ethers.utils.formatEther(
+    }' with a balance of ${hre.ethers.utils.formatEther(
       await deployer.getBalance()
-    )} for deployment...`
+    )} native tokens.`
   );
 };
 
 export default func;
-func.tags = ['Info', 'Deployment'];
+func.tags = ['Info', 'CreateRepo', 'NewVersion', 'UpgradeRepo'];

packages/contracts/deploy/01_repo/10_create_repo.ts

@@ -1,102 +1,113 @@
-import {PLUGIN_REPO_ENS_NAME} from '../../plugin-settings';
-import {ENS__factory} from '../../typechain';
-import {PluginRepoRegisteredEvent} from '../../typechain/@aragon/osx/framework/plugin/repo/PluginRepoRegistry';
+import {PLUGIN_REPO_ENS_SUBDOMAIN_NAME} from '../../plugin-settings';
 import {
-  findEventTopicLog,
-  addDeployedRepo as addCreatedRepo,
-  getPluginRepoFactoryAddress,
-  getPluginRepoRegistryAddress,
+  findPluginRepo,
+  getProductionNetworkName,
+  pluginEnsDomain,
 } from '../../utils/helpers';
 import {
-  PluginRepoFactory__factory,
+  getLatestNetworkDeployment,
+  getNetworkNameByAlias,
+} from '@aragon/osx-commons-configs';
+import {
+  UnsupportedNetworkError,
+  findEventTopicLog,
+} from '@aragon/osx-commons-sdk';
+import {
+  PluginRepoRegistryEvents,
   PluginRepoRegistry__factory,
   PluginRepo__factory,
-  ENSSubdomainRegistrar__factory,
+  PluginRepoFactory__factory,
 } from '@aragon/osx-ethers';
-import {ethers} from 'hardhat';
 import {DeployFunction} from 'hardhat-deploy/types';
 import {HardhatRuntimeEnvironment} from 'hardhat/types';
+import path from 'path';
 
+/**
+ * Creates a plugin repo under Aragon's ENS base domain with subdomain requested in the `./plugin-settings.ts` file.
+ * @param {HardhatRuntimeEnvironment} hre
+ */
 const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
-  console.log(`\nDeploying the "${PLUGIN_REPO_ENS_NAME}" plugin repo`);
+  console.log(
+    `Creating the '${pluginEnsDomain(
+      hre
+    )}' plugin repo through Aragon's 'PluginRepoFactory'...`
+  );
 
-  const {network} = hre;
   const [deployer] = await hre.ethers.getSigners();
 
-  // Get the PluginRepoFactory address
-  const pluginRepoFactoryAddr: string = getPluginRepoFactoryAddress(
-    network.name
-  );
-
+  // Get the Aragon `PluginRepoFactory` from the `osx-commons-configs`
+  const productionNetworkName = getProductionNetworkName(hre);
+  const network = getNetworkNameByAlias(productionNetworkName);
+  if (network === null) {
+    throw new UnsupportedNetworkError(productionNetworkName);
+  }
+  const networkDeployments = getLatestNetworkDeployment(network);
+  if (networkDeployments === null) {
+    throw `Deployments are not available on network ${network}.`;
+  }
   const pluginRepoFactory = PluginRepoFactory__factory.connect(
-    pluginRepoFactoryAddr,
+    networkDeployments.PluginRepoFactory.address,
     deployer
   );
 
-  // Create the PluginRepo
+  // Create the `PluginRepo` through the Aragon `PluginRepoFactory`
   const tx = await pluginRepoFactory.createPluginRepo(
-    PLUGIN_REPO_ENS_NAME,
+    PLUGIN_REPO_ENS_SUBDOMAIN_NAME,
     deployer.address
   );
 
-  const eventLog = await findEventTopicLog<PluginRepoRegisteredEvent>(
-    tx,
-    PluginRepoRegistry__factory.createInterface(),
-    'PluginRepoRegistered'
-  );
-  if (!eventLog) {
-    throw new Error('Failed to get PluginRepoRegistered event log');
-  }
+  // Get the PluginRepo address and deployment block number from the txn and event therein
+  const eventLog =
+    await findEventTopicLog<PluginRepoRegistryEvents.PluginRepoRegisteredEvent>(
+      tx,
+      PluginRepoRegistry__factory.createInterface(),
+      'PluginRepoRegistered'
+    );
 
   const pluginRepo = PluginRepo__factory.connect(
     eventLog.args.pluginRepo,
     deployer
   );
 
-  const blockNumberOfDeployment = (await tx.wait()).blockNumber;
-
   console.log(
-    `"${PLUGIN_REPO_ENS_NAME}" PluginRepo deployed at: ${pluginRepo.address} at block ${blockNumberOfDeployment}.`
+    `'${pluginEnsDomain(hre)}' PluginRepo deployed at: ${pluginRepo.address}.`
   );
 
-  // Store the information
-  addCreatedRepo(
-    network.name,
-    PLUGIN_REPO_ENS_NAME,
-    pluginRepo.address,
-    [],
-    blockNumberOfDeployment
-  );
+  hre.aragonToVerifyContracts.push({
+    address: pluginRepo.address,
+    args: [],
+  });
 };
 
 export default func;
-func.tags = ['PluginRepo', 'Deployment'];
-func.skip = async (hre: HardhatRuntimeEnvironment) => {
-  // Skip plugin repo creation if the ENS name is taken already
+func.tags = ['CreateRepo'];
 
-  const [deployer] = await hre.ethers.getSigners();
-
-  const pluginRepoRegistry = PluginRepoRegistry__factory.connect(
-    getPluginRepoRegistryAddress(hre.network.name),
-    deployer
-  );
+/**
+ * Skips `PluginRepo` creation if the ENS name is claimed already
+ * @param {HardhatRuntimeEnvironment} hre
+ */
+func.skip = async (hre: HardhatRuntimeEnvironment) => {
+  console.log(`\n🏗️  ${path.basename(__filename)}:`);
 
-  const registrar = ENSSubdomainRegistrar__factory.connect(
-    await pluginRepoRegistry.subdomainRegistrar(),
-    deployer
-  );
+  // Check if the ens record exists already
+  const {pluginRepo, ensDomain} = await findPluginRepo(hre);
 
-  const ens = ENS__factory.connect(await registrar.ens(), deployer);
+  if (pluginRepo !== null) {
+    console.log(
+      `ENS name '${ensDomain}' was claimed already at '${
+        pluginRepo.address
+      }' on network '${getProductionNetworkName(hre)}'. Skipping deployment...`
+    );
 
-  const recordExists = await ens.recordExists(
-    ethers.utils.namehash(`${PLUGIN_REPO_ENS_NAME}.plugin.dao.eth`)
-  );
+    hre.aragonToVerifyContracts.push({
+      address: pluginRepo.address,
+      args: [],
+    });
 
-  console.log(
-    `ENS name ${PLUGIN_REPO_ENS_NAME}.plugin.dao.eth does ${
-      recordExists ? 'exist already' : 'not exist yet'
-    }`
-  );
+    return true;
+  } else {
+    console.log(`ENS name '${ensDomain}' is unclaimed. Deploying...`);
 
-  return recordExists;
+    return false;
+  }
 };

packages/contracts/deploy/02_setup/10_setup.ts

@@ -1,9 +1,14 @@
 import {PLUGIN_SETUP_CONTRACT_NAME} from '../../plugin-settings';
 import {DeployFunction} from 'hardhat-deploy/types';
 import {HardhatRuntimeEnvironment} from 'hardhat/types';
+import path from 'path';
 
+/**
+ * Deploys the plugin setup contract with the plugin implementation inside.
+ * @param {HardhatRuntimeEnvironment} hre
+ */
 const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
-  console.log(`\nDeploying ${PLUGIN_SETUP_CONTRACT_NAME}`);
+  console.log(`\n🏗️  ${path.basename(__filename)}:`);
 
   const {deployments, getNamedAccounts} = hre;
   const {deploy} = deployments;
@@ -17,4 +22,4 @@ const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
 };
 
 export default func;
-func.tags = [PLUGIN_SETUP_CONTRACT_NAME, 'Deployment'];
+func.tags = [PLUGIN_SETUP_CONTRACT_NAME, 'NewVersion', 'Deployment'];

packages/contracts/deploy/02_setup/11_setup_conclude.ts

@@ -2,32 +2,34 @@ import {PLUGIN_SETUP_CONTRACT_NAME} from '../../plugin-settings';
 import {MyPluginSetup__factory, MyPlugin__factory} from '../../typechain';
 import {DeployFunction} from 'hardhat-deploy/types';
 import {HardhatRuntimeEnvironment} from 'hardhat/types';
-import {setTimeout} from 'timers/promises';
+import path from 'path';
 
+/**
+ * Concludes the plugin setup and implementation contract deployment by queuing the addresses in the verification array.
+ * @param {HardhatRuntimeEnvironment} hre
+ */
 const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
-  console.log(`Concluding ${PLUGIN_SETUP_CONTRACT_NAME} deployment.\n`);
-  const [deployer] = await hre.ethers.getSigners();
+  console.log(`\n🔎 ${path.basename(__filename)}:`);
+  console.log(`Concluding '${PLUGIN_SETUP_CONTRACT_NAME}' deployment.`);
 
-  const {deployments, network} = hre;
+  const [deployer] = await hre.ethers.getSigners();
+  const {deployments} = hre;
 
+  // Get the plugin setup address
   const setupDeployment = await deployments.get(PLUGIN_SETUP_CONTRACT_NAME);
   const setup = MyPluginSetup__factory.connect(
     setupDeployment.address,
     deployer
   );
+  // Get the plugin implementation address
   const implementation = MyPlugin__factory.connect(
     await setup.implementation(),
     deployer
   );
 
-  // Add a timeout for polygon because the call to `implementation()` can fail for newly deployed contracts in the first few seconds
-  if (network.name === 'polygon') {
-    console.log(`Waiting 30secs for ${network.name} to finish up...`);
-    await setTimeout(30000);
-  }
-
+  // Queue the plugin setup and implementation for verification on the block explorers
   hre.aragonToVerifyContracts.push({
-    address: setupDeployment.address,
+    address: setup.address,
     args: setupDeployment.args,
   });
   hre.aragonToVerifyContracts.push({
@@ -37,4 +39,4 @@ const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
 };
 
 export default func;
-func.tags = [PLUGIN_SETUP_CONTRACT_NAME, 'Verification'];
+func.tags = [PLUGIN_SETUP_CONTRACT_NAME, 'NewVersion', 'Verification'];