Feat: update deploy script

packages/contracts/deploy/10_create_repo/11_create_repo.ts

@@ -18,6 +18,7 @@ import {
   PluginRepo__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';
@@ -27,6 +28,7 @@ import path from 'path';
  * @param {HardhatRuntimeEnvironment} hre
  */
 const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+  // todo change this log
   console.log(
     `Creating the '${pluginEnsDomain(
       hre
@@ -36,23 +38,55 @@ const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
   const [deployer] = await hre.ethers.getSigners();
 
   // 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}.`;
+  let pluginRepoFactoryAddress;
+  let subdomainRegistrar;
+  if (
+    process.env.PLUGIN_REPO_FACTORY_ADDRESS &&
+    process.env.PLUGIN_REPO_FACTORY_ADDRESS !== ethers.constants.AddressZero
+  ) {
+    // use this factory
+    pluginRepoFactoryAddress = process.env.PLUGIN_REPO_FACTORY_ADDRESS;
+
+    const pluginRepoFactory = PluginRepoFactory__factory.connect(
+      pluginRepoFactoryAddress,
+      deployer
+    );
+
+    const pluginRepoRegistry = PluginRepoRegistry__factory.connect(
+      await pluginRepoFactory.pluginRepoRegistry(),
+      deployer
+    );
+    subdomainRegistrar = await pluginRepoRegistry.subdomainRegistrar();
+  } else {
+    // get the factory from osx-commons-configs deployments
+    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}.`;
+    }
+    pluginRepoFactoryAddress = networkDeployments.PluginRepoFactory.address;
+
+    subdomainRegistrar =
+      networkDeployments.PluginENSSubdomainRegistrarProxy.address;
   }
+  // subdomain will depend on if the framework has the ens or not
+  const subdomain =
+    subdomainRegistrar !== ethers.constants.AddressZero
+      ? PLUGIN_REPO_ENS_SUBDOMAIN_NAME
+      : 'empty'; // todo set to empty when is possible
+
   const pluginRepoFactory = PluginRepoFactory__factory.connect(
-    networkDeployments.PluginRepoFactory.address,
+    pluginRepoFactoryAddress,
     deployer
   );
 
   // Create the `PluginRepo` through the Aragon `PluginRepoFactory`
   const tx = await pluginRepoFactory.createPluginRepo(
-    PLUGIN_REPO_ENS_SUBDOMAIN_NAME,
+    subdomain,
     deployer.address
   );
 
@@ -90,24 +124,46 @@ func.skip = async (hre: HardhatRuntimeEnvironment) => {
   console.log(`\n🏗️  ${path.basename(__filename)}:`);
 
   // Check if the ens record exists already
-  const {pluginRepo, ensDomain} = await findPluginRepo(hre);
+  let pluginRepoAddress;
+  let ensDomain = '';
+  if (
+    !process.env.PLUGIN_REPO_ADDRESS ||
+    process.env.PLUGIN_REPO_ADDRESS === ethers.constants.AddressZero
+  ) {
+    // try getting the plugin repo from the ens
+    const res = await findPluginRepo(hre);
+    pluginRepoAddress = res.pluginRepo?.address;
+    ensDomain = res.ensDomain;
+  } else {
+    // use the provided plugin repo address
+    pluginRepoAddress = process.env.PLUGIN_REPO_ADDRESS;
 
-  if (pluginRepo !== null) {
     console.log(
-      `ENS name '${ensDomain}' was claimed already at '${
-        pluginRepo.address
-      }' on network '${getProductionNetworkName(hre)}'. Skipping deployment...`
+      `Plugin Repo already deployed at '${pluginRepoAddress}' on network '${getProductionNetworkName(
+        hre
+      )}'. Skipping deployment...`
+    );
+    return true;
+  }
+
+  if (pluginRepoAddress) {
+    console.log(
+      `ENS name '${ensDomain}' was claimed already at '${pluginRepoAddress}' on network '${getProductionNetworkName(
+        hre
+      )}'. Skipping deployment...`
     );
 
+    // todo if the plugin repo was already published should it be verified?
     hre.aragonToVerifyContracts.push({
-      address: pluginRepo.address,
+      address: pluginRepoAddress,
       args: [],
     });
-
     return true;
   } else {
-    console.log(`ENS name '${ensDomain}' is unclaimed. Deploying...`);
-
+    // todo change this log
+    console.log(
+      `ENS name '${ensDomain}' is unclaimed. Deploying Plugin Repo...`
+    );
     return false;
   }
 };

packages/contracts/deploy/20_new_version/23_publish.ts

