certora-cli-beta-mirror 7.28.0__py3-none-any.whl → 7.29.0__py3-none-any.whl

certora_cli/CertoraProver/Compiler/CompilerCollectorVy.py

@@ -556,43 +556,78 @@ class CompilerLangVy(CompilerLang, metaclass=Singleton):
         else:
             raise Exception(f"Unexpected ast_node {ast_node}, cannot evaluate constant")
 
+    @staticmethod
+    def subscript_node(ast_node: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        ty = ast_node.get("ast_type")
+        # pre-vyper 0.4.0, look deeper within
+        if ty == "Index":
+            nested = ast_node.get("value")
+            if nested is None or not isinstance(nested, dict):
+                return None
+            return nested
+        else:
+            return ast_node
+
+    @staticmethod
+    def int_subscript(ast_node: Dict[str, Any], named_constants: Dict[str, int]) -> Optional[int]:
+        node = CompilerLangVy.subscript_node(ast_node)
+        if node is None:
+            return None
+
+        if "id" in node and node["id"] in named_constants:
+            return named_constants[node["id"]]
+        elif node.get("ast_type") == "Int":
+            return node.get("value")
+        else:
+            return None
+
+    @staticmethod
+    def get_tuple_elements(ast_node: Dict[str, Any]) -> List[Dict[str, Any]]:
+        node = CompilerLangVy.subscript_node(ast_node)
+        if node is None or node.get("ast_type") != "Tuple":
+            raise Exception("Couldn't get tuple elements from ast node")
+        return node["elements"]
+
     @staticmethod
     def extract_type_from_subscript_node(ast_subscript_node: Dict[str, Any],
                                          named_constants: Dict[str, int]) -> VyperType:
         value_id = ast_subscript_node['value'].get('id', None)
         if value_id == 'String':
-            max_bytes = ast_subscript_node['slice']['value']['value']
+            max_bytes = CompilerLangVy.int_subscript(ast_subscript_node['slice'], named_constants)
+            if max_bytes is None:
+                raise Exception("Failed to find max length for string type declaration")
             return CompilerLangVy.VyperTypeString(max_bytes)
         elif value_id == 'Bytes':
-            max_bytes = ast_subscript_node['slice']['value']['value']
+            max_bytes = CompilerLangVy.int_subscript(ast_subscript_node['slice'], named_constants)
+            if max_bytes is None:
+                raise Exception("Failed to find max length for bytes type declaration")
             return CompilerLangVy.VyperTypeBytes(max_bytes)
         elif value_id == 'DynArray':
-            elem_type = CompilerLangVy.extract_type_from_type_annotation_node(
-                ast_subscript_node['slice']['value']['elements'][0], named_constants)
-            max_elements = CompilerLangVy.extract_constant(ast_subscript_node['slice']['value']['elements'][1],
-                                                           named_constants)
+            tup_elems = CompilerLangVy.get_tuple_elements(ast_subscript_node["slice"])
+            elem_type = CompilerLangVy.extract_type_from_type_annotation_node(tup_elems[0], named_constants)
+            max_elements = CompilerLangVy.extract_constant(tup_elems[1], named_constants)
             return CompilerLangVy.VyperTypeDynArray(elem_type, max_elements)
         elif value_id == 'HashMap':
-            elements_node = ast_subscript_node['slice']['value']['elements']
+            elements_node = CompilerLangVy.get_tuple_elements(ast_subscript_node['slice'])
             key_type = CompilerLangVy.extract_type_from_type_annotation_node(elements_node[0], named_constants)
             value_type = CompilerLangVy.extract_type_from_type_annotation_node(elements_node[1], named_constants)
             return CompilerLangVy.VyperTypeHashMap(key_type, value_type)
         else:  # StaticArray key_type[size]
             key_type = CompilerLangVy.extract_type_from_type_annotation_node(ast_subscript_node['value'],
                                                                              named_constants)
-            max_elements_node = ast_subscript_node['slice']['value']
-            if 'id' in max_elements_node and max_elements_node['id'] in named_constants:
-                return CompilerLangVy.VyperTypeStaticArray(key_type, named_constants[max_elements_node['id']])
+            max_elem_value = CompilerLangVy.int_subscript(ast_subscript_node['slice'], named_constants)
+            if max_elem_value is not None:
+                return CompilerLangVy.VyperTypeStaticArray(key_type, max_elem_value)
             else:
                 # this is very specific to curve code which has uint256[CONST/2] static array declaration.
+                max_elements_node = CompilerLangVy.subscript_node(ast_subscript_node["slice"])
+                if max_elements_node is None:
+                    raise Exception("Couldn't find subscript node for array type")
                 if 'ast_type' in max_elements_node:
                     if max_elements_node['ast_type'] == 'BinOp' or max_elements_node['ast_type'] in ('Int', 'Name'):
                         # good chance this will succeed
                         static_array_len = CompilerLangVy.extract_constant(max_elements_node, named_constants)
                         return CompilerLangVy.VyperTypeStaticArray(key_type, static_array_len)
-                elif 'value' in max_elements_node:
-                    return CompilerLangVy.VyperTypeStaticArray(key_type, max_elements_node['value'])
-
                 raise Exception(
                     f"Don't know how to deal with vyper static array declaration with length {max_elements_node}")
 

certora_cli/CertoraProver/certoraBuild.py

@@ -411,6 +411,8 @@ def generate_modifier_finder(f: Func, internal_id: int, sym: int,
         formal_strings = []
         arg_strings = []
         for (logged_ty, logged_name) in zip(loggable_types, loggable_names):
+            if logged_name == "":
+                continue
             arg_strings.append(logged_name)
             formal_strings.append(f"{logged_ty} {logged_name}")
         modifier_body = f"modifier {modifier_name}"
@@ -1198,10 +1200,15 @@ class CertoraBuildGenerator:
         return x[TYPE] == FUNCTION or x[TYPE] == CertoraBuildGenerator.CONSTRUCTOR_STRING
 
     @staticmethod
-    def collect_srcmap(data: Dict[str, Any]) -> Any:
+    def collect_srcmap(data: Dict[str, Any]) -> Tuple[str, str]:
         # no source map object in vyper
-        return (data["evm"]["deployedBytecode"].get("sourceMap", ""),
-                data["evm"]["bytecode"].get("sourceMap", ""))
+        deployed = data["evm"]["deployedBytecode"].get("sourceMap", "")
+        if isinstance(deployed, dict):
+            deployed = deployed.get("pc_pos_map_compressed", "")
+        regular = data["evm"]["bytecode"].get("sourceMap", "")
+        if isinstance(regular, dict):
+            regular = regular.get("pc_pos_map_compressed", "")
+        return deployed, regular
 
     @staticmethod
     def collect_varmap(contract: str, data: Dict[str, Any]) -> Any:
@@ -1516,7 +1523,8 @@ class CertoraBuildGenerator:
             sources_dict = {str(contract_file_posix_abs): {
                 "urls": [str(contract_file_posix_abs)]}}  # type: Dict[str, Dict[str, Any]]
             output_selection = ["transientStorageLayout", "storageLayout", "abi", "evm.bytecode",
-                                "evm.deployedBytecode", "evm.methodIdentifiers", "evm.assembly"]
+                                "evm.deployedBytecode", "evm.methodIdentifiers", "evm.assembly",
+                                "evm.bytecode.functionDebugData"]
             ast_selection = ["id", "ast"]
         elif compiler_collector_lang == CompilerLangVy():
             with open(contract_file_posix_abs) as f:
@@ -1739,6 +1747,10 @@ class CertoraBuildGenerator:
         sdc_name = f"{Path(build_arg_contract_file).name}_{file_index}"
         compilation_path = self.get_compilation_path(sdc_name)
         self.file_to_sdc_name[Util.abs_norm_path(build_arg_contract_file)] = sdc_name
+
+        compiler_collector = self.compiler_coll_factory \
+            .get_compiler_collector(Path(path_for_compiler_collector_file))
+
         # update remappings and collect_cmd:
         if not is_vyper:
             Util.safe_create_dir(compilation_path)
@@ -1786,8 +1798,10 @@ class CertoraBuildGenerator:
             compiler_logger.debug(f"collect_cmd: {collect_cmd}\n")
         else:
             compiler_ver_to_run = get_relevant_compiler(Path(build_arg_contract_file), self.context)
-
-            collect_cmd = f'{compiler_ver_to_run} -p "{self.context.solc_allow_path}" -o "{compilation_path}" ' \
+            path_string = ""
+            if compiler_collector.compiler_version[1] < 4:
+                path_string = f' -p "{self.context.solc_allow_path}"'
+            collect_cmd = f'{compiler_ver_to_run}{path_string} -o "{compilation_path}" ' \
                           f'--standard-json'
 
         # Make sure compilation artifacts are always deleted
@@ -1800,9 +1814,6 @@ class CertoraBuildGenerator:
             # (we do not try to save a big chain history of changes, just a previous and current)
             self.backup_compiler_outputs(sdc_name, smart_contract_lang, "prev")
 
-        compiler_collector = self.compiler_coll_factory \
-            .get_compiler_collector(Path(path_for_compiler_collector_file))
-
         # Standard JSON
         remappings = [] if isinstance(compiler_collector, CompilerCollectorYul) else self.context.remappings
         input_for_solc = self.standard_json(Path(file_abs_path), build_arg_contract_file, remappings,
@@ -2246,6 +2257,14 @@ class CertoraBuildGenerator:
                                                          build_arg_contract_file)
         immutables = self.collect_immutables(contract_data, build_arg_contract_file, compiler_lang)
 
+        internal_function_entrypoints = set([])
+
+        if compiler_lang == CompilerLangSol() and "functionDebugData" in contract_data["evm"]["deployedBytecode"]:
+            debug = contract_data["evm"]["deployedBytecode"]["functionDebugData"]
+            for (_, v) in debug.items():
+                if "entryPoint" in v and v["entryPoint"] is not None:
+                    internal_function_entrypoints.add(v["entryPoint"])
+
         if self.context.internal_funcs is not None:
             all_internal_functions: Dict[str, Any] = \
                 Util.read_json_file(self.context.internal_funcs)
@@ -2296,7 +2315,8 @@ class CertoraBuildGenerator:
                              extension_contracts=list(),
                              local_assignments={},
                              branches={},
-                             requires={}
+                             requires={},
+                             internal_starts=list(internal_function_entrypoints)
                              )
 
     @staticmethod
