certora-cli 8.1.1__tar.gz → 8.3.0__tar.gz

{certora_cli-8.1.1/certora_cli.egg-info → certora_cli-8.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: certora-cli
-Version: 8.1.1
+Version: 8.3.0
 Summary: Runner for the Certora Prover
 Home-page: https://pypi.org/project/certora-cli
 Author: Certora
@@ -39,4 +39,4 @@ Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 
-Commit b03ee33.                    Build and Run scripts for executing the Certora Prover on Solidity smart contracts.
+Commit 3c8a0dd.                    Build and Run scripts for executing the Certora Prover on Solidity smart contracts.

certora_cli-8.3.0/README.md

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

{certora_cli-8.1.1 → certora_cli-8.3.0}/certora_cli/CertoraProver/certoraApp.py

@@ -33,6 +33,9 @@ class EvmApp(EvmAppClass):
 class RustAppClass(CertoraApp):
     pass
 
+class MoveAppClass(CertoraApp):
+    pass
+
 class SolanaApp(RustAppClass):
     attr_class = Attrs.SolanaProverAttributes
 
@@ -45,5 +48,5 @@ class RangerApp(EvmAppClass):
 class ConcordApp(EvmAppClass):
     attr_class = Attrs.ConcordAttributes
 
-class SuiApp(EvmAppClass):
+class SuiApp(MoveAppClass):
     attr_class = Attrs.SuiProverAttributes

{certora_cli-8.1.1 → certora_cli-8.3.0}/certora_cli/CertoraProver/certoraBuild.py

@@ -203,11 +203,18 @@ class PresetImmutableReference(ImmutableReference):
 # this function is Solidity specific.
 # todo: create certoraBuildUtilsSol.py file, where such solidity specific functions will be.
 def generate_finder_body(f: Func, internal_id: int, sym: int, compiler_collector: CompilerCollectorSol,
-                         compressed: bool = False) -> Optional[Tuple[List[int], str]]:
+                         compressed: bool = False,
+                         should_generate_inlining: bool = True) -> Optional[Tuple[List[int], str]]:
     if compressed:
         return generate_compressed_finder(
             f, internal_id, sym, compiler_collector
         )
+    elif not should_generate_inlining:
+        # We should not generate inlining as reported in CERT-9399, only when compressed=False.
+        # used_symbols is being generated the exact same way as in generate_full_finder
+        used_symbols = [i for i in range(len(f.fullArgs))]
+        return used_symbols, ''
+
     else:
         return generate_full_finder(
             f, internal_id, sym, compiler_collector
@@ -403,8 +410,9 @@ def get_modifier_param_type_name(ind: int, def_node: Dict[str, Any], f: Func) ->
 
 def generate_modifier_finder(f: Func, internal_id: int, sym: int,
                              compiler_collector: CompilerCollectorSol, def_node: Dict[str, Any],
-                             compress: bool) -> Optional[Tuple[str, str]]:
-    compressed = generate_finder_body(f, internal_id, sym, compiler_collector, compressed=compress)
+                             compress: bool, should_generate_inlining: bool) -> Optional[Tuple[str, str]]:
+    compressed = generate_finder_body(f, internal_id, sym, compiler_collector, compressed=compress,
+                                      should_generate_inlining=should_generate_inlining)
     if compressed is None:
         return None
     modifier_name = f"logInternal{internal_id}"