@@ -140,11 +140,24 @@ const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
       []
     )
   ) {
-    const placeholderSetup = getLatestContractAddress('PlaceholderSetup', hre);
+    let placeholderSetup = getLatestContractAddress('PlaceholderSetup', hre);
+
     if (placeholderSetup == '') {
-      throw new Error(
-        'Aborting. Placeholder setup not present in this network'
-      );
+      // deploy placeholder setup
+      const {deploy} = deployments;
+      const res = await deploy(PLUGIN_SETUP_CONTRACT_NAME, {
+        from: deployer.address,
+        args: [],
+        log: true,
+      });
+
+      placeholderSetup = res.address;
+
+      // Queue the placeholder for verification
+      hre.aragonToVerifyContracts.push({
+        address: placeholderSetup,
+        args: [],
+      });
     }
     if (latestBuild == 0 && VERSION.build > 1) {
       for (let i = 0; i < VERSION.build - 1; i++) {

packages/contracts/deploy/30_upgrade_repo/_common.ts

@@ -4,8 +4,13 @@ import {
   getNetworkNameByAlias,
 } from '@aragon/osx-commons-configs';
 import {UnsupportedNetworkError} from '@aragon/osx-commons-sdk';
-import {PluginRepo, PluginRepo__factory} from '@aragon/osx-ethers';
+import {
+  PluginRepo,
+  PluginRepo__factory,
+  PluginRepoFactory__factory,
+} from '@aragon/osx-ethers';
 import {SignerWithAddress} from '@nomiclabs/hardhat-ethers/signers';
+import {ethers} from 'hardhat';
 import {DeployFunction} from 'hardhat-deploy/types';
 import {HardhatRuntimeEnvironment} from 'hardhat/types';
 import path from 'path';
@@ -30,10 +35,6 @@ export async function fetchData(
   if (network === null) {
     throw new UnsupportedNetworkError(productionNetworkName);
   }
-  const networkDeployments = getLatestNetworkDeployment(network);
-  if (networkDeployments === null) {
-    throw `Deployments are not available on network ${network}.`;
-  }
 
   // Get PluginRepo
   const {pluginRepo, ensDomain} = await findPluginRepo(hre);
@@ -46,10 +47,29 @@ export async function fetchData(
   );
 
   // Get the latest `PluginRepo` implementation as the upgrade target
-  const latestPluginRepoImplementation = PluginRepo__factory.connect(
-    networkDeployments.PluginRepoBase.address,
-    deployer
-  );
+  let latestPluginRepoImplementation;
+  if (
+    process.env.PLUGIN_REPO_FACTORY_ADDRESS &&
+    process.env.PLUGIN_REPO_FACTORY_ADDRESS !== ethers.constants.AddressZero
+  ) {
+    const pluginRepoFactory = PluginRepoFactory__factory.connect(
+      process.env.PLUGIN_REPO_FACTORY_ADDRESS,
+      deployer
+    );
+    latestPluginRepoImplementation = PluginRepo__factory.connect(
+      await pluginRepoFactory.pluginRepoBase(),
+      deployer
+    );
+  } else {
+    const networkDeployments = getLatestNetworkDeployment(network);
+    if (networkDeployments === null) {
+      throw `Deployments are not available on network ${network}.`;
+    }
+    latestPluginRepoImplementation = PluginRepo__factory.connect(
+      networkDeployments.PluginRepoBase.address,
+      deployer
+    );
+  }
 
   // Get the current OSX protocol version from the current plugin repo implementation
   let current: SemVer;

packages/contracts/src/mocks/Migration.sol

@@ -16,6 +16,8 @@ pragma solidity ^0.8.8;
 /* solhint-disable no-unused-import */
 
 import {DAO} from "@aragon/osx/core/dao/DAO.sol";
+import {PlaceholderSetup} from "@aragon/osx/framework/plugin/repo/placeholder/PlaceholderSetup.sol";
+
 import {PluginRepo} from "@aragon/osx-v1.3.0/framework/plugin/repo/PluginRepo.sol";
 import {ProxyFactory} from "@aragon/osx-commons-contracts/src/utils/deployment/ProxyFactory.sol";
 

packages/contracts/utils/helpers.ts

@@ -15,6 +15,8 @@ import {
   PluginRepo,
   PluginRepoEvents,
   PluginRepo__factory,
+  PluginRepoFactory__factory,
+  PluginRepoRegistry__factory,
 } from '@aragon/osx-ethers';
 import {setBalance} from '@nomicfoundation/hardhat-network-helpers';
 import {SignerWithAddress} from '@nomiclabs/hardhat-ethers/signers';
@@ -69,21 +71,51 @@ export async function findPluginRepo(
   hre: HardhatRuntimeEnvironment
 ): Promise<{pluginRepo: PluginRepo | null; ensDomain: string}> {
   const [deployer] = await hre.ethers.getSigners();
-  const productionNetworkName: string = 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}.`;
+  let subdomainRegistrarAddress;
+  if (
+    process.env.PLUGIN_REPO_FACTORY_ADDRESS &&
+    process.env.PLUGIN_REPO_FACTORY_ADDRESS !== ethers.constants.AddressZero
+  ) {
+    // get ENS registrar from the plugin factory provided
+    const pluginRepoFactory = PluginRepoFactory__factory.connect(
+      process.env.PLUGIN_REPO_FACTORY_ADDRESS,
+      deployer
+    );
+
+    const pluginRepoRegistry = PluginRepoRegistry__factory.connect(
+      await pluginRepoFactory.pluginRepoRegistry(),
+      deployer
+    );
+
+    subdomainRegistrarAddress = await pluginRepoRegistry.subdomainRegistrar();
+  } else {
+    // get ENS registrar from the commons configs deployments
+    const productionNetworkName: string = 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}.`;
+    }
+
+    subdomainRegistrarAddress =
+      networkDeployments.PluginENSSubdomainRegistrarProxy.address;
   }
 
-  const registrar = ENSSubdomainRegistrar__factory.connect(
-    networkDeployments.PluginENSSubdomainRegistrarProxy.address,
-    deployer
-  );
+  let registrar;
+  if (subdomainRegistrarAddress === ethers.constants.AddressZero) {
+    // the network does not support ENS
+    return {pluginRepo: null, ensDomain: ''};
+  } else {
+    registrar = ENSSubdomainRegistrar__factory.connect(
+      subdomainRegistrarAddress,
+      deployer
+    );
+  }
 
   // Check if the ens record exists already
   const ens = ENS__factory.connect(await registrar.ens(), deployer);