certora-cli 7.17.2__tar.gz → 7.20.3__tar.gz

{certora_cli-7.17.2/certora_cli.egg-info → certora_cli-7.20.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: certora-cli
-Version: 7.17.2
+Version: 7.20.3
 Summary: Runner for the Certora Prover
 Home-page: https://pypi.org/project/certora-cli
 Author: Certora
@@ -20,5 +20,6 @@ Requires-Dist: sly
 Requires-Dist: tabulate
 Requires-Dist: tqdm
 Requires-Dist: StrEnum
+Requires-Dist: tomli
 
-Commit 501a551.                    Build and Run scripts for executing the Certora Prover on Solidity smart contracts.
+Commit 7b9a1c7.                    Build and Run scripts for executing the Certora Prover on Solidity smart contracts.

certora_cli-7.20.3/README.md

@@ -0,0 +1 @@
+Commit 7b9a1c7.                    Build and Run scripts for executing the Certora Prover on Solidity smart contracts.

{certora_cli-7.17.2 → certora_cli-7.20.3}/certora_cli/EVMVerifier/Compiler/CompilerCollectorFactory.py

@@ -1,42 +1,47 @@
 import os
-import shutil
 
-from Shared.certoraUtils import run_compiler_cmd, VYPER, CompilerVersion, version_triplet_regex
+from Shared import certoraUtils as Util
 from pathlib import Path
 from functools import lru_cache
-from typing import Dict, Set, Callable
+from typing import Set, Callable
 import re
 import logging
 from EVMVerifier.Compiler.CompilerCollector import CompilerLang, CompilerCollector
 from EVMVerifier.Compiler.CompilerCollectorSol import CompilerCollectorSol, CompilerLangSol
 from EVMVerifier.Compiler.CompilerCollectorYul import CompilerLangYul, CompilerCollectorYul
 from EVMVerifier.Compiler.CompilerCollectorVy import CompilerCollectorVy, CompilerLangVy
-from Shared.certoraUtils import is_windows, match_path_to_mapping_key, remove_file, get_certora_config_dir
+from Shared.certoraUtils import match_path_to_mapping_key, remove_file, get_certora_config_dir
 from EVMVerifier.certoraContextClass import CertoraContext
 
 # logger for running the Solidity compiler and reporting any errors it emits
 compiler_logger = logging.getLogger("compiler")
 
 
-def get_relevant_compiler(contract_file_path: Path, default_compiler: str, compiler_mappings: Dict[str, str]) -> str:
+def get_relevant_compiler(contract_file_path: Path, context: CertoraContext) -> str:
     """
     @param contract_file_path: the contract that we are working on
-    @param compiler_mappings: input arg mapping contract to compiler
-    @param default_compiler: compiler we want to run in case the specified file_name is not in compiler_mappings
-    @return: the name of the compiler executable we want to run on this contract (as a string, could be a path
+    @param context: context object
+    @return: the name of the compiler executable we want to run on this file (as a string, could be a path
              or a resolvable executable name)
     """
-    match = None
-    if compiler_mappings:
-        match = match_path_to_mapping_key(contract_file_path, compiler_mappings)
-    if match is not None:
-        base = match
-    else:
-        base = default_compiler
-    if is_windows() and not base.endswith(".exe"):
-        base = base + ".exe"
-    compiler_logger.debug(f"relevant compiler is {base}")
-    return base
+    if context.solc_map:
+        match = match_path_to_mapping_key(contract_file_path, context.solc_map)
+        if match:
+            return match
+        else:
+            raise RuntimeError(f'cannot match compiler to {contract_file_path} from solc_map')
+
+    if Util.is_vyper_file(str(contract_file_path)):
+        if context.vyper:
+            return context.vyper
+        else:
+            return Util.DEFAULT_VYPER_COMPILER
+    elif Util.is_solidity_file(str(contract_file_path)):
+        if context.solc:
+            return context.solc
+        else:
+            return Util.DEFAULT_SOLC_COMPILER
+    raise RuntimeError(f'cannot match compiler to {contract_file_path}')
 
 
 class CompilerCollectorFactory:
@@ -50,12 +55,8 @@ class CompilerCollectorFactory:
     We added context as first step of making it the only parameters (the other params already appear in Context)
     """
 
-    def __init__(self, context: CertoraContext, default_compiler: str,
-                 compiler_mappings: Dict[str, str]):
+    def __init__(self, context: CertoraContext):
         self.context = context
-        self._default_compiler = default_compiler
-        self._compiler_mappings = compiler_mappings
-
         self._stdout_paths_to_clean: Set[Path] = set()
         self._stderr_paths_to_clean: Set[Path] = set()
 
@@ -80,46 +81,29 @@ class CompilerCollectorFactory:
         else:
             raise RuntimeError(f'expected {path} to represent a Solidity, Yul, or Vyper file')
 
-    @staticmethod
-    def get_vyper_compiler(contract_file_path: Path, default_compiler: str, compiler_mappings: Dict[str, str]) -> str:
-        """
-        @param contract_file_path: the contract that we wish to compile
-        @param default_compiler: the default compiler for the contract
-        @param compiler_mappings: mappings from context mapping files to the relevant compiler executable
-        @return: the name of the compiler executable to run
-        """
-        vyper_location = shutil.which(VYPER, os.F_OK)
-        if vyper_location is not None:
-            # has vyper. use it
-            compiler = VYPER
-        else:
-            compiler = default_compiler
-
-        vyper_exec = get_relevant_compiler(contract_file_path, compiler, compiler_mappings)
-        return vyper_exec
-
-    def __get_vyper_version(self, contract_file_path: Path) -> CompilerVersion:
+    def __get_vyper_version(self, contract_file_path: Path) -> Util.CompilerVersion:
         """
         @param contract_file_path: the contract that we are working on
         @return: the running Vyper version
         """
-        vyper_exec_to_run = self.get_vyper_compiler(contract_file_path, self._default_compiler, self._compiler_mappings)
+        vyper_exec_to_run = get_relevant_compiler(contract_file_path, self.context)
         version = self.__get_compiler_exe_version(vyper_exec_to_run, self.__version_string_handler_vyper)
         return version
 
-    def __get_solc_version(self, contract_file_path: Path) -> CompilerVersion:
+    def __get_solc_version(self, contract_file_path: Path) -> Util.CompilerVersion:
         """
         @param contract_file_path: the contract that we are working on
         @return: the running solc version
         """
         compiler_logger.debug(f"visiting contract file {contract_file_path}")
-        solc_path = get_relevant_compiler(contract_file_path, self._default_compiler, self._compiler_mappings)
+        solc_path = get_relevant_compiler(contract_file_path, self.context)
         version = self.__get_compiler_exe_version(solc_path, self.__version_string_handler_solc)
         return version
 
     @lru_cache(maxsize=32)
     def __get_compiler_exe_version(self, compiler_name: str,
-                                   version_string_handler: Callable[[str], CompilerVersion]) -> CompilerVersion:
+                                   version_string_handler:
+                                   Callable[[str], Util.CompilerVersion]) -> Util.CompilerVersion:
         """
         @param compiler_name: name of the solc we want to run on this contract
         @return: the running compiler version
@@ -130,7 +114,7 @@ class CompilerCollectorFactory:
         self._stdout_paths_to_clean.add(stdout_path)
         self._stderr_paths_to_clean.add(stderr_path)
 
-        run_compiler_cmd(
+        Util.run_compiler_cmd(
             f"{compiler_name} --version",
             wd=Path(os.getcwd()),
             output_file_name=out_name)
@@ -140,8 +124,8 @@ class CompilerCollectorFactory:
         return version_string_handler(version_string)
 
     @staticmethod
-    def __version_string_handler_vyper(version_string: str) -> CompilerVersion:
-        version_matches = re.findall(version_triplet_regex(), version_string, re.MULTILINE)
+    def __version_string_handler_vyper(version_string: str) -> Util.CompilerVersion:
+        version_matches = re.findall(Util.version_triplet_regex(), version_string, re.MULTILINE)
         if len(version_matches) != 1:
             msg = f"Couldn't extract Vyper version from output {version_string}, giving up"
             compiler_logger.debug(msg)
@@ -150,8 +134,8 @@ class CompilerCollectorFactory:
         return int(match[0]), int(match[1]), int(match[2])
 
     @staticmethod
-    def __version_string_handler_solc(version_string: str) -> CompilerVersion:
-        version_matches = re.findall(version_triplet_regex(prefix="Version: "), version_string, re.MULTILINE)
+    def __version_string_handler_solc(version_string: str) -> Util.CompilerVersion:
+        version_matches = re.findall(Util.version_triplet_regex(prefix="Version: "), version_string, re.MULTILINE)
         if len(version_matches) != 1:
             msg = f"Couldn't extract Solidity version from output {version_string}, giving up"
             compiler_logger.debug(msg)

{certora_cli-7.17.2 → certora_cli-7.20.3}/certora_cli/EVMVerifier/Compiler/CompilerCollectorVy.py

@@ -11,7 +11,7 @@ from typing import Any, Dict, List, Set, Tuple, Optional
 import EVMVerifier.certoraType as CT
 from Crypto.Hash import keccak
 from EVMVerifier.Compiler.CompilerCollector import CompilerCollector, CompilerLang, CompilerLangFunc
-from Shared.certoraUtils import Singleton, VYPER, CompilerVersion
+from Shared.certoraUtils import Singleton, DEFAULT_VYPER_COMPILER, CompilerVersion
 from Shared.certoraUtils import print_failed_to_run, get_certora_config_dir
 
 ast_logger = logging.getLogger("ast")
@@ -24,11 +24,11 @@ class CompilerLangVy(CompilerLang, metaclass=Singleton):
 
     @property
     def name(self) -> str:
-        return VYPER.capitalize()  # yes, Vyper wants to be spelled "Vyper" in the json input
+        return DEFAULT_VYPER_COMPILER.capitalize()  # yes, Vyper wants to be spelled "Vyper" in the json input
 
     @property
     def compiler_name(self) -> str:
-        return VYPER
+        return DEFAULT_VYPER_COMPILER
 
     @staticmethod
     def normalize_func_hash(func_hash: str) -> str: