certora-cli-beta-mirror 7.30.1__py3-none-any.whl → 8.0.0__py3-none-any.whl

certora_cli/CertoraProver/Compiler/CompilerCollectorFactory.py

@@ -25,8 +25,9 @@ from CertoraProver.Compiler.CompilerCollector import CompilerLang, CompilerColle
 from CertoraProver.Compiler.CompilerCollectorSol import CompilerCollectorSol, CompilerLangSol
 from CertoraProver.Compiler.CompilerCollectorYul import CompilerLangYul, CompilerCollectorYul
 from CertoraProver.Compiler.CompilerCollectorVy import CompilerCollectorVy, CompilerLangVy
-from Shared.certoraUtils import match_path_to_mapping_key, remove_file, get_certora_config_dir
+from Shared.certoraUtils import remove_file, get_certora_config_dir
 from CertoraProver.certoraContextClass import CertoraContext
+import CertoraProver.certoraContext as Ctx
 
 # logger for running the Solidity compiler and reporting any errors it emits
 compiler_logger = logging.getLogger("compiler")
@@ -42,8 +43,16 @@ def get_relevant_compiler(contract_file_path: Path, context: CertoraContext) ->
 
     if contract_file_path.is_absolute():
         contract_file_path = Path(os.path.relpath(contract_file_path, Path.cwd()))
+
+    # If the contract file is in the sources directory, we want to use the relative path from the "cwd" in the source tree.
+    if Util.get_certora_sources_dir() in contract_file_path.parents:
+        cwd_in_source = Util.get_certora_sources_dir() / context.cwd_rel_in_sources
+        contract_file_path = Path(os.path.relpath(contract_file_path, cwd_in_source))
+
     if context.compiler_map:
-        match = match_path_to_mapping_key(contract_file_path, context.compiler_map)
+        match = Ctx.get_map_attribute_value(context, contract_file_path, 'compiler')
+        assert isinstance(match, str), (f"In the attribute compiler_map, {contract_file_path} expected to be matched "
+                                        f"to a string, {match} is of type {type(match)} not a string")
         if match:
             return match
         else:

certora_cli/CertoraProver/certoraBuild.py

@@ -39,8 +39,6 @@ from CertoraProver.certoraSourceFinders import add_source_finders
 from CertoraProver.certoraVerifyGenerator import CertoraVerifyGenerator
 from CertoraProver.certoraContractFuncs import Func, InternalFunc, STATEMUT, SourceBytes
 
-from Shared.certoraUtils import is_relative_to
-
 scripts_dir_path = Path(__file__).parent.parent.resolve()  # containing directory
 sys.path.insert(0, str(scripts_dir_path))
 from CertoraProver.Compiler.CompilerCollector import CompilerLang, CompilerCollector