@@ -427,9 +435,10 @@ def generate_modifier_finder(f: Func, internal_id: int, sym: int,
         return f'{modifier_name}({",".join(arg_strings)})', modifier_body
 
 
-def generate_inline_finder(f: Func, internal_id: int, sym: int,
-                           compiler_collector: CompilerCollectorSol, should_compress: bool) -> Optional[str]:
-    finder = generate_finder_body(f, internal_id, sym, compiler_collector, compressed=should_compress)
+def generate_inline_finder(f: Func, internal_id: int, sym: int, compiler_collector: CompilerCollectorSol,
+                           should_compress: bool, should_generate_inlining: bool) -> Optional[str]:
+    finder = generate_finder_body(f, internal_id, sym, compiler_collector, compressed=should_compress,
+                                  should_generate_inlining=should_generate_inlining)
     if finder is None:
         return None
     return finder[1]
@@ -2448,6 +2457,19 @@ class CertoraBuildGenerator:
                     # (deprecate this option later)
                     should_compress = self.context.function_finder_mode == Vf.FunctionFinderMode.DEFAULT.name
 
+                if self.context.solc_optimize and self.get_solc_via_ir_value(Path(contract_file)) and \
+                   any(param_name == "" for param_name in f.paramNames):
+                    # As reported in CERT-9399, we should not generate function finder for this edge case
+
+                    instrumentation_logger.warning(f"Failed to generate auto finder for {f.name} @ {f.where()}.")
+                    instrumentation_logger.warning(
+                        "Cannot apply summaries for internal functions with unnamed argument when compiling "
+                        "using solc_optimize and solc_via_ir"
+                    )
+                    should_generate_inlining = False
+                else:
+                    should_generate_inlining = True
+
                 if len(mods) > 0:
                     # we need to add the instrumentation in a modifer because solidity modifiers will (potentially)
                     # appear before any instrumentation we add to the literal source body, which will tank the detection
@@ -2459,8 +2481,10 @@ class CertoraBuildGenerator:
                     # where in the source such modifiers will go. In order to insert a modifier, we have to have at
                     # least one modifier already present, and then insert before the first modifier's location in the
                     # source code
-                    mod_inst = generate_modifier_finder(f, internal_id, function_symbol, sdc.compiler_collector,
-                                                        def_node, compress=should_compress)
+                    mod_inst = generate_modifier_finder(
+                        f, internal_id, function_symbol, sdc.compiler_collector, def_node,
+                        compress=should_compress, should_generate_inlining=should_generate_inlining
+                    )
                     if mod_inst is None:
                         instrumentation_logger.debug(f"Modifier generation for {f.name} @ {f.where()} failed")
                         return None
@@ -2494,8 +2518,8 @@ class CertoraBuildGenerator:
                     per_file_inst[first_mod_offset] = Instrumentation(expected=bytes(modifier_name[0:1], "utf-8"),
                                                                       to_ins=modifier_invocation, mut=InsertBefore())
                 else:
-                    finder_res = generate_inline_finder(f, internal_id, function_symbol,
-                                                        sdc.compiler_collector, should_compress)
+                    finder_res = generate_inline_finder(f, internal_id, function_symbol, sdc.compiler_collector,
+                                                        should_compress, should_generate_inlining)
                     if finder_res is None:
                         instrumentation_logger.debug(f"Generating auto finder for {f.name} @ {f.where()}"
                                                      f" failed, giving up generation")
@@ -2505,7 +2529,7 @@ class CertoraBuildGenerator:
                                                                 mut=InsertAfter())
         return function_finder_by_contract, function_finder_instrumentation
 
-    def add_internal_func_harnesses(self, contract_file: str, sdc: SDC, specCalls: List[str]) -> Optional[Tuple[Dict[str, str], Dict[str, Dict[int, Instrumentation]]]]:
+    def add_internal_func_harnesses(self, contract_file: str, sdc: SDC, spec_calls: List[str]) -> Optional[Tuple[Dict[str, str], Dict[str, Dict[int, Instrumentation]]]]:
         # contract file -> byte offset -> to insert
         harness_function_instrumentation: Dict[str, Dict[int, Instrumentation]] = defaultdict(dict)
         # internal function name -> harness fuction name
@@ -2519,7 +2543,7 @@ class CertoraBuildGenerator:
 
         for c in sdc.contracts:
             for f in c.internal_funcs:
-                if f"{sdc.primary_contract}.{f.name}" not in specCalls:
+                if f"{sdc.primary_contract}.{f.name}" not in spec_calls:
                     continue
 
                 if f.fromLib:
@@ -2669,14 +2693,14 @@ class CertoraBuildGenerator:
     def build(self, certora_verify_generator: CertoraVerifyGenerator) -> None:
         context = self.context
 
-        specCalls: List[str] = []
+        spec_calls: List[str] = []
         if context.verify and not context.disallow_internal_function_calls:
             with tempfile.NamedTemporaryFile("r", dir=Util.get_build_dir()) as tmp_file:
                 try:
                     Ctx.run_local_spec_check(False, context, ["-listCalls",  tmp_file.name], print_errors=False)
-                    specCalls = tmp_file.read().split("\n")
+                    spec_calls = tmp_file.read().split("\n")
                 except Exception as e:
