crytic_compile.platform.solc_standard_json

  1"""
  2Handle compilation through the standard solc json format
  3"""
  4import json
  5import logging
  6import os
  7import shutil
  8import subprocess
  9from pathlib import Path
 10from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 11
 12from crytic_compile.compilation_unit import CompilationUnit
 13from crytic_compile.compiler.compiler import CompilerVersion
 14from crytic_compile.platform.exceptions import InvalidCompilation
 15from crytic_compile.platform.solc import (
 16    Solc,
 17    get_version,
 18    is_optimized,
 19    relative_to_short,
 20)
 21from crytic_compile.platform.types import Type
 22from crytic_compile.utils.naming import convert_filename
 23
 24# Cycle dependency
 25from crytic_compile.utils.natspec import Natspec
 26
 27if TYPE_CHECKING:
 28    from crytic_compile import CryticCompile
 29
 30LOGGER = logging.getLogger("CryticCompile")
 31
 32
 33# pylint: disable=too-many-arguments
 34def standalone_compile(
 35    filenames: List[str],
 36    compilation_unit: CompilationUnit,
 37    working_dir: Optional[str] = None,
 38    remappings: Optional[List[str]] = None,
 39    evm_version: Optional[str] = None,
 40    via_ir: Optional[bool] = None,
 41) -> None:
 42    """
 43    Boilerplate function to run the the standardjson. compilation_unit.compiler_version must be set before calling this function
 44
 45    Example of usage:
 46        compilation_unit = CompilationUnit(crytic_compile, name_target)
 47        compilation_unit.compiler_version = CompilerVersion(
 48            compiler="solc", version=compiler_version, optimized=optimization_used, optimize_runs=optimize_runs
 49        )
 50        standalone_compile(filenames_to_compile, compilation_unit
 51
 52    Args:
 53        filenames (List[str]): list of the files to compile
 54        compilation_unit (CompilationUnit): compilation unit object to populate
 55        working_dir (Optional[str]): working directory
 56        remappings (Optional[List[str]]): list of solc remaps to use
 57        evm_version (Optional[str]): EVM version to target. None for default
 58        via_ir (Optional[bool]): whether to enable the viaIR compilation flag. None for unset
 59
 60    Returns:
 61
 62    """
 63
 64    if compilation_unit.compiler_version.version == "N/A":
 65        LOGGER.error("The compiler version of the compilation unit must be set")
 66        return
 67
 68    standard_json_dict: Dict = {}
 69    build_standard_json_default(standard_json_dict)
 70
 71    for filename in filenames:
 72        add_source_file(standard_json_dict, filename)
 73
 74    if remappings is not None:
 75        for remap in remappings:
 76            add_remapping(standard_json_dict, remap)
 77
 78    if evm_version is not None:
 79        add_evm_version(standard_json_dict, evm_version)
 80
 81    if via_ir is not None:
 82        add_via_ir(standard_json_dict, via_ir)
 83
 84    add_optimization(
 85        standard_json_dict,
 86        compilation_unit.compiler_version.optimized,
 87        compilation_unit.compiler_version.optimize_runs,
 88    )
 89
 90    targets_json = run_solc_standard_json(
 91        standard_json_dict,
 92        compiler_version=compilation_unit.compiler_version,
 93        solc_disable_warnings=False,
 94        working_dir=working_dir,
 95    )
 96
 97    parse_standard_json_output(targets_json, compilation_unit, solc_working_dir=working_dir)
 98
 99