@@ -2527,7 +2547,7 @@ class CertoraBuildGenerator:
                 sources_from_pre_finder_SDCs |= sdc.all_contract_files
             sources = self.collect_sources(context, certora_verify_generator, sources_from_pre_finder_SDCs)
             try:
-                self.cwd_rel_in_sources = build_source_tree(sources, context)
+                build_source_tree(sources, context)
             except Exception as e:
                 build_logger.debug(f"build_source_tree failed. Sources: {sources}", exc_info=e)
                 raise
@@ -2698,8 +2718,8 @@ class CertoraBuildGenerator:
                 return None
             cloned_field = storage_field_info.copy()
             cloned_field["slot"] = str(link_slot)
-            # Try to uniquify the name
-            cloned_field["label"] = f"certoralink_{ext_instance.name}_{var_name}"
+            # Don't bother trying to uniquify the name
+            cloned_field["label"] = var_name
             return cloned_field
 
         def handle_one_extension(storage_ext: str) -> tuple[Any, str, List[Dict[str, Any]]] :
@@ -2750,23 +2770,34 @@ class CertoraBuildGenerator:
             if target_contract.storage_layout.get("types") is None:
                 target_contract.storage_layout["types"] = {}
             target_slots = {storage["slot"] for storage in target_contract.storage_layout["storage"]}
