refactor(common): align missed tasks

Author: isaacdecoded

gateway-contracts/tasks/getters.ts

@@ -1,13 +1,13 @@
 import { task, types } from "hardhat/config";
-import type { TaskArguments } from "hardhat/types";
+import type { HardhatEthersHelpers, TaskArguments } from "hardhat/types";
 
 import { GatewayConfig } from "../typechain-types";
 
 import { getRequiredEnvVar, loadGatewayAddresses } from "./utils";
 
 async function loadGatewayConfigContract(
   useInternalProxyAddress: boolean,
-  ethers: typeof import("hardhat").ethers,
+  ethers: HardhatEthersHelpers,
 ): Promise<GatewayConfig> {
   if (useInternalProxyAddress) {
     loadGatewayAddresses();

gateway-contracts/tasks/reshareKeys.ts

@@ -1,9 +1,6 @@
-import dotenv from "dotenv";
 import { task, types } from "hardhat/config";
-import path from "path";
 
-import { ADDRESSES_DIR } from "../hardhat.config";
-import { getRequiredEnvVar } from "./utils/loadVariables";
+import { getRequiredEnvVar, loadGatewayAddresses } from "./utils/loadVariables";
 
 task("task:prssInit")
   .addParam(
@@ -20,7 +17,7 @@ task("task:prssInit")
     const deployer = new hre.ethers.Wallet(deployerPrivateKey).connect(hre.ethers.provider);
 
     if (useInternalProxyAddress) {
-      dotenv.config({ path: path.join(ADDRESSES_DIR, ".env.gateway"), override: true });
+      loadGatewayAddresses();
     }
     const proxyAddress = getRequiredEnvVar("KMS_GENERATION_ADDRESS");
 
@@ -46,7 +43,7 @@ task("task:keyReshareSameSet")
     const deployer = new hre.ethers.Wallet(deployerPrivateKey).connect(hre.ethers.provider);
 
     if (useInternalProxyAddress) {
-      dotenv.config({ path: path.join(ADDRESSES_DIR, ".env.gateway"), override: true });
+      loadGatewayAddresses();
     }
     const proxyAddress = getRequiredEnvVar("KMS_GENERATION_ADDRESS");
 

host-contracts/tasks/taskUtils.ts

@@ -1,9 +1,7 @@
-import dotenv from 'dotenv';
-import fs from 'fs';
-import { task } from 'hardhat/config';
-import type { TaskArguments } from 'hardhat/types';
+import { task, types } from 'hardhat/config';
 
 import { InputVerifier, KMSVerifier } from '../types';
+import { getRequiredEnvVar, loadHostAddresses } from './utils/loadVariables';
 
 ////////////////////////////////////////////////////////////////////////////////
 // Faucet
@@ -27,18 +25,18 @@ task('task:faucetToPrivate')
 ////////////////////////////////////////////////////////////////////////////////
 
 task('task:getKmsSigners')
-  .addOptionalParam(
-    'customKmsVerifierAddress',
-    'Use a custom address for the KMSVerifier contract instead of the default one - ie stored inside .env.host',
+  .addParam(
+    'useInternalProxyAddress',
+    'If proxy address from the /addresses directory should be used',
+    false,
+    types.boolean,
   )
-  .setAction(async function (taskArguments: TaskArguments, { ethers }) {
+  .setAction(async function ({ useInternalProxyAddress }, { ethers }) {
     const factory = await ethers.getContractFactory('./contracts/KMSVerifier.sol:KMSVerifier');
-    let kmsAdd;
-    if (taskArguments.customKmsVerifierAddress) {
-      kmsAdd = taskArguments.customKmsVerifierAddress;
-    } else {
-      kmsAdd = dotenv.parse(fs.readFileSync('addresses/.env.host')).KMS_VERIFIER_CONTRACT_ADDRESS;
+    if (useInternalProxyAddress) {
+      loadHostAddresses();
     }
+    const kmsAdd = getRequiredEnvVar('KMS_VERIFIER_CONTRACT_ADDRESS');
     const kmsVerifier = factory.attach(kmsAdd).connect(ethers.provider) as KMSVerifier;
     const listCurrentKMSSigners = await kmsVerifier.getKmsSigners();
     console.log('The list of current KMS Signers stored inside KMSVerifier contract is: ', listCurrentKMSSigners);
@@ -49,18 +47,18 @@ task('task:getKmsSigners')
 ////////////////////////////////////////////////////////////////////////////////
 
 task('task:getCoprocessorSigners')
-  .addOptionalParam(
-    'customInputVerifierAddress',
-    'Use a custom address for the InputVerifier contract instead of the default one - ie stored inside .env.host',
+  .addParam(
+    'useInternalProxyAddress',
+    'If proxy address from the /addresses directory should be used',
+    false,
+    types.boolean,
   )
-  .setAction(async function (taskArguments: TaskArguments, { ethers }) {
+  .setAction(async function ({ useInternalProxyAddress }, { ethers }) {
     const factory = await ethers.getContractFactory('./contracts/InputVerifier.sol:InputVerifier');
-    let inputVerifierAdd;
-    if (taskArguments.customInputVerifierAddress) {
-      inputVerifierAdd = taskArguments.customInputVerifierAddress;
-    } else {
-      inputVerifierAdd = dotenv.parse(fs.readFileSync('addresses/.env.host')).INPUT_VERIFIER_CONTRACT_ADDRESS;
+    if (useInternalProxyAddress) {
+      loadHostAddresses();
     }
+    const inputVerifierAdd = getRequiredEnvVar('INPUT_VERIFIER_CONTRACT_ADDRESS');
     const inputVerifier = factory.attach(inputVerifierAdd).connect(ethers.provider) as InputVerifier;
     const listCurrentCoprocessorSigners = await inputVerifier.getCoprocessorSigners();
     console.log(

host-contracts/tasks/upgradeContracts.ts

@@ -355,28 +355,19 @@ task('task:upgradeInputVerifier')
     true,
     types.boolean,
   )
-  .setAction(async function (
-    { currentImplementation, newImplementation, useInternalProxyAddress, verifyContract }: TaskArguments,
-    hre,
-  ) {
-    await compileImplementations(currentImplementation, newImplementation, hre);
-    await checkImplementationArtifacts('InputVerifier', currentImplementation, newImplementation, hre);
-
-    if (useInternalProxyAddress) {
+  .setAction(async function (taskArgs: TaskArguments, hre) {
+    if (taskArgs.useInternalProxyAddress) {
       loadHostAddresses();
     }
-    const proxyAddress = getRequiredEnvVar('INPUT_VERIFIER_CONTRACT_ADDRESS');
 
-    let initialSigners: string[] = [];
+    const initialSigners: string[] = [];
     const numSigners = getRequiredEnvVar('NUM_COPROCESSORS');
     for (let idx = 0; idx < +numSigners; idx++) {
-      const inputSignerAddress = getRequiredEnvVar(`COPROCESSOR_SIGNER_ADDRESS_${idx}`);
-      initialSigners.push(inputSignerAddress);
+      initialSigners.push(getRequiredEnvVar(`COPROCESSOR_SIGNER_ADDRESS_${idx}`));
     }
-
     const coprocessorThreshold = getRequiredEnvVar('COPROCESSOR_THRESHOLD');
 
-    await upgradeCurrentToNew(proxyAddress, currentImplementation, newImplementation, verifyContract, hre, [
+    await upgradeContract('InputVerifier', 'INPUT_VERIFIER_CONTRACT_ADDRESS', taskArgs, hre, [
       initialSigners,
       coprocessorThreshold,
     ]);
@@ -421,29 +412,10 @@ task('task:upgradeHCULimit')
     '20000000',
     types.string,
   )
-  .setAction(async function (
-    {
-      currentImplementation,
-      newImplementation,
-      useInternalProxyAddress,
-      verifyContract,
-      hcuCapPerBlock,
-      maxHcuDepthPerTx,
-      maxHcuPerTx,
-    }: TaskArguments,
-    hre,
-  ) {
-    await compileImplementations(currentImplementation, newImplementation, hre);
-    await checkImplementationArtifacts('HCULimit', currentImplementation, newImplementation, hre);
-
-    if (useInternalProxyAddress) {
-      loadHostAddresses();
-    }
-    const proxyAddress = getRequiredEnvVar('HCU_LIMIT_CONTRACT_ADDRESS');
-
-    await upgradeCurrentToNew(proxyAddress, currentImplementation, newImplementation, verifyContract, hre, [
-      BigInt(hcuCapPerBlock),
-      BigInt(maxHcuDepthPerTx),
-      BigInt(maxHcuPerTx),
+  .setAction(async function (taskArgs: TaskArguments, hre) {
+    await upgradeContract('HCULimit', 'HCU_LIMIT_CONTRACT_ADDRESS', taskArgs, hre, [
+      BigInt(taskArgs.hcuCapPerBlock),
+      BigInt(taskArgs.maxHcuDepthPerTx),
+      BigInt(taskArgs.maxHcuPerTx),
     ]);
   });

library-solidity/tasks/addPausers.ts

@@ -1,8 +1,6 @@
-import dotenv from 'dotenv';
 import { task, types } from 'hardhat/config';
-import path from 'path';
 
-import { getRequiredEnvVar } from './utils/loadVariables';
+import { getRequiredEnvVar, loadHostAddresses } from './utils/loadVariables';
 
 // Add pausers to the PauserSet contract
 // Note: Internal PauserSet address is defined in the `addresses/` directory. It should be used
@@ -24,7 +22,7 @@ task('task:addHostPausers')
     }
 
     if (useInternalProxyAddress) {
-      dotenv.config({ path: path.join('fhevmTemp/addresses/', '.env.host'), override: true });
+      loadHostAddresses();
     }
     const pauserSetAddress = getRequiredEnvVar('PAUSER_SET_CONTRACT_ADDRESS');
 

library-solidity/tasks/utils/loadVariables.ts

@@ -1,3 +1,10 @@
+import dotenv from 'dotenv';
+import fs from 'fs';
+import path from 'path';
+
+const ADDRESSES_DIR = path.resolve(__dirname, '../../fhevmTemp/addresses');
+const HOST_ADDRESSES_ENV_FILE_NAME = '.env.host';
+
 // Get the required environment variable, throw an error if it's not set
 // We only check if the variable is set, not if it's empty
 export function getRequiredEnvVar(name: string): string {
@@ -6,3 +13,18 @@ export function getRequiredEnvVar(name: string): string {
   }
   return process.env[name]!;
 }
+
+// Load the addresses as environment variables from the env file
+export function loadAddressEnvVarsFromFile(fileName: string) {
+  const envFilePath = path.join(ADDRESSES_DIR, fileName);
+
+  if (!fs.existsSync(envFilePath)) {
+    throw new Error(`Environment file for addresses not found: ${envFilePath}`);
+  }
+
+  dotenv.config({ path: envFilePath, override: true });
+}
+
+export function loadHostAddresses() {
+  loadAddressEnvVarsFromFile(HOST_ADDRESSES_ENV_FILE_NAME);
+}