refactor: verification script

Author: viraj124

packages/solidity-contracts/deploy/upgradeTest/prepareUpgrade.chain_state.ts

@@ -28,8 +28,8 @@ const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
     implementation: contractDeployment.implementation,
     linkedData: {
       constructorArgs: contractDeployment.linkedData.constructorArgs,
-      isProxy: true,
-      isImplementation: false,
+      isProxy: false,
+      isImplementation: true,
       proxyAddress: contractDeployment.address,
     },
   });

packages/solidity-contracts/deployments/upgradeTest/FuelChainState.json

@@ -579,8 +579,8 @@
       30,
       5
     ],
-    "isProxy": true,
-    "isImplementation": false,
+    "isProxy": false,
+    "isImplementation": true,
     "proxyAddress": "0x13Df4fD5e07Fc9E4336aF443F9E70b9f2Ebf2Dc9"
   },
   "implementation": "0x3bd5C81a8Adf3355078Dc5F73c41d3194B316690"

packages/solidity-contracts/deployments/upgradeTest/upgradeTest.json

@@ -1,7 +1,6 @@
 export * from './pause';
 export * from './unpause';
 export * from './grantRole';
-export * from './prepareUpgradeFuelChainState';
 export * from './verifyDeployment';
 export * from './depositETH';
 export * from './depositToken';

packages/solidity-contracts/scripts/hardhat/index.ts

@@ -1,20 +1,5 @@
 import { task } from 'hardhat/config';
 import { HardhatRuntimeEnvironment } from 'hardhat/types';
-import fs from 'fs';
-import path from 'path';
-
-interface Deployment {
-  contractName: string;
-  address: string;
-  args: any[];
-  isProxy?: boolean;
-  isImplementation?: boolean;
-  proxyAddress?: string;
-}
-
-const BLOCKS_PER_COMMIT_INTERVAL = 30;
-const TIME_TO_FINALIZE = 5;
-const COMMIT_COOLDOWN = TIME_TO_FINALIZE;
 
 task('verify-deployment', 'Verifies the deployed contract bytecode').setAction(
   async (taskArgs: any, hre: HardhatRuntimeEnvironment): Promise<void> => {
@@ -23,41 +8,15 @@ task('verify-deployment', 'Verifies the deployed contract bytecode').setAction(
       `Verifying contract bytecode on ${network}:${hre.network.config.chainId}...`
     );
 
-    const deploymentsFile = path.join(`deployments/${network}/${network}.json`);
-    if (!fs.existsSync(deploymentsFile)) {
-      console.error(`Deployments file not found: ${deploymentsFile}`);
-      return;
-    }
-
-    const deployments: Deployment[] = JSON.parse(
-      fs.readFileSync(deploymentsFile, 'utf8')
-    );
+    const deployments = await hre.deployments.all();
 
-    for (const deployment of deployments) {
-      console.log(
-        `\nVerifying ${deployment.contractName} (${deployment.address}):`
-      );
+    for (const [contractName, deployment] of Object.entries(deployments)) {
+      console.log(`\nVerifying ${contractName} (${deployment.address}):`);
 
       try {
-        console.log('  Reading contract artifact...');
-        const artifactPath = path.join(
-          `artifacts/contracts/fuelchain/${deployment.contractName}.sol/${deployment.contractName}.json`
-        );
-
-        if (!fs.existsSync(artifactPath)) {
-          console.log('  Artifact not found. Compiling contracts...');
-          await hre.run('compile');
-
-          if (!fs.existsSync(artifactPath)) {
-            throw new Error(
-              `Artifact not found even after compilation: ${artifactPath}`
-            );
-          }
-        }
-
         console.log('--- Fetching deployed bytecode...');
         let deployedBytecode: string;
-        if (deployment.isProxy) {
+        if (deployment.linkedData.isProxy) {
           const implementationAddress =
             await hre.upgrades.erc1967.getImplementationAddress(
               deployment.address
@@ -78,53 +37,45 @@ task('verify-deployment', 'Verifies the deployed contract bytecode').setAction(
 
         console.log('--- Deploying contract locally...');
         const ContractFactory = await localHardhat.ethers.getContractFactory(
-          deployment.contractName
+          contractName
         );
         let localAddress: string;
-        if (deployment.isProxy) {
+        if (deployment.linkedData.isProxy) {
           const localContract = await localHardhat.upgrades.deployProxy(
             ContractFactory,
             [],
             {
               kind: 'uups',
               initializer: 'initialize',
-              constructorArgs: [
-                TIME_TO_FINALIZE,
-                BLOCKS_PER_COMMIT_INTERVAL,
-                COMMIT_COOLDOWN,
-              ],
+              constructorArgs: deployment.linkedData.constructorArgs,
             }
           );
           await localContract.waitForDeployment();
           localAddress = await localContract.getAddress();
-        } else if (deployment.isImplementation) {
+        } else if (deployment.linkedData.isImplementation) {
           console.log('--- Validating Upgrade...');
           await localHardhat.upgrades.validateUpgrade(
-            deployment.proxyAddress as string,
+            deployment.linkedData.proxyAddress as string,
             ContractFactory,
             {
               kind: 'uups',
-              constructorArgs: [
-                TIME_TO_FINALIZE,
-                BLOCKS_PER_COMMIT_INTERVAL,
-                COMMIT_COOLDOWN,
-              ],
+              constructorArgs: deployment.linkedData.constructorArgs,
             }
           );
 
           console.log('--- Upgrade success');
           localAddress = deployment.address;
         } else {
           const localContract = await ContractFactory.deploy(
-            ...deployment.args
+            ...deployment.linkedData.constructorArgs
           );
           await localContract.deployed();
           localAddress = await localContract.getAddress();
         }
 
         console.log('--- Fetching local deployment bytecode...');
         let localBytecode: string;
-        if (deployment.isProxy) {
+        if (deployment.linkedData.isProxy) {
           const localImplementationAddress =
             await localHardhat.upgrades.erc1967.getImplementationAddress(
               localAddress
@@ -153,17 +104,17 @@ task('verify-deployment', 'Verifies the deployed contract bytecode').setAction(
           hre.ethers.keccak256(localBytecode)
         ) {
           console.log(
-            `✅ ${deployment.contractName} (${deployment.address}): Bytecode verified successfully`
+            `✅ ${contractName} (${deployment.address}): Bytecode verified successfully`
           );
         } else {
           console.log(
-            `❌ ${deployment.contractName} (${deployment.address}): Bytecode mismatch`
+            `❌ ${contractName} (${deployment.address}): Bytecode mismatch`
           );
           throw new Error('Bytecode mismatch');
         }
       } catch (error) {
         console.log(
-          `❌ ${deployment.contractName} (${deployment.address}): Verification failed`
+          `❌ ${contractName} (${deployment.address}): Verification failed`
         );
         console.error(`   Error: ${error.message}`);
       }