+            target_vars = {storage["label"] for storage in target_contract.storage_layout["storage"]}
             # Keep track of slots we've added, and error if we
             # find two extensions extending the same slot
             added_slots: Dict[str, str] = {}
+            added_vars: Dict[str, str] = {}
             for ext in extensions:
                 (new_fields, new_types) = to_add[ext]
 
                 for f in new_fields:
-                    # See if any of the new fields is a slot we've already added
+                    # See if any of the new fields is a slot or variable name we've already added
                     slot = f["slot"]
+                    var = f["label"]
                     if slot in added_slots:
                         seen = added_slots[slot]
-                        raise Util.CertoraUserInputError(f"Slot {slot} added to {target_contract.name} by {ext} already added by {seen}")
+                        raise Util.CertoraUserInputError(f"Slot {slot} added to {target_contract.name} by {ext} was already added by {seen}")
+
+                    if var in added_vars:
+                        seen = added_vars[var]
+                        raise Util.CertoraUserInputError(f"Var '{var}' added to {target_contract.name} by {ext} was already added by {seen}")
 
                     if slot in target_slots:
-                        raise Util.CertoraUserInputError(f"Slot {slot} added to {target_contract.name} by {ext} already mapped by {target_contract.name}")
+                        raise Util.CertoraUserInputError(f"Slot {slot} added to {target_contract.name} by {ext} is already mapped by {target_contract.name}")
+
+                    if var in target_vars:
+                        raise Util.CertoraUserInputError(f"Var '{var}' added to {target_contract.name} by {ext} is already declared by {target_contract.name}")
 
                     added_slots[slot] = ext
