certora-cli-beta-mirror 7.27.1__tar.gz → 7.29.0__tar.gz

certora_cli_beta_mirror-7.29.0/LICENSE

@@ -0,0 +1,15 @@
+
+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/>.

{certora_cli_beta_mirror-7.27.1/certora_cli_beta_mirror.egg-info → certora_cli_beta_mirror-7.29.0}/PKG-INFO

@@ -1,12 +1,15 @@
 Metadata-Version: 2.2
 Name: certora-cli-beta-mirror
-Version: 7.27.1
+Version: 7.29.0
 Summary: Runner for the Certora Prover
 Home-page: https://pypi.org/project/certora-cli-beta-mirror
 Author: Certora
 Author-email: support@certora.com
+License: GPL-3.0-only
+Project-URL: Documentation, https://docs.certora.com/en/latest/
+Project-URL: Source, https://github.com/Certora/CertoraProver
 Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
@@ -28,8 +31,10 @@ Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
+Dynamic: license
+Dynamic: project-url
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 
-Commit 363f2a8.                    Build and Run scripts for executing the Certora Prover on Solidity smart contracts.
+Commit 3f35845.                    Build and Run scripts for executing the Certora Prover on Solidity smart contracts.

certora_cli_beta_mirror-7.29.0/README.md

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

{certora_cli_beta_mirror-7.27.1 → certora_cli_beta_mirror-7.29.0}/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_beta_mirror-7.27.1 → certora_cli_beta_mirror-7.29.0}/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}"
@@ -825,7 +827,7 @@ class CertoraBuildGenerator:
                     ast_logger.debug(f"No body for {func_def} but ast claims it is implemented")
 
                 if original_contract is not None:
-                    if method := original_contract.find_method(func_name):
+                    if method := original_contract.find_method(func_name, solidity_type_args):
                         source_bytes = method.source_bytes
                         original_file = method.original_file
                     else:
@@ -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:
@@ -3137,7 +3168,7 @@ class CertoraBuildGenerator:
                                                      f"for contract extension")
                 extension_contract = contracts_by_name[extension]
                 for f in ext["exclude"]:
-                    if extension_contract.find_method(f) is None:
+                    if not extension_contract.has_method_with_name(f):
                         raise Util.CertoraUserInputError(f"Can't find a method named {f} in contract "
                                                          f"{extension_contract.name}")
                 extended_contract.add_extension(ContractExtension(extension_contract, ext["exclude"]))
@@ -3419,6 +3450,8 @@ class CertoraBuildGenerator:
             sources.add(Path(context.bytecode_spec))
         if context.yul_abi:
             sources.add(Path(context.yul_abi))
+        if context.override_base_config:
+            sources.add(Path(context.override_base_config))
 
         if hasattr(context, Attrs.EvmProverAttributes.PROVER_RESOURCE_FILES.get_conf_key()) \
                 and context.prover_resource_files:
@@ -3447,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)
@@ -3489,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()
 
@@ -3498,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()
@@ -3514,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:
@@ -3659,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:
@@ -3673,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_beta_mirror-7.27.1 → certora_cli_beta_mirror-7.29.0}/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()},
@@ -218,12 +221,24 @@ class ContractInSDC:
             "localAssignments": {k: v.as_dict() for k, v in self.local_assignments.items()}
         }
 
-    def find_method(self, name: str) -> Optional[Func]:
+    def find_method(self, name: str, fullArgs: List[CT.TypeInstance]) -> Optional[Func]:
+        """
+        attempts to find and return a matching method. from Solidity documentation,
+        the combination of the method name and (ordered) parameter types
+        is sufficient to disambiguate method overloading.
+        """
         for method in self.methods:
             if method.name == name:
-                return method
+                if Util.eq_by(CT.TypeInstance.matches, method.fullArgs, fullArgs):
+                    return method
         return None
 
+    def has_method_with_name(self, name: str) -> bool:
+        for method in self.methods:
+            if method.name == name:
+                return True
+        return False
+
     def __repr__(self) -> str:
         return repr(self.as_printable_dict())
 

certora_cli_beta_mirror-7.29.0/certora_cli/CertoraProver/certoraBuildRust.py

@@ -0,0 +1,153 @@
+#     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/>.
+
+import glob
+import shutil
+from pathlib import Path
+from typing import Set, List
+
+from CertoraProver.certoraBuild import build_source_tree
+from CertoraProver.certoraContextClass import CertoraContext
+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:
+        build_command = [context.build_script]
+        feature_flag = '--cargo_features'
+
+    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)
+
+    if build_command:
+        if context.cargo_features is not None:
+            build_command.extend([feature_flag] + context.cargo_features)
+
+        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)
+
+    else:
+        if not context.files:
+            raise Util.CertoraUserInputError("'files' or 'build_script' must be set for Rust projects")
+        if len(context.files) > 1:
+            raise Util.CertoraUserInputError("Rust projects must specify exactly one executable in 'files'.")
+
+        try:
+            Util.get_certora_sources_dir().mkdir(parents=True, exist_ok=True)
+            shutil.copy(Util.get_last_conf_file(), Util.get_certora_sources_dir() / Util.LAST_CONF_FILE)
+        except Exception as e:
+            raise Util.CertoraUserInputError(f"Collecting build files failed with the exception: {e}")
+
+    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_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 = [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 ")
+        file_paths = [Path(s) for s in attr_value]
+        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().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"]
+
+    if hasattr(context, 'rust_project_directory'):
+        project_directory = Path(context.rust_project_directory)
+
+        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'{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(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_from_prover_args(context)
+    add_solana_files_to_sources(context, sources)
+
+
+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)
+    if rust_logs := getattr(context, 'rust_logs_stderr', None):
+        shutil.copy(Path(rust_logs), Util.get_build_dir() / Path(rust_logs).name)