certora-cli 7.29.3__tar.gz → 7.31.1__tar.gz

{certora_cli-7.29.3/certora_cli.egg-info → certora_cli-7.31.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: certora-cli
-Version: 7.29.3
+Version: 7.31.1
 Summary: Runner for the Certora Prover
 Home-page: https://pypi.org/project/certora-cli
 Author: Certora
@@ -25,6 +25,7 @@ Requires-Dist: tqdm
 Requires-Dist: StrEnum
 Requires-Dist: universalmutator
 Requires-Dist: jinja2
+Requires-Dist: wcmatch
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -37,4 +38,4 @@ Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 
-Commit 206ede4.                    Build and Run scripts for executing the Certora Prover on Solidity smart contracts.
+Commit 9a7c8df.                    Build and Run scripts for executing the Certora Prover on Solidity smart contracts.

certora_cli-7.31.1/README.md

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

{certora_cli-7.29.3 → certora_cli-7.31.1}/certora_cli/CertoraProver/Compiler/CompilerCollectorFactory.py

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

{certora_cli-7.29.3 → certora_cli-7.31.1}/certora_cli/CertoraProver/certoraBuild.py

@@ -25,8 +25,11 @@ from collections import OrderedDict, defaultdict
 from enum import Enum
 from functools import lru_cache
 from pathlib import Path
-from typing import Any, Dict, List, Tuple, Optional, Set, Iterator, NoReturn
 from Crypto.Hash import keccak
+import tempfile
+
+from typing import Any, Dict, List, Tuple, Optional, Set, Iterator, NoReturn
+
 
 from CertoraProver.certoraBuildCacheManager import CertoraBuildCacheManager, CachedFiles
 from CertoraProver.certoraBuildDataClasses import CONTRACTS, ImmutableReference, ContractExtension, ContractInSDC, SDC, \
@@ -35,6 +38,7 @@ from CertoraProver.certoraCompilerParameters import SolcParameters
 from CertoraProver.certoraSourceFinders import add_source_finders
 from CertoraProver.certoraVerifyGenerator import CertoraVerifyGenerator
 from CertoraProver.certoraContractFuncs import Func, InternalFunc, STATEMUT, SourceBytes
+
 from Shared.certoraUtils import is_relative_to
 
 scripts_dir_path = Path(__file__).parent.parent.resolve()  # containing directory
@@ -54,7 +58,11 @@ from Shared import certoraValidateFuncs as Vf
 from CertoraProver import certoraContextValidator as Cv
 from Shared import certoraUtils as Util
 import CertoraProver.certoraContext as Ctx
-
+from CertoraProver import storageExtension
+from CertoraProver.storageExtension import (
+    NameSpacedStorage,
+    NewStorageInfo,
+)
 
 BUILD_IS_LIBRARY = False
 AUTO_FINDER_PREFIX = "autoFinder_"
@@ -72,6 +80,7 @@ MUTANTS_LOCATION = "mutants_location"
 
 FunctionSig = Tuple[str, List[str], List[str], str]
 
+
 # logger for building the abstract syntax tree
 ast_logger = logging.getLogger("ast")
 # logger for issues calling/shelling out to external functions
@@ -84,12 +93,10 @@ build_logger = logging.getLogger("build_conf")
 # logger of the build cache
 build_cache_logger = logging.getLogger("build_cache")
 
-
 def fatal_error(logger: logging.Logger, msg: str) -> NoReturn:
     logger.fatal(msg)
     raise Exception(msg)
 
-
 class InputConfig:
     def __init__(self, context: CertoraContext) -> None:
         """
@@ -443,8 +450,12 @@ def convert_pathname_to_posix(json_dict: Dict[str, Any], entry: str, smart_contr
             if path_obj.is_file():
                 json_dict_posix_paths[path_obj.as_posix()] = json_dict[entry][file_path]
             else:
+                json_dict_str = str(json_dict)
+                # protecting against long strings
+                if len(json_dict_str) > 200:
+                    json_dict_str = json_dict_str[:200] + '...'
                 fatal_error(compiler_logger, f"The path of the source file {file_path}"
-                                             f"in the standard json file {json_dict} does not exist")
+                                             f"in the standard json file {json_dict_str} does not exist")
         json_dict[entry] = json_dict_posix_paths
 
 
@@ -1354,49 +1365,51 @@ class CertoraBuildGenerator:
 
         return bytecode
 
-    def _handle_via_ir(self, contract_file_path: str, settings_dict: Dict[str, Any]) -> None:
-        if not self.context.solc_via_ir_map and not self.context.solc_via_ir:
-            return
-        if self.context.solc_via_ir_map:
-            match = Util.match_path_to_mapping_key(Path(contract_file_path), self.context.solc_via_ir_map)
-            if match:
-                settings_dict["viaIR"] = match
-        elif self.context.solc_via_ir:
+    def get_solc_via_ir_value(self, contract_file_path: Path) -> bool:
+        match = Ctx.get_map_attribute_value(self.context, contract_file_path, 'solc_via_ir')
+        assert isinstance(match, (bool, type(None))), f"Expected solc_via_ir to be bool or None, got {type(match)}"
+        return bool(match)
+
+    def get_solc_evm_version_value(self, contract_file_path: Path) -> Optional[str]:
+        match = Ctx.get_map_attribute_value(self.context, contract_file_path, 'solc_evm_version')
+        assert isinstance(match, (str, type(None))), f"Expected solc_evm_version to be string or None, got {type(match)}"
+        return match
+
+    def get_solc_optimize_value(self, contract_file_path: Path) -> Optional[str]:
+        match = Ctx.get_map_attribute_value(self.context, contract_file_path, 'solc_optimize')
+        assert isinstance(match, (str, type(None))), f"Expected solc_optimize to be string or None, got {type(match)}"
+        return match
+
+    def _handle_via_ir(self, contract_file_path: Path, settings_dict: Dict[str, Any]) -> None:
+        if self.get_solc_via_ir_value(contract_file_path):
             settings_dict["viaIR"] = True
 
-    def _handle_evm_version(self, contract_file_path: str, settings_dict: Dict[str, Any]) -> None:
-        if self.context.solc_evm_version_map:
-            match = Util.match_path_to_mapping_key(Path(contract_file_path), self.context.solc_evm_version_map)
-            if match:
-                settings_dict["evmVersion"] = match
-        elif self.context.solc_evm_version:
-            settings_dict["evmVersion"] = self.context.solc_evm_version
+    def _handle_evm_version(self, contract_file_path: Path, settings_dict: Dict[str, Any]) -> None:
+        match = self.get_solc_evm_version_value(contract_file_path)
+        if match:
+            settings_dict["evmVersion"] = match
 
-    def _handle_optimize(self, contract_file_path: str, settings_dict: Dict[str, Any],
+    def _handle_optimize(self, contract_file_path: Path, settings_dict: Dict[str, Any],
                          compiler_collector: CompilerCollector) -> None:
         """
         @param contract_file_path: the contract that we are working on
         @param settings_dict: data structure for sending to the solc compiler
         """
-        if self.context.solc_optimize_map:
-            match = Util.match_path_to_mapping_key(Path(contract_file_path), self.context.solc_optimize_map)
-            if match and int(match) > 0:
-                settings_dict["optimizer"] = {"enabled": True}
-                settings_dict["optimizer"]['runs'] = int(match)
-        elif self.context.solc_optimize:
+        match = self.get_solc_optimize_value(contract_file_path)
+        if match:
             settings_dict["optimizer"] = {"enabled": True}
-            if int(self.context.solc_optimize) > 0:
-                settings_dict["optimizer"]['runs'] = int(self.context.solc_optimize)
+            if int(match) > 0:
+                settings_dict["optimizer"]['runs'] = int(match)
 
         # if optimizer is true, we should also define settings_dict["optimizer"]["details"]
         # for both optimize map and optimize
         optimizer = settings_dict.get("optimizer")
         if optimizer and isinstance(optimizer, dict) and optimizer.get('enabled'):
             # if we are not disabling finder friendly optimizer specifically, enable it whenever viaIR is also enabled
-            if not self.context.strict_solc_optimizer and self.context.solc_via_ir:
+            if not self.context.strict_solc_optimizer and self.get_solc_via_ir_value(contract_file_path):
                 # The default optimizer steps (taken from libsolidity/interface/OptimiserSettings.h) but with the
                 # full inliner step removed
-                solc0_8_26_to_0_8_29 = ("dhfoDgvulfnTUtnIfxa[r]EscLMVcul[j]Trpeulxa[r]cLCTUca[r]LSsTFOtfDnca[r]" +
+                solc0_8_26_to_0_8_30 = ("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"
@@ -1426,6 +1439,8 @@ class CertoraBuildGenerator:
                     raise Util.CertoraUserInputError(err_msg)
                 elif minor < 6 or (minor == 6 and patch < 7):
                     raise Util.CertoraUserInputError(err_msg)
+                elif self.context.yul_optimizer_steps:
+                    yul_optimizer_steps = self.context.yul_optimizer_steps
                 elif (minor == 6 and patch >= 7) or (minor == 7 and 0 <= patch <= 1):
                     yul_optimizer_steps = solc0_6_7_to_0_7_1
                 elif minor == 7 and 2 <= patch <= 5:
@@ -1440,8 +1455,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 <= 29:
-                    yul_optimizer_steps = solc0_8_26_to_0_8_29
+                elif minor == 8 and 26 <= patch <= 30:
+                    yul_optimizer_steps = solc0_8_26_to_0_8_30
                 assert yul_optimizer_steps is not None, \
                     'Yul Optimizer steps missing for requested Solidity version. Please contact Certora team.'
 
@@ -1463,7 +1478,7 @@ class CertoraBuildGenerator:
                 for opt_pass in self.context.disable_solc_optimizers:
                     settings_dict["optimizer"]["details"][opt_pass] = False
 
-    def _fill_codegen_related_options(self, contract_file_path: str, settings_dict: Dict[str, Any],
+    def _fill_codegen_related_options(self, contract_file_path: Path, settings_dict: Dict[str, Any],
                                       compiler_collector: CompilerCollector) -> None:
         """
         Fills options that control how we call solc and affect the bytecode in some way
@@ -1544,7 +1559,7 @@ class CertoraBuildGenerator:
                 }
             }
 
