@layerzerolabs/verify-contract 1.0.0

package/constants/blockExplorerApi.json

@@ -0,0 +1,27 @@
+{
+  "avalanche": "api.snowtrace.io",
+  "fuji": "api-testnet.snowtrace.io",
+  "bsc": "api.bscscan.com",
+  "bsc-testnet": "api-testnet.bscscan.com",
+  "ethereum": "api.etherscan.io",
+  "ethereum-goerli": "api-goerli.etherscan.io",
+  "fantom": "api.ftmscan.com",
+  "fantom-testnet": "api-testnet.ftmscan.com",
+  "arbitrum": "api.arbiscan.io",
+  "arbitrum-goerli": "api-goerli.arbiscan.io",
+  "polygon": "api.polygonscan.com",
+  "mumbai": "api-testnet.polygonscan.com",
+  "optimism": "api-optimistic.etherscan.io",
+  "optimism-goerli": "api-goerli-optimistic.etherscan.io",
+
+  "aptos": "",
+  "celo": "",
+  "dexalot": "",
+  "dfk": "",
+  "harmony": "",
+  "intain": "",
+  "klaytn": "",
+  "metis": "",
+  "moonbeam": "api-moonbeam.moonscan.io",
+  "swimmer": ""
+}

package/index.js

@@ -0,0 +1,185 @@
+const FileSystem = require("fs");
+const https = require('https');
+const querystring = require('querystring');
+const BLOCK_EXPLORER_API_URL = require("./constants/blockExplorerApi.json")
+
+const licenseTypes = {
+    "None": 1,
+    "Unlicense": 2,
+    "MIT": 3,
+    "GNU-GPLv2": 4,
+    'GNU-GPLv3': 5,
+    'GNU-LGPLv2.1': 6,
+    'GNU-LGPLv3': 7,
+    'BSD-2-Clause': 8,
+    "BSD-3-Clause": 9,
+    "MPL-2.0": 10,
+    "OSL-3.0": 11,
+    "Apache-2.0": 12,
+    "GNU-AGPLv3": 13,
+    "BUSL-1.1": 14
+}
+
+function getContractInheritance(baseContractString, remainingContracts, finalObj) {
+    let contractNamesInherited = baseContractString.match(/(import).*(;)/g)
+    // we have reached the end of the inheritance as the base contract contains no more imports
+    if (!contractNamesInherited) { return finalObj }
+
+    // extract import names
+    contractNamesInherited = contractNamesInherited.map(
+        x => {
+            if (x.includes('"')) {
+                return (x.split(`"`)[1])
+                    .split(`/`).pop()
+            } else {
+                return (x.split(`'`)[1])
+                    .split(`/`).pop()
+            }
+        }
+    )
+
+    // there are more parent contracts to check, push them into final object
+    let parentContracts = []
+    for (const contractName of contractNamesInherited) {
+        for (const contract of remainingContracts) {
+            if (contract[0].includes("/" + contractName)) {
+                parentContracts.push(contract)
+            }
+        }
+    }
+
+    // filter out contracts that we haven't added to the finalObj yet
+    let remainingContractsNew = remainingContracts.filter(([k, v]) => !Object.keys(Object.fromEntries(parentContracts)).includes(k))
+
+    // take existing contracts and the new verified parent contracts and merge into object
+    let resp = {...finalObj, ...Object.fromEntries(parentContracts)}
+
+    // go through each of the parent contracts and get inheritance
+    for (const [k, v] of parentContracts) {
+        resp =  {...getContractInheritance(v["content"], remainingContractsNew, finalObj), ...resp}
+    }
+
+    return resp
+}
+
+function formatPutObj(baseContract, contractBuildInfo, contractDeployment, contract, network) {
+    let putObj= {
+        apikey: process.env[`SCAN_API_KEY_${network}`],
+        module: "contract",
+        action: "verifysourcecode",
+        sourceCode: JSON.stringify(contractBuildInfo["input"]),
+        contractaddress: contractDeployment["address"],
+        codeformat: "solidity-standard-json-input",
+        contractname: `${baseContract[0]}:${contract}`,
+        compilerversion: "v" + contractBuildInfo["solcLongVersion"],
+        licenseType: licenseTypes["None"] // default to none
+    }
+
+    // specify license type if one is found in the base contract
+    for (const [license, type] of Object.entries(licenseTypes)) {
+        if (baseContract[1]["content"].includes(`SPDX-License-Identifier: ${license}`)) {
+            putObj["licenseType"] = type
+        }
+    }
+
+    if (contractBuildInfo["input"]["settings"]["optimizer"]["enabled"]) {
+        putObj["optimizationUsed"] = 1
+        putObj["runs"] = contractBuildInfo["input"]["settings"]["optimizer"]["runs"]
+    } else {
+        putObj["optimizationUsed"] = 0
+    }
+
+    let constructorAbiEncoded
+    if (baseContract[1]["content"].includes("constructor(")) {
+        let constructorTypes = (contractDeployment["abi"].filter(x => x["type"] && x["type"] == "constructor")[0]["inputs"]).map(x => x["type"])
+        constructorAbiEncoded = ethers.utils.defaultAbiCoder.encode(constructorTypes, contractDeployment["args"])
+    }
+
+    if (constructorAbiEncoded) {
+        putObj["constructorArguements"] = constructorAbiEncoded.substring(2) // misspelled in etherscans api
+    }
+
+    return putObj
+}
+
+function getBaseAndRemainingContract(contractName, contractBuildInfo) {
+    const baseContract = Object.entries(contractBuildInfo["input"]["sources"]).filter(([k, v]) => k.includes(contractName))[0]
+    const remainingContracts = Object.entries(contractBuildInfo["input"]["sources"]).filter(([k, v]) => !k.includes(contractName))
+    return [baseContract, remainingContracts]
+}
+
+
+module.exports = async function (network, contract) {
+    if(!BLOCK_EXPLORER_API_URL[network]) {
+        throw `Unsupported block explorer network: ${network}`
+    }
+    if (!process.env[`SCAN_API_KEY_${network}`]) {
+        throw `Missing API key for network: ${network}`
+    }
+
+    const contractName = `/${contract}.sol`
+
+    // get the build files/artifacts
+    const contractDeployment = JSON.parse(FileSystem.readFileSync(`./deployments/${network}/${contract}.json`, "utf8"))
+    // iterate the build-info to find the correct build file
+    let contractBuildInfo
+    FileSystem.readdirSync(`./artifacts/build-info/`).forEach(fileName => {
+        const f = JSON.parse(FileSystem.readFileSync(`./artifacts/build-info/${fileName}`, "utf8"))
+
+        let test = Object.entries(f["input"]["sources"]).filter(([k, v]) => k.includes(contractName))
+        if (test[0] && test[0][0]) {
+            if (test[0][0].includes(contractName)) {
+                contractBuildInfo = f
+            }
+        }
+    })
+    if (!contractBuildInfo) throw `Could not find contract: ${contractName} inside of build-info!`
+
+    console.log(`\n\nVerifying... Network: ${network}, contractName: ${contractName}, address: ${contractDeployment["address"]}`)
+
+    // parse and filter out the extra build files, because the verifier freaks out if too many contracts to check
+    const [baseContract, remainingContracts] = getBaseAndRemainingContract(contractName, contractBuildInfo)
+    contractBuildInfo["input"]["sources"] = getContractInheritance(baseContract[1]["content"], remainingContracts, Object.fromEntries([baseContract]))
+
+    // format the put request
+    const putObj = formatPutObj(baseContract, contractBuildInfo, contractDeployment, contract, network)
+
+    const response = await makeRequest(`${BLOCK_EXPLORER_API_URL[network]}`, putObj)
+    console.log(JSON.parse(response))
+}
+
+async function makeRequest(url, data) {
+    const postData = querystring.stringify(data);
+
+    const options = {
+        hostname: url,
+        path: '/api',
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            'Content-Length': Buffer.byteLength(postData)
+        }
+    };
+
+    return new Promise((resolve, reject) => {
+        const req = https.request(options, (res) => {
+            let data = '';
+            res.on('data', (chunk) => {
+                data += chunk;
+            });
+            res.on('end', () => {
+                resolve(data);
+            });
+        });
+
+        req.on('error', (error) => {
+            reject(error);
+        });
+
+        req.write(postData);
+        req.end();
+    });
+}
+
+
+

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@layerzerolabs/verify-contract",
+  "version": "1.0.0",
+  "description": "Verify Solidity contracts on supported block explorers",
+  "main": "index.js",
+  "scripts": {},
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/LayerZero-Labs/verify-contract.git"
+  },
+  "author": "Lz.Warlock",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/LayerZero-Labs/verify-contract/issues"
+  },
+  "homepage": "https://github.com/LayerZero-Labs/verify-contract#readme"
+}