-                    instrumentation_logger.warning(f"Failed to get calls from spec\n{e}")
+                    instrumentation_logger.debug(f"Failed to get calls from spec\n{e}")
 
         self.context.remappings = []
         for i, build_arg_contract_file in enumerate(sorted(self.input_config.sorted_files)):
@@ -2729,7 +2753,7 @@ class CertoraBuildGenerator:
                 # We start by trying to instrument _all_ finders, both autofinders and source finders
                 added_finders, all_finders_success, src_finders_gen_success, post_backup_dir = self.finders_compilation_round(
                     build_arg_contract_file, i, ignore_patterns, path_for_compiler_collector_file, pre_backup_dir,
-                    sdc_pre_finders, not context.disable_source_finders, specCalls)
+                    sdc_pre_finders, not context.disable_source_finders, spec_calls)
 
                 # we could have a case where source finders failed but regular finders succeeded.
                 # e.g. if we processed the AST wrong and skipped source finders generation
@@ -2741,7 +2765,7 @@ class CertoraBuildGenerator:
                     # let's try just the function autofinders
                     added_finders, function_autofinder_success, _, post_backup_dir = self.finders_compilation_round(
                         build_arg_contract_file, i, ignore_patterns, path_for_compiler_collector_file, pre_backup_dir,
-                        sdc_pre_finders, False, specCalls)
+                        sdc_pre_finders, False, spec_calls)
 
                     if not function_autofinder_success:
                         self.auto_finders_failed = True
@@ -2825,7 +2849,7 @@ class CertoraBuildGenerator:
             self.handle_erc7201_annotations()
         self.handle_storage_extension_harnesses()
 