-        self._fill_codegen_related_options(contract_file_as_provided, settings_dict, compiler_collector)
+        self._fill_codegen_related_options(Path(contract_file_as_provided), settings_dict, compiler_collector)
 
         result_dict = {"language": compiler_collector_lang.name, "sources": sources_dict, "settings": settings_dict}
         # debug_print("Standard json input")
@@ -2279,7 +2294,7 @@ class CertoraBuildGenerator:
 
         if compiler_lang == CompilerLangSol():
             settings_dict: Dict[str, Any] = {}
-            self._fill_codegen_related_options(build_arg_contract_file, settings_dict,
+            self._fill_codegen_related_options(Path(build_arg_contract_file), settings_dict,
                                                compiler_collector_for_contract_file)
             solc_optimizer_on, solc_optimizer_runs = self.solc_setting_optimizer_runs(settings_dict)
             solc_via_ir = self.solc_setting_via_ir(settings_dict)
@@ -2409,7 +2424,7 @@ class CertoraBuildGenerator:
                 # if no function finder mode set, determine based on viaIR enabled or not:
                 if self.context.function_finder_mode is None:
                     # in via-ir, should not compress
-                    if self.context.solc_via_ir:
+                    if self.get_solc_via_ir_value(Path(contract_file)):
                         should_compress = False
                     else:
                         should_compress = True
@@ -2539,7 +2554,6 @@ class CertoraBuildGenerator:
             Util.print_progress_message(f"Compiling {orig_file_name}...")
             sdc_pre_finders = self.collect_for_file(build_arg_contract_file, i, compiler_lang, Path(os.getcwd()),
                                                     path_for_compiler_collector_file, original_sdc=None)
-
             # Build sources tree
             build_logger.debug("Building source tree")
             sources_from_pre_finder_SDCs = set()
@@ -2672,8 +2686,154 @@ class CertoraBuildGenerator:
         self.handle_links()
         self.handle_struct_links()
         self.handle_contract_extensions()
+        if self.context.storage_extension_annotation:
+            self.handle_erc7201_annotations()
         self.handle_storage_extension_harnesses()
 
+    def extract_slayout(self, original_file: str, ns_storage: Set[NameSpacedStorage]) -> NewStorageInfo:
+        """
+        Given a file containing a contract with namespaced storage, extract the storage information
+        corresponding to the namespaced types.
+
+        Args:
+            original_file: Path to the Solidity file containing namespaced storage declarations
+            ns_storage: Set of tuples (type_name, namespace) for each namespaced storage
+
+        Returns:
+            NewStorageInfo: A tuple (fields, types) where:
+                - fields: List of new fields added by the namespaced storage
+                - types: Dictionary of types referenced by the fields
+        """
+        file_dir = Path(original_file).parent
+
+        # Generate a unique name for the harness contract based on the contract names in the file
+        harness_name = storageExtension.generate_harness_name(original_file)
+
+        with tempfile.NamedTemporaryFile(mode="w+t", suffix=".sol", dir=file_dir, delete=True) as tmp_file:
+            # Import the original file.
+            # Note we import and don't inline the file's contents since that's how the
+            # original file is accessed also in the actual code, and compiling it
+            # directly can cause issues.
+            tmp_file.write(f"import \"{original_file}\";\n\n")
+
+            # Write the harness contract with dummy fields for each namespaced storage
+            var_to_slot = storageExtension.write_harness_contract(tmp_file, harness_name, ns_storage)
+            tmp_file.flush()
+
+            if self.context.extract_storage_extension_annotation:
+                # If the flag is set, save the storage extension contract
+                build_dir = Util.get_build_dir()
+                shutil.copyfile(
+                    Path(tmp_file.name),
+                    build_dir / f"{Path(original_file).stem}_storage_extension.sol"
+                )
+
+            # Add harness to compiler map
+            storageExtension.add_harness_to_compiler_map(
+                original_file,
+                tmp_file,
+                self.context
+            )
+
+            # normalize the path exactly the way collect_for_file expects it:
+            abs_path = Util.abs_posix_path(tmp_file.name)
+            self.context.file_to_contract[abs_path] = {harness_name}
+
+            try:
+                # Compile & fetch the raw storage_layout
+                compile_idx = storageExtension.get_next_file_index(self.file_to_sdc_name)
+                sdcs = self.collect_for_file(tmp_file.name, compile_idx, CompilerLangSol(), Path.cwd(), Util.abs_posix_path(tmp_file.name), None)
+                if not sdcs:
+                    raise RuntimeError(f"Failed to compile harness contract for {tmp_file}")
+                layout = storageExtension.extract_harness_contract_layout(sdcs, harness_name)
+
+                # Remap each slot according to the ERC-7201 namespace
+                remapped_fields = storageExtension.remapped_fields_from_layout(layout, var_to_slot)
+
+                return (remapped_fields, layout.get('types', {}))
+
+            except Exception as e:
+                build_logger.error(f"Error extracting storage layout for {original_file}: {str(e)}")
+                raise
+            finally:
+                # Delete the key from the context
+                self.context.file_to_contract.pop(abs_path, None)
+
+    def handle_erc7201_annotations(self) -> None:
+        """
+        Look for contracts that use erc-7201 namespaced storage layout
+        (see https://eips.ethereum.org/EIPS/eip-7201).
+
+        Find contracts A s.t. A contain a type declaration with such an annotation, e.g.
+          /** @custom:storage-location erc-7201:some.name.space */
+          struct T { ... }
+
+        Then, for any contract C that has A as a base contract, _extend_ C's storage layout
+        information such that it contains the information for a `T` at the slot
+        erc-7201(some.name.space) as defined in the EIP.
+        """
+        # Find all erc7201-like contracts, generate+compile a harness & extract layout information
+        # maps (path,contract) -> new storage info added by (path,contract)
+        slayouts: Dict[Tuple[str, str], NewStorageInfo] = {}
+
+        # Scan all of the contracts (including dependencies of targets) for namespaced storage
+        # layout information
+        for target_file in self.context.file_paths:
+            if target_file not in self.asts:
+                # No AST for this file, so we can't do anything
+                continue
+            for (imported_file, imported_file_ast) in self.asts[target_file].items():
+                for def_node in imported_file_ast.values():
+                    if def_node.get("nodeType") != "ContractDefinition":
+                        continue
+
+                    # Construct a key for the contract definition node
+                    contract_name = def_node.get("name")
+                    key = (imported_file, contract_name)
+                    if key in slayouts:
+                        # We already have this contract's storage layout information
+                        continue
+
+                    # Collect any @custom:storage-location annotations
+                    ns_storage = storageExtension.get_namespace_storage_from_ast(def_node)
+
+                    if not ns_storage:
+                        # No namespaced storage found in this contract
+                        continue
+
+                    # Now that we have all the storage layout information, extract it once
+                    slayouts[key] = self.extract_slayout(imported_file, ns_storage)
+
+        if self.context.test == str(Util.TestValue.STORAGE_EXTENSION_LAYOUT):
+            raise Util.TestResultsReady(slayouts)
+
+        if not slayouts:
+            # No contracts with namespaced storage found
+            return
+
+        # Finally, extend each target contract with the storage layout info from
+        # all of its base contracts
+        for target in self.get_primary_contracts_from_sdcs():
+            if target.name not in self.context.contract_to_file:
+                # This is a contract that was not compiled, so we don't have a file for it
+                continue
+            target_file = self.context.contract_to_file[target.name]
+            base_contracts = self.retrieve_base_contracts_list(
+                target_file,
+                Util.abs_posix_path(target_file),
+                target.name
+            )
+            extensions: Set[str] = set()
+            harnesses: Dict[str, NewStorageInfo] = {}
+            for base in base_contracts:
+                layout = slayouts.get((base[0], base[1]))
+                if layout is not None:
+                    extensions.add(base[1])
+                    harnesses[base[1]] = layout
+                else:
+                    build_logger.warning(f"Could not find storage layout for {base[1]} in {base[0]}")
+            storageExtension.apply_extensions(target, extensions, harnesses)
+
     def handle_storage_extension_harnesses(self) -> None:
         def new_field_of_node(ext_instance: Any, node: Dict[str, Any]) -> Optional[Dict[str, Any]]:
             """
@@ -2760,52 +2920,6 @@ class CertoraBuildGenerator:
                     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
@@ -2834,7 +2948,7 @@ class CertoraBuildGenerator:
             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)
+            storageExtension.apply_extensions(target_contract, extensions, extension_to_fields_and_types)
 
     def finders_compilation_round(self,
                                   build_arg_contract_file: str,
@@ -3436,8 +3550,9 @@ class CertoraBuildGenerator:
                 raise Util.CertoraUserInputError(f"collect_sources: {path_to_file} does not exist cwd - {Path.cwd()}."
                                                  f"abs - {os.path.normpath(Path.cwd() / path_to_file)}")
 
-        sources = set()
-        sources |= sources_from_SDCs
+        sources = set(sources_from_SDCs)
+        if context.files:
+            sources.update(Path(p) for p in context.files)  # all files in "files" attribute are uploaded
         sources |= certora_verify_generator.get_spec_files()
         if Util.PACKAGE_FILE.exists():
             add_to_sources(Util.PACKAGE_FILE)
@@ -3507,7 +3622,7 @@ def build_source_tree(sources: Set[Path], context: CertoraContext, overwrite: bo
 
         try:
             if overwrite:
-                # expecting target path to exist.
+                # expecting the target path to exist.
                 if target_path.exists():
                     build_logger.debug(f"Overwriting {target_path} by copying from {source_path}")
                 else:
@@ -3525,7 +3640,7 @@ def build_source_tree(sources: Set[Path], context: CertoraContext, overwrite: bo
     cwd_file_path.parent.mkdir(parents=True, exist_ok=True)
     cwd_file_path.touch()
 
-    #  the empty file .project_directory is written in the source tree to denote the projecct directory
+    #  the empty file .project_directory is written in the source tree to denote the project directory
     rust_proj_dir = getattr(context, 'rust_project_directory', None)
     if rust_proj_dir:
         proj_dir_parent_relative = os.path.relpath(rust_proj_dir, os.getcwd())
@@ -3546,7 +3661,8 @@ 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
 
-def build_from_scratch(certora_build_generator: CertoraBuildGenerator,
+def build_from_scratch(context: CertoraContext,
+                       certora_build_generator: CertoraBuildGenerator,
                        certora_verify_generator: CertoraVerifyGenerator,
                        build_cache_enabled: bool) -> CachedFiles:
     """
@@ -3572,9 +3688,16 @@ def build_from_scratch(certora_build_generator: CertoraBuildGenerator,
     may_store_in_build_cache = True
     absolute_sources_dir = Util.get_certora_sources_dir().absolute()
     for sdc in certora_build_generator.SDCs.values():
+
+        # add to cache also source files that were found in the SDCs (e.g., storage extensions)
+        paths_set = sdc.all_contract_files
+        for f in context.files:
+            path = f.split(':')[0]  # `f` is either 'path/to/file.sol' or 'path/to/file.sol:ContractName'
+            paths_set.add(Path(path).absolute())
+
         # the contract files in SDCs are relative to .certora_sources. Which isn't good for us here.
         # Need to be relative to original paths
-        for f in sdc.all_contract_files:
+        for f in paths_set:
             if is_relative_to(f, absolute_sources_dir):
                 rel_f = f.relative_to(absolute_sources_dir)
             else:
@@ -3610,8 +3733,7 @@ def build_from_scratch(certora_build_generator: CertoraBuildGenerator,
 
 def build_from_cache_or_scratch(context: CertoraContext,
                                 certora_build_generator: CertoraBuildGenerator,
-                                certora_verify_generator: CertoraVerifyGenerator,
-                                certora_build_cache_manager: CertoraBuildCacheManager) \
+                                certora_verify_generator: CertoraVerifyGenerator) \
         -> Tuple[bool, bool, CachedFiles]:
     """
     Builds either from cache (fast path) or from scratch (slow path)
@@ -3623,23 +3745,23 @@ def build_from_cache_or_scratch(context: CertoraContext,
     cached_files: Optional[CachedFiles] = None
 
     if not context.build_cache:
-        cached_files = build_from_scratch(certora_build_generator,
+        cached_files = build_from_scratch(context, certora_build_generator,
                                           certora_verify_generator,
                                           False)
         return cache_hit, False, cached_files
 
-    build_cache_applicable = certora_build_cache_manager.cache_is_applicable(context)
+    build_cache_applicable = CertoraBuildCacheManager.cache_is_applicable(context)
 
     if not build_cache_applicable:
-        build_cache_disabling_options = certora_build_cache_manager.cache_disabling_options(context)
+        build_cache_disabling_options = CertoraBuildCacheManager.cache_disabling_options(context)
         build_logger.warning("Requested to enable the build cache, but the build cache is not applicable "
                              f"to this run because of the given options: {build_cache_disabling_options}")
-        cached_files = build_from_scratch(certora_build_generator,
+        cached_files = build_from_scratch(context, certora_build_generator,
                                           certora_verify_generator,
                                           False)
         return cache_hit, False, cached_files
 
-    cached_files = certora_build_cache_manager.build_from_cache(context)
+    cached_files = CertoraBuildCacheManager.build_from_cache(context)
     # if no match, will rebuild from scratch
     if cached_files is not None:
         # write to .certora_build.json
@@ -3660,7 +3782,7 @@ def build_from_cache_or_scratch(context: CertoraContext,
         cache_hit = True
     else:
         # rebuild
-        cached_files = build_from_scratch(certora_build_generator,
+        cached_files = build_from_scratch(context, certora_build_generator,
                                           certora_verify_generator,
                                           True)
 
@@ -3678,7 +3800,7 @@ def build(context: CertoraContext, ignore_spec_syntax_check: bool = False) -> No
 
     try:
         input_config = InputConfig(context)
-
+        context.main_cache_key = CertoraBuildCacheManager.get_main_cache_key(context)
         # Create generators
         certora_build_generator = CertoraBuildGenerator(input_config, context)
 
@@ -3694,12 +3816,9 @@ def build(context: CertoraContext, ignore_spec_syntax_check: bool = False) -> No
             else:
                 Ctx.run_local_spec_check(False, context)
 
-        certora_build_cache_manager = CertoraBuildCacheManager()
-
         cache_hit, build_cache_enabled, cached_files = build_from_cache_or_scratch(context,
                                                                                    certora_build_generator,
-                                                                                   certora_verify_generator,
-                                                                                   certora_build_cache_manager)
+                                                                                   certora_verify_generator)
 
         # avoid running the same test over and over again for each split run, context.split_rules is true only for
         # the first run and is set to [] for split runs
@@ -3719,7 +3838,7 @@ def build(context: CertoraContext, ignore_spec_syntax_check: bool = False) -> No
 
         # save in build cache
         if not cache_hit and build_cache_enabled and cached_files.may_store_in_build_cache:
-            certora_build_cache_manager.save_build_cache(context, cached_files)
+            CertoraBuildCacheManager.save_build_cache(context, cached_files)
 
         certora_verify_generator.update_certora_verify_struct(True)
         certora_verify_generator.dump()  # second dump with properly rooted specs