+                    added_vars[var] = ext
 
                 target_contract.storage_layout["storage"].extend(new_fields)
 
@@ -3003,7 +3034,7 @@ class CertoraBuildGenerator:
             for k, v in autofinder_remappings.items():
                 self.function_finder_file_remappings[Util.abs_posix_path(k)] = Util.abs_posix_path(v)
             new_sdcs = self.collect_for_file(new_file, i, get_compiler_lang(build_arg_contract_file),
-                                             Util.get_certora_sources_dir() / self.cwd_rel_in_sources,
+                                             Util.get_certora_sources_dir() / self.context.cwd_rel_in_sources,
                                              path_for_compiler_collector_file,
                                              sdc_pre_finder,
                                              fail_on_compilation_error=False,
@@ -3031,7 +3062,7 @@ class CertoraBuildGenerator:
         contract_path = Util.abs_posix_path_obj(contract_file)
         rel_directory = Path(os.path.relpath(contract_file, '.')).parent
         contract_filename = contract_path.name
-        new_path = Util.get_certora_sources_dir() / self.cwd_rel_in_sources / rel_directory / contract_filename
+        new_path = Util.get_certora_sources_dir() / self.context.cwd_rel_in_sources / rel_directory / contract_filename
         new_path.parent.mkdir(parents=True, exist_ok=True)
         return str(new_path)
 
@@ -3041,7 +3072,7 @@ class CertoraBuildGenerator:
         This assumes those paths can be related to cwd.
         """
         rel_to_cwd_path = Path(os.path.relpath(path, '.'))
-        new_path = Util.get_certora_sources_dir() / self.cwd_rel_in_sources / rel_to_cwd_path
+        new_path = Util.get_certora_sources_dir() / self.context.cwd_rel_in_sources / rel_to_cwd_path
         return str(new_path.absolute())
 
     def handle_links(self) -> None:
@@ -3449,20 +3480,19 @@ def sources_to_abs(sources: Set[Path]) -> Set[Path]:
     return result
 
 
-def build_source_tree(sources: Set[Path], context: CertoraContext, overwrite: bool = False) -> Path:
+def build_source_tree(sources: Set[Path], context: CertoraContext, overwrite: bool = False) -> None:
     """
     Copies files to .certora_sources
-    @returns the cwd relative in sources
     """
     sources = sources_to_abs(sources)
-    cwd_rel_in_sources, common_path = CertoraBuildGenerator.get_cwd_rel_in_sources(sources)
+    context.cwd_rel_in_sources, context.common_path = CertoraBuildGenerator.get_cwd_rel_in_sources(sources)
 
     for source_path in sources:
         is_dir = source_path.is_dir()
         # copy file to the path of the file from the common root under the sources directory
 
         # make sure directory exists
-        target_path = Util.get_certora_sources_dir() / source_path.relative_to(common_path)
+        target_path = Util.get_certora_sources_dir() / source_path.relative_to(context.common_path)
         target_directory = target_path if is_dir else target_path.parent
         try:
             target_directory.mkdir(parents=True, exist_ok=True)
@@ -3491,7 +3521,7 @@ def build_source_tree(sources: Set[Path], context: CertoraContext, overwrite: bo
             raise
 
     #  the empty file .cwd is written in the source tree to denote the current working directory
-    cwd_file_path = Util.get_certora_sources_dir() / cwd_rel_in_sources / Util.CWD_FILE
+    cwd_file_path = Util.get_certora_sources_dir() / context.cwd_rel_in_sources / Util.CWD_FILE
     cwd_file_path.parent.mkdir(parents=True, exist_ok=True)
     cwd_file_path.touch()
 
@@ -3500,7 +3530,7 @@ def build_source_tree(sources: Set[Path], context: CertoraContext, overwrite: bo
     if rust_proj_dir:
         proj_dir_parent_relative = os.path.relpath(rust_proj_dir, os.getcwd())
         assert Path(rust_proj_dir).is_dir(), f"build_source_tree: not a directory {rust_proj_dir}"
-        proj_dir_parent_file = (Util.get_certora_sources_dir() / cwd_rel_in_sources / proj_dir_parent_relative /
+        proj_dir_parent_file = (Util.get_certora_sources_dir() / context.cwd_rel_in_sources / proj_dir_parent_relative /
                                 Util.PROJECT_DIR_FILE)
         proj_dir_parent_file.parent.mkdir(parents=True, exist_ok=True)
         proj_dir_parent_file.touch()
@@ -3516,9 +3546,6 @@ def build_source_tree(sources: Set[Path], context: CertoraContext, overwrite: bo
         build_logger.debug("Couldn't copy repro conf to certora sources.", exc_info=e)
         raise
 
-    return cwd_rel_in_sources
-
-
 def build_from_scratch(certora_build_generator: CertoraBuildGenerator,
                        certora_verify_generator: CertoraVerifyGenerator,
                        build_cache_enabled: bool) -> CachedFiles:
@@ -3661,8 +3688,7 @@ def build(context: CertoraContext, ignore_spec_syntax_check: bool = False) -> No
 
         # Start by syntax checking, if we're in the right mode
         if Cv.mode_has_spec_file(context) and not context.build_only and not ignore_spec_syntax_check:
-            attr = context.disable_local_typechecking
-            if attr:
+            if context.disable_local_typechecking:
                 build_logger.warning(
                     "Local checks of CVL specification files disabled. It is recommended to enable the checks.")
             else:
@@ -3675,6 +3701,11 @@ def build(context: CertoraContext, ignore_spec_syntax_check: bool = False) -> No
                                                                                    certora_verify_generator,
                                                                                    certora_build_cache_manager)
 
+        # 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
+        if context.split_rules:
+            Ctx.run_local_spec_check(True, context)
+
         # .certora_verify.json is always constructed even if build cache is enabled
         # Sources construction should only happen when rebuilding
         # Build sources tree

certora_cli/CertoraProver/certoraBuildDataClasses.py

@@ -107,7 +107,8 @@ class ContractInSDC:
                  extension_contracts: List[ContractExtension],
                  local_assignments: Dict[str, UnspecializedSourceFinder],
                  branches: Dict[str, UnspecializedSourceFinder],
-                 requires: Dict[str, UnspecializedSourceFinder]
+                 requires: Dict[str, UnspecializedSourceFinder],
+                 internal_starts: List[int]
                  ):
         self.name = name
         self.original_file = source_file
@@ -139,6 +140,7 @@ class ContractInSDC:
         self.original_file_name = Path(source_file).name
         self.compiler_collector = compiler_collector
         self.compiler_parameters = compiler_parameters
+        self.internal_starts = internal_starts
 
         if not self.compiler_collector:
             compiler_version = ""
@@ -193,7 +195,8 @@ class ContractInSDC:
             "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],
-            "localAssignments": {k: v.as_dict() for k, v in self.local_assignments.items()}
+            "localAssignments": {k: v.as_dict() for k, v in self.local_assignments.items()},
+            "internalFunctionStarts": self.internal_starts
         }
         # "sourceHints": {"localAssignments": {k: v.as_dict() for k, v in self.local_assignments.items()},
         #                 "branches": {k: v.as_dict() for k, v in self.branches.items()},

certora_cli/CertoraProver/certoraBuildRust.py

@@ -16,32 +16,40 @@
 import glob
 import shutil
 from pathlib import Path
-from typing import Set
+from typing import Set, List
 
 from CertoraProver.certoraBuild import build_source_tree
 from CertoraProver.certoraContextClass import CertoraContext
-from CertoraProver.certoraParseBuildScript import run_script_and_parse_json
+from CertoraProver.certoraParseBuildScript import run_rust_build
 import CertoraProver.certoraContextAttributes as Attrs
 from Shared import certoraUtils as Util
 
 
 def build_rust_app(context: CertoraContext) -> None:
+    build_command: List[str] = []
+    feature_flag = None
     if context.build_script:
-        run_script_and_parse_json(context)
-        if not context.rust_executables:
-            raise Util.CertoraUserInputError("failed to get target executable")
+        build_command = [context.build_script]
+        feature_flag = '--cargo_features'
 
-        sources: Set[Path] = set()
-        collect_files_from_rust_sources(context, sources)
+    elif not context.files:
+        build_command = ["cargo", "certora-sbf"]
+        feature_flag = '--features'
+        if context.cargo_tools_version:
+            build_command.append("--tools-version")
+            build_command.append(context.cargo_tools_version)
 
-        try:
-            # Create generators
-            build_source_tree(sources, context)
+    if build_command:
+        if context.cargo_features is not None:
+            build_command.extend([feature_flag] + context.cargo_features)
 
-            copy_files_to_build_dir(context)
+        build_command.extend(['--json', '-l'])
+
+        if context.test == str(Util.TestValue.SOLANA_BUILD_CMD):
+            raise Util.TestResultsReady(build_command)
+
+        run_rust_build(context, build_command)
 
-        except Exception as e:
-            raise Util.CertoraUserInputError(f"Collecting build files failed with the exception: {e}")
     else:
         if not context.files:
             raise Util.CertoraUserInputError("'files' or 'build_script' must be set for Rust projects")
@@ -54,17 +62,49 @@ def build_rust_app(context: CertoraContext) -> None:
         except Exception as e:
             raise Util.CertoraUserInputError(f"Collecting build files failed with the exception: {e}")
 
-        context.rust_executables = context.files[0]
+    copy_files_to_build_dir(context)
+
+    sources: Set[Path] = set()
+    collect_files_from_rust_sources(context, sources)
+
+    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 add_solana_files(context: CertoraContext, sources: Set[Path]) -> None:
-    for attr in [Attrs.SolanaProverAttributes.SOLANA_INLINING, Attrs.SolanaProverAttributes.SOLANA_SUMMARIES]:
+
+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,
+                 Attrs.SolanaProverAttributes.SOLANA_SUMMARIES,
+                 Attrs.SolanaProverAttributes.BUILD_SCRIPT,
+                 Attrs.SolanaProverAttributes.FILES]:
         attr_name = attr.get_conf_key()
         attr_value = getattr(context, attr_name, None)
         if not attr_value:
             continue
         if isinstance(attr_value, str):
-            attr_value = [str]
+            attr_value = [attr_value]
         if not isinstance(attr_value, list):
             raise Util.CertoraUserInputError(f"{attr_value} is not a valid value for {attr_name} {attr_value}. Value "
                                              f"must be a string or a llist ")
@@ -72,44 +112,40 @@ def add_solana_files(context: CertoraContext, sources: Set[Path]) -> None:
         for file_path in file_paths:
             if not file_path.exists():
                 raise Util.CertoraUserInputError(f"in {attr_name} file {file_path} does not exist")
-            sources.add(file_path.absolute())
+            sources.add(file_path.absolute().resolve())
 
 
 def collect_files_from_rust_sources(context: CertoraContext, sources: Set[Path]) -> None:
     patterns = ["*.rs", "*.so", "*.wasm", "Cargo.toml", "Cargo.lock", "justfile"]
     exclude_dirs = [".certora_internal"]
 
-    root_directory = Path(context.rust_project_directory)
+    if hasattr(context, 'rust_project_directory'):
+        project_directory = Path(context.rust_project_directory)
 
-    if not root_directory.is_dir():
-        raise ValueError(f"The given directory '{root_directory}' is not valid.")
+        if not project_directory.is_dir():
+            raise ValueError(f"The given directory '{project_directory}' is not valid.")
 
-    for source in context.rust_sources:
-        for file in glob.glob(f'{root_directory.joinpath(source)}', recursive=True):
-            file_path = Path(file)
-            if any(excluded in file_path.parts for excluded in exclude_dirs):
-                continue
-            if file_path.is_file() and any(file_path.match(pattern) for pattern in patterns):
-                sources.add(file_path)
+        for source in context.rust_sources:
+            for file in glob.glob(f'{project_directory.joinpath(source)}', recursive=True):
+                file_path = Path(file)
+                if any(excluded in file_path.parts for excluded in exclude_dirs):
+                    continue
+                if file_path.is_file() and any(file_path.match(pattern) for pattern in patterns):
+                    sources.add(file_path)
 
-    sources.add(Path(context.rust_project_directory).absolute())
-    if Path(context.build_script).exists():
-        sources.add(Path(context.build_script).resolve())
+        sources.add(project_directory.absolute())
+        if Path(context.build_script).exists():
+            sources.add(Path(context.build_script).resolve())
     if getattr(context, 'conf_file', None) and Path(context.conf_file).exists():
         sources.add(Path(context.conf_file).absolute())
-    add_solana_files(context, sources)
 
+    add_solana_files_from_prover_args(context)
+    add_solana_files_to_sources(context, sources)
 
-def copy_files_to_build_dir(context: CertoraContext) -> None:
-    rust_executable = Path(context.rust_project_directory) / context.rust_executables
-    shutil.copyfile(rust_executable, Util.get_build_dir() / rust_executable.name)
-
-    additional_files = (getattr(context, 'solana_inlining', None) or []) + \
-                       (getattr(context, 'solana_summaries', None) or [])
 
-    for file in additional_files:
-        file_path = Path(file).resolve()
-        shutil.copy(file_path, Util.get_build_dir() / file_path.name)
+def copy_files_to_build_dir(context: CertoraContext) -> None:
+    assert context.files, "copy_files_to_build_dir: expecting files to be non-empty"
+    shutil.copyfile(context.files[0], Util.get_build_dir() / Path(context.files[0]).name)
 
     if rust_logs := getattr(context, 'rust_logs_stdout', None):
         shutil.copy(Path(rust_logs), Util.get_build_dir() / Path(rust_logs).name)