100def build_standard_json_default(json_dict: Dict) -> None:
101    """
102    Populate the given json_dict with the default values for the solc standard json input
103    Only write values for which the keys are not existing
104
105    Args:
106        json_dict (Dict): dictionary used for the solc standard input
107
108    Returns:
109
110    """
111    if "language" not in json_dict:
112        json_dict["language"] = "Solidity"
113    if "sources" not in json_dict:
114        json_dict["sources"] = {}
115    if "settings" not in json_dict:
116        json_dict["settings"] = {}
117
118    if "remappings" not in json_dict["settings"]:
119        json_dict["settings"]["remappings"] = []
120    if "optimizer" not in json_dict["settings"]:
121        json_dict["settings"]["optimizer"] = {"enabled": False}
122    if "outputSelection" not in json_dict["settings"]:
123        json_dict["settings"]["outputSelection"] = {
124            "*": {
125                "*": [
126                    "abi",
127                    "metadata",
128                    "devdoc",
129                    "userdoc",
130                    "evm.bytecode",
131                    "evm.deployedBytecode",
132                ],
133                "": ["ast"],
134            }
135        }
136
137
138# pylint: disable=too-many-locals
139def run_solc_standard_json(
140    solc_input: Dict,
141    compiler_version: CompilerVersion,
142    solc_disable_warnings: bool = False,
143    working_dir: Optional[str] = None,
144) -> Dict:
145    """Run the solc standard json compilation.
146    Ensure that crytic_compile.compiler_version is set prior calling _run_solc
147
148    Args:
149        solc_input (Dict): standard json object
150        compiler_version (CompilerVersion): info regarding the compiler
151        solc_disable_warnings (bool): True to not print the solc warnings. Defaults to False.
152        working_dir (Optional[str], optional): Working directory to run solc. Defaults to None.
153
154    Raises:
155        InvalidCompilation: If the compilation failed
156
157    Returns:
158        Dict: Solc json output
159    """
160    working_dir_resolved = Path(working_dir if working_dir else ".").resolve()
161    cmd = [compiler_version.compiler, "--standard-json", "--allow-paths", str(working_dir_resolved)]
162    additional_kwargs: Dict = {"cwd": working_dir} if working_dir else {}
163
164    env = dict(os.environ)
165    if compiler_version.version:
166        env["SOLC_VERSION"] = compiler_version.version
167
168    stderr = ""
169    LOGGER.info(
170        "'%s' running",
171        " ".join(cmd),
172    )
173    try:
174        with subprocess.Popen(
175            cmd,
176            stdin=subprocess.PIPE,
177            stdout=subprocess.PIPE,
178            stderr=subprocess.PIPE,
179            env=env,
180            executable=shutil.which(cmd[0]),
181            **additional_kwargs,
182        ) as process:
183            stdout_b, stderr_b = process.communicate(json.dumps(solc_input).encode("utf-8"))
184            stdout, stderr = (
185                stdout_b.decode(),
186                stderr_b.decode(errors="backslashreplace"),
187            )  # convert bytestrings to unicode strings
188
189            solc_json_output = json.loads(stdout)
190
191            # Check for errors and raise them if any exist.
192            solc_errors = solc_json_output.get("errors", [])
193            if solc_errors:
194                solc_error_occurred = False
195                solc_exception_str = ""
196                for solc_error in solc_errors:
197                    if solc_error["severity"] != "warning":
198                        solc_error_occurred = True
199                    elif solc_disable_warnings:
200                        continue
201                    solc_exception_str += (
202                        f"{solc_error.get('type', 'UnknownExceptionType')}: "
203                        f"{solc_error.get('formattedMessage', 'N/A')}\n"
204                    )
205
206                if solc_error_occurred:
207                    raise InvalidCompilation(solc_exception_str)
208                if solc_exception_str:
209                    LOGGER.warning(solc_exception_str)
210
211            return solc_json_output
212
213    except OSError as error:
214        # pylint: disable=raise-missing-from
215        raise InvalidCompilation(error)
216
217    except json.decoder.JSONDecodeError:
218        # pylint: disable=raise-missing-from
219        raise InvalidCompilation(f"Invalid solc compilation {stderr}")
220
221
222def add_source_file(json_dict: Dict, file_path: str) -> None:
223    """
224    Add a path to the solc standard json input
225
226    Args:
227        json_dict (Dict): solc standard json input
228        file_path (str): file to add
229
230    Returns:
231
232    """
233    json_dict["sources"][file_path] = {"urls": [file_path]}
234
235
236def add_remapping(json_dict: Dict, remapping: str) -> None:
237    """
238    Add a remapping to the solc standard json input
239
240    Args:
241        json_dict (Dict): solc standard json input
242        remapping (str): remapping
243
244    Returns:
245
246    """
247    json_dict["settings"]["remappings"].append(remapping)
248
249
250def add_optimization(
251    json_dict: Dict, optimize: Optional[bool], optimize_runs: Optional[int]
252) -> None:
253    """
254    Add optimization settings to the solc standard json input
255
256    Args:
257        json_dict (Dict): solc standard json input
258        optimize (bool): true if optimization are enabled
259        optimize_runs (Optional[int]): number of optimize runs
260
261    Returns:
262
263    """
264    if optimize:
265        json_dict["settings"]["optimizer"] = {"enabled": True}
266        if optimize_runs:
267            json_dict["settings"]["optimizer"]["runs"] = optimize_runs
268        return
269    json_dict["settings"]["optimizer"] = {"enabled": False}
270
271
272def add_evm_version(json_dict: Dict, version: str) -> None:
273    """
274    Add the version of the EVM to compile for.
275
276    Can be one of the following values: homestead, tangerineWhistle,
277    spuriousDragon, byzantium, constantinople, petersburg, istanbul,
278    berlin, london or paris
279
280    Args:
281        json_dict (Dict): solc standard json input
282        version (str): the EVM version to target
283
284    Returns:
285
286    """
287    json_dict["settings"]["evmVersion"] = version
288
289
290def add_via_ir(json_dict: Dict, enabled: bool) -> None:
291    """
292    Enable or disable the "viaIR" compilation flag.
293
294    Args:
295        json_dict (Dict): solc standard json input
296        enabled (bool): whether viaIR is enabled
297
298    Returns:
299
300    """
301    json_dict["settings"]["viaIR"] = enabled
302
303
304def parse_standard_json_output(
305    targets_json: Dict, compilation_unit: CompilationUnit, solc_working_dir: Optional[str] = None
306) -> None:
307    """
308    Parse the targets_json output from solc, and populate compilation_unit accordingly
309
310
311    Args:
312        targets_json (Dict): output from solc
313        compilation_unit (CompilationUnit): compilation unit to populate
314        solc_working_dir (Optional[str]): working dir
315
316    Returns:
317
318    """
319
320    skip_filename = compilation_unit.compiler_version.version in [f"0.4.{x}" for x in range(0, 10)]
321
322    if "sources" in targets_json:
323        for path, info in targets_json["sources"].items():
324            if skip_filename:
325                path = convert_filename(
326                    path,
327                    relative_to_short,
328                    compilation_unit.crytic_compile,
329                    working_dir=solc_working_dir,
330                )
331            else:
332                path = convert_filename(
333                    path,
334                    relative_to_short,
335                    compilation_unit.crytic_compile,
336                    working_dir=solc_working_dir,
337                )
338            source_unit = compilation_unit.create_source_unit(path)
339
340            source_unit.ast = info.get("ast")
341
342    if "contracts" in targets_json:
343        for file_path, file_contracts in targets_json["contracts"].items():
344            for contract_name, info in file_contracts.items():
345                # for solc < 0.4.10 we cant retrieve the filename from the ast
346                if skip_filename:
347                    filename = convert_filename(
348                        file_path,
349                        relative_to_short,
350                        compilation_unit.crytic_compile,
351                        working_dir=solc_working_dir,
352                    )
353                else:
354                    filename = convert_filename(
355                        file_path,
356                        relative_to_short,
357                        compilation_unit.crytic_compile,
358                        working_dir=solc_working_dir,
359                    )
360
361                source_unit = compilation_unit.create_source_unit(filename)
362
363                source_unit.add_contract_name(contract_name)
364                compilation_unit.filename_to_contracts[filename].add(contract_name)
365                source_unit.abis[contract_name] = info["abi"]
366
367                userdoc = info.get("userdoc", {})
368                devdoc = info.get("devdoc", {})
369                natspec = Natspec(userdoc, devdoc)
370                source_unit.natspec[contract_name] = natspec
371
372                source_unit.bytecodes_init[contract_name] = info["evm"]["bytecode"]["object"]
373                source_unit.bytecodes_runtime[contract_name] = info["evm"]["deployedBytecode"][
374                    "object"
375                ]
376                source_unit.srcmaps_init[contract_name] = info["evm"]["bytecode"][
377                    "sourceMap"
378                ].split(";")
379                source_unit.srcmaps_runtime[contract_name] = info["evm"]["deployedBytecode"][
380                    "sourceMap"
381                ].split(";")
382
383
384# Inherits is_dependency/is_supported from Solc
385class SolcStandardJson(Solc):
386    """
387    Represent the Standard solc Json object
388    """
389
390    NAME = "Solc-json"
391    PROJECT_URL = "https://solidity.readthedocs.io/en/latest/using-the-compiler.html#compiler-input-and-output-json-description"
392    TYPE = Type.SOLC_STANDARD_JSON
393
394    def __init__(self, target: Union[str, dict] = None, **kwargs: str):
395        """Initializes an object which represents solc standard json
396
397        Args:
398            target (Union[str, dict], optional): A string path to a standard json, or a standard json. Defaults to None.
399            **kwargs: optional arguments.
400
401        Raises:
402            ValueError: If invalid json
403        """
404
405        super().__init__(str(target), **kwargs)
406
407        if target is None:
408            self._json: Dict = {}
409        elif isinstance(target, str):
410            if os.path.isfile(target):
411                with open(target, mode="r", encoding="utf-8") as target_file:
412                    self._json = json.load(target_file)
413            else:
414                self._json = json.loads(target)
415
416        elif isinstance(target, dict):
417            self._json = target
418        else:
419            raise ValueError("Invalid target for solc standard json input.")
420
421        build_standard_json_default(self._json)
422
423    def add_source_file(self, file_path: str) -> None:
424        """Append file
425
426        Args:
427            file_path (str): file to append
428        """
429        add_source_file(self._json, file_path)
430
431    def add_source_files(self, files_path: List[str]) -> None:
432        """Append files
433
434        Args:
435            files_path (List[str]): files to append
436        """
437        for file_path in files_path:
438            add_source_file(self._json, file_path)
439
440    def add_remapping(self, remapping: str) -> None:
441        """Append our remappings
442
443        Args:
444            remapping (str): remapping to add
445        """
446        add_remapping(self._json, remapping)
447
448    def to_dict(self) -> Dict:
449        """Patch in our desired output types
450
451        Returns:
452            Dict:
453        """
454        return self._json
455
456    # pylint: disable=too-many-locals
457    def compile(self, crytic_compile: "CryticCompile", **kwargs: Any) -> None:
458        """[summary]
459
460        Args:
461            crytic_compile (CryticCompile): Associated CryticCompile object
462            **kwargs: optional arguments. Used: "solc", "solc_disable_warnings", "solc_args", "solc_working_dir",
463                "solc_remaps", "solc_env"
464        """
465
466        solc: str = kwargs.get("solc", "solc")
467        solc_disable_warnings: bool = kwargs.get("solc_disable_warnings", False)
468        solc_arguments: str = kwargs.get("solc_args", "")
469
470        solc_remaps: Optional[Union[str, List[str]]] = kwargs.get("solc_remaps", None)
471        solc_working_dir: Optional[str] = kwargs.get("solc_working_dir", None)
472        solc_env: Optional[Dict] = kwargs.get("solc_env", None)
473
474        compilation_unit = CompilationUnit(crytic_compile, "standard_json")
475
476        compilation_unit.compiler_version = CompilerVersion(
477            compiler="solc",
478            version=get_version(solc, solc_env),
479            optimized=is_optimized(solc_arguments)
480            or self.to_dict().get("settings", {}).get("optimizer", {}).get("enabled", False),
481            optimize_runs=self.to_dict().get("settings", {}).get("optimizer", {}).get("runs", None),
482        )
483
484        add_optimization(
485            self._json,
486            compilation_unit.compiler_version.optimized,
487            compilation_unit.compiler_version.optimize_runs,
488        )
489
490        # Add all remappings
491        if solc_remaps:
492            if isinstance(solc_remaps, str):
493                solc_remaps = solc_remaps.split(" ")
494            for solc_remap in solc_remaps:
495                self.add_remapping(solc_remap)
496
497        # Invoke solc
498        targets_json = run_solc_standard_json(
499            self.to_dict(),
500            compilation_unit.compiler_version,
501            solc_disable_warnings=solc_disable_warnings,
502            working_dir=solc_working_dir,
503        )
504
505        parse_standard_json_output(
506            targets_json, compilation_unit, solc_working_dir=solc_working_dir
507        )
508
509    def _guessed_tests(self) -> List[str]:
510        """Guess the potential unit tests commands
511
512        Returns:
513            List[str]: The guessed unit tests commands
514        """
515        return []