-    def extract_slayout(self, original_file: str, ns_storage: Set[NameSpacedStorage], compiler_version: str) -> NewStorageInfo:
+    def extract_slayout(self, original_file: str, ns_storage: Set[NameSpacedStorage], compiler_version: str, target_file: str) -> NewStorageInfo:
         """
         Given a file containing a contract with namespaced storage, extract the storage information
         corresponding to the namespaced types.
@@ -2869,8 +2893,8 @@ class CertoraBuildGenerator:
             abs_path = Util.abs_posix_path(tmp_file.name)
             self.context.file_to_contract[abs_path] = {harness_name}
 
-            try:
-                # Compile & fetch the raw storage_layout
+            def attempt_compilation() -> NewStorageInfo:
+                """Helper function to compile and extract layout"""
                 compile_idx = storageExtension.get_next_file_index(self.file_to_sdc_name)
                 sdcs = self.collect_for_file(tmp_file.name, compile_idx, CompilerLangSol(), Path.cwd(), Util.abs_posix_path(tmp_file.name), None)
                 if not sdcs:
@@ -2879,12 +2903,38 @@ class CertoraBuildGenerator:
 
                 # Remap each slot according to the ERC-7201 namespace
                 remapped_fields = storageExtension.remapped_fields_from_layout(layout, var_to_slot)
-
                 return (remapped_fields, layout.get('types', {}))
 
+            # First attempt with original content
+            try:
+                return attempt_compilation()
             except Exception as e:
-                build_logger.error(f"Error extracting storage layout for {original_file}: {str(e)}")
-                raise
+                if not target_file:
+                    build_logger.error(f"Error extracting storage layout for {original_file}: {str(e)}")
+                    raise
+
+                # Retry with target file import
+                build_logger.info("First attempt failed, retrying with import of target file")
+
+                # Read current content
+                tmp_file.seek(0)
+                current_content = tmp_file.read()
+
+                # Prepare modified content with target import at the beginning
+                rel_target_path = os.path.relpath(target_file, Path.cwd())
+                modified_content = f'import "{rel_target_path}";\n{current_content}'
+
+                # Write modified content
+                tmp_file.seek(0)
+                tmp_file.truncate()
+                tmp_file.write(modified_content)
+                tmp_file.flush()
+
+                try:
+                    return attempt_compilation()
+                except Exception as retry_e:
+                    build_logger.error(f"Retry also failed for {original_file}: {str(retry_e)}")
+                    raise retry_e
             finally:
                 # Delete the key from the context
                 self.context.file_to_contract.pop(abs_path, None)
@@ -2933,7 +2983,8 @@ class CertoraBuildGenerator:
 
                     # Now that we have all the storage layout information, extract it once
                     slayouts[key] = self.extract_slayout(imported_file, ns_storage,
-                                                         get_relevant_compiler(Path(target_file), self.context))
+                                                         get_relevant_compiler(Path(target_file), self.context),
+                                                         target_file)
 
         if self.context.test == str(Util.TestValue.STORAGE_EXTENSION_LAYOUT):
             raise Util.TestResultsReady(slayouts)
@@ -3089,12 +3140,12 @@ class CertoraBuildGenerator:
                                   pre_backup_dir: Path,
                                   sdc_pre_finders: List[SDC],
                                   with_source_finders: bool,
-                                  specCalls: List[str]) -> Tuple[
+                                  spec_calls: List[str]) -> Tuple[
             List[Tuple[Dict[str, InternalFunc], Dict[str, UnspecializedSourceFinder], Dict[str, str], SDC]], bool, bool, Path]:
         added_finders_to_sdc, finders_compilation_success, source_finders_gen_success = \
             self.instrument_auto_finders(
                 build_arg_contract_file, i, sdc_pre_finders,
-                path_for_compiler_collector_file, with_source_finders, specCalls)
+                path_for_compiler_collector_file, with_source_finders, spec_calls)
         # successful or not, we backup current .certora_sources for either debuggability, or for availability
         # of sources.
         post_backup_dir = self.get_fresh_backupdir(Util.POST_AUTOFINDER_BACKUP_DIR)
@@ -3167,7 +3218,7 @@ class CertoraBuildGenerator:
                                 sdc_pre_finders: List[SDC],
                                 path_for_compiler_collector_file: str,
                                 instrument_source_finders: bool,
-                                specCalls: List[str]) -> Tuple[
+                                spec_calls: List[str]) -> Tuple[
             List[Tuple[Dict[str, InternalFunc], Dict[str, UnspecializedSourceFinder], Dict[str, str], SDC]], bool, bool]:
 
         # initialization
@@ -3188,7 +3239,7 @@ class CertoraBuildGenerator:
 
         added_internal_function_harnesses: Dict[str, str] = {}
         if not self.context.disallow_internal_function_calls:
-            added_internal_func_harness_tuple = self.add_internal_func_harnesses(build_arg_contract_file, sdc_pre_finder, specCalls)
+            added_internal_func_harness_tuple = self.add_internal_func_harnesses(build_arg_contract_file, sdc_pre_finder, spec_calls)
             if added_internal_func_harness_tuple:
                 instr = CertoraBuildGenerator.merge_dicts_instrumentation(function_instr, added_internal_func_harness_tuple[1])
                 added_internal_function_harnesses = added_internal_func_harness_tuple[0]
@@ -3793,6 +3844,14 @@ def build_source_tree(sources: Set[Path], context: CertoraContext, overwrite: bo
     cwd_file_path.parent.mkdir(parents=True, exist_ok=True)
     cwd_file_path.touch()
 
+    # copy context.forge_remappings to remappings.txt in the source tree, overwriting any existing remappings.txt
+    forge_remappings = getattr(context, 'forge_remappings', None)
+    if forge_remappings:
+        remappings_file_path = Util.get_certora_sources_dir() / context.cwd_rel_in_sources / Util.REMAPPINGS_FILE
+        with remappings_file_path.open("w") as remap_file:
+            for remap in context.forge_remappings:
+                remap_file.write(remap + "\n")
+
     #  the empty file .project_directory is written in the source tree to denote the project directory
     rust_proj_dir = getattr(context, 'rust_project_directory', None)
     if rust_proj_dir:
@@ -3887,21 +3946,19 @@ def build_from_scratch(context: CertoraContext,
 def build_from_cache_or_scratch(context: CertoraContext,
                                 certora_build_generator: CertoraBuildGenerator,
                                 certora_verify_generator: CertoraVerifyGenerator) \
-        -> Tuple[bool, bool, CachedFiles]:
+        -> Tuple[bool, CachedFiles]:
     """
     Builds either from cache (fast path) or from scratch (slow path)