@@ -450,8 +448,12 @@ def convert_pathname_to_posix(json_dict: Dict[str, Any], entry: str, smart_contr
             if path_obj.is_file():
                 json_dict_posix_paths[path_obj.as_posix()] = json_dict[entry][file_path]
             else:
-                fatal_error(compiler_logger, f"The path of the source file {file_path}"
-                                             f"in the standard json file {json_dict} does not exist")
+                json_dict_str = str(json_dict)
+                # protecting against long strings
+                if len(json_dict_str) > 200:
+                    json_dict_str = json_dict_str[:200] + '...'
+                fatal_error(compiler_logger, f"The path of the source file {file_path} "
+                                             f"in the standard json file does not exist!\n{json_dict_str} ")
         json_dict[entry] = json_dict_posix_paths
 
 
@@ -1361,46 +1363,48 @@ class CertoraBuildGenerator:
 
         return bytecode
 
-    def _handle_via_ir(self, contract_file_path: str, settings_dict: Dict[str, Any]) -> None:
-        if not self.context.solc_via_ir_map and not self.context.solc_via_ir:
-            return
-        if self.context.solc_via_ir_map:
-            match = Util.match_path_to_mapping_key(Path(contract_file_path), self.context.solc_via_ir_map)
-            if match:
-                settings_dict["viaIR"] = match
-        elif self.context.solc_via_ir:
+    def get_solc_via_ir_value(self, contract_file_path: Path) -> bool:
+        match = Ctx.get_map_attribute_value(self.context, contract_file_path, 'solc_via_ir')
+        assert isinstance(match, (bool, type(None))), f"Expected solc_via_ir to be bool or None, got {type(match)}"
+        return bool(match)
+
+    def get_solc_evm_version_value(self, contract_file_path: Path) -> Optional[str]:
+        match = Ctx.get_map_attribute_value(self.context, contract_file_path, 'solc_evm_version')
+        assert isinstance(match, (str, type(None))), f"Expected solc_evm_version to be string or None, got {type(match)}"
+        return match
+
+    def get_solc_optimize_value(self, contract_file_path: Path) -> Optional[str]:
+        match = Ctx.get_map_attribute_value(self.context, contract_file_path, 'solc_optimize')
+        assert isinstance(match, (str, type(None))), f"Expected solc_optimize to be string or None, got {type(match)}"
+        return match
+
+    def _handle_via_ir(self, contract_file_path: Path, settings_dict: Dict[str, Any]) -> None:
+        if self.get_solc_via_ir_value(contract_file_path):
             settings_dict["viaIR"] = True
 
-    def _handle_evm_version(self, contract_file_path: str, settings_dict: Dict[str, Any]) -> None:
-        if self.context.solc_evm_version_map:
-            match = Util.match_path_to_mapping_key(Path(contract_file_path), self.context.solc_evm_version_map)
-            if match:
-                settings_dict["evmVersion"] = match
-        elif self.context.solc_evm_version:
-            settings_dict["evmVersion"] = self.context.solc_evm_version
+    def _handle_evm_version(self, contract_file_path: Path, settings_dict: Dict[str, Any]) -> None:
+        match = self.get_solc_evm_version_value(contract_file_path)
+        if match:
+            settings_dict["evmVersion"] = match
 
-    def _handle_optimize(self, contract_file_path: str, settings_dict: Dict[str, Any],
+    def _handle_optimize(self, contract_file_path: Path, settings_dict: Dict[str, Any],
                          compiler_collector: CompilerCollector) -> None:
         """
         @param contract_file_path: the contract that we are working on
         @param settings_dict: data structure for sending to the solc compiler
         """
-        if self.context.solc_optimize_map:
-            match = Util.match_path_to_mapping_key(Path(contract_file_path), self.context.solc_optimize_map)
-            if match and int(match) > 0:
-                settings_dict["optimizer"] = {"enabled": True}
-                settings_dict["optimizer"]['runs'] = int(match)
-        elif self.context.solc_optimize:
+        match = self.get_solc_optimize_value(contract_file_path)
+        if match:
             settings_dict["optimizer"] = {"enabled": True}
-            if int(self.context.solc_optimize) > 0:
-                settings_dict["optimizer"]['runs'] = int(self.context.solc_optimize)
+            if int(match) > 0:
+                settings_dict["optimizer"]['runs'] = int(match)
 
         # if optimizer is true, we should also define settings_dict["optimizer"]["details"]
         # for both optimize map and optimize
         optimizer = settings_dict.get("optimizer")
         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.context.solc_via_ir:
+            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_26_to_0_8_30 = ("dhfoDgvulfnTUtnIfxa[r]EscLMVcul[j]Trpeulxa[r]cLCTUca[r]LSsTFOtfDnca[r]" +
@@ -1426,13 +1430,18 @@ class CertoraBuildGenerator:
                 compiler_version = compiler_collector.compiler_version
                 major, minor, patch = compiler_version
 
-                err_msg = "--finder_friendly_optimizer option supports solc versions 0.6.7 - 0.8.25 only, " \
-                          f"got {major}.{minor}.{patch}"
+                err_msg = \
+                    f"Unsupported solc version {major}.{minor}.{patch} for `solc_via_ir`. " \
+                    f"Supported versions: 0.6.7 – 0.8.25.\n" \
+                    f"Use `solc_via_ir_map` to disable `solc_via_ir` for specific files with older compiler versions."
+
                 yul_optimizer_steps = None
                 if major != 0:
                     raise Util.CertoraUserInputError(err_msg)
                 elif minor < 6 or (minor == 6 and patch < 7):
                     raise Util.CertoraUserInputError(err_msg)
+                elif self.context.yul_optimizer_steps:
+                    yul_optimizer_steps = self.context.yul_optimizer_steps
                 elif (minor == 6 and patch >= 7) or (minor == 7 and 0 <= patch <= 1):
                     yul_optimizer_steps = solc0_6_7_to_0_7_1
                 elif minor == 7 and 2 <= patch <= 5:
@@ -1470,7 +1479,7 @@ class CertoraBuildGenerator:
                 for opt_pass in self.context.disable_solc_optimizers:
                     settings_dict["optimizer"]["details"][opt_pass] = False
 
-    def _fill_codegen_related_options(self, contract_file_path: str, settings_dict: Dict[str, Any],
+    def _fill_codegen_related_options(self, contract_file_path: Path, settings_dict: Dict[str, Any],
                                       compiler_collector: CompilerCollector) -> None:
         """
         Fills options that control how we call solc and affect the bytecode in some way
@@ -1551,7 +1560,7 @@ class CertoraBuildGenerator:
                 }
             }
 
-        self._fill_codegen_related_options(contract_file_as_provided, settings_dict, compiler_collector)
+        self._fill_codegen_related_options(Path(contract_file_as_provided), settings_dict, compiler_collector)
 
         result_dict = {"language": compiler_collector_lang.name, "sources": sources_dict, "settings": settings_dict}
         # debug_print("Standard json input")
@@ -2286,7 +2295,7 @@ class CertoraBuildGenerator:
 
         if compiler_lang == CompilerLangSol():
             settings_dict: Dict[str, Any] = {}
-            self._fill_codegen_related_options(build_arg_contract_file, settings_dict,
+            self._fill_codegen_related_options(Path(build_arg_contract_file), settings_dict,
                                                compiler_collector_for_contract_file)
             solc_optimizer_on, solc_optimizer_runs = self.solc_setting_optimizer_runs(settings_dict)
             solc_via_ir = self.solc_setting_via_ir(settings_dict)
@@ -2416,7 +2425,7 @@ class CertoraBuildGenerator:
                 # if no function finder mode set, determine based on viaIR enabled or not:
                 if self.context.function_finder_mode is None:
                     # in via-ir, should not compress
-                    if self.context.solc_via_ir:
+                    if self.get_solc_via_ir_value(Path(contract_file)):
                         should_compress = False
                     else:
                         should_compress = True
@@ -2682,7 +2691,7 @@ class CertoraBuildGenerator:
             self.handle_erc7201_annotations()
         self.handle_storage_extension_harnesses()
 
-    def extract_slayout(self, original_file: str, ns_storage: Set[NameSpacedStorage]) -> NewStorageInfo:
+    def extract_slayout(self, original_file: str, ns_storage: Set[NameSpacedStorage], compiler_version: str) -> NewStorageInfo:
         """
         Given a file containing a contract with namespaced storage, extract the storage information
         corresponding to the namespaced types.
@@ -2707,7 +2716,9 @@ class CertoraBuildGenerator:
             # 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")
-
+            rel_path = os.path.relpath(tmp_file.name, Path.cwd())
+            if self.context.compiler_map:
+                self.context.compiler_map.update({rel_path: compiler_version}, last=False)
             # Write the harness contract with dummy fields for each namespaced storage
             var_to_slot = storageExtension.write_harness_contract(tmp_file, harness_name, ns_storage)
             tmp_file.flush()
@@ -2720,13 +2731,6 @@ class CertoraBuildGenerator:
                     build_dir / f"{Path(original_file).stem}_storage_extension.sol"
                 )
 
-            # Add harness to compiler map
-            storageExtension.add_harness_to_compiler_map(
-                original_file,
-                tmp_file,
-                self.context
-            )
-
             # normalize the path exactly the way collect_for_file expects it:
             abs_path = Util.abs_posix_path(tmp_file.name)
             self.context.file_to_contract[abs_path] = {harness_name}
@@ -2794,7 +2798,8 @@ class CertoraBuildGenerator:
                         continue
 
                     # Now that we have all the storage layout information, extract it once
-                    slayouts[key] = self.extract_slayout(imported_file, ns_storage)
+                    slayouts[key] = self.extract_slayout(imported_file, ns_storage,
+                                                         get_relevant_compiler(Path(target_file), self.context))
 
         if self.context.test == str(Util.TestValue.STORAGE_EXTENSION_LAYOUT):
             raise Util.TestResultsReady(slayouts)
@@ -3575,7 +3580,11 @@ class CertoraBuildGenerator:
         return sources
 
     def __del__(self) -> None:
-        self.cleanup()
+        try:
+            self.cleanup()
+        except ImportError:
+            # Avoiding Python interpreter shutdown exceptions which are safe to ignore
+            pass
 
 
 # make sure each source file exists and its path is in absolute format
@@ -3614,7 +3623,7 @@ def build_source_tree(sources: Set[Path], context: CertoraContext, overwrite: bo
 
         try:
             if overwrite:
-                # expecting target path to exist.
+                # expecting the target path to exist.
                 if target_path.exists():
                     build_logger.debug(f"Overwriting {target_path} by copying from {source_path}")
                 else:
@@ -3632,7 +3641,7 @@ 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()
 
-    #  the empty file .project_directory is written in the source tree to denote the projecct directory
+    #  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:
         proj_dir_parent_relative = os.path.relpath(rust_proj_dir, os.getcwd())
@@ -3683,13 +3692,14 @@ def build_from_scratch(context: CertoraContext,
 
         # add to cache also source files that were found in the SDCs (e.g., storage extensions)
         paths_set = sdc.all_contract_files
-        for p in context.files:
-            paths_set.add(Path(p).absolute())
+        for f in context.files:
+            path = f.split(':')[0]  # `f` is either 'path/to/file.sol' or 'path/to/file.sol:ContractName'
+            paths_set.add(Path(path).absolute())
 
         # the contract files in SDCs are relative to .certora_sources. Which isn't good for us here.
         # Need to be relative to original paths
         for f in paths_set:
-            if is_relative_to(f, absolute_sources_dir):
+            if f.is_relative_to(absolute_sources_dir):
                 rel_f = f.relative_to(absolute_sources_dir)
             else:
                 # may be an absolute path already outside .certora_sources, so we can keep it.
@@ -3724,8 +3734,7 @@ def build_from_scratch(context: CertoraContext,
 
 def build_from_cache_or_scratch(context: CertoraContext,
                                 certora_build_generator: CertoraBuildGenerator,
-                                certora_verify_generator: CertoraVerifyGenerator,
-                                certora_build_cache_manager: CertoraBuildCacheManager) \
+                                certora_verify_generator: CertoraVerifyGenerator) \
         -> Tuple[bool, bool, CachedFiles]:
     """
     Builds either from cache (fast path) or from scratch (slow path)
@@ -3742,10 +3751,10 @@ def build_from_cache_or_scratch(context: CertoraContext,
                                           False)
         return cache_hit, False, cached_files
 
-    build_cache_applicable = certora_build_cache_manager.cache_is_applicable(context)
+    build_cache_applicable = CertoraBuildCacheManager.cache_is_applicable(context)
 
     if not build_cache_applicable:
-        build_cache_disabling_options = certora_build_cache_manager.cache_disabling_options(context)
+        build_cache_disabling_options = CertoraBuildCacheManager.cache_disabling_options(context)
         build_logger.warning("Requested to enable the build cache, but the build cache is not applicable "
                              f"to this run because of the given options: {build_cache_disabling_options}")
         cached_files = build_from_scratch(context, certora_build_generator,
@@ -3753,7 +3762,7 @@ def build_from_cache_or_scratch(context: CertoraContext,
                                           False)
         return cache_hit, False, cached_files
 
-    cached_files = certora_build_cache_manager.build_from_cache(context)
+    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
@@ -3792,7 +3801,7 @@ def build(context: CertoraContext, ignore_spec_syntax_check: bool = False) -> No
 
     try:
         input_config = InputConfig(context)
-
+        context.main_cache_key = CertoraBuildCacheManager.get_main_cache_key(context)
         # Create generators
         certora_build_generator = CertoraBuildGenerator(input_config, context)
 
@@ -3808,12 +3817,9 @@ def build(context: CertoraContext, ignore_spec_syntax_check: bool = False) -> No
             else:
                 Ctx.run_local_spec_check(False, context)
 
-        certora_build_cache_manager = CertoraBuildCacheManager()
-
         cache_hit, build_cache_enabled, cached_files = build_from_cache_or_scratch(context,
                                                                                    certora_build_generator,
-                                                                                   certora_verify_generator,
-                                                                                   certora_build_cache_manager)
+                                                                                   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
@@ -3833,7 +3839,7 @@ def build(context: CertoraContext, ignore_spec_syntax_check: bool = False) -> No
 
         # save in build cache
         if not cache_hit and build_cache_enabled and cached_files.may_store_in_build_cache:
-            certora_build_cache_manager.save_build_cache(context, cached_files)
+            CertoraBuildCacheManager.save_build_cache(context, cached_files)
 
         certora_verify_generator.update_certora_verify_struct(True)
         certora_verify_generator.dump()  # second dump with properly rooted specs

certora_cli/CertoraProver/certoraBuildCacheManager.py

@@ -66,10 +66,9 @@ class CertoraBuildCacheManager:
         @returns None if no cache hit, otherwise - the matching `.certora_build.json` file, and a set of source files
         """
         build_cache_dir = Util.get_certora_build_cache_dir()
-        main_cache_key = CertoraBuildCacheManager.get_main_cache_key(context)
-        main_cache_entry_dir = build_cache_dir / main_cache_key
+        main_cache_entry_dir = build_cache_dir / context.main_cache_key
         if not main_cache_entry_dir.exists():
-            build_cache_logger.info(f"cache miss on build cache key {main_cache_key}")
+            build_cache_logger.info(f"cache miss on build cache key {context.main_cache_key}")
             return None
 
         # here's the tricky matching part:
@@ -92,7 +91,7 @@ class CertoraBuildCacheManager:
                     build_cache_logger.debug(f"Current sub build cache key computed for {file_list_file} is invalid")
                     continue
                 elif sub_cache_key_current_for_list == sub_cache_key_from_saved_entry:
-                    build_cache_logger.info(f"We have a match on build cache key {main_cache_key} and "
+                    build_cache_logger.info(f"We have a match on build cache key {context.main_cache_key} and "
                                             f"{sub_cache_key_current_for_list}")
                     sub_cache_key = sub_cache_key_current_for_list
                     all_contract_files = set([Path(f) for f in file_list])
@@ -103,24 +102,24 @@ class CertoraBuildCacheManager:
 
         if sub_cache_key is None:
             build_cache_logger.info("All sub-cache-key file list files missed, cache miss on build cache key "
-                                    f"{main_cache_key}")
+                                    f"{context.main_cache_key}")
             return None
 
         # cache hit
         certora_build_file = main_cache_entry_dir / f"{sub_cache_key}.{CachedFiles.certora_build_suffix}"
         if not certora_build_file.exists():
-            build_cache_logger.warning(f"Got a cache-hit on build cache key {main_cache_key} and {sub_cache_key} "
+            build_cache_logger.warning(f"Got a cache-hit on build cache key {context.main_cache_key} and {sub_cache_key} "
                                        "but .certora_build.json file does not exist")
             return None
 
         if all_contract_files is None:  # should not be feasible
-            build_cache_logger.warning(f"Got a cache-hit on build cache key {main_cache_key} and {sub_cache_key} "
-                                       "but file list file does not exist")
+            build_cache_logger.warning(f"Got a cache-hit on build cache key {context.main_cache_key} and "
+                                       f"{sub_cache_key} but file list file does not exist")
             return None
 
         build_output_props_file = main_cache_entry_dir / f"{sub_cache_key}.{CachedFiles.build_output_props_suffix}"
         if not build_output_props_file.exists():
-            build_cache_logger.warning(f"Got a cache-hit on build cache key {main_cache_key} and {sub_cache_key} "
+            build_cache_logger.warning(f"Got a cache-hit on build cache key {context.main_cache_key} and {sub_cache_key} "
                                        f"but {CachedFiles.build_output_props_suffix} file does not exist")
             return None
 
@@ -131,26 +130,26 @@ class CertoraBuildCacheManager:
     @staticmethod
     def save_build_cache(context: CertoraContext, cached_files: CachedFiles) -> None:
         build_cache_dir = Util.get_certora_build_cache_dir()
-        main_cache_key = CertoraBuildCacheManager.get_main_cache_key(context)
-        main_cache_entry_dir = build_cache_dir / main_cache_key
+        main_cache_entry_dir = build_cache_dir / context.main_cache_key
         sub_cache_key = CertoraBuildCacheManager.get_sub_cache_key(cached_files.all_contract_files)
         if sub_cache_key is None:
-            build_cache_logger.warning(f"Cannot save cache for main build cache key {main_cache_key} "
+            build_cache_logger.warning(f"Cannot save cache for main build cache key {context.main_cache_key} "
                                        "as sub-cache-key could not be computed")
             return
 
         if main_cache_entry_dir.exists():
-            build_cache_logger.info(f"main build cache key already exists {main_cache_key}, "
+            build_cache_logger.info(f"main build cache key already exists {context.main_cache_key}, "
                                     f"saving sub build cache key {sub_cache_key}")
             if cached_files.all_exist(main_cache_entry_dir, sub_cache_key):
                 build_cache_logger.debug("cache already saved under this build cache key, override")
             else:
-                build_cache_logger.debug(f"cache was corrupted, need to re-save build cache key {main_cache_key} "
-                                         f"and sub cache key {sub_cache_key}")
+                build_cache_logger.debug(f"cache was corrupted, need to re-save build cache key "
+                                         f"{context.main_cache_key} and sub cache key {sub_cache_key}")
             CertoraBuildCacheManager.save_files(cached_files, main_cache_entry_dir,
                                                 sub_cache_key)
         else:
-            build_cache_logger.info(f"saving main build cache key {main_cache_key} and sub cache key {sub_cache_key}")
+            build_cache_logger.info(f"saving main build cache key {context.main_cache_key} and sub cache key "
+                                    f"{sub_cache_key}")
             safe_create_dir(main_cache_entry_dir)
             CertoraBuildCacheManager.save_files(cached_files, main_cache_entry_dir,
                                                 sub_cache_key)
@@ -180,6 +179,8 @@ class CertoraBuildCacheManager:
             trg = trg_path_with_additional_included_files / post_autofinder_dir.name
             if post_autofinder_dir != trg:
                 if post_autofinder_dir.is_dir():
+                    if trg.exists():
+                        shutil.rmtree(trg)
                     Util.safe_copy_folder(post_autofinder_dir, trg, shutil.ignore_patterns())
                 else:
                     # highly unlikely .post_autofinder.[digit] will be a file and not a directory,

certora_cli/CertoraProver/certoraBuildRust.py

@@ -13,10 +13,20 @@
 #     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 sys
+from pathlib import Path
+
+scripts_dir_path = Path(__file__).parent.parent.resolve()  # containing directory
+sys.path.insert(0, str(scripts_dir_path))
+
 import glob
 import shutil
+import time
+import logging
 from pathlib import Path
-from typing import Set
+from typing import Set, Dict
 
 from CertoraProver.certoraBuild import build_source_tree
 from CertoraProver.certoraContextClass import CertoraContext
@@ -25,6 +35,25 @@ import CertoraProver.certoraContextAttributes as Attrs
 from Shared import certoraUtils as Util
 
 
+log = logging.getLogger(__name__)
+
+
+def build_rust_project(context: CertoraContext, timings: Dict) -> None:
+    """
+    Compile the Rust 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 Rust target")
+    start = time.perf_counter()
+    set_rust_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_rust_build_directory(context: CertoraContext) -> None:
     if not context.files:
         build_rust_app(context)
@@ -41,6 +70,7 @@ def set_rust_build_directory(context: CertoraContext) -> None:
     except Exception as e:
         raise Util.CertoraUserInputError(f"Collecting build files failed with the exception: {e}")
 
+
 def build_rust_app(context: CertoraContext) -> None:
     assert not context.files, "build_rust_app: expecting files to be empty"
     if context.build_script:
@@ -51,6 +81,7 @@ def build_rust_app(context: CertoraContext) -> None:
         feature_flag = '--features'
         if context.cargo_tools_version:
             build_command.extend(["--tools-version", context.cargo_tools_version])
+        context.rust_project_directory = Util.find_nearest_cargo_toml()
 
     if context.cargo_features is not None:
         build_command.append(feature_flag)
@@ -61,24 +92,6 @@ def build_rust_app(context: CertoraContext) -> None:
 
     run_rust_build(context, build_command)
 
-def add_solana_files_from_prover_args(context: CertoraContext) -> None:
-    if context.prover_args:
-        inlining_file = False
-        summaries_file = False
-        for prover_arg in context.prover_args:
-            for arg in prover_arg.split(' '):
-                if inlining_file:
-                    context.solana_inlining = context.solana_inlining or [Path(arg)]
-                    inlining_file = False
-                if summaries_file:
-                    context.solana_summaries = context.solana_summaries or [Path(arg)]
-                    summaries_file = False
-
-                if arg == '-solanaInlining':
-                    inlining_file = True
-                elif arg == '-solanaSummaries':
-                    summaries_file = True
-
 
 def add_solana_files_to_sources(context: CertoraContext, sources: Set[Path]) -> None:
     for attr in [Attrs.SolanaProverAttributes.SOLANA_INLINING,
@@ -102,7 +115,7 @@ def add_solana_files_to_sources(context: CertoraContext, sources: Set[Path]) ->
 
 
 def collect_files_from_rust_sources(context: CertoraContext, sources: Set[Path]) -> None:
-    patterns = ["*.rs", "*.so", "*.wasm", "Cargo.toml", "Cargo.lock", "justfile"]
+    patterns = ["*.rs", "*.so", "*.wasm", Util.CARGO_TOML_FILE, "Cargo.lock", "justfile"]
     exclude_dirs = [".certora_internal"]
 
     if hasattr(context, 'rust_project_directory'):
@@ -125,7 +138,6 @@ def collect_files_from_rust_sources(context: CertoraContext, sources: Set[Path])
     if getattr(context, 'conf_file', None) and Path(context.conf_file).exists():
         sources.add(Path(context.conf_file).absolute())
 
-    add_solana_files_from_prover_args(context)
     add_solana_files_to_sources(context, sources)
 
 

certora_cli/{Shared/rustProverCommon.py → CertoraProver/certoraBuildSui.py}

@@ -13,13 +13,6 @@
 #     You should have received a copy of the GNU General Public License
 #     along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
-"""
-Shared helpers for Rust-based targets (Solana & Soroban).
-
-Placing the build  logic in one module removes
-duplication from the dedicated entry scripts.
-"""
-
 from __future__ import annotations
 
 import sys
@@ -28,25 +21,21 @@ 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 typing import Dict
-
-from Shared import certoraUtils as Util
+from pathlib import Path
+from typing import Set, Dict
 
+from CertoraProver.certoraBuild import build_source_tree
 from CertoraProver.certoraContextClass import CertoraContext
-
-from CertoraProver.certoraBuildRust import set_rust_build_directory
+from Shared import certoraUtils as Util
 
 
 log = logging.getLogger(__name__)
 
 
-# --------------------------------------------------------------------------- #
-# Build
-# --------------------------------------------------------------------------- #
-
-def build_rust_project(context: CertoraContext, timings: Dict) -> None:
+def build_sui_project(context: CertoraContext, timings: Dict) -> None:
     """
     Compile the Rust artefact and record elapsed time in *timings*.
 
@@ -56,7 +45,24 @@ def build_rust_project(context: CertoraContext, timings: Dict) -> None:
     """
     log.debug("Build Rust target")
     start = time.perf_counter()
-    set_rust_build_directory(context)
+    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:
+    assert context.move_path, "build_sui_project: expecting move_path to link to a build directory"
+
+    shutil.copytree(context.move_path, Util.get_build_dir() / Path(context.move_path).name)
+
+    sources: Set[Path] = set()
+    if getattr(context, 'conf_file', None) and Path(context.conf_file).exists():
+        sources.add(Path(context.conf_file).absolute())
+
+    try:
+        # Create generators
+        build_source_tree(sources, context)
+
+    except Exception as e:
+        raise Util.CertoraUserInputError(f"Collecting build files failed with the exception: {e}")