crytic_compile.platform.etherlime

  1"""
  2Etherlime platform. https://github.com/LimeChain/etherlime
  3"""
  4
  5import glob
  6import json
  7import logging
  8import os
  9import re
 10import shutil
 11import subprocess
 12from pathlib import Path
 13from typing import TYPE_CHECKING, List, Optional, Any
 14
 15from crytic_compile.compilation_unit import CompilationUnit
 16from crytic_compile.compiler.compiler import CompilerVersion
 17from crytic_compile.platform.abstract_platform import AbstractPlatform
 18from crytic_compile.platform.exceptions import InvalidCompilation
 19from crytic_compile.platform.types import Type
 20from crytic_compile.utils.naming import convert_filename
 21
 22# Cycle dependency
 23from crytic_compile.utils.natspec import Natspec
 24
 25if TYPE_CHECKING:
 26    from crytic_compile import CryticCompile
 27
 28LOGGER = logging.getLogger("CryticCompile")
 29
 30
 31def _run_etherlime(target: str, npx_disable: bool, compile_arguments: Optional[str]) -> None:
 32    """Run etherlime
 33
 34    Args:
 35        target (str): path to the target
 36        npx_disable (bool): true if npx should not be used
 37        compile_arguments (Optional[str]): additional arguments
 38
 39    Raises:
 40        InvalidCompilation: if etherlime fails
 41    """
 42    cmd = ["etherlime", "compile", target, "deleteCompiledFiles=true"]
 43
 44    if not npx_disable:
 45        cmd = ["npx"] + cmd
 46
 47    if compile_arguments:
 48        cmd += compile_arguments.split(" ")
 49
 50    try:
 51        with subprocess.Popen(
 52            cmd,
 53            stdout=subprocess.PIPE,
 54            stderr=subprocess.PIPE,
 55            cwd=target,
 56            executable=shutil.which(cmd[0]),
 57        ) as process:
 58            stdout_bytes, stderr_bytes = process.communicate()
 59            stdout, stderr = (
 60                stdout_bytes.decode(errors="backslashreplace"),
 61                stderr_bytes.decode(errors="backslashreplace"),
 62            )  # convert bytestrings to unicode strings
 63
 64            LOGGER.info(stdout)
 65
 66            if stderr:
 67                LOGGER.error(stderr)
 68    except OSError as error:
 69        # pylint: disable=raise-missing-from
 70        raise InvalidCompilation(error)
 71
 72
 73class Etherlime(AbstractPlatform):
 74    """
 75    Etherlime platform
 76    """
 77
 78    NAME = "Etherlime"
 79    PROJECT_URL = "https://github.com/LimeChain/etherlime"
 80    TYPE = Type.ETHERLIME
 81
 82    # pylint: disable=too-many-locals
 83    def compile(self, crytic_compile: "CryticCompile", **kwargs: Any) -> None:
 84        """Run the compilation
 85
 86        Args:
 87            crytic_compile (CryticCompile): Associated CryticCompile object
 88            **kwargs: optional arguments. Used "etherlime_ignore_compile", "ignore_compile"
 89
 90        Raises:
 91            InvalidCompilation: if etherlime failed to run
 92        """
 93
 94        etherlime_ignore_compile = kwargs.get("etherlime_ignore_compile", False) or kwargs.get(
 95            "ignore_compile", False
 96        )
 97
 98        build_directory = "build"
 99        compile_arguments: Optional[str] = kwargs.get("etherlime_compile_arguments", None)
