ContractCompiler.ts

import * as fs from "async-file";
import * as path from "path";
import * as recursiveReadDir from "recursive-readdir";
import asyncMkdirp = require("async-mkdirp");
import { CompilerInput, CompilerOutput } from "solc";
import { Abi } from "ethereum";
import { ChildProcess, exec, spawn } from "child_process";
import { format } from "util";
import { CompilerConfiguration } from "./CompilerConfiguration";

interface AbiOutput {
  [contract: string]: Abi;
}

export class ContractCompiler {
  private readonly configuration: CompilerConfiguration;
  private readonly flattenerBin = "solidity_flattener";
  private readonly flattenerCommand: string;

  public constructor(configuration: CompilerConfiguration) {
    this.configuration = configuration;
    this.flattenerCommand = `${this.flattenerBin} --allow-path . %s`;
  }

  private async getCommandOutputFromInput(
    childProcess: ChildProcess,
    stdin: string
  ): Promise<string> {
    return new Promise<string>((resolve, reject) => {
      const buffers: Array<Buffer> = [];
      childProcess.stdout.on("data", function(data: Buffer) {
        buffers.push(data);
      });
      const errorBuffers: Array<Buffer> = [];
      childProcess.stderr.on("data", function(data: Buffer) {
        errorBuffers.push(data);
      });
      childProcess.on("close", function(code) {
        const errorMessage = Buffer.concat(errorBuffers).toString();
        if (code > 0)
          return reject(
            new Error(`Process Exit Code ${code}\n${errorMessage}`)
          );
        return resolve(Buffer.concat(buffers).toString());
      });
      childProcess.stdin.write(stdin);
      childProcess.stdin.end();
    });
  }

  private async compileCustomWrapper(
    compilerInputJson: CompilerInput
  ): Promise<CompilerOutput> {
    const childProcess = spawn("solc", ["--standard-json"]);
    const compilerOutputJson = await this.getCommandOutputFromInput(
      childProcess,
      JSON.stringify(compilerInputJson)
    );
    return JSON.parse(compilerOutputJson);
  }

  public async compileContracts(): Promise<CompilerOutput> {
    // Check if all contracts are cached (and thus do not need to be compiled)
    try {
      const stats = await fs.stat(this.configuration.contractOutputPath);
      const lastCompiledTimestamp = stats.mtime;
      const ignoreCachedFile = function(
        file: string,
        stats: fs.Stats
      ): boolean {
        return (
          (stats.isFile() && path.extname(file) !== ".sol") ||
          (stats.isFile() &&
            path.extname(file) === ".sol" &&
            stats.mtime < lastCompiledTimestamp)
        );
      };
      const uncachedFiles = await recursiveReadDir(
        this.configuration.contractSourceRoot,
        [ignoreCachedFile]
      );
      if (uncachedFiles.length === 0) {
        return JSON.parse(
          await fs.readFile(this.configuration.contractOutputPath, "utf8")
        );
      }
    } catch {
      // Unable to read compiled contracts output file (likely because it has not been generated)
    }

    console.log("Compiling contracts, this may take a minute...");

    // Compile all contracts in the specified input directory
    const compilerInputJson = await this.generateCompilerInput();
    const compilerOutput = await this.compileCustomWrapper(compilerInputJson);

    if (compilerOutput.errors) {
      let errors = "";

      for (let error of compilerOutput.errors) {
        // FIXME: https://github.com/ethereum/solidity/issues/3273
        if (
          error.message.includes(
            "instruction is only available after the Metropolis hard fork"
          )
        )
          continue;
        errors += error.formattedMessage + "\n";
      }

      if (errors.length > 0) {
        throw new Error(
          "The following errors/warnings were returned by solc:\n\n" + errors
        );
      }
    }

    // Create output directory (if it doesn't exist)
    await asyncMkdirp(path.dirname(this.configuration.contractOutputPath));

    // Output contract data to single file
    const filteredCompilerOutput = this.filterCompilerOutput(compilerOutput);
    await fs.writeFile(
      this.configuration.contractOutputPath,
      JSON.stringify(filteredCompilerOutput, null, "\t")
    );

    // Output abi data to a single file
    const abiOutput = this.generateAbiOutput(filteredCompilerOutput);
    await fs.writeFile(
      this.configuration.abiOutputPath,
      JSON.stringify(abiOutput, null, "\t")
    );

    return filteredCompilerOutput;
  }

  public async generateFlattenedSolidity(filePath: string): Promise<string> {
    const relativeFilePath = filePath
      .replace(this.configuration.contractSourceRoot, "")
      .replace(/\\/g, "/");

    const childProcess = exec(format(this.flattenerCommand, relativeFilePath), {
      encoding: "buffer",
      cwd: this.configuration.contractSourceRoot
    });
    return await this.getCommandOutputFromInput(childProcess, "");
  }

  public async generateCompilerInput(): Promise<CompilerInput> {
    const ignoreFile = function(file: string, stats: fs.Stats): boolean {
      return stats.isFile() && path.extname(file) !== ".sol";
    };
    const filePaths = await recursiveReadDir(
      this.configuration.contractSourceRoot,
      [ignoreFile]
    );
    const filesPromises = filePaths.map(
      async filePath => await this.generateFlattenedSolidity(filePath)
    );
    const files = await Promise.all(filesPromises);

    let inputJson: CompilerInput = {
      language: "Solidity",
      settings: {
        optimizer: {
          enabled: true,
          runs: 500
        },
        outputSelection: {
          "*": {
            "*": ["abi", "evm.bytecode.object"]
          }
        }
      },
      sources: {}
    };
    for (var file in files) {
      const filePath = filePaths[file]
        .replace(this.configuration.contractSourceRoot, "")
        .replace(/\\/g, "/");
      inputJson.sources[filePath] = { content: files[file] };
    }

    return inputJson;
  }

  private filterCompilerOutput(compilerOutput: CompilerOutput): CompilerOutput {
    const result: CompilerOutput = { contracts: {} };
    for (let relativeFilePath in compilerOutput.contracts) {
      for (let contractName in compilerOutput.contracts[relativeFilePath]) {
        // don't include libraries
        if (
          relativeFilePath.startsWith("libraries/") &&
          contractName !== "Delegator" &&
          contractName !== "Map"
        )
          continue;
        // don't include embedded libraries
        if (
          !(
            relativeFilePath === `${contractName}.sol` ||
            relativeFilePath.endsWith(`/${contractName}.sol`)
          )
        )
          continue;
        const abi =
          compilerOutput.contracts[relativeFilePath][contractName].abi;
        if (abi === undefined) continue;
        const bytecode =
          compilerOutput.contracts[relativeFilePath][contractName].evm.bytecode
            .object;
        if (bytecode === undefined) continue;
        // don't include interfaces or Abstract contracts
        if (/^(?:I|Base)[A-Z].*/.test(contractName)) continue;
        if (bytecode.length === 0)
          throw new Error(
            "Contract: " +
              contractName +
              " has no bytecode, but this is not expected. It probably doesn't implement all its abstract methods"
          );

        result.contracts[relativeFilePath] = {
          [contractName]: {
            abi: abi,
            evm: { bytecode: { object: bytecode } }
          }
        };
      }
    }
    return result;
  }

  private generateAbiOutput(compilerOutput: CompilerOutput): AbiOutput {
    const result: AbiOutput = {};
    for (let relativeFilePath in compilerOutput.contracts) {
      for (let contractName in compilerOutput.contracts[relativeFilePath]) {
        result[contractName] =
          compilerOutput.contracts[relativeFilePath][contractName].abi;
      }
    }

    return result;
  }
}