truffle-plugin-stdjsonin 0.5.14

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Mehrdad Salehi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,30 @@
+# truffle-plugin-stdjsonin
+  
+A [Truffle](https://trufflesuite.com/index.html) plugin for generating a flat Solidity Json Input file.
+
+The [Solidity Json Input](https://docs.soliditylang.org/en/v0.8.10/using-the-compiler.html#compiler-input-and-output-json-description) format is preferred over [flattening](https://www.npmjs.com/package/truffle-flattener) your files during verification on Etherscan as it :
+- preserves code formatting
+- maintains multipart files
+- embeds compiler settings, including optimization and bytecodehash
+
+## Installation
+1. Install the plugin using npm 
+  ```
+  npm install -D https://github.com/nhancv/truffle-plugin-stdjsonin/
+  ```
+2. Add the plugin to your `truffle-config.js` file
+  ```javascript
+  module.exports = {
+    /* ... rest of truffle-config */
+
+    plugins: [
+     'truffle-plugin-stdjsonin'
+    ]
+  }
+  ```
+## Usage
+1. Run the plugin on your specified contract name 
+  ```
+  truffle run stdjsonin ContractName
+  ```
+  A `ContractName-Input.json` file is generated in your project directory. 

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "truffle-plugin-stdjsonin",
+  "version": "0.5.14",
+  "description": "generate Standrad JSON Input from the Truffle CLI",
+  "repository": "https://github.com/nhancv/truffle-plugin-stdjsonin",
+  "main": "stdjsonin.js",
+  "files": [
+    "util.js",
+    "stdjsonin.js",
+    "truffle-plugin.json"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "lint": "eslint ."
+  },
+  "keywords": [
+    "Standard JSON Input",
+    "truffle",
+    "plugin",
+    "ethereum",
+    "etherscan",
+    "verify"
+  ],
+  "author": "Mehrdad Salehi",
+  "license": "MIT",
+  "dependencies": {
+    "cli-logger": "^0.5.40"
+  },
+  "devDependencies": {
+    "eslint": "^7.32.0",
+    "eslint-config-standard": "^16.0.3",
+    "eslint-plugin-import": "^2.24.2",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-promise": "^5.1.0",
+    "eslint-plugin-standard": "^5.0.0"
+  }
+}

package/stdjsonin.js

@@ -0,0 +1,149 @@
+const cliLogger = require("cli-logger");
+const fs = require("fs");
+const path = require("path");
+const { enforce, enforceOrThrow, normaliseContractPath } = require("./util");
+const { version } = require("./package.json");
+
+const logger = cliLogger({ level: "info" });
+
+module.exports = async (config) => {
+  // Set debug logging
+  if (config.debug) logger.level("debug");
+  logger.debug("DEBUG logging is turned ON");
+  logger.debug(`Running truffle-plugin-stdjsonin v${version}`);
+
+  const options = parseConfig(config);
+  const contractNameAddressPairs = config._.slice(1);
+
+  for (const contractNameAddressPair of contractNameAddressPairs) {
+    logger.info(`Generating Standard JSON Input ${contractNameAddressPair}`);
+    try {
+      const contractName = contractNameAddressPair.split("@")[0];
+      const artifact = getArtifact(contractName, options);
+      const inputJSON = getInputJSON(artifact, options);
+      fs.writeFileSync(`${contractName}-input.json`, JSON.stringify(inputJSON));
+      console.log(
+        `Standard JSON Input for ${contractName} is saved in ${contractName}-input.json`
+      );
+      console.log(
+        "[Optional step] trying to compile and check with generated Standard JSON Input..."
+      );
+      tryCompileAndMatch(artifact, inputJSON, contractName);
+    } catch (error) {
+      logger.error(error.message);
+    }
+    logger.info();
+  }
+};
+
+const parseConfig = (config) => {
+  enforce(config._.length > 1, "No contract name(s) specified", logger);
+
+  const workingDir = config.working_directory;
+  const contractsBuildDir = config.contracts_build_directory;
+  const contractsDir = config.contracts_directory;
+
+  let forceConstructorArgsType, forceConstructorArgs;
+  if (config.forceConstructorArgs) {
+    [forceConstructorArgsType, forceConstructorArgs] =
+      config.forceConstructorArgs.split(":");
+    enforce(
+      forceConstructorArgsType === "string",
+      "Force constructor args must be string type",
+      logger
+    );
+    logger.debug(`Force custructor args provided: 0x${forceConstructorArgs}`);
+  }
+
+  return {
+    workingDir,
+    contractsBuildDir,
+    contractsDir,
+    forceConstructorArgs,
+  };
+};
+
+const getArtifact = (contractName, options) => {
+  const artifactPath = path.resolve(
+    options.contractsBuildDir,
+    `${contractName}.json`
+  );
+  logger.debug(`Reading artifact file at ${artifactPath}`);
+  enforceOrThrow(
+    fs.existsSync(artifactPath),
+    `Could not find ${contractName} artifact at ${artifactPath}`
+  );
+  // Stringify + parse to make a deep copy (to avoid bugs with PR #19)
+  return JSON.parse(JSON.stringify(require(artifactPath)));
+};
+
+const getInputJSON = (artifact, options) => {
+  const metadata = JSON.parse(artifact.metadata);
+  // const libraries = getLibraries(artifact, options)
+
+  const sources = {};
+  for (const contractPath in metadata.sources) {
+    // If we're on Windows we need to de-Unixify the path so that Windows can read the file
+    // We also need to replace the 'project:' prefix so that the file can be read
+    const normalisedContractPath = normaliseContractPath(
+      contractPath,
+      options.contractsDir
+    );
+    const absolutePath = require.resolve(normalisedContractPath);
+    const content = fs.readFileSync(absolutePath, "utf8");
+
+    // Remove the 'project:' prefix that was added in Truffle v5.3.14
+    const relativeContractPath = contractPath;
+
+    sources[relativeContractPath] = { content };
+  }
+
+  const inputJSON = {
+    language: metadata.language,
+    sources,
+    settings: {
+      remappings: metadata.settings.remappings,
+      optimizer: metadata.settings.optimizer,
+      evmVersion: metadata.settings.evmVersion,
+    },
+  };
+
+  return inputJSON;
+};
+
+const tryCompileAndMatch = (artifact, jsonInput, contractName) => {
+  const solc = require("solc");
+  const i = JSON.stringify(jsonInput);
+  const iObj = JSON.parse(i);
+  iObj.settings.outputSelection = { "*": { "*": ["*", "*"] } };
+  const o = solc.compile(JSON.stringify(iObj));
+  const oObj = JSON.parse(o);
+  if (oObj.errors?.length > 0) {
+    console.warn("tryCompileAndMatch ERROR:", oObj.errors[0].message);
+    return;
+  }
+  const metadataOld = artifact.metadata;
+  const metadataOldObj = JSON.parse(metadataOld);
+
+  const path = Object.keys(metadataOldObj.settings.compilationTarget)[0];
+  const metadataNew =
+    oObj.contracts[path][metadataOldObj.settings.compilationTarget[path]]
+      .metadata;
+
+  const bytecodeNew = oObj.contracts[path][
+    metadataOldObj.settings.compilationTarget[path]
+  ].evm.bytecode.object.replace("0x", "");
+  const bytecodeOld = artifact.bytecode.replace("0x", "");
+
+  if (metadataOld === metadataNew) {
+    console.log("\u2713 metadata matches EXACTLY!");
+  } else {
+    console.log("ERROR: metadata does not match");
+  }
+
+  if (bytecodeOld === bytecodeNew) {
+    console.log("\u2713 bytecode matches EXACTLY!");
+  } else {
+    console.log("ERROR: bytecode does not match");
+  }
+};

package/truffle-plugin.json

@@ -0,0 +1,5 @@
+{
+    "commands": {
+        "stdjsonin": "stdjsonin.js"
+    }
+}

package/util.js

@@ -0,0 +1,79 @@
+const path = require('path')
+
+const abort = (message, logger = console, code = 1) => {
+  logger.error(message)
+  process.exit(code)
+}
+
+const enforce = (condition, message, logger, code) => {
+  if (!condition) abort(message, logger, code)
+}
+
+const enforceOrThrow = (condition, message) => {
+  if (!condition) throw new Error(message)
+}
+
+/**
+ * The metadata in the Truffle artifact file changes source paths on Windows. Instead of
+ * D:\Hello\World.sol, it looks like /D/Hello/World.sol. When trying to read this path,
+ * Windows cannot find it, since it is not a valid path. This function changes
+ * /D/Hello/World.sol to D:\Hello\World.sol. This way, Windows is able to read these source
+ * files. It does not change regular Unix paths, only Unixified Windows paths. It also does
+ * not make any changes on platforms that aren't Windows.
+ *
+ * @param {string} contractPath path to a contract file in any format.
+ * @param {any} options Options object containing the parsed truffle-plugin-verify options
+ * @returns {string} path to the contract in Windows format when on Windows, or Unix format otherwise.
+ */
+const normaliseContractPath = (contractPath, options) => {
+  // Replace the 'project:' prefix that was added in Truffle v5.3.14 with the actual project path
+  const absolutePath = getAbsolutePath(contractPath, options)
+
+  // If the current platform is not Windows, the path does not need to be changed
+  if (process.platform !== 'win32') return absolutePath
+
+  // If the contract path doesn't start with '/[A-Z]/' it is not a Unixified Windows path
+  if (!absolutePath.match(/^\/[A-Z]\//i)) return absolutePath
+
+  const driveLetter = absolutePath.substring(1, 2)
+  const normalisedContractPath = path.resolve(`${driveLetter}:/${absolutePath.substring(3)}`)
+
+  return normalisedContractPath
+}
+
+/**
+ * @param {string} contractPath path to a contract file in any format.
+ * @param {string} contractsDir path to the directory containing contract source files.
+ * @returns {string} absolute path to the contract source file
+ */
+const getAbsolutePath = (contractPath, contractsDir) => {
+  // Older versions of truffle already used the absolute path
+  if (!contractPath.startsWith('project:/')) return contractPath
+
+  // Figure out the project path and use it to construct the absolute path
+  const relativeContractPath = contractPath.replace('project:/', '')
+  const projectPath = findProjectPath(relativeContractPath, contractsDir)
+  const absolutePath = path.join(projectPath, relativeContractPath)
+
+  return absolutePath
+}
+
+/**
+ * @param {string} relativeContractPath path to a contract file in any format.
+ * @param {string} contractsPath path to the directory containing contract source files.
+ * @returns {string} project path
+ */
+const findProjectPath = (relativeContractPath, contractsDir) => {
+  for (let currentPath = relativeContractPath; currentPath.length > 0; currentPath = currentPath.slice(0, -1)) {
+    if (contractsDir.endsWith(currentPath)) {
+      return contractsDir.slice(0, -1 * currentPath.length)
+    }
+  }
+}
+
+module.exports = {
+  abort,
+  enforce,
+  enforceOrThrow,
+  normaliseContractPath
+}