100        npx_disable: bool = kwargs.get("npx_disable", False)
101
102        if not etherlime_ignore_compile:
103            _run_etherlime(self._target, npx_disable, compile_arguments)
104
105        # similar to truffle
106        if not os.path.isdir(os.path.join(self._target, build_directory)):
107            raise InvalidCompilation(
108                "No truffle build directory found, did you run `truffle compile`?"
109            )
110        filenames = glob.glob(os.path.join(self._target, build_directory, "*.json"))
111
112        version = None
113        compiler = "solc-js"
114
115        compilation_unit = CompilationUnit(crytic_compile, str(self._target))
116
117        for file in filenames:
118            with open(file, encoding="utf8") as file_desc:
119                target_loaded = json.load(file_desc)
120
121                if version is None:
122                    if "compiler" in target_loaded:
123                        if "version" in target_loaded["compiler"]:
124                            version = re.findall(
125                                r"\d+\.\d+\.\d+", target_loaded["compiler"]["version"]
126                            )[0]
127
128                if "ast" not in target_loaded:
129                    continue
130
131                filename_txt = target_loaded["ast"]["absolutePath"]
132                filename = convert_filename(filename_txt, _relative_to_short, crytic_compile)
133
134                source_unit = compilation_unit.create_source_unit(filename)
135
136                source_unit.ast = target_loaded["ast"]
137                contract_name = target_loaded["contractName"]
138
139                compilation_unit.filename_to_contracts[filename].add(contract_name)
140                source_unit.add_contract_name(contract_name)
141                source_unit.abis[contract_name] = target_loaded["abi"]
142                source_unit.bytecodes_init[contract_name] = target_loaded["bytecode"].replace(
143                    "0x", ""
144                )
145                source_unit.bytecodes_runtime[contract_name] = target_loaded[
146                    "deployedBytecode"
147                ].replace("0x", "")
148                source_unit.srcmaps_init[contract_name] = target_loaded["sourceMap"].split(";")
149                source_unit.srcmaps_runtime[contract_name] = target_loaded[
150                    "deployedSourceMap"
151                ].split(";")
152
153                userdoc = target_loaded.get("userdoc", {})
154                devdoc = target_loaded.get("devdoc", {})
155                natspec = Natspec(userdoc, devdoc)
156                source_unit.natspec[contract_name] = natspec
157
158        compilation_unit.compiler_version = CompilerVersion(
159            compiler=compiler, version=version, optimized=_is_optimized(compile_arguments)
160        )
161
162    def clean(self, **_kwargs: str) -> None:
163        # TODO: research if there's a way to clean artifacts
164        pass
165
166    @staticmethod
167    def is_supported(target: str, **kwargs: str) -> bool:
168        """Check if the target is an etherlime project
169
170        Args:
171            target (str): path to the target
172            **kwargs: optional arguments. Used "etherlime_ignore"
173
174        Returns:
175            bool: True if the target is a etherlime project
176        """
177        etherlime_ignore = kwargs.get("etherlime_ignore", False)
178        if etherlime_ignore:
179            return False
180        if os.path.isfile(os.path.join(target, "package.json")):
181            with open(os.path.join(target, "package.json"), encoding="utf8") as file_desc:
182                package = json.load(file_desc)
183            if "dependencies" in package:
184                return (
185                    "etherlime-lib" in package["dependencies"]
186                    or "etherlime" in package["dependencies"]
187                )
188            if "devDependencies" in package:
189                return (
190                    "etherlime-lib" in package["devDependencies"]
191                    or "etherlime" in package["devDependencies"]
192                )
193        return False
194
195    def is_dependency(self, path: str) -> bool:
196        """Check if the path is a dependency
197
198        Args:
199            path (str): path to the target
200
201        Returns:
202            bool: True if the target is a dependency
203        """
204        if path in self._cached_dependencies:
205            return self._cached_dependencies[path]
206        ret = "node_modules" in Path(path).parts
207        self._cached_dependencies[path] = ret
208        return ret
209
210    def _guessed_tests(self) -> List[str]:
211        """Guess the potential unit tests commands
212
213        Returns:
214            List[str]: The guessed unit tests commands
215        """
216        return ["etherlime test"]
217
218
219def _is_optimized(compile_arguments: Optional[str]) -> bool:
220    """Check if the optimization is enabled
221
222    Args:
223        compile_arguments (Optional[str]): list of compilation arguments
224
225    Returns:
226        bool: True if the optimizations are enabled
227    """
228    if compile_arguments:
229        return "--run" in compile_arguments
230    return False
231
232
233def _relative_to_short(relative: Path) -> Path:
234    """Translate relative path to short
235
236    Args:
237        relative (Path): path to the target
238
239    Returns:
240        Path: Translated path
241    """
242    short = relative
243    try:
244        short = short.relative_to(Path("contracts"))
245    except ValueError:
246        try:
247            short = short.relative_to("node_modules")
248        except ValueError:
249            pass
250    return short