certora-cli 8.19.2__tar.gz → 8.20.2__tar.gz

{certora_cli-8.19.2/certora_cli.egg-info → certora_cli-8.20.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: certora-cli
-Version: 8.19.2
+Version: 8.20.2
 Summary: Runner for the Certora Prover
 Home-page: https://pypi.org/project/certora-cli
 Author: Certora
@@ -38,4 +38,4 @@ Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 
-Commit 63fdea8.                    Build and Run scripts for executing the Certora Prover on Solidity smart contracts.
+Commit f5f7778.                    Build and Run scripts for executing the Certora Prover on Solidity smart contracts.

certora_cli-8.20.2/README.md

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

{certora_cli-8.19.2 → certora_cli-8.20.2}/certora_cli/CertoraProver/Compiler/CompilerCollector.py

@@ -190,6 +190,20 @@ class CompilerCollector(ABC):
     def compiler_version(self) -> CompilerVersion:
         pass
 
+    # Full version identifier from the compiler's `--version` output
+    # (e.g. solc '0.8.34+commit.80d5c536.Darwin.appleclang'), recording the exact
+    # compiler build. None when it could not be extracted. Set by the factory after
+    # construction so subclass constructors need not change.
+    _compiler_version_full: Optional[str] = None
+
+    @property
+    def compiler_version_full(self) -> Optional[str]:
+        return self._compiler_version_full
+
+    @compiler_version_full.setter
+    def compiler_version_full(self, value: Optional[str]) -> None:
+        self._compiler_version_full = value
+
     def normalize_file_compiler_path_name(self, file_abs_path: str) -> str:
         """
         Normalizes the absolute path name [file_abs_path] of a file, given to the compiler.

{certora_cli-8.19.2 → certora_cli-8.20.2}/certora_cli/CertoraProver/Compiler/CompilerCollectorFactory.py

@@ -18,7 +18,7 @@ import os
 from Shared import certoraUtils as Util
 from pathlib import Path
 from functools import lru_cache
-from typing import Set, Callable
+from typing import Set, Callable, Tuple, Optional
 import re
 import logging
 from CertoraProver.Compiler.CompilerCollector import CompilerLang, CompilerCollector
@@ -94,44 +94,48 @@ class CompilerCollectorFactory:
         @param path: path of the file to create [CompilerCollector] for
         """
         if str(path).endswith(".vy"):
-            version = self.__get_vyper_version(path)
-            return CompilerCollectorVy(version)
+            version, full_version = self.__get_vyper_version(path)
+            collector: CompilerCollector = CompilerCollectorVy(version)
         elif str(path).endswith(".sol"):
-            version = self.__get_solc_version(path)
-
-            return CompilerCollectorSol(version, CompilerLangSol(), not self.context.no_memory_safe_autofinders)
+            version, full_version = self.__get_solc_version(path)
+            collector = CompilerCollectorSol(version, CompilerLangSol(), not self.context.no_memory_safe_autofinders)
         elif str(path).endswith(".yul"):
-            version = self.__get_solc_version(path)
-            return CompilerCollectorYul(version, CompilerLangYul())
+            version, full_version = self.__get_solc_version(path)
+            collector = CompilerCollectorYul(version, CompilerLangYul())
         else:
             raise RuntimeError(f'expected {path} to represent a Solidity, Yul, or Vyper file')
 
-    def __get_vyper_version(self, contract_file_path: Path) -> Util.CompilerVersion:
+        collector.compiler_version_full = full_version
+        return collector
+
+    def __get_vyper_version(self, contract_file_path: Path) -> Tuple[Util.CompilerVersion, Optional[str]]:
         """
         @param contract_file_path: the contract that we are working on
-        @return: the running Vyper version
+        @return: the running Vyper version (triplet, full identifier)
         """
         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
+        return self.__get_compiler_exe_version(vyper_exec_to_run, self.__version_string_handler_vyper)
 
-    def __get_solc_version(self, contract_file_path: Path) -> Util.CompilerVersion:
+    def __get_solc_version(self, contract_file_path: Path) -> Tuple[Util.CompilerVersion, Optional[str]]:
         """
         @param contract_file_path: the contract that we are working on
-        @return: the running solc version
+        @return: the running solc version (triplet, full identifier)
         """
         compiler_logger.debug(f"visiting contract file {contract_file_path}")
         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
+        return self.__get_compiler_exe_version(solc_path, self.__version_string_handler_solc)
 
     @lru_cache(maxsize=32)
     def __get_compiler_exe_version(self, compiler_name: str,
                                    version_string_handler:
-                                   Callable[[str], Util.CompilerVersion]) -> Util.CompilerVersion:
+                                   Callable[[str], Util.CompilerVersion]) -> Tuple[Util.CompilerVersion, Optional[str]]:
         """
         @param compiler_name: name of the solc we want to run on this contract
-        @return: the running compiler version
+        @return: a tuple of (the running compiler version triplet, the full version
+                 identifier string from `--version` such as
+                 '0.8.34+commit.80d5c536.Darwin.appleclang', or None if it could not
+                 be extracted). The triplet is used for behavioural checks; the full
+                 identifier records the exact compiler build for reproducibility.
         """
         out_name = f"version_check_{Path(compiler_name).name}"
         stdout_path = get_certora_config_dir() / f'{out_name}.stdout'