-    @returns 1st tuple element whether there was a cache hit or not
-    @returns 2nd tuple element whether the build cache is enabled and applicable
-    @returns 3rd tuple element the artifacts of the build to potentially be cached
+    @returns 1st tuple element whether the cache should be saved
+    @returns 2nd tuple element the artifacts of the build to potentially be cached
     """
-    cache_hit = False
     cached_files: Optional[CachedFiles] = None
 
     if not context.build_cache:
         cached_files = build_from_scratch(context, certora_build_generator,
                                           certora_verify_generator,
                                           False)
-        return cache_hit, False, cached_files
+        return False, cached_files
 
     build_cache_applicable = CertoraBuildCacheManager.cache_is_applicable(context)
 
@@ -3912,34 +3969,60 @@ def build_from_cache_or_scratch(context: CertoraContext,
         cached_files = build_from_scratch(context, certora_build_generator,
                                           certora_verify_generator,
                                           False)
-        return cache_hit, False, cached_files
+        return False, cached_files
 
     cached_files = CertoraBuildCacheManager.build_from_cache(context)
-    # if no match, will rebuild from scratch
-    if cached_files is not None:
-        # write to .certora_build.json
-        shutil.copyfile(cached_files.certora_build_file, Util.get_certora_build_file())
-        # write build_output_props file
-        shutil.copyfile(cached_files.build_output_props_file, Util.get_built_output_props_file())
-        # write build_cache indicator file
-        with open(Util.get_build_cache_indicator_file(), "w+") as indicator_handle:
-            json.dump({"build_cache_hit": True}, indicator_handle)
-        # write in sources all the additional paths found
-        for p in cached_files.path_with_additional_included_files.glob("*"):
-            if p.is_dir():
-                Util.safe_copy_folder(p,
-                                      Util.get_certora_sources_dir() / p.name,
-                                      shutil.ignore_patterns())
-            else:
-                shutil.copyfile(p, Util.get_certora_sources_dir() / p.name)
-        cache_hit = True
-    else:
-        # rebuild
+
+    if not cached_files:
+        # No match, rebuild
         cached_files = build_from_scratch(context, certora_build_generator,
                                           certora_verify_generator,
                                           True)
+        return True, cached_files
 
-    return cache_hit, True, cached_files
+    # Cache hit!
+
+    # write to .certora_build.json
+    # This must happen _before_ searching for new internal function calls - the typechecker needs this file.
+    shutil.copyfile(cached_files.certora_build_file, Util.get_certora_build_file())
+
+    # Check whether there are any new internal function calls in the spec file - if there are then we need to build
+    # from scratch in order to create the relevant harness function.
+    if context.verify and not context.disallow_internal_function_calls:
+        with tempfile.NamedTemporaryFile("r", dir=Util.get_build_dir()) as tmp_file:
+            internal_calls = []
+            try:
+                Ctx.run_local_spec_check(True, context, ["-listCalls",  tmp_file.name], print_errors=False)
+                output = tmp_file.read().strip()
+                if output:
+                    internal_calls = output.split("\n")
+            except Exception as e:
+                instrumentation_logger.debug(f"Failed to get calls from spec\n{e}")
+
+            if internal_calls:
+                build_logger.info("Found new internal calls in the spec file, need to recompile anyway")
+                # There are new internal calls in the spec, we need to rebuild in order to generate the
+                # external harness functions for them.
+                cached_files = build_from_scratch(context, certora_build_generator,
+                                                  certora_verify_generator,
+                                                  True)
+                return True, cached_files
+
+    # write build_output_props file
+    shutil.copyfile(cached_files.build_output_props_file, Util.get_built_output_props_file())
+    # write build_cache indicator file
+    with open(Util.get_build_cache_indicator_file(), "w+") as indicator_handle:
+        json.dump({"build_cache_hit": True}, indicator_handle)
+    # write in sources all the additional paths found
+    for p in cached_files.path_with_additional_included_files.glob("*"):
+        if p.is_dir():
+            Util.safe_copy_folder(p,
+                                  Util.get_certora_sources_dir() / p.name,
+                                  shutil.ignore_patterns())
+        else:
+            shutil.copyfile(p, Util.get_certora_sources_dir() / p.name)
+
+    return False, cached_files
 
 
 def build(context: CertoraContext, ignore_spec_syntax_check: bool = False) -> None:
@@ -3965,13 +4048,10 @@ def build(context: CertoraContext, ignore_spec_syntax_check: bool = False) -> No
         if Cv.mode_has_spec_file(context) and not context.build_only and not ignore_spec_syntax_check:
             if Ctx.should_run_local_speck_check(context):
                 Ctx.run_local_spec_check(False, context)
-            else:
-                build_logger.warning(
-                    "Local checks of CVL specification files disabled. It is recommended to enable the checks.")
 
-        cache_hit, build_cache_enabled, cached_files = build_from_cache_or_scratch(context,
-                                                                                   certora_build_generator,
-                                                                                   certora_verify_generator)
+        should_save_cache, cached_files = build_from_cache_or_scratch(context,
+                                                                      certora_build_generator,
+                                                                      certora_verify_generator)
 
         # avoid running the same test over and over again for each split run, context.split_rules is true only for
         # the first run and is set to [] for split runs
@@ -3990,7 +4070,7 @@ def build(context: CertoraContext, ignore_spec_syntax_check: bool = False) -> No
             build_logger.debug("build_source_tree failed", exc_info=e)
 
         # save in build cache
-        if not cache_hit and build_cache_enabled and cached_files.may_store_in_build_cache:
+        if should_save_cache and cached_files.may_store_in_build_cache:
             CertoraBuildCacheManager.save_build_cache(context, cached_files)
 
         certora_verify_generator.update_certora_verify_struct(True)

certora_cli-8.3.0/certora_cli/CertoraProver/certoraBuildSui.py

@@ -0,0 +1,112 @@
+#     The Certora Prover
+#     Copyright (C) 2025  Certora Ltd.
+#
+#     This program is free software: you can redistribute it and/or modify
+#     it under the terms of the GNU General Public License as published by
+#     the Free Software Foundation, version 3 of the License.
+#
+#     This program is distributed in the hope that it will be useful,
+#     but WITHOUT ANY WARRANTY; without even the implied warranty of
+#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#     GNU General Public License for more details.
+#
+#     You should have received a copy of the GNU General Public License
+#     along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+scripts_dir_path = Path(__file__).parent.parent.resolve()  # containing directory
+sys.path.insert(0, str(scripts_dir_path))
+
+import shutil
+import time
+import logging
+from pathlib import Path
+from typing import Set, Dict
+
+from CertoraProver.certoraBuild import build_source_tree
+from CertoraProver.certoraContextClass import CertoraContext
+from Shared import certoraUtils as Util
+
+
+log = logging.getLogger(__name__)
+
+
+def build_sui_project(context: CertoraContext, timings: Dict) -> None:
+    """
+    Compile the Sui artefact and record elapsed time in *timings*.
+
+    Args:
+        context: The CertoraContext object containing the configuration.
+        timings: A dictionary to store timing information.
+    """
+    log.debug("Build Sui target")
+    start = time.perf_counter()
+    set_sui_build_directory(context)
+    timings["buildTime"] = round(time.perf_counter() - start, 4)
+    if context.test == str(Util.TestValue.AFTER_BUILD):
+        raise Util.TestResultsReady(context)
+
+
+def set_sui_build_directory(context: CertoraContext) -> None:
+    sources: Set[Path] = set()
+
+    # If no move_path was specified, try to build the package
+    if not context.move_path:
+        move_toml_file = Util.find_file_in_parents("Move.toml")
+        if not move_toml_file:
+            raise Util.CertoraUserInputError("Could not find Move.toml, and no move_path was specified.")
+        sources.add(move_toml_file.absolute())
+        run_sui_build(context, move_toml_file.parent)
+
+    assert context.move_path, "expecting move_path to be set after build"
+    move_dir = Path(context.move_path)
+    assert move_dir.exists(), f"Output path '{move_dir}' does not exist"
+    assert move_dir.is_dir(), f"Output path '{move_dir}' is not a directory"
+
+    # Add all source files.  We get these from the Sui build output, because it includes dependencies as well, and is
+    # available even if we didn't run the build ourselves.
+    sources.update(move_dir.rglob("*.move"))
+
+    # Add conf file if it exists
+    if getattr(context, 'conf_file', None) and Path(context.conf_file).exists():
+        sources.add(Path(context.conf_file).absolute())
+
+    # Copy the binary modules and source maps
+    shutil.copytree(move_dir,
+                    Util.get_build_dir() / move_dir.name,
+                    ignore=shutil.ignore_patterns('*.move'))
+
+    try:
+        # Create generators
+        build_source_tree(sources, context)
+
+    except Exception as e:
+        raise Util.CertoraUserInputError(f"Collecting build files failed with the exception: {e}")
+
+def run_sui_build(context: CertoraContext, package_dir: Path) -> None:
+    assert not context.move_path, "run_sui_build: expecting move_path to be empty"
+
+    build_cmd = ["sui", "move", "build", "--test", "--path", str(package_dir)]
+
+    try:
+        build_cmd_text = ' '.join(build_cmd)
+        log.info(f"Building by calling `{build_cmd_text}`")
+        result = subprocess.run(build_cmd, capture_output=False)
+
+        # Check if the script executed successfully
+        if result.returncode != 0:
+            raise Util.CertoraUserInputError(f"Error running `{build_cmd_text}`")
+
+        context.move_path = str(package_dir / "build")
+
+    except Util.TestResultsReady as e:
+        raise e
+    except Util.CertoraUserInputError as e:
+        raise e
+    except Exception as e:
+        raise Util.CertoraUserInputError(f"An unexpected error occurred: {e}")

{certora_cli-8.1.1 → certora_cli-8.3.0}/certora_cli/CertoraProver/certoraConfigIO.py

@@ -111,6 +111,8 @@ def handle_override_base_config(context: CertoraContext) -> None:
             if hasattr(context, attr):
                 value = getattr(context, attr, False)
                 if not value:
+                    if attr in context.conf_file_attr and value is False:
+                        continue  # skip override if a boolean attribute was explicitly set to False in the conf file
                     setattr(context, attr, override_base_config_attrs.get(attr))
             else:
                 raise Util.CertoraUserInputError(f"{attr} appears in the base conf file {context.override_base_config} but is not a known attribute.")

{certora_cli-8.1.1 → certora_cli-8.3.0}/certora_cli/CertoraProver/certoraContext.py

@@ -523,7 +523,15 @@ def __rename_key(context: CertoraContext, old_key: str, new_key: str) -> None:
 
 
 def should_run_local_speck_check(context: CertoraContext) -> bool:
-    return not (context.disable_local_typechecking or Util.is_ci_or_git_action())
+    output = context.compilation_steps_only or not (context.disable_local_typechecking or Util.is_ci_or_git_action())
+    if not output:
+        if context.disable_local_typechecking:
+            context_logger.warning(
+                "Local checks of CVL specification files disabled. It is recommended to enable the checks."
+            )
+        else:
+            context_logger.info("Local checks of CVL specification files skipped in CI and will run remotely.")
+    return output
 
 
 def run_typechecker(typechecker_name: str, with_typechecking: bool, args: List[str], print_errors: bool) -> None:
@@ -550,18 +558,13 @@ def run_typechecker(typechecker_name: str, with_typechecking: bool, args: List[s
     context_logger.debug(f"typechecking cmd: {' '.join(cmd_str_list)}")
 
     exit_code = Util.run_jar_cmd(cmd_str_list, False,
-                                 custom_error_message="Failed to run Certora Prover locally. Please check the errors "
-                                                      "below for problems in the specifications (.spec files) or the "
-                                                      "prover_args defined in the .conf file.",
+                                 custom_error_message="Failed to run Certora Prover typechecker locally.\n"
+                                                      "Please check the errors below for problems in the specifications"
+                                                      " (.spec files) or the prover_args defined in the .conf file.",
                                  logger_topic="type_check",
                                  print_err=print_errors)
     if exit_code != 0:
-        raise Util.CertoraUserInputError(
-            "CVL syntax or type check failed.\n Please fix the issue. "
-            "Using --disable_local_typechecking to skip this check is strongly discouraged, "
-            "as simple syntax errors will only be detected during the cloud run."
-            "with --disable_local_typechecking is not recommended is not recommended as "
-            "simple syntax failures will be visible only on the cloud run.")
+        raise Util.CertoraUserInputError("CVL syntax or type check failed, please fix the issue.")
 
 
 def run_local_spec_check(with_typechecking: bool, context: CertoraContext, extra_args: List[str] = list(), print_errors: bool = True) -> None: