Migration of hardhat-upgrade to plugin to use hardhat v3

packages/core/src/call-optional-signature.ts

@@ -2,9 +2,12 @@ import { keccak256 } from 'ethereumjs-util';
 import { call, EthereumProvider } from './provider';
 
 export async function callOptionalSignature(provider: EthereumProvider, address: string, signature: string) {
+
   const data = '0x' + keccak256(Buffer.from(signature)).toString('hex').slice(0, 8);
+
   try {
-    return await call(provider, address, data);
+    const result = await call(provider, address, data);
+    return result;
   } catch (e: any) {
     if (
       e.message.includes('function selector was not recognized') ||

packages/core/src/cli/validate/build-info-file.ts

@@ -129,52 +129,137 @@ async function exists(dir: string) {
 
 async function getJsonFiles(dir: string): Promise<string[]> {
   const files = await fs.readdir(dir);
-  const jsonFiles = files.filter(file => file.endsWith('.json'));
+  const jsonFiles = files.filter(file => file.endsWith('.json') && !file.endsWith('.output.json'));
   return jsonFiles.map(file => path.join(dir, file));
 }
 
 async function readBuildInfo(buildInfoFilePaths: string[], dirShortName: string) {
   const buildInfoFiles: BuildInfoFile[] = [];
 
   for (const buildInfoFilePath of buildInfoFilePaths) {
-    const buildInfoJson = await readJSON(buildInfoFilePath);
-    if (
-      buildInfoJson.input === undefined ||
-      buildInfoJson.output === undefined ||
-      buildInfoJson.solcVersion === undefined
-    ) {
-      throw new ValidateCommandError(
-        `Build info file ${buildInfoFilePath} must contain Solidity compiler input, output, and solcVersion.`,
-      );
-    } else {
-      checkOutputSelection(buildInfoJson, buildInfoFilePath);
+    const buildInfo = await loadBuildInfo(buildInfoFilePath);
+
+    checkOutputSelection(buildInfo.input, buildInfoFilePath);
+
+    buildInfoFiles.push({
+      input: buildInfo.input,
+      output: buildInfo.output,
+      solcVersion: buildInfo.solcVersion,
+      dirShortName,
+    });
+  }
+  return buildInfoFiles;
+}
+
+async function loadBuildInfo(buildInfoFilePath: string): Promise<{
+  input: SolcInput;
+  output: SolcOutput;
+  solcVersion: string;
+}> {
+  const buildInfoJson = await readJSON(buildInfoFilePath);
+
+  if (buildInfoJson.input !== undefined && buildInfoJson.output !== undefined && buildInfoJson.solcVersion !== undefined) {
+    return {
+      input: buildInfoJson.input,
+      output: buildInfoJson.output,
+      solcVersion: buildInfoJson.solcVersion,
+    };
+  }
+
+  const format = buildInfoJson._format as string | undefined;
+
+  if (typeof format === 'string' && (format.startsWith('hh3-sol-build-info') || format.startsWith('hh-sol-build-info'))) {
+    if (buildInfoJson.input !== undefined && buildInfoJson.solcVersion !== undefined) {
+      let inputData: SolcInput = buildInfoJson.input;
+      let outputData: SolcOutput | undefined = buildInfoJson.output;
+
+      if (outputData === undefined) {
+        const { dir, name } = path.parse(buildInfoFilePath);
+        const outputFilePath = path.join(dir, `${name}.output.json`);
 
-      buildInfoFiles.push({
-        input: buildInfoJson.input,
-        output: buildInfoJson.output,
+        try {
+          const outputJson = await readJSON(outputFilePath);
+          outputData = outputJson.output ?? outputJson;
+        } catch (error) {
+          throw new ValidateCommandError(
+            `Build info file ${buildInfoFilePath} does not contain output, and output file ${outputFilePath} could not be read.`,
+          );
+        }
+
+        if (outputData === undefined) {
+          throw new ValidateCommandError(
+            `Build info file ${buildInfoFilePath} does not contain output, and output file ${outputFilePath} is missing Solidity compiler output.`,
+          );
+        }
+      }
+
+      const userSourceNameMap: Record<string, string> | undefined = buildInfoJson.userSourceNameMap;
+      if (userSourceNameMap !== undefined) {
+        const canonicalToUser = Object.entries(userSourceNameMap).reduce<Record<string, string>>((acc, [userSource, canonicalSource]) => {
+          acc[canonicalSource] = userSource;
+          return acc;
+        }, {});
+
+        if (inputData.sources !== undefined) {
+          inputData = {
+            ...inputData,
+            sources: remapKeys(inputData.sources, canonicalToUser),
+          };
+        }
+
+        if (outputData.sources !== undefined) {
+          outputData = {
+            ...outputData,
+            sources: remapKeys(outputData.sources, canonicalToUser),
+            contracts: outputData.contracts !== undefined ? remapKeys(outputData.contracts, canonicalToUser) : outputData.contracts,
+          };
+        } else if (outputData.contracts !== undefined) {
+          outputData = {
+            ...outputData,
+            contracts: remapKeys(outputData.contracts, canonicalToUser),
+          };
+        }
+      }
+
+      return {
+        input: inputData,
+        output: outputData,
         solcVersion: buildInfoJson.solcVersion,
-        dirShortName: dirShortName,
-      });
+      };
     }
   }
-  return buildInfoFiles;
+
+  throw new ValidateCommandError(
+    `Build info file ${buildInfoFilePath} must contain Solidity compiler input, output, and solcVersion. Got format: ${format ?? 'unknown'}.`,
+  );
 }
 
 /**
  * Gives an error if there is empty output selection for any contract, or a contract does not have storage layout.
  */
-function checkOutputSelection(buildInfoJson: any, buildInfoFilePath: string) {
-  const o = buildInfoJson.input.settings?.outputSelection;
+function checkOutputSelection(input: SolcInput, buildInfoFilePath: string) {
+  const outputSelection = input.settings?.outputSelection;
 
-  return Object.keys(o).forEach((item: any) => {
-    if ((o[item][''] === undefined || o[item][''].length === 0) && o[item]['*'].length === 0) {
+  if (outputSelection === undefined) {
+    throw new ValidateCommandError(
+      `Build info file ${buildInfoFilePath} does not define compiler outputSelection.`,
+      () => STORAGE_LAYOUT_HELP,
+    );
+  }
+
+  Object.keys(outputSelection).forEach(item => {
+    const selection = outputSelection[item] ?? {};
+    const unnamed = Array.isArray(selection['']) ? selection[''] : [];
+    const wildcard = Array.isArray(selection['*']) ? selection['*'] : [];
+
+    if (unnamed.length === 0 && wildcard.length === 0) {
       // No outputs at all for this contract e.g. if there were no changes since the last compile in Foundry.
       // This is not supported for now, since it leads to AST nodes that reference node ids in other build-info files.
       throw new ValidateCommandError(
         `Build info file ${buildInfoFilePath} is not from a full compilation.`,
         () => PARTIAL_COMPILE_HELP,
       );
-    } else if (!o[item]['*'].includes('storageLayout')) {
+    } else if (!wildcard.includes('storageLayout')) {
       throw new ValidateCommandError(
         `Build info file ${buildInfoFilePath} does not contain storage layout for all contracts.`,
         () => STORAGE_LAYOUT_HELP,
@@ -186,3 +271,12 @@ function checkOutputSelection(buildInfoJson: any, buildInfoFilePath: string) {
 async function readJSON(path: string) {
   return JSON.parse(await fs.readFile(path, 'utf8'));
 }
+
+function remapKeys<T>(original: Record<string, T>, canonicalToUser: Record<string, string>): Record<string, T> {
+  const remapped: Record<string, T> = {};
+  for (const [key, value] of Object.entries(original)) {
+    const mappedKey = canonicalToUser[key] ?? key;
+    remapped[mappedKey] = value;
+  }
+  return remapped;
+}

packages/core/src/impl-address.ts

@@ -20,19 +20,28 @@ export class InvalidBeacon extends UpgradesError {}
  * @throws {InvalidBeacon} If the implementation() function could not be called or does not return an address.
  */
 export async function getImplementationAddressFromBeacon(
-  provider: EthereumProvider,
+  provider: EthereumProvider, // v2 may differ from v3
   beaconAddress: string,
 ): Promise<string> {
-  const impl = await callOptionalSignature(provider, beaconAddress, 'implementation()');
-  let parsedImplAddress;
-  if (impl !== undefined) {
-    parsedImplAddress = parseAddress(impl);
-  }
+  try {
+    const impl = await callOptionalSignature(provider, beaconAddress, 'implementation()');
 
-  if (parsedImplAddress === undefined) {
-    throw new InvalidBeacon(`Contract at ${beaconAddress} doesn't look like a beacon`);
-  } else {
-    return parsedImplAddress;
+    let parsedImplAddress;
+    if (impl !== undefined) {
+      try {
+        parsedImplAddress = parseAddress(impl);
+      } catch (parseErr) {
+        throw new InvalidBeacon(`Contract at ${beaconAddress} doesn't look like a beacon`);
+      }
+    }
+
+    if (parsedImplAddress === undefined) {
+      throw new InvalidBeacon(`Contract at ${beaconAddress} doesn't look like a beacon`);
+    } else {
+      return parsedImplAddress;
+    }
+  } catch (err) {
+    throw err;
   }
 }
 

packages/plugin-hardhat/CHANGELOG.md

@@ -1,5 +1,7 @@
 # Changelog
 
+## 3.10.0 (2025-XX-YY)
+- Update hardhat, hardhat-ethers and hardhat-verify to support to hardhat v3
 
 ## 3.9.1 (2025-06-30)
 

packages/plugin-hardhat/ava.config.js

@@ -1,4 +1,4 @@
-module.exports = {
+export default {
   workerThreads: false,
   files: ['test/*.js'],
   watchMode: {

packages/plugin-hardhat/contracts/GreeterInitializable.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+
+contract GreeterInitializable is Initializable, OwnableUpgradeable {
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    constructor() {
+        _disableInitializers();
+    }
+
+    string public greeting;
+
+    function initialize(address initialOwner, string memory _greeting) public initializer {
+        __Ownable_init(initialOwner);
+        greeting = _greeting;
+    }
+}

packages/plugin-hardhat/contracts/GreeterProxiable.sol

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+
+contract GreeterProxiable is Initializable, OwnableUpgradeable, UUPSUpgradeable {
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    constructor() {
+        _disableInitializers();
+    }
+
+    string public greeting;
+
+    function initialize(address initialOwner, string memory _greeting) public initializer {
+        __Ownable_init(initialOwner);
+        __UUPSUpgradeable_init();
+        greeting = _greeting;
+    }
+
+    function greet() public view returns (string memory) {
+        return greeting;
+    }
+
+    function setGreeting(string memory _greeting) public {
+        greeting = _greeting;
+    }
+
+    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
+}

packages/plugin-hardhat/contracts/GreeterStorageConflictProxiable.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+
+// These contracts are for testing only, they are not safe for use in production.
+
+/// @custom:oz-upgrades-from GreeterProxiable
+contract GreeterStorageConflictProxiable is Initializable, OwnableUpgradeable, UUPSUpgradeable {
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    constructor() {
+        _disableInitializers();
+    }
+
+    // Storage conflict: uint before string (different order than GreeterProxiable)
+    uint public greets;
+    string public greeting;
+
+    function initialize(address initialOwner, string memory _greeting) public initializer {
+        __Ownable_init(initialOwner);
+        __UUPSUpgradeable_init();
+        greeting = _greeting;
+    }
+
+    function greet() public returns (string memory) {
+        greets = greets + 1;
+        return greeting;
+    }
+
+    function setGreeting(string memory _greeting) public {
+        greeting = _greeting;
+    }
+
+    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
+}
+

packages/plugin-hardhat/contracts/GreeterV2Proxiable.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+
+// These contracts are for testing only, they are not safe for use in production.
+
+/// @custom:oz-upgrades-from GreeterProxiable
+contract GreeterV2Proxiable is Initializable, OwnableUpgradeable, UUPSUpgradeable {
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    constructor() {
+        _disableInitializers();
+    }
+
+    string public greeting;
+
+    function initialize(address initialOwner, string memory _greeting) public initializer {
+        __Ownable_init(initialOwner);
+        __UUPSUpgradeable_init();
+        greeting = _greeting;
+    }
+
+    function greet() public view returns (string memory) {
+        return greeting;
+    }
+
+    function setGreeting(string memory _greeting) public {
+        greeting = _greeting;
+    }
+
+    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
+
+    function resetGreeting() public {
+        greeting = "Hello World";
+    }
+}