@@ -146,7 +150,23 @@ class CompilerCollectorFactory:
 
         with stdout_path.open() as r:
             version_string = r.read(-1)
-        return version_string_handler(version_string)
+        return version_string_handler(version_string), self.__extract_full_version(version_string)
+
+    @staticmethod
+    def __extract_full_version(version_string: str) -> Optional[str]:
+        """
+        Extracts the full version identifier from a compiler's `--version` output.
+        solc prints a `Version: <id>` line (e.g. 'Version: 0.8.34+commit.80d5c536.Darwin.appleclang');
+        vyper prints the bare identifier. Returns the identifier token, or None if not found.
+        """
+        version_matches = re.findall(r'^Version:\s*(\S+)', version_string, re.MULTILINE)
+        if version_matches:
+            return version_matches[0]
+        for line in version_string.splitlines():
+            line = line.strip()
+            if line:
+                return line
+        return None
 
     @staticmethod
     def __version_string_handler_vyper(version_string: str) -> Util.CompilerVersion:

{certora_cli-8.19.2 → certora_cli-8.20.2}/certora_cli/CertoraProver/certoraBuild.py

@@ -468,6 +468,25 @@ def convert_pathname_to_posix(json_dict: Dict[str, Any], entry: str, compiler_co
         json_dict[entry] = json_dict_posix_paths
 
 
+def relative_import_path(importer_dir: Path, target: str) -> str:
+    """
+    The path under which a Solidity file in [importer_dir] imports [target].
+    solc resolves an import starting with `./` or `../` against the importing file's directory.
+    """
+    rel = Util.as_posix(os.path.relpath(Util.abs_posix_path(target), Util.abs_posix_path(importer_dir)))
+    return rel if rel.startswith("../") else f"./{rel}"
+
+
+def harness_import_path(importer_dir: Path, target: str) -> str:
+    """
+    The path under which a harness in [importer_dir] imports [target], a solc source unit name from the main build.
+    A name that does not start with `./` or `../` is imported as is, so solc gives the file the same name as in the
+    main build and loads it once even if the harness also reaches it through other imports. A name that does would be
+    resolved against the harness's directory, so it is rewritten relative to it.
+    """
+    return relative_import_path(importer_dir, target) if target.startswith(("./", "../")) else target
+
+
 class CertoraBuildGenerator:
     # 12,14,04,06,00,04,10 is 0xce4604a aka certora.
     CONSTRUCTOR_STRING = "constructor"
@@ -1438,6 +1457,19 @@ class CertoraBuildGenerator:
         if match:
             settings_dict["evmVersion"] = match
 
+    @staticmethod
+    def _solc_takes_inliner_detail(compiler_version: Tuple[int, int, int]) -> bool:
+        """Whether this compiler accepts `settings.optimizer.details.inliner`.
+
+        solc learned the key in 0.8.5; older compilers reject the whole standard-json input with
+        `Unknown key "inliner"`, so the file fails to compile rather than compiling un-inlined.
+        See https://github.com/ethereum/solidity/blob/v0.8.4/libsolidity/interface/StandardCompiler.cpp
+        """
+        major, minor, patch = compiler_version
+        if major != 0:
+            raise Util.CertoraUserInputError(f"Unrecognized version {major}.{minor}.{patch}")
+        return (minor == 8 and patch >= 5) or (minor > 8)
+
     def _handle_optimize(self, contract_file_path: Path, settings_dict: Dict[str, Any],
                          compiler_collector: CompilerCollector) -> None:
         """
@@ -1456,29 +1488,47 @@ class CertoraBuildGenerator:
         if optimizer and isinstance(optimizer, dict) and optimizer.get('enabled'):
             # if we are not disabling finder friendly optimizer specifically, enable it whenever viaIR is also enabled
             if not self.context.strict_solc_optimizer and self.get_solc_via_ir_value(contract_file_path):
-                # The default optimizer steps (taken from libsolidity/interface/OptimiserSettings.h) but with the
-                # full inliner step removed
-                solc0_8_34_to_0_8_36 = ("dfDvulfnTUtnIfxa[r]EscLMVcul[j]Trpeulxa[r]cLvifMCTUca[r]LSsTFOtfDnca[r]"
-                                        "IulcscCTUtvifMx[scCTUt]TOntnfDIulvifMjmul[jul]VcTOculjmul")
-                solc0_8_26_to_0_8_33 = ("dhfoDgvulfnTUtnIfxa[r]EscLMVcul[j]Trpeulxa[r]cLCTUca[r]LSsTFOtfDnca[r]" +
-                                        "IulcscCTUtx[scCTUt]TOntnfDIuljmul[jul]VcTOculjmul")
-                solc0_8_13_to_0_8_25 = "dhfoDgvulfnTUtnIf[xa[r]EscLMcCTUtTOntnfDIulLculVcul[j]T" + \
-                                       "peulxa[rul]xa[r]cLgvifCTUca[r]LSsTFOtfDnca[r]Iulc]jmul[jul]VcTOculjmul"
-                solc0_8_12 = "dhfoDgvulfnTUtnIf[xa[r]EscLMcCTUtTOntnfDIulLculVcul[j]T" + \
-                             "peulxa[rul]xa[r]cLgvifCTUca[r]LsTFOtfDnca[r]Iulc]jmul[jul]VcTOculjmul"
-                solc0_8_10_to_0_8_11 = "dhfoDgvulfnTUtnIf[xa[r]scLMcCTUtTOntnfDIulLculVcul[j]T" + \
-                                       "peulxa[rul]xa[r]cLgvifCTUca[r]LsTFOtfDnca[r]Iulc]jmul[jul]VcTOculjmul"
-                solc0_8_1_to_0_8_9 = "dhfoDgvulfnTUtnIf[xarrscLMcCTUtTOntnfDIulLculVculjjT" + \
-                                     "peulxarulrulxarrcLgvifCTUcarrLsTFOtfDncarrIulc]jmuljuljulVcTOculjmul"
-                solc0_7_6_to_0_8_0 = "dhfoDgvulfnTUtnIf[xarrscLMcCTUtTOntnfDIulLculVculjjT" + \
-                                     "peulxarulrulxarrcLgvifCTUcarrLsTFOtfDncarrIulc]jmuljuljulVcTOculjmul"
-                solc0_7_2_to_0_7_5 = "NdhfoDgvulfnTUtnIf[xarrscLMcCTUtTOntnfDIulLculVculjjT" + \
-                                     "peulxarulrulxarrcLgvifCTUcarrLsTFOtfDncarrIulc]jmuljuljulVcTOculjmulN"
-                solc0_6_7_to_0_7_1 = "dhfoDgvulfnTUtnIf[xarrscLMcCTUtTOntnfDIulLculVculjj" + \
-                                     "eulxarulrulxarrcLgvifCTUcarrLsTFOtfDncarrIulc]jmuljuljulVcTOculjmul"
-
-                def standard_replacement(optimizer_steps: str) -> str:
-                    return optimizer_steps.replace("gvif", "gvf")  # replace gvif with gvf
+                # The default Yul optimizer steps, copied verbatim from
+                # libsolidity/interface/OptimiserSettings.h at each release that changed them. Keeping them
+                # verbatim is what makes the full inliner the only difference between what we send and what
+                # solc would have run by itself.
+                solc0_8_34_to_0_8_36 = ("dfDvulfnTUtnIfxa[r]EscLMVcul[j]Trpeulxa[r]cLvifMCTUca[r]LSsTFOtfDnca[r]Iulcsc"
+                                        "CTUtvifMx[scCTUt]TOntnfDIulvifMjmul[jul]VcTOculjmul")
+                solc0_8_26_to_0_8_33 = ("dhfoDgvulfnTUtnIfxa[r]EscLMVcul[j]Trpeulxa[r]cLgvifMCTUca[r]LSsTFOtfDnca[r]Iu"
+                                        "lcscCTUtgvifMx[scCTUt]TOntnfDIulgvifMjmul[jul]VcTOculjmul")
+                solc0_8_13_to_0_8_25 = ("dhfoDgvulfnTUtnIf[xa[r]EscLMcCTUtTOntnfDIulLculVcul[j]Tpeulxa[rul]xa[r]cLgvif"
+                                        "CTUca[r]LSsTFOtfDnca[r]Iulc]jmul[jul]VcTOculjmul")
+                solc0_8_12 = ("dhfoDgvulfnTUtnIf[xa[r]EscLMcCTUtTOntnfDIulLculVcul[j]Tpeulxa[rul]xa[r]cLgvifCTUca[r]Ls"
+                              "TFOtfDnca[r]Iulc]jmul[jul]VcTOculjmul")
+                solc0_8_10_to_0_8_11 = ("dhfoDgvulfnTUtnIf[xa[r]scLMcCTUtTOntnfDIulLculVcul[j]Tpeulxa[rul]xa[r]cLgvifC"
+                                        "TUca[r]LsTFOtfDnca[r]Iulc]jmul[jul]VcTOculjmul")
+                solc0_8_4_to_0_8_9 = ("dhfoDgvulfnTUtnIf[xarrscLMcCTUtTOntnfDIulLculVculjjTpeulxarulrulxarrcLgvifCTUca"
+                                      "rrLsTFOtfDncarrIulc]jmuljuljulVcTOculjmul")
+                solc0_7_6_to_0_8_3 = ("dhfoDgvulfnTUtnIf[xarrscLMcCTUtTOntnfDIulLculVculjjTpeulxarulrulxarrcLgvifCTUca"
+                                      "rrLsTOtfDncarrIulc]jmuljuljulVcTOculjmul")
+                solc0_7_2_to_0_7_5 = ("NdhfoDgvulfnTUtnIf[xarrscLMcCTUtTOntnfDIulLculVculjjTpeulxarulrulxarrcLgvifCTUc"
+                                      "arrLsTOtfDncarrIulc]jmuljuljulVcTOculjmulN")
+                solc0_6_7_to_0_7_1 = ("dhfoDgvulfnTUtnIf[xarrscLMcCTUtTOntnfDIulLculVculjjeulxarulrulxarrcLgvifCTUcarr"
+                                      "LsTOtfDncarrIulc]jmuljuljulVcTOculjmul")
+
+                def without_full_inliner(optimizer_steps: str) -> str:
+                    """Take the full inliner out of a Yul optimizer step sequence.
+
+                    The full inliner pulls internal functions into their callers, which erases the autofinders
+                    that internal-function summaries are matched against. It is the letter `i`, and in every
+                    sequence solc ships it appears only inside the trigram `vif`: EquivalentFunctionCombiner,
+                    FullInliner, BlockFlattener, the flattener being there to tidy up after the inliner. Dropping
+                    the middle letter of that trigram removes the inliner and leaves every other pass in place
+                    and in order.
+
+                    Upstream writes the trigram plus its surrounding steps as one line in
+                    OptimiserSettings.h and comments the whole line "Run full inliner", so it is tempting to
+                    drop all of it. On every rung here, taking out `i` alone keeps just as many internal
+                    functions as taking out the whole group, so this is the smaller deviation from what solc
+                    would have run for the same result. Public/CITests/testYulOptimizerStepsInlining.py is
+                    what checks the rewrite still does its job on each compiler.
+                    """
+                    return optimizer_steps.replace("vif", "vf")
 
                 compiler_version = compiler_collector.compiler_version
                 major, minor, patch = compiler_version
@@ -1499,10 +1549,10 @@ class CertoraBuildGenerator:
                     yul_optimizer_steps = solc0_6_7_to_0_7_1
                 elif minor == 7 and 2 <= patch <= 5:
                     yul_optimizer_steps = solc0_7_2_to_0_7_5
-                elif (minor == 7 and 6 <= patch) or (minor == 8 and patch == 0):
-                    yul_optimizer_steps = solc0_7_6_to_0_8_0
-                elif minor == 8 and 1 <= patch <= 9:
-                    yul_optimizer_steps = solc0_8_1_to_0_8_9
+                elif (minor == 7 and 6 <= patch) or (minor == 8 and patch <= 3):
+                    yul_optimizer_steps = solc0_7_6_to_0_8_3
+                elif minor == 8 and 4 <= patch <= 9:
+                    yul_optimizer_steps = solc0_8_4_to_0_8_9
                 elif minor == 8 and 10 <= patch <= 11:
                     yul_optimizer_steps = solc0_8_10_to_0_8_11
                 elif minor == 8 and patch == 12:
@@ -1516,17 +1566,19 @@ class CertoraBuildGenerator:
                 assert yul_optimizer_steps is not None, \
                     'Yul Optimizer steps missing for requested Solidity version. Please contact Certora team.'
 
-                yul_optimizer_steps = standard_replacement(yul_optimizer_steps)
-
-                settings_dict["optimizer"]["details"] = {"inliner": False, "yulDetails": {
-                    "optimizerSteps": yul_optimizer_steps
-                }}
+                yul_optimizer_steps = without_full_inliner(yul_optimizer_steps)
+                assert self.context.yul_optimizer_steps or "i" not in yul_optimizer_steps, \
+                    'Full inliner still present in the Yul optimizer steps. Please contact Certora team.'
+
+                # The Yul steps carry the inlining decision for the via-IR pipeline on every
+                # supported version; `inliner` speaks to the legacy-codegen inliner and exists only
+                # from 0.8.5, so it is added where it is understood and left out where it is not.
+                details: Dict[str, Any] = {"yulDetails": {"optimizerSteps": yul_optimizer_steps}}
+                if self._solc_takes_inliner_detail(compiler_version):
+                    details["inliner"] = False
+                settings_dict["optimizer"]["details"] = details
             elif not self.context.strict_solc_optimizer:
-                compiler_version = compiler_collector.compiler_version
-                major, minor, patch = compiler_version
-                if major != 0:
-                    raise Util.CertoraUserInputError(f"Unrecognized version {major}.{minor}.{patch}")
-                if (minor == 8 and patch >= 5) or (minor > 8):
+                if self._solc_takes_inliner_detail(compiler_collector.compiler_version):
                     settings_dict["optimizer"]["details"] = {"inliner": False}
             if self.context.disable_solc_optimizers is not None:
                 if "details" not in settings_dict["optimizer"]:
@@ -3082,7 +3134,7 @@ class CertoraBuildGenerator:
             # Note we import and don't inline the file's contents since that's how the
             # original file is accessed also in the actual code, and compiling it
             # directly can cause issues.
-            tmp_file.write(f"import \"{original_file}\";\n\n")
+            tmp_file.write(f"import \"{harness_import_path(file_dir, original_file)}\";\n\n")
             rel_path = os.path.relpath(tmp_file.name, Path.cwd())
             tmp_abs_path = Util.abs_posix_path(tmp_file.name)
             # Add the temp file to all map attributes so that map lookups
@@ -3146,7 +3198,7 @@ class CertoraBuildGenerator:
                 current_content = tmp_file.read()
 
                 # Prepare modified content with target import at the beginning
-                rel_target_path = os.path.relpath(target_file, Path.cwd())
+                rel_target_path = harness_import_path(file_dir, target_file)
                 modified_content = f'import "{rel_target_path}";\n{current_content}'
 
                 # Write modified content

{certora_cli-8.19.2 → certora_cli-8.20.2}/certora_cli/CertoraProver/certoraBuildDataClasses.py

@@ -194,6 +194,10 @@ class ContractInSDC:
             "solidityTypes": [x.as_dict() for x in self.types],
             "compilerName": "" if not self.compiler_collector else self.compiler_collector.compiler_name,
             "compilerVersion": self.compiler_version,
+            # Full compiler build identifier from `--version` (e.g.
+            # '0.8.34+commit.80d5c536.Darwin.appleclang'); additive alongside the
+            # triplet-only compilerVersion above. None if unavailable.
+            "compilerVersionFull": None if not self.compiler_collector else self.compiler_collector.compiler_version_full,
             "compilerParameters": None if not self.compiler_parameters else self.compiler_parameters.as_dict(),
             "sourceBytes": None if self.source_bytes is None else self.source_bytes.as_dict(),
             "extensionContracts": [e.as_dict() for e in self.extension_contracts],