feat: verify contracts on filfox

axelar-chains-config/info/mainnet.json

@@ -1172,7 +1172,8 @@
       "confirmations": 3,
       "explorer": {
         "name": "Filfox",
-        "url": "https://www.filfox.info"
+        "url": "https://www.filfox.info",
+        "api": "https://filfox.info/api/v1/tools/verifyContract"
       },
       "gasOptions": {
         "gasLimit": 500000000

axelar-chains-config/info/testnet.json

@@ -1276,7 +1276,8 @@
       },
       "explorer": {
         "name": "Filfox",
-        "url": "https://calibration.filfox.info"
+        "url": "https://calibration.filfox.info",
+        "api": "https://calibration.filfox.info/api/v1/tools/verifyContract"
       },
       "gasOptions": {
         "gasLimit": 300000000

axelar-chains-config/package.json

@@ -21,7 +21,9 @@
     "jsonschema": "^1.4.1",
     "prettier": "^3.0.3",
     "typescript": "^5.2.2",
-    "vitest": "^0.34.4"
+    "vitest": "^0.34.4",
+    "path": "^0.12.7",
+    "axios": "^1.6.2"
   },
   "dependencies": {
     "@ethersproject/keccak256": "^5.7.0",

axelar-chains-config/src/utils/verifyContract.js

@@ -1,5 +1,139 @@
 const { execSync } = require('child_process');
 const { writeFileSync } = require('fs');
+const fs = require('fs');
+const path = require('path');
+const axios = require('axios');
+
+async function getSmallestFile(directoryPath) {
+    const fileNames = await fs.promises.readdir(directoryPath);
+    let smallestFile = null;
+    let smallestSize = Number.MAX_SAFE_INTEGER;
+
+    for (const fileName of fileNames) {
+        const filePath = path.join(directoryPath, fileName);
+        const stats = await fs.promises.stat(filePath);
+
+        if (stats.size < smallestSize) {
+            smallestFile = filePath;
+            smallestSize = stats.size;
+        }
+    }
+
+    return smallestFile;
+}
+
+function getContractFileName(config, address) {
+    for (const [key, currentValue] of Object.entries(config)) {
+        if (currentValue === address) {
+            return key.charAt(0).toUpperCase() + key.slice(1);
+        }
+    }
+
+    return null;
+}
+
+async function findFilePath(startPath, targetFileName) {
+    if (!fs.existsSync(startPath)) {
+        throw new Error(`Start path does not exist: ${startPath}`);
+    }
+
+    const directoriesToSearch = [startPath];
+
+    while (directoriesToSearch.length > 0) {
+        const currentDirectory = directoriesToSearch.pop();
+        const filesAndDirectories = fs.readdirSync(currentDirectory, { withFileTypes: true });
+
+        for (const fileOrDirectory of filesAndDirectories) {
+            const fullPath = path.join(currentDirectory, fileOrDirectory.name);
+
+            if (fileOrDirectory.isDirectory()) {
+                directoriesToSearch.push(fullPath);
+            } else if (fileOrDirectory.isFile() && fileOrDirectory.name === targetFileName) {
+                return fullPath;
+            }
+        }
+    }
+
+    throw new Error(`File not found: ${targetFileName}`);
+}
+
+async function verifyFilfox(env, contract, options) {
+    const { dir, contractName } = options;
+
+    if (!dir || !contractName) {
+        throw new Error('Invalid verification options');
+    }
+
+    const config = require(`../../info/${env}.json`);
+    const contractConfig = config.chains.filecoin.contracts[contractName];
+    const contractFileName = getContractFileName(contractConfig, contract);
+
+    const contractPath = await findFilePath(dir, `${contractFileName}.sol`);
+
+    const sourceFiles = {
+        [`${contractFileName}.sol`]: {
+            content: fs.readFileSync(contractPath, 'utf8'),
+        },
+    };
+
+    let buildInfo;
+
+    try {
+        const buildInfoPath = path.join(dir, 'build-info');
+        const smallestFile = await getSmallestFile(buildInfoPath);
+
+        if (!smallestFile) {
+            throw new Error('No build info files found');
+        }
+
+        const buildInfoContent = fs.readFileSync(smallestFile, 'utf8');
+        buildInfo = JSON.parse(buildInfoContent);
+    } catch (error) {
+        console.error('Error reading contract build info', error);
+    }
+
+    const language = buildInfo.input?.language;
+    const compiler = buildInfo.solcLongVersion;
+    const settings = buildInfo.input?.settings;
+
+    const optimize = settings.optimizer?.enabled || true;
+    const optimizeRuns = settings.optimizer?.runs;
+    const optimizerDetails = settings.optimizer?.details || '';
+    const evmVersion = settings.evmVersion;
+
+    const data = {
+        address: contract,
+        language,
+        compiler,
+        optimize,
+        optimizeRuns,
+        optimizerDetails,
+        sourceFiles,
+        license: 'MIT License (MIT)',
+        evmVersion,
+        viaIR: false,
+        libraries: '',
+        metadata: '',
+    };
+
+    const api = config.chains.filecoin.explorer?.api;
+
+    if (!api) {
+        throw new Error(`Explorer API not present for filecoin ${env}`);
+    }
+
+    try {
+        const response = await axios.post(api, data, {
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+
+        console.log('Verification response:', JSON.stringify(response.data));
+    } catch (error) {
+        console.error('Error during verification:', JSON.stringify(error.response.data));
+    }
+}
 
 /**
  * Verifies a contract on etherscan-like explorer of the provided chain using hardhat.
@@ -12,7 +146,12 @@ const { writeFileSync } = require('fs');
  * @param {any[]} args
  * @returns {void}
  */
-const verifyContract = (env, chain, contract, args, options = {}) => {
+const verifyContract = async (env, chain, contract, args, options = {}) => {
+    if (chain.toLowerCase() === 'filecoin') {
+        await verifyFilfox(env, contract, options);
+        return;
+    }
+
     const stringArgs = args.map((arg) => JSON.stringify(arg));
     const content = `module.exports = [\n    ${stringArgs.join(',\n    ')}\n];`;
     const file = 'temp-arguments.js';

evm/verify-contract.js

@@ -18,7 +18,9 @@ async function processCommand(config, chain, options) {
     const { env, contractName, dir } = options;
     const provider = getDefaultProvider(chain.rpc);
     const wallet = Wallet.createRandom().connect(provider);
-    const verifyOptions = {};
+    const verifyOptions = {
+        contractName,
+    };
 
     if (dir) {
         verifyOptions.dir = dir;