certora-cli 7.26.0__tar.gz → 7.29.1__tar.gz

certora_cli-7.29.1/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-7.26.0/certora_cli.egg-info → certora_cli-7.29.1}/PKG-INFO

@@ -1,12 +1,15 @@
 Metadata-Version: 2.2
 Name: certora-cli
-Version: 7.26.0
+Version: 7.29.1
 Summary: Runner for the Certora Prover
 Home-page: https://pypi.org/project/certora-cli
 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
@@ -20,18 +23,18 @@ Requires-Dist: sly
 Requires-Dist: tabulate
 Requires-Dist: tqdm
 Requires-Dist: StrEnum
-Requires-Dist: tomli
 Requires-Dist: universalmutator
 Requires-Dist: jinja2
-Requires-Dist: setuptools==75.8.2
 Dynamic: author
 Dynamic: author-email
 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 4799cf7.                    Build and Run scripts for executing the Certora Prover on Solidity smart contracts.
+Commit b8a319d.                    Build and Run scripts for executing the Certora Prover on Solidity smart contracts.

certora_cli-7.29.1/README.md

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

{certora_cli-7.26.0 → certora_cli-7.29.1}/certora_cli/CertoraProver/Compiler/CompilerCollectorFactory.py

@@ -39,12 +39,15 @@ def get_relevant_compiler(contract_file_path: Path, context: CertoraContext) ->
     @return: the name of the compiler executable we want to run on this file (as a string, could be a path
              or a resolvable executable name)
     """
-    if context.solc_map:
-        match = match_path_to_mapping_key(contract_file_path, context.solc_map)
+
+    if contract_file_path.is_absolute():
+        contract_file_path = Path(os.path.relpath(contract_file_path, Path.cwd()))
+    if context.compiler_map:
+        match = match_path_to_mapping_key(contract_file_path, context.compiler_map)
         if match:
             return match
         else:
-            raise RuntimeError(f'cannot match compiler to {contract_file_path} from solc_map')
+            raise RuntimeError(f'cannot match compiler to {contract_file_path} from compiler_map')
 
     if Util.is_vyper_file(str(contract_file_path)):
         if context.vyper:

{certora_cli-7.26.0 → certora_cli-7.29.1}/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-7.26.0 → certora_cli-7.29.1}/certora_cli/CertoraProver/certoraBuild.py

@@ -21,7 +21,7 @@ import re
 import shutil
 import sys
 import typing
-from collections import OrderedDict
+from collections import OrderedDict, defaultdict
 from enum import Enum
 from functools import lru_cache
 from pathlib import Path
@@ -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:
@@ -1389,7 +1396,7 @@ class CertoraBuildGenerator:
             if not self.context.strict_solc_optimizer and self.context.solc_via_ir:
                 # The default optimizer steps (taken from libsolidity/interface/OptimiserSettings.h) but with the
                 # full inliner step removed
-                solc0_8_26_to_0_8_28 = ("dhfoDgvulfnTUtnIfxa[r]EscLMVcul[j]Trpeulxa[r]cLCTUca[r]LSsTFOtfDnca[r]" +
+                solc0_8_26_to_0_8_29 = ("dhfoDgvulfnTUtnIfxa[r]EscLMVcul[j]Trpeulxa[r]cLCTUca[r]LSsTFOtfDnca[r]" +
                                         "IulcscCTUtx[scCTUt]TOntnfDIuljmul[jul]VcTOculjmul")
                 solc0_8_13_to_0_8_25 = "dhfoDgvulfnTUtnIf[xa[r]EscLMcCTUtTOntnfDIulLculVcul[j]T" + \
                                        "peulxa[rul]xa[r]cLgvifCTUca[r]LSsTFOtfDnca[r]Iulc]jmul[jul]VcTOculjmul"
@@ -1433,8 +1440,8 @@ class CertoraBuildGenerator:
                     yul_optimizer_steps = solc0_8_12
                 elif minor == 8 and 13 <= patch <= 25:
                     yul_optimizer_steps = solc0_8_13_to_0_8_25
-                elif minor == 8 and 26 <= patch <= 28:
-                    yul_optimizer_steps = solc0_8_26_to_0_8_28
+                elif minor == 8 and 26 <= patch <= 29:
+                    yul_optimizer_steps = solc0_8_26_to_0_8_29
                 assert yul_optimizer_steps is not None, \
                     'Yul Optimizer steps missing for requested Solidity version. Please contact Certora team.'
 
@@ -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
@@ -2652,6 +2672,169 @@ class CertoraBuildGenerator:
         self.handle_links()
         self.handle_struct_links()
         self.handle_contract_extensions()
+        self.handle_storage_extension_harnesses()
+
+    def handle_storage_extension_harnesses(self) -> None:
+        def new_field_of_node(ext_instance: Any, node: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+            """
+            If this node is a storage variable declaration like the following:
+
+            /** @custom:certoralink 0x12345 */
+            T x;
+
+            and if so, return a storage field matching the type of x but using 0x12345 as the slot
+            """
+
+            if node.get("nodeType") != "VariableDeclaration":
+                return None
+            if not node.get("stateVariable"):
+                return None
+            if "documentation" not in node:
+                return None
+            if node["documentation"].get("nodeType") != "StructuredDocumentation":
+                return None
+            annot_link = node["documentation"].get("text")
+            var_name = node.get("name")
+            if var_name is None or not isinstance(annot_link, str):
+                return None
+
+            link_regex = r'@custom:certoralink\s+(0x[0-9a-fA-F]+)\s*'
+            link_match = re.search(link_regex, annot_link)
+
+            if link_match is None:
+                raise Util.CertoraUserInputError(f"Couldn't parse annotation in on "
+                                                 f"{ext_instance.original_file_name}.{var_name}: {annot_link}")
+            try:
+                link_slot = int(link_match.group(1), 16)
+            except ValueError:
+                raise Util.CertoraUserInputError(f"Invalid certoralink slot value in annotation on"
+                                                 f"{ext_instance.original_file_name}.{var_name}: {annot_link}")
+            storage_field_info = None
+            for field in ext_instance.storage_layout["storage"]:
+                if field["label"] == var_name:
+                    storage_field_info = field
+                    break
+            if storage_field_info is None:
+                return None
+            cloned_field = storage_field_info.copy()
+            cloned_field["slot"] = str(link_slot)
+            # 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]]] :
+            """
+            Get the extension contract plus the new fields
+            """
+            extension_sdc_cands = self.get_matching_sdc_names_from_SDCs(storage_ext)
+            assert len(extension_sdc_cands) == 1, f"Zero or multiple possible contracts for {storage_ext}"
+            extension_sdc_name = extension_sdc_cands[0]
+            extension_sdc = self.SDCs.get(extension_sdc_name)
+            assert extension_sdc and extension_sdc.primary_contract == storage_ext, f"Could not find SDC for {extension_sdc_name}"
+            ext_instance = extension_sdc.find_contract(storage_ext)
+            assert ext_instance is not None, f"Could not find extension contract {storage_ext}"
+
+            # let's try to find the AST now
+            build_file_ast = None
+            for (k, v) in self.asts.items():
+                if ext_instance.original_file in v:
+                    build_file_ast = k
+                    break
+            if build_file_ast is None:
+                raise RuntimeError(f"Couldn't find file for storage extension file {storage_ext}")
+
+            contract_def_node = self.get_contract_def_node_ref(
+                build_file_ast,
+                ext_instance.original_file,
+                storage_ext
+            )
+            def_node = self.asts[build_file_ast][ext_instance.original_file][contract_def_node]
+            nodes = def_node.get("nodes")
+            if not isinstance(nodes, list):
+                raise RuntimeError(f"Couldn't find nodes for body of {storage_ext}")
+
+            new_fields = []
+            for node in nodes:
+                new_field = new_field_of_node(ext_instance, node)
+                if new_field is not None:
+                    new_fields.append(new_field)
+
+            return (ext_instance, extension_sdc_name, new_fields)
+
+        def apply_extensions(target_contract: Any, extensions: Set[str], to_add: Dict[str, Tuple[List[Dict[str, Any]], Dict[str, Any]]]) -> None:
+            """
+            Apply the fields from each extension to the target contract,
+            """
+            if target_contract.storage_layout.get("storage") is None:
+                target_contract.storage_layout["storage"] = []
+            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 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} 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} 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)
+
+                for (new_id, new_ty) in new_types.items():
+                    if new_id in target_contract.storage_layout["types"]:
+                        continue
+                    target_contract.storage_layout["types"][new_id] = new_ty
+
+        extension_contracts: Set[str] = set()
+        storage_extensions: Dict[str, Set[str]] = defaultdict(set)
+        storage_ext = self.context.storage_extension_harnesses
+
+        if storage_ext is None:
+            return
+
+        for i in storage_ext:
+            target_contract, extension_contract = i.split("=")
+            extension_contracts.add(extension_contract)
+            storage_extensions[target_contract].add(extension_contract)
+
+        # These are the new fields to add for each contract
+        extension_to_fields_and_types: Dict[str, Tuple[List[Dict[str, Any]], Dict[str, Any]]] = {}
+
+        for storage_ext in extension_contracts:
+            (ext_instance, extension_sdc_name, new_fields) = handle_one_extension(storage_ext)
+            new_types = ext_instance.storage_layout["types"]
+            extension_to_fields_and_types[storage_ext] = (new_fields, {} if new_types is None else new_types)
+            del self.SDCs[extension_sdc_name]
+
+        for (target, extensions) in storage_extensions.items():
+            target_sdc_names = self.get_matching_sdc_names_from_SDCs(target)
+            assert len(target_sdc_names) == 1, f"no matching sdc for {target}"
+            target_sdc = target_sdc_names[0]
+            sdc = self.SDCs[target_sdc]
+            target_contract = sdc.find_contract(target)
+            assert target_contract is not None, f"could not find contract for {target}"
+            apply_extensions(target_contract, extensions, extension_to_fields_and_types)
 
     def finders_compilation_round(self,
                                   build_arg_contract_file: str,
@@ -2851,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,
@@ -2879,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)
 
@@ -2889,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:
@@ -2985,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"]))
@@ -3267,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:
@@ -3295,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)
@@ -3337,28 +3521,19 @@ 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
-    if cwd_rel_in_sources != '.':
-        file_path = Util.get_certora_sources_dir() / cwd_rel_in_sources / Util.CWD_FILE
-        file_path.parent.mkdir(parents=True, exist_ok=True)
-        file_path.touch()
-
-    """
-    Once the resource files are copied to the source tree, the paths in the value of the 'prover_resource_files'
-    attribute are replaced with the relative path of the resource file from the source tree root.
-    This way The server can easily find the resource files in the source tree. The path from the source tree is the
-    relative path of cwd from source tree root (most cases '.') concatenated with the relative path of the resource
-    file from cwd
-    """
-    if context.prover_resource_files:
-        new_value = []
-        len_orig = len(context.prover_resource_files)
-        for value in context.prover_resource_files:
-            label, file_path = value.split(':')
-            rel_path = Path(os.path.relpath(file_path, '.'))
-            new_value.append(':'.join([label, os.path.normpath(rel_path)]))
-        if len_orig != len(new_value):
-            raise RuntimeError(f"fail to process prover_resource_files {len_orig} out of {len(new_value)}")
-        context.prover_resource_files = new_value
+    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()
+
+    #  the empty file .project_directory is written in the source tree to denote the projecct 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())
+        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() / 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()
 
     # Copy the repro conf file to the sources as the overall way to reproduce this run easily.
     # The file is being copied in here and not added through collect_sources, because we want
@@ -3371,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:
@@ -3516,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:
@